| 
														
															@@ -162,6 +162,8 @@ const dialogFormVisibleFormula = ref(false); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const formulaForm = ref([]); 
														 | 
														
														 | 
														
															 const formulaForm = ref([]); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const grade = ref(); 
														 | 
														
														 | 
														
															 const grade = ref(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const conditionVerifyApi = async () => { 
														 | 
														
														 | 
														
															 const conditionVerifyApi = async () => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  grade.value = null; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  formulaForm.value = []; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   dialogFormVisibleFormula.value = true; 
														 | 
														
														 | 
														
															   dialogFormVisibleFormula.value = true; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   try { 
														 | 
														
														 | 
														
															   try { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     formulaForm.value = []; 
														 | 
														
														 | 
														
															     formulaForm.value = []; 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -223,6 +225,33 @@ function reverseReplace(oldValue, dataObject) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   }); 
														 | 
														
														 | 
														
															   }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   return dataObject; 
														 | 
														
														 | 
														
															   return dataObject; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 } 
														 | 
														
														 | 
														
															 } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+function calculateScore(inputString) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  // 将 formulaForm.value 转换为一个键值对映射,方便替换 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  const valueMap = formulaForm.value.reduce((map, item) => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    map[item.name] = item.value !== null ? item.value : 0; // 用 0 替代 null 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    return map; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  }, {}); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  // 替换字符串中的关键字为对应的 value 值 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  let formula = inputString; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  for (const [key, value] of Object.entries(valueMap)) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    if (formula.includes(key)) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      // 使用正则替换所有匹配的关键字 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      const regex = new RegExp(key, "g"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      formula = formula.replace(regex, value); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  try { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    // 使用 eval 计算公式 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    const result = eval(formula); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    return result; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  } catch (error) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    console.error("公式计算出错:", error); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    return null; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+} 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const countComputed = async () => { 
														 | 
														
														 | 
														
															 const countComputed = async () => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   try { 
														 | 
														
														 | 
														
															   try { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     if (params.formulaType == 0) { 
														 | 
														
														 | 
														
															     if (params.formulaType == 0) { 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -269,14 +298,58 @@ const countComputed = async () => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         }); 
														 | 
														
														 | 
														
															         }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															       } 
														 | 
														
														 | 
														
															       } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     } else if (params.formulaType == 1) { 
														 | 
														
														 | 
														
															     } else if (params.formulaType == 1) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-      let oldValue = {}; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-      Object.assign(oldValue, addmanyChange); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-      let formListNum = formulaForm.value; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-      let newValue = reverseReplace(formListNum, oldValue); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-      const { code, msg, data } = 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        await calculateScoreByConditionMoCondition(newValue); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-      if (code == 200) { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        grade.value = data; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      let oldValue = JSON.parse(JSON.stringify(addmanyChange)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      // Object.assign(oldValue, addmanyChange); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      const formulaPar = JSON.stringify(oldValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      const res = await conditionVerify({ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        formulaType: params.formulaType, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        formula: formulaPar 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      if (res.code == 200) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        if (oldValue.outerConditionValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          oldValue.outerConditionValue = calculateScore( 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            oldValue.outerConditionValue 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          ); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        if (oldValue.innerConditionExpression.length > 0) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          oldValue.innerConditionExpression.map(itEx => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            if (itEx.startValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              itEx.startValue = calculateScore(itEx.startValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            if (itEx.endValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              itEx.endValue = calculateScore(itEx.endValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            if (itEx.innerScore) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              itEx.innerScore = calculateScore(itEx.innerScore); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            if (itEx?.scoreRuleMoreInnerVO[0]?.innerConditionValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              itEx.scoreRuleMoreInnerVO[0].innerConditionValue = calculateScore( 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                itEx.scoreRuleMoreInnerVO[0].innerConditionValue 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              ); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            if (itEx?.scoreRuleMoreInnerVO[0]?.scoreRules.length > 0) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              itEx.scoreRuleMoreInnerVO[0].scoreRules.map(itRule => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                if (itRule.score) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                  itRule.score = calculateScore(itRule.score); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                if (itRule.startValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                  itRule.startValue = calculateScore(itRule.startValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                if (itRule.endValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                  itRule.endValue = calculateScore(itRule.endValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        console.log("计算后的数据oldValue", oldValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        console.log("计算后的数据addmanyChange", addmanyChange); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        // let newValue = reverseReplace(formListNum, oldValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        const { code, msg, data } = 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          await calculateScoreByConditionMoCondition(oldValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        if (code == 200) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          grade.value = data; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															       } else { 
														 | 
														
														 | 
														
															       } else { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         ElMessageBox.confirm( 
														 | 
														
														 | 
														
															         ElMessageBox.confirm( 
														 | 
													
												
											
												
													
														| 
														 | 
														
															           "如果不修改将无法计算得分", 
														 | 
														
														 | 
														
															           "如果不修改将无法计算得分", 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -384,6 +457,7 @@ const open = row => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     ] 
														 | 
														
														 | 
														
															     ] 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   }); 
														 | 
														
														 | 
														
															   }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   getIndexInfoApi(row.id); 
														 | 
														
														 | 
														
															   getIndexInfoApi(row.id); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  calculatorShow.value = true; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const editShow = ref(true); 
														 | 
														
														 | 
														
															 const editShow = ref(true); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 defineExpose({ 
														 | 
														
														 | 
														
															 defineExpose({ 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -523,19 +597,23 @@ const addItemFormulaList = (item, index) => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     } 
														 | 
														
														 | 
														
															     } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   ]; 
														 | 
														
														 | 
														
															   ]; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.innerConditionExpression[index].innerScore = ""; 
														 | 
														
														 | 
														
															   addmanyChange.innerConditionExpression[index].innerScore = ""; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const deleteItem = index => { 
														 | 
														
														 | 
														
															 const deleteItem = index => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.innerConditionExpression.splice(index, 1); 
														 | 
														
														 | 
														
															   addmanyChange.innerConditionExpression.splice(index, 1); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const dataleListItem = (index, indexList) => { 
														 | 
														
														 | 
														
															 const dataleListItem = (index, indexList) => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.innerConditionExpression[ 
														 | 
														
														 | 
														
															   addmanyChange.innerConditionExpression[ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     index 
														 | 
														
														 | 
														
															     index 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   ].scoreRuleMoreInnerVO[0].scoreRules.splice(indexList, 1); 
														 | 
														
														 | 
														
															   ].scoreRuleMoreInnerVO[0].scoreRules.splice(indexList, 1); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 // 条件变量 
														 | 
														
														 | 
														
															 // 条件变量 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const dataleListItemAll = (item, index) => { 
														 | 
														
														 | 
														
															 const dataleListItemAll = (item, index) => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   item.scoreRuleMoreInnerVO = []; 
														 | 
														
														 | 
														
															   item.scoreRuleMoreInnerVO = []; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const addNewItem = () => { 
														 | 
														
														 | 
														
															 const addNewItem = () => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.innerConditionExpression.push({ 
														 | 
														
														 | 
														
															   addmanyChange.innerConditionExpression.push({ 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -546,6 +624,7 @@ const addNewItem = () => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     comparisonEnd: null, 
														 | 
														
														 | 
														
															     comparisonEnd: null, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     scoreRuleMoreInnerVO: [] 
														 | 
														
														 | 
														
															     scoreRuleMoreInnerVO: [] 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   }); 
														 | 
														
														 | 
														
															   }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const addNewItemOldValue = item => { 
														 | 
														
														 | 
														
															 const addNewItemOldValue = item => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.innerConditionExpression.push({ 
														 | 
														
														 | 
														
															   addmanyChange.innerConditionExpression.push({ 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -556,6 +635,7 @@ const addNewItemOldValue = item => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     comparisonEnd: null, 
														 | 
														
														 | 
														
															     comparisonEnd: null, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     scoreRuleMoreInnerVO: [] 
														 | 
														
														 | 
														
															     scoreRuleMoreInnerVO: [] 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   }); 
														 | 
														
														 | 
														
															   }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const addItemDataList = ( 
														 | 
														
														 | 
														
															 const addItemDataList = ( 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   index: number, 
														 | 
														
														 | 
														
															   index: number, 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -575,9 +655,10 @@ const addItemDataList = ( 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     comparisonEnd: null 
														 | 
														
														 | 
														
															     comparisonEnd: null 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   }); 
														 | 
														
														 | 
														
															   }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.innerConditionExpression[index].innerScore = ""; 
														 | 
														
														 | 
														
															   addmanyChange.innerConditionExpression[index].innerScore = ""; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 // 多条件公式验证 
														 | 
														
														 | 
														
															 // 多条件公式验证 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-const keywords = ["目标值", "完成值", "挑战值", "增幅", "降幅"]; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+const keywords = ["目标值", "完成值", "挑战值", "门槛值", "增幅", "降幅"]; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 // 处理字符串,提取关键词 
														 | 
														
														 | 
														
															 // 处理字符串,提取关键词 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 function extractKeywords(value) { 
														 | 
														
														 | 
														
															 function extractKeywords(value) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   // 如果是字符串,处理包含的关键词 
														 | 
														
														 | 
														
															   // 如果是字符串,处理包含的关键词 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -613,21 +694,76 @@ function traverseObject(obj) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     } 
														 | 
														
														 | 
														
															     } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   } 
														 | 
														
														 | 
														
															   } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 } 
														 | 
														
														 | 
														
															 } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+function extractKeywordsAndPush(keywordsList, inputString) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  keywords.forEach(keyword => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    if ( 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      inputString?.includes(keyword) && // 检查字符串是否包含关键字 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      !formulaForm.value.some(item => item.name === keyword) // 确保没有重复 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    ) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      // 如果包含且未重复,构造对象并push到formulaForm.value 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      formulaForm.value.push({ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        name: keyword, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        value: null // 根据需求赋值 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  return formulaForm; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+} 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const manyConditions = () => { 
														 | 
														
														 | 
														
															 const manyConditions = () => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  grade.value = null; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   dialogFormVisibleFormula.value = true; 
														 | 
														
														 | 
														
															   dialogFormVisibleFormula.value = true; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   formulaForm.value = []; 
														 | 
														
														 | 
														
															   formulaForm.value = []; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   // 提取 addmanyChange 对象中的条件值 
														 | 
														
														 | 
														
															   // 提取 addmanyChange 对象中的条件值 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-  const oldValue = addmanyChange; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-  traverseObject(oldValue); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  let oldValue = addmanyChange; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  if (oldValue.outerConditionValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    extractKeywordsAndPush(keywords, oldValue.outerConditionValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  if (oldValue.innerConditionExpression.length > 0) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    oldValue.innerConditionExpression.map(itemExp => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      if (itemExp.startValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        extractKeywordsAndPush(keywords, itemExp.startValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      if (itemExp.endValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        extractKeywordsAndPush(keywords, itemExp.endValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      if (itemExp.innerScore) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        extractKeywordsAndPush(keywords, itemExp.innerScore); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      if (itemExp?.scoreRuleMoreInnerVO[0]?.innerConditionValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        extractKeywordsAndPush( 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          keywords, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          itemExp.scoreRuleMoreInnerVO[0].innerConditionValue 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        ); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      if (itemExp?.scoreRuleMoreInnerVO.length > 0) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        if (itemExp?.scoreRuleMoreInnerVO[0]?.scoreRules.length > 0) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          itemExp?.scoreRuleMoreInnerVO[0]?.scoreRules.map(itSc => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            if (itSc.score) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              extractKeywordsAndPush(keywords, itSc.score); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            if (itSc.startValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              extractKeywordsAndPush(keywords, itSc.startValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            if (itSc.endValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              extractKeywordsAndPush(keywords, itSc.endValue); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 // 计算器 
														 | 
														
														 | 
														
															 // 计算器 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const jishuanqiRef = ref(); 
														 | 
														
														 | 
														
															 const jishuanqiRef = ref(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const countNoConditionFormula = item => { 
														 | 
														
														 | 
														
															 const countNoConditionFormula = item => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.outerConditionValue = item; 
														 | 
														
														 | 
														
															   addmanyChange.outerConditionValue = item; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const jishuanqiRef1 = ref(); 
														 | 
														
														 | 
														
															 const jishuanqiRef1 = ref(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const countNoConditionFormula1 = (item, index) => { 
														 | 
														
														 | 
														
															 const countNoConditionFormula1 = (item, index) => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.innerConditionExpression[index].endValue = item; 
														 | 
														
														 | 
														
															   addmanyChange.innerConditionExpression[index].endValue = item; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const jishuanqiRef2 = ref(); 
														 | 
														
														 | 
														
															 const jishuanqiRef2 = ref(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const countNoConditionFormula2 = (item, index) => { 
														 | 
														
														 | 
														
															 const countNoConditionFormula2 = (item, index) => { 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -635,20 +771,24 @@ const countNoConditionFormula2 = (item, index) => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.innerConditionExpression[ 
														 | 
														
														 | 
														
															   addmanyChange.innerConditionExpression[ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     index 
														 | 
														
														 | 
														
															     index 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   ].scoreRuleMoreInnerVO[0].innerConditionValue = item; 
														 | 
														
														 | 
														
															   ].scoreRuleMoreInnerVO[0].innerConditionValue = item; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const jishuanqiRef3 = ref(); 
														 | 
														
														 | 
														
															 const jishuanqiRef3 = ref(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const countNoConditionFormula3 = (item, index, indexList) => { 
														 | 
														
														 | 
														
															 const countNoConditionFormula3 = (item, index, indexList) => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.innerConditionExpression[ 
														 | 
														
														 | 
														
															   addmanyChange.innerConditionExpression[ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     index 
														 | 
														
														 | 
														
															     index 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   ].scoreRuleMoreInnerVO[0].scoreRules[indexList].endValue = item; 
														 | 
														
														 | 
														
															   ].scoreRuleMoreInnerVO[0].scoreRules[indexList].endValue = item; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const countNoConditionFormula4 = (item, index, indexList) => { 
														 | 
														
														 | 
														
															 const countNoConditionFormula4 = (item, index, indexList) => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.innerConditionExpression[ 
														 | 
														
														 | 
														
															   addmanyChange.innerConditionExpression[ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     index 
														 | 
														
														 | 
														
															     index 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   ].scoreRuleMoreInnerVO[0].scoreRules[indexList].score = item; 
														 | 
														
														 | 
														
															   ].scoreRuleMoreInnerVO[0].scoreRules[indexList].score = item; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 const countNoConditionFormulaInnerScore = (item, index, indexList) => { 
														 | 
														
														 | 
														
															 const countNoConditionFormulaInnerScore = (item, index, indexList) => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   addmanyChange.innerConditionExpression[index].innerScore = item; 
														 | 
														
														 | 
														
															   addmanyChange.innerConditionExpression[index].innerScore = item; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  changeAddMay(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															 // 转换函数 --- 人员 
														 | 
														
														 | 
														
															 // 转换函数 --- 人员 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -675,6 +815,60 @@ const handleRreeSelect = () => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   }); 
														 | 
														
														 | 
														
															   }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															   params.designatedPersonnel = arr.map(item => item.value).join(","); 
														 | 
														
														 | 
														
															   params.designatedPersonnel = arr.map(item => item.value).join(","); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+// 取消计算 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+const quxiaoCmputed = () => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  formulaForm.value = []; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  dialogFormVisibleFormula.value = false; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+}; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+// 监听数据变化 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+const changeAddMay = () => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  let addmanyChangeOldVal = JSON.parse(JSON.stringify(addmanyChange)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  addmanyChange.innerConditionExpression.forEach((item, index, arr) => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    if (index + 1 <= arr.length) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      console.log("12312", addmanyChangeOldVal.innerConditionExpression); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      if (item.endValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        if (addmanyChangeOldVal.innerConditionExpression.length > 1) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          addmanyChangeOldVal.innerConditionExpression[index + 1].startValue = 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            item?.endValue; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          addmanyChangeOldVal.innerConditionExpression[index + 1].startExpress = 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            item?.endExpress; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          addmanyChangeOldVal.innerConditionExpression[ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            index + 1 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          ].comparisonStart = item?.comparisonEnd == "≥" ? ">" : "≥"; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      if (item.scoreRuleMoreInnerVO.length > 0) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        if (item.scoreRuleMoreInnerVO[0].scoreRules.length > 0) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          item.scoreRuleMoreInnerVO[0].scoreRules.map((it, id, arrChild) => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            if (id + 1 <= arrChild.length) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              if (it.endValue) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                // if ( 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                //   addmanyChangeOldVal.innerConditionExpression[index + 1] 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                //     .scoreRuleMoreInnerVO.length > 0 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                // ) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                addmanyChangeOldVal.innerConditionExpression[ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                  index 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                ].scoreRuleMoreInnerVO[0].scoreRules[id + 1].startValue = 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                  it?.endValue; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                addmanyChangeOldVal.innerConditionExpression[ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                  index 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                ].scoreRuleMoreInnerVO[0].scoreRules[id + 1].startExpress = 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                  it?.startExpress; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                addmanyChangeOldVal.innerConditionExpression[ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                  index 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                ].scoreRuleMoreInnerVO[0].scoreRules[id + 1].comparisonStart = 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                  it?.comparisonEnd; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                // } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+              } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  }); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+  Object.assign(addmanyChange, addmanyChangeOldVal); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+}; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+// { deep: true }; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 </script> 
														 | 
														
														 | 
														
															 </script> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															 <template> 
														 | 
														
														 | 
														
															 <template> 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -1264,7 +1458,12 @@ const handleRreeSelect = () => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															       </template> 
														 | 
														
														 | 
														
															       </template> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     </el-drawer> 
														 | 
														
														 | 
														
															     </el-drawer> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     <!-- 公式验证 --> 
														 | 
														
														 | 
														
															     <!-- 公式验证 --> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    <el-dialog v-model="dialogFormVisibleFormula" title="完成值" width="500"> 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    <el-dialog 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      v-model="dialogFormVisibleFormula" 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      title="完成值" 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      width="500" 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+      :before-close="quxiaoCmputed" 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    > 
														 | 
													
												
											
												
													
														| 
														 | 
														
															       <el-form :model="formulaForm"> 
														 | 
														
														 | 
														
															       <el-form :model="formulaForm"> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         <div v-for="(itemF, indexF) in formulaForm" :key="indexF"> 
														 | 
														
														 | 
														
															         <div v-for="(itemF, indexF) in formulaForm" :key="indexF"> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															           <el-form-item :label="itemF.name"> 
														 | 
														
														 | 
														
															           <el-form-item :label="itemF.name"> 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -1277,7 +1476,7 @@ const handleRreeSelect = () => { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															       </el-form> 
														 | 
														
														 | 
														
															       </el-form> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															       <template #footer> 
														 | 
														
														 | 
														
															       <template #footer> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         <div class="dialog-footer"> 
														 | 
														
														 | 
														
															         <div class="dialog-footer"> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-          <el-button @click="dialogFormVisibleFormula = false">取消</el-button> 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+          <el-button @click="quxiaoCmputed">取消</el-button> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															           <el-button type="primary" @click="countComputed"> 计算 </el-button> 
														 | 
														
														 | 
														
															           <el-button type="primary" @click="countComputed"> 计算 </el-button> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         </div> 
														 | 
														
														 | 
														
															         </div> 
														 | 
													
												
											
												
													
														| 
														 | 
														
															       </template> 
														 | 
														
														 | 
														
															       </template> 
														 |