cloud-web-corejs 1.0.54-dev.423 → 1.0.54-dev.425

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cloud-web-corejs",
   "private": false,
-  "version": "1.0.54-dev.423",
+  "version": "1.0.54-dev.425",
   "scripts": {
     "dev": "vue-cli-service serve",
     "lint": "eslint --ext .js,.vue src",

package/src/components/VabUpload/mixins.js

@@ -486,7 +486,6 @@ tmixins = {
       };
     },
     changeFile(param) {
-      debugger
       if (!param.file || param.file.status == "fail") return;
       let target = this.$refs.upload;
       if (!target) return;

package/src/components/xform/utils/formula-util.js

@@ -125,6 +125,7 @@ export function calculateFormula(VFR, DSV, formulaJs, formulaFieldRef, changedFi
   return formulaValue
 }
 
+// ... existing code ...
 export function baseCalculateFormula(that,formulaStr, row /* VFR, DSV, formulaJs, formulaFieldRef, changedFieldRef */) {
   if(!formulaStr)return
   let formula = formulaStr;
@@ -132,15 +133,62 @@ export function baseCalculateFormula(that,formulaStr, row /* VFR, DSV, formulaJs
   let DSV = that.getGlobalDsv()
   let formulaJs = formulajs
   let formulaFieldRef = that;
+  let changedFieldRef = arguments[5];
+
+  // 增强子表单字段变化时的计算范围控制
   if (formulaFieldRef.tableParam) {
-  } else if (!!formulaFieldRef.subFormItemFlag && !!changedFieldRef.subFormItemFlag) {
-    /* 子表单字段变化，只能触发子表单同一行字段的计算公式重新计算！！ */
-    /* if (changedFieldRef.subFormRowId !== formulaFieldRef.subFormRowId) {
+  } else if (!!formulaFieldRef.subFormItemFlag && !!changedFieldRef?.subFormItemFlag) {
+    /* 子表单字段变化，只能触发子表单同一行字段的计算公式重新计算 */
+    if (changedFieldRef.subFormRowId !== formulaFieldRef.subFormRowId) {
       return
-    } */
+    }
   }
 
-  formula = baseReplaceFieldsAndFunctionsOfFormula(VFR, formulaFieldRef,formula,row)  //替换字段值
+  // 预处理：识别并标记聚合函数，记录它们的参数字段所属子表单
+  const aggregationFunctions = ['SUM', 'AVERAGE', 'MAX', 'MIN', 'SUMIF', 'SUMIFS'];
+  let functionCalls = [];
+
+  // 解析公式中的函数调用
+  // 方案1：先替换占位符，再解析函数调用
+  // 临时处理公式中的占位符，以便正确识别函数调用
+  let tempFormula = formulaStr;
+  const placeholders = tempFormula.match(/\{\{([^}]*)\}\}/g) || [];
+  placeholders.forEach(placeholder => {
+    // 处理函数占位符
+    if (placeholder.includes('.func')) {
+      const parts = placeholder.split('.');
+      if (parts.length >= 2) {
+        const fieldId = parts[0].substring(2); // 去掉开头的 {{
+        const funcName = parts[1];
+        // 临时替换函数占位符为函数名，便于后续解析
+        tempFormula = tempFormula.replace(placeholder, funcName);
+      }
+    }
+  });
+
+  // 解析公式中的函数调用 - 修改正则表达式，支持大小写字母
+  let functionCallMatch;
+  const functionCallRegex = /([A-Za-z]+)\s*\(([^)]*)\)/g;
+  while ((functionCallMatch = functionCallRegex.exec(tempFormula)) !== null) {
+    const funcName = functionCallMatch[1].toUpperCase();
+    const params = functionCallMatch[2];
+
+    if (aggregationFunctions.includes(funcName)) {
+      // 找出原始公式中对应的位置
+      const originalStart = formulaStr.indexOf(functionCallMatch[0].substring(0, 10));
+
+      functionCalls.push({
+        name: funcName,
+        params: params,
+        fullMatch: functionCallMatch[0],
+        start: originalStart > -1 ? originalStart : functionCallMatch.index
+      });
+    }
+  }
+
+  // 替换字段值，增加对子表单引用子表单场景的特殊处理
+  formula = baseReplaceFieldsAndFunctionsOfFormula(VFR, formulaFieldRef, formula, row, functionCalls)
+
   if (!formula) {
     return
   }
@@ -158,26 +206,17 @@ export function baseCalculateFormula(that,formulaStr, row /* VFR, DSV, formulaJs
     })
   }
 
-  const formulaValue = evalFn(formula, DSV, VFR, formulaJs)
-  return formulaValue
-}
-
-
-function getFieldKeyName(widget) {
-    let o = widget.options.name;
-    return (widget.options.keyNameEnabled && widget.options.keyName) || o;
+  try {
+    const formulaValue = evalFn(formula, DSV, VFR, formulaJs)
+    return formulaValue
+  } catch (error) {
+    console.error('公式计算错误:', error, '公式:', formula);
+    return null;
+  }
 }
 
-function funOtherHanlde(){
-
-}
-/**
- * 替换计算公式中的字段值
- * @param VFR
- * @param formulaFieldRef
- * @returns {*}
- */
-export function baseReplaceFieldsAndFunctionsOfFormula(VFR, formulaFieldRef, formula, row) {
+// 优化 baseReplaceFieldsAndFunctionsOfFormula 方法，增加对聚合函数的特殊处理
+export function baseReplaceFieldsAndFunctionsOfFormula(VFR, formulaFieldRef, formula, row, functionCalls = []) {
   // let formula = formulaFieldRef.field.options.formula
   const matchResult = formula.match(FORMULA_REG_EXP)
   if (!matchResult) {
@@ -186,16 +225,16 @@ export function baseReplaceFieldsAndFunctionsOfFormula(VFR, formulaFieldRef, for
 
   let resultFormula = formula
   let quitFlag = false
+
+  // 记录所有字段引用及其所属子表单
+  let fieldReferences = [];
+
   matchResult.forEach(mi => {
     const thirdPart = mi.split('.')[2]
     const nodeType = thirdPart.substring(0, thirdPart.length - 2)
     if (nodeType === 'func') {
       const funcName = mi.split('.')[1]
       resultFormula = resultFormula.replace(mi, funcName)
-
-      /* if(funcName === "SUMIF" || funcName === "SUMIFS"){
-        debugger
-      } */
       return
     }
 
@@ -205,64 +244,124 @@ export function baseReplaceFieldsAndFunctionsOfFormula(VFR, formulaFieldRef, for
     if (!!fieldSchema) {
       let fieldRef = VFR.getWidgetRef(fieldSchema.options.name)
       if (!!fieldRef) {
-        //是否要考虑字符串值的替换？？
-        // resultFormula = resultFormula.replace(mi, fieldRef.currentValue)
         let fieldKeyName = getFieldKeyName(fieldSchema)
         let value = fieldRef.formModel[fieldKeyName]??null;
         resultFormula = resultFormula.replace(mi, value)
       } else {  //getWidgetRef找不到，则可能是子表单字段
         const subFormNameOfField = VFR.getSubFormNameOfWidget(fieldSchema.options.name)
+
+        // 记录字段引用信息
+        fieldReferences.push({
+          placeholder: mi,
+          fieldName: fieldSchema.options.name,
+          subFormName: subFormNameOfField
+        });
+
         if (!!formulaFieldRef.subFormItemFlag || formulaFieldRef.tableParam || row) {
           /* 如果当前计算字段是子表单字段，要判断公式中的子表单字段是否和当前计算字段是否属于同一子表单！！ */
-          if(row){
-            let fieldKeyName = getFieldKeyName(fieldSchema)
-            let value = row[fieldKeyName]??null;
-            resultFormula = resultFormula.replaceAll(mi, value)
-            /*
-            let subFormRowId = row._X_ROW_KEY
-            fieldRef = VFR.getWidgetRef(fieldSchema.options.name + '_' + subFormRowId)
-            if (!!fieldRef) {
-              let value = fieldRef.currentValue;
-              resultFormula = resultFormula.replaceAll(mi, value)
-            } else {
-              de
-              quitFlag = true
-              console.error('Field not found: ' + fieldSchema.options.label)
-            } */
-          }else if (subFormNameOfField === formulaFieldRef?.parentWidget?.options?.name) {
-            let subFormRowId = formulaFieldRef.tableParam.row._X_ROW_KEY
-            fieldRef = VFR.getWidgetRef(fieldSchema.options.name + '_' + subFormRowId)
-            if (!!fieldRef) {
-              let value = fieldRef.currentValue??null;
+          // 判断是否是同一子表单
+          const isSameSubForm = subFormNameOfField === formulaFieldRef?.parentWidget?.options?.name ||
+                              subFormNameOfField === formulaFieldRef.subFormName;
+
+          // 检查该字段是否在某个聚合函数的参数中
+          let isInAggregationParam = false;
+          functionCalls.forEach(call => {
+            if (call.params.includes(mi)) {
+              isInAggregationParam = true;
+            }
+          });
+
+          /* if(functionCalls.length){
+            debugger
+          } */
+
+          if (isSameSubForm && !isInAggregationParam) {
+            // 同一子表单且不在聚合函数参数中，使用当前行数据
+            if(row){
+              let fieldKeyName = getFieldKeyName(fieldSchema)
+              let value = row[fieldKeyName]??null;
               resultFormula = resultFormula.replaceAll(mi, value)
-            } else {
-              quitFlag = true
-              console.error('Field not found: ' + fieldSchema.options.label)
+            }else if (subFormNameOfField === formulaFieldRef?.parentWidget?.options?.name) {
+              let subFormRowId = formulaFieldRef.tableParam.row._X_ROW_KEY
+              fieldRef = VFR.getWidgetRef(fieldSchema.options.name + '_' + subFormRowId)
+              if (!!fieldRef) {
+                let value = fieldRef.currentValue??null;
+                resultFormula = resultFormula.replaceAll(mi, value)
+              } else {
+                quitFlag = true
+                console.error('Field not found: ' + fieldSchema.options.label)
+              }
+            } else if (subFormNameOfField === formulaFieldRef.subFormName) {
+              fieldRef = VFR.getWidgetRef(fieldSchema.options.name + '@row' + formulaFieldRef.subFormRowId)
+              if (!!fieldRef) {
+                resultFormula = resultFormula.replaceAll(mi, fieldRef.currentValue)
+              } else {
+                quitFlag = true
+                console.error('Field not found: ' + fieldSchema.options.label)
+              }
             }
-          } else if (subFormNameOfField === formulaFieldRef.subFormName) {
-            fieldRef = VFR.getWidgetRef(fieldSchema.options.name + '@row' + formulaFieldRef.subFormRowId)
-            if (!!fieldRef) {
-              resultFormula = resultFormula.replaceAll(mi, fieldRef.currentValue)
-            } else {
-              quitFlag = true
-              console.error('Field not found: ' + fieldSchema.options.label)
+          } else {
+            // 不同子表单或在聚合函数参数中，使用全部明细行数据创建数组表达式
+            let dataTableRef = VFR.getWidgetRef(subFormNameOfField)
+            if (!dataTableRef) {
+              console.error('Subform not found: ' + subFormNameOfField);
+              quitFlag = true;
+              return;
             }
-          }else {
-            console.error('Invalid formula!')
+
+            const subFormValue = VFR.formDataModel[fieldKeyName(dataTableRef.widget)] || [];
+            const subFieldName = fieldKeyName(fieldSchema);
+
+            // 构建有效的数组表达式
+            let arrayExpr = '[';
+            subFormValue.forEach((vi, idx) => {
+              const val = vi[subFieldName] ?? null;
+              // 确保数值类型正确处理
+              if (val === null || val === undefined || val === '') {
+                arrayExpr += (idx === 0) ? '0' : ', 0';
+              } else if (typeof val === 'string' && !isNaN(Number(val))) {
+                arrayExpr += (idx === 0) ? Number(val) : ', ' + Number(val);
+              } else if (typeof val === 'number') {
+                arrayExpr += (idx === 0) ? val : ', ' + val;
+              } else {
+                arrayExpr += (idx === 0) ? '0' : ', 0';
+              }
+            });
+            arrayExpr += ']';
+
+            resultFormula = resultFormula.replaceAll(mi, arrayExpr);
           }
         } else {
           /* 在主表单字段的计算公式中使用子表单字段，应将子表单所有记录同字段的值代入！！ */
-          // const subFormValue = VFR.formDataModel[subFormNameOfField]
           let dataTableRef = VFR.getWidgetRef(subFormNameOfField)
           const subFormValue = VFR.formDataModel[fieldKeyName(dataTableRef.widget)]
           let allSubFieldValues = ''
-          // const subFieldName = fieldSchema.options.name
           const subFieldName = fieldKeyName(fieldSchema)
-          subFormValue.forEach((vi, idx) => {
-            let val = vi[subFieldName]??null
-            allSubFieldValues = (idx === 0) ? val : allSubFieldValues + ', ' + val
-          })
-          resultFormula = resultFormula.replaceAll(mi, allSubFieldValues)
+
+          // 对于聚合函数，创建数组表达式
+          let isInAggregationParam = false;
+          functionCalls.forEach(call => {
+            if (call.params.includes(mi)) {
+              isInAggregationParam = true;
+            }
+          });
+
+          if (isInAggregationParam) {
+            let arrayExpr = '[';
+            subFormValue.forEach((vi, idx) => {
+              const val = vi[subFieldName] ?? 0;
+              arrayExpr += (idx === 0) ? val : ', ' + val;
+            });
+            arrayExpr += ']';
+            resultFormula = resultFormula.replaceAll(mi, arrayExpr);
+          } else {
+            // 非聚合函数，使用逗号分隔的字符串
+            subFormValue.forEach((vi, idx) => {
+              let val = vi[subFieldName]??null
+              allSubFieldValues = (idx === 0) ? val : allSubFieldValues + ', ' + val
+            })
+            resultFormula = resultFormula.replaceAll(mi, allSubFieldValues)
+          }
         }
       }
     }
@@ -270,6 +369,17 @@ export function baseReplaceFieldsAndFunctionsOfFormula(VFR, formulaFieldRef, for
 
   return quitFlag ? null : resultFormula
 }
+// ... existing code ...
+
+
+function getFieldKeyName(widget) {
+    let o = widget.options.name;
+    return (widget.options.keyNameEnabled && widget.options.keyName) || o;
+}
+
+function funOtherHanlde(){
+
+}
 
 export function calculateFormula2(formulaStr, data, that) {
   if(!formulaStr)return