cloud-web-corejs 1.0.54-dev.389 → 1.0.54-dev.390

package/package.json

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

package/src/components/xform/form-designer/form-widget/dialog/baseFormulaDialog.vue

@@ -0,0 +1,962 @@
+<template>
+  <el-dialog
+    :visible.sync="formulaDialogVisible"
+    :title="i18nt('designer.hint.formulaSetting')"
+    custom-class="dialog-style list-dialog"
+    :close-on-click-modal="false"
+    :close-on-press-escape="false"
+    :destroy-on-close="true"
+    :append-to-body="true"
+    width="70%"
+    top="0px"
+    ref="colFormulaDialog"
+    @close="dialogClose"
+  >
+    <div class="cont">
+      <el-row>
+        <el-col :span="24">
+          <div class="editor">
+            <div class="editor-top">
+              <el-row>
+                <el-col :span="22">
+                  <div style="font-weight: bold">value =</div>
+                </el-col>
+                <!-- el-tag 模式 按钮 end -->
+                <el-col :span="2">
+                  <el-button size="small" @click="clearFormula" type="danger" plain>
+                    {{ i18nt("designer.hint.formulaClear") }}
+                  </el-button>
+                </el-col>
+              </el-row>
+              <div ref="cmRef" style="height: 83px; width: 100%"></div>
+            </div>
+            <!-- -->
+            <div class="editor-bottom">
+              <el-button
+                v-on:click="insertSymbol(item)"
+                size="default"
+                v-for="(item, idx) in operate"
+                :key="idx"
+              >
+                {{ item }}
+              </el-button>
+            </div>
+            <!-- -->
+          </div>
+        </el-col>
+      </el-row>
+      <el-row style="margin: 10px">
+        <el-col :span="6">
+          <div class="group-item-left">
+            <div class="item-header">
+              {{ i18nt("designer.hint.formulaWidgetList") }}
+            </div>
+            <el-input
+              :placeholder="i18nt('designer.hint.formulaSearch')"
+              v-model="filterText"
+              clearable
+            ></el-input>
+            <div class="item-body-left">
+              <el-tree
+                ref="fieldTree"
+                :data="fieldTreeData"
+                :filter-node-method="filterNode"
+                @node-click="insertField"
+              >
+                <template #default="{ node, data }">
+                  <span class="custom-tree-node">
+                    <el-tooltip effect="dark" :content="node.label" placement="right">
+                      <span>{{ node.label }}</span>
+                    </el-tooltip>
+                  </span>
+                </template>
+              </el-tree>
+            </div>
+          </div>
+        </el-col>
+        <el-col :span="6">
+          <el-row>
+            <el-col :span="24">
+              <div class="group-item-right-top">
+                <div class="item-header">
+                  {{ i18nt("designer.hint.formulaFunctionList") }}
+                </div>
+                <div class="function-list">
+                  <el-collapse v-model="funcActiveCollapseNames">
+                    <template v-for="(item, index) in funcList">
+                      <el-collapse-item
+                        :key="index"
+                        :title="i18nt(item.fClass)"
+                        :name="index"
+                        v-if="index < 2"
+                      >
+                        <div
+                          v-for="(info, i) in item.flist"
+                          :key="i"
+                          class="field-item"
+                          @click="insertFunction(info.fName + '(')"
+                          @mouseenter="
+                            showIntro(
+                              i18nt(info.fName),
+                              i18nt(item.fClass),
+                              i18nt(info.fIntro)
+                            )
+                          "
+                          v-on:mouseleave="resetIntro"
+                        >
+                          <span>{{ info.fName }}</span>
+                          <el-tag :type="getClass(info.fType)"
+                            >{{ i18nt(info.fType) }}
+                          </el-tag>
+                        </div>
+                      </el-collapse-item>
+                    </template>
+                  </el-collapse>
+                </div>
+              </div>
+            </el-col>
+          </el-row>
+        </el-col>
+        <el-col :span="12">
+          <div class="group-item-right-bottom">
+            <div class="item-header">{{ introTitle }}</div>
+            <div class="item-body-right-bottom">
+              <ul>
+                <li
+                  v-if="introduction.title !== ''"
+                  style="font-size: 16px; color: #0a5d7c"
+                >
+                  {{ introduction.title }}
+                </li>
+                <li>
+                  <div class="intro-content" v-html="introduction.content"></div>
+                </li>
+              </ul>
+            </div>
+          </div>
+        </el-col>
+      </el-row>
+    </div>
+    <div class="dialog-footer" slot="footer">
+      <el-button
+        @click="formulaDialogVisible = false"
+        class="button-sty"
+        icon="el-icon-close"
+      >
+        {{ i18nt("designer.hint.cancel") }}
+      </el-button>
+      <el-button
+        type="primary"
+        @click="saveFormula"
+        class="button-sty"
+        icon="el-icon-check"
+      >
+        {{ i18nt("designer.hint.confirm") }}
+      </el-button>
+    </div>
+  </el-dialog>
+</template>
+
+<script>
+import { basicSetup, EditorView } from "codemirror";
+import { javascript } from "@codemirror/lang-javascript";
+import { EditorState } from "@codemirror/state";
+import i18n from "@base/components/xform/utils/i18n";
+import {
+  deepClone,
+  getAllContainerWidgets,
+  getAllFieldWidgets,
+  getFieldWidgetById,
+  traverseFieldWidgetsOfContainer,
+  loopHandleWidget,
+  traverseAllWidgetsNew,
+} from "@base/components/xform/utils/util";
+import {
+  placeholders,
+  baseTheme,
+  formulas,
+  FORMULA_REG_EXP,
+} from "@base/components/xform/utils/formula-util";
+
+export default {
+  name: "formula-editor",
+  mixins: [i18n],
+  components: {},
+  props: {
+    option: Object,
+  },
+  computed: {
+    formulaForView() {
+      const matchResult = this.formula.match(FORMULA_REG_EXP);
+      if (!matchResult) {
+        return this.formula;
+      }
+
+      let resultFormula = this.formula;
+      matchResult.forEach((mi) => {
+        const secondPart = mi.split(".")[1];
+        resultFormula = resultFormula.replaceAll(mi, secondPart);
+      });
+
+      return resultFormula;
+    },
+  },
+  watch: {
+    filterText(val) {
+      this.$refs.fieldTree.filter(val);
+    },
+  },
+  data() {
+    return {
+      codeMirror: null,
+      formula: "",
+      tags: [], // 公式页签集合
+      fieldTreeData: [], // 设计器字段树
+      filterText: "",
+      formulaDialogVisible: true,
+      operate: ["+", "-", "*", "/", "!=", "==", "<", ">", "<=", ">=", "(", ")", ","],
+      insertNum: 0,
+      insertStr: "",
+      activeNames: ["1"],
+      widgetSizes: [
+        {
+          label: this.i18nt("designer.hint.formulaSizeLarge"),
+          value: "large",
+        },
+        {
+          label: this.i18nt("designer.hint.formulaSizeMedium"),
+          value: "default",
+        },
+        {
+          label: this.i18nt("designer.hint.formulaSizeSmall"),
+          value: "small",
+        },
+        {
+          label: this.i18nt("designer.hint.formulaSizeMini"),
+          value: "small",
+        },
+      ],
+      introTitle: this.i18nt("designer.hint.formulaFunctionExplain"),
+      introduction: {
+        title: this.i18nt("designer.hint.formulaPleaseSelect"),
+        content:
+          '<span class="cg">' +
+          this.i18nt("designer.hint.formulaSample") +
+          '：</span><span class="fname">SUM</span><span class="cg">(</span><span class="cs">' +
+          this.i18nt("designer.hint.formulaPara") +
+          '1</span><span class="cg">,</span><span class="cs">' +
+          this.i18nt("designer.hint.formulaPara") +
+          '2</span><span class="cg">)</span>',
+      },
+      funcList: formulas,
+      funcActiveCollapseNames: [0],
+
+      targetFormTemplate: null,
+      targetFormJson: null,
+    };
+  },
+  created() {
+    this.editFormula();
+  },
+  mounted() {},
+  methods: {
+    dialogClose() {
+      this.formulaDialogVisible = false;
+      this.$emit("update:visiable", false);
+    },
+    clearFormula(event) {
+      this.formula = ""; //CodeMirror 模式
+      this.tags = []; //el-tag模式
+      this.codeMirror.dispatch({
+        changes: { from: 0, to: this.codeMirror.state.doc.length, insert: "" },
+      });
+    },
+
+    /** 删除字符串str中的第n个subStr
+     * @param {Object} str
+     * @param {Object} subStr
+     * @param {Object} n
+     */
+    deleteChar(str, subStr, n) {
+      let num = -1;
+      return str.replace(/a/g, (item) => {
+        num++;
+        return num === n ? "" : item;
+      });
+    },
+
+    filterNode(value, data) {
+      if (!value) return true;
+      return data.label.indexOf(value) !== -1;
+    },
+    handleTableConfigData(widget, callback) {
+      callback(widget);
+    },
+    initFields() {
+      let option = this.option;
+      let formCode = option.formCode;
+      if (formCode) {
+        this.getReportTemplate(formCode, () => {
+          this.loadFieldListToTree();
+        });
+      }
+    },
+    initHandleFields() {
+      let option = this.option;
+      let formWidgetNames = option.formWidgetNames || [];
+      let itemWidgets = option.itemWidgets || [];
+      let tableWidgetNames = itemWidgets.map((item) => item.widgetName);
+
+      let tableWidgetMap0 = itemWidgets.map((item) => {
+        return {
+          [item.widgetName]: item.columnWidgetNames,
+        };
+      });
+
+      let formWidgetMap = {};
+      let tableWidgetMap = itemWidgets.map((item) => {
+        let columnWidgetMap = {};
+        item.columnWidgetNames.forEach((columnWidgetName) => {
+          return (columnWidgetMap[columnWidgetName] = null);
+        });
+        return {
+          [item.widgetName]: {
+            tableWidget: null,
+            columnWidgetMap,
+          },
+        };
+      });
+
+      traverseAllWidgetsNew(this.targetFormJson.widgetList, (widget, pWidget) => {
+        if (pWidget && pWidget.type === "data-table") {
+          if (tableWidgetNames.includes(pWidget.options.name)) {
+            let tableItems = tableWidgetMap0[pWidget.options.name];
+            if (
+              widget.formItemFlag &&
+              widget.options.label &&
+              tableItems.includes(widget.options.label)
+            ) {
+              tableWidgetMap[pWidget.options.name].columnWidgetMap[
+                widget.options.label
+              ] = widget;
+            }
+            tableWidgetMap[pWidget.options.name].tableWidget = widget;
+          }
+          formWidgetNames.push(widget.widgetName);
+          itemWidgets.push(widget);
+        } else if (
+          widget.formItemFlag &&
+          widget.options.label &&
+          formWidgetNames.includes(widget.options.label)
+        ) {
+          formWidgetMap[widget.options.label] = widget;
+        }
+      });
+    },
+    async getReportTemplate(formCode, callback) {
+      let url, data;
+      url = USER_PREFIX + `/formTemplate/getByFormCode`;
+      data = { stringOne: formCode };
+      await this.$http({
+        // aes: true,
+        url: url,
+        method: `post`,
+        data: data,
+        isLoading: true,
+        // loadingTarget: document.body,
+        // modalStrictly: true,
+        success: async (res) => {
+          let formTemplate = res.objx || {};
+          this.targetFormTemplate = formTemplate;
+          this.targetFormJson = formTemplate.formViewContent
+            ? JSON.parse(formTemplate.formViewContent)
+            : {};
+          callback && callback();
+        },
+      });
+    },
+    getTargetWidgetList() {
+      let widgetList = this.targetFormJson.widgetList;
+      return widgetList;
+    },
+    loadFieldListToTree() {
+      let option = this.option;
+      let formWidgetNames = option.formWidgetNames || [];
+      let itemWidgets = option.itemWidgets || [];
+      let tableWidgetNames = itemWidgets.map((item) => item.widgetName);
+      let tableWidgetMap = {};
+      itemWidgets.forEach((item) => {
+        tableWidgetMap[item.widgetName] = item.columnWidgetNames;
+      });
+
+      this.fieldTreeData.length = 0; //先清空
+
+      let widgetList = this.getTargetWidgetList();
+
+      const allFields = getAllFieldWidgets(widgetList);
+      const allContainers = getAllContainerWidgets(widgetList);
+
+      const subFormArray = [];
+      let sfFieldArray = [];
+      const subFormFieldMap = {};
+
+      //获取子表单容器内部的字段
+      allContainers.forEach((con) => {
+        if (con.type === "data-table") {
+          if (tableWidgetNames.includes(con.container.options.name)) {
+            subFormArray.push(con.container);
+            const tmpFieldArray = [];
+            const fwHandler = (fw) => {
+              /* if (!!fw.formItemFlag && fw.type === "number") {
+                tmpFieldArray.push(fw);
+              } */
+              if (tableWidgetMap[con.container.options.name]?.includes(fw.options.name)) {
+                tmpFieldArray.push(fw);
+              }
+            };
+
+            // this.traverseFieldWidgetsOfTableDataWidget(con.container, fwHandler);
+            traverseFieldWidgetsOfContainer(con.container, fwHandler);
+            subFormFieldMap[con.container.options.name] = tmpFieldArray;
+            sfFieldArray = sfFieldArray.concat(tmpFieldArray);
+          }
+        }
+      });
+
+      //加载到树形组件数据对象
+      allFields.forEach((fld) => {
+        let flag1 = !sfFieldArray.find((item) => item.id === fld.field.id);
+        let flag2 =
+          fld.field.options.label && formWidgetNames.includes(fld.field.options.name);
+        let flag = flag2;
+        if (flag) {
+          //排除子表单字段
+          const fieldNode = {
+            id: fld.field.id,
+            name: fld.field.options.name,
+            label: fld.field.options.label,
+            type: fld.field.type,
+            formItemFlag: true,
+          };
+          this.fieldTreeData.push(fieldNode);
+        }
+      });
+
+      subFormArray.forEach((sf) => {
+        const subFormNode = {
+          id: sf.id,
+          name: sf.options.name,
+          label: sf.options.label || sf.options.name,
+          type: sf.type,
+          formItemFlag: false,
+          children: [],
+        };
+
+        subFormFieldMap[sf.options.name].forEach((fld) => {
+          const fieldNode = {
+            id: fld.id,
+            name: fld.options.name,
+            label: fld.options.label,
+            type: fld.type,
+            formItemFlag: true,
+          };
+          subFormNode.children.push(fieldNode);
+        });
+
+        this.fieldTreeData.push(subFormNode);
+      });
+    },
+
+    // 插入字段
+    insertField(obj, node, self) {
+      if (!!obj.formItemFlag) {
+        let fieldId = obj.id + "";
+        let fieldLabel = "[" + obj.label + "]";
+        this.updateCodeMirror(fieldId, fieldLabel, "field");
+      }
+    },
+
+    // 插入符号
+    insertSymbol(opt) {
+      this.updateCodeMirror(opt, opt, null);
+    },
+
+    // 插入函数
+    insertFunction(opt) {
+      const val = opt.substring(0, opt.length - 1);
+      this.updateCodeMirror(val, val, "func");
+    },
+
+    updateCodeMirror(field, text, type = null) {
+      if (type) {
+        let obj = {
+          field: field,
+          text: text,
+          type: type,
+        };
+        let selectionLet = obj.field.length + obj.text.length + obj.type.length; //光标位置；
+        let code = `{{${obj.field}.${obj.text}.${obj.type}}}`;
+        if (type === "func") {
+          code += "()";
+          selectionLet = selectionLet + 7;
+        } else {
+          selectionLet = selectionLet + 6;
+        }
+
+        if (code) {
+          this.codeMirror.dispatch({
+            changes: {
+              from: this.codeMirror.state.selection.main.head,
+              to: this.codeMirror.state.selection.main.head,
+              insert: code,
+            },
+            selection: {
+              anchor: this.codeMirror.state.selection.main.head + selectionLet,
+            },
+          });
+        }
+      } else {
+        this.codeMirror.dispatch({
+          changes: {
+            from: this.codeMirror.state.selection.main.head,
+            to: this.codeMirror.state.selection.main.head,
+            insert: text,
+          },
+          selection: {
+            anchor: this.codeMirror.state.selection.main.head + text.length,
+          },
+        });
+      }
+    },
+
+    // 在字符串中查找[开始]结尾的字符串，并删除
+    removeStr(str) {
+      let a = str.indexOf("[");
+      if (a === -1) {
+        return str;
+      }
+      let b = str.indexOf("]", a) + 1;
+      let c = str.substring(a, b);
+      let strArr = str.split(c);
+      let newStr = "";
+      for (let i = 0; i < strArr.length; i++) {
+        newStr += strArr[i];
+      }
+      return this.removeStr(newStr);
+    },
+    extractFieldNames(formula) {
+      if (!formula) return [];
+      const fieldArray = [];
+      let tempFormula = formula;
+
+      // 循环查找所有 [字段名] 格式的引用
+      while (true) {
+        const startIndex = tempFormula.indexOf("[");
+        if (startIndex === -1) {
+          break; // 没有更多字段引用了
+        }
+
+        const endIndex = tempFormula.indexOf("]", startIndex);
+        if (endIndex === -1) {
+          break; // 格式不正确，没有匹配的右括号
+        }
+
+        // 提取字段名（不包含方括号）
+        const fieldName = tempFormula.substring(startIndex + 1, endIndex);
+
+        // 避免重复添加相同的字段名
+        if (!fieldArray.includes(fieldName)) {
+          fieldArray.push(fieldName);
+        }
+
+        // 从剩余部分继续查找
+        tempFormula = tempFormula.substring(endIndex + 1);
+      }
+
+      return fieldArray;
+    },
+    /**
+     * 字段label可能在公式保存后再次被修改，当编辑公式时需要再次刷新公式中的字段label（不刷新也不会影响公式计算结果）
+     */
+    refreshFormula() {
+      const matchResult = this.option.formula?.match(FORMULA_REG_EXP);
+      if (!matchResult) {
+        return this.option.formula;
+      }
+
+      matchResult.forEach((mi) => {
+        const firstPart = mi.split(".")[0];
+        const secondPart = mi.split(".")[1];
+        const thirdPart = mi.split(".")[2];
+        const nodeType = thirdPart.substring(0, thirdPart.length - 2);
+        if (nodeType === "func") {
+          return;
+        }
+
+        const fieldId = firstPart.substring(2, firstPart.length);
+        const fieldSchema = getFieldWidgetById(
+          // this.designer.widgetList,
+          this.getTargetWidgetList(),
+          fieldId,
+          false
+        );
+        if (!!fieldSchema) {
+          const newLabel = fieldSchema.options.label || fieldSchema.options.name;
+          this.option.formula = this.option.formula.replace(
+            mi,
+            firstPart + ".[" + newLabel + "]." + thirdPart
+          );
+        } else {
+          this.$message.error(
+            this.i18nt("designer.hint.deletedFieldInFormula") + secondPart
+          );
+        }
+      });
+    },
+
+    // 打开编辑公式弹窗
+    editFormula() {
+      this.fieldTreeData.length = 0;
+      // 初始化字段树
+
+      // this.loadFieldListToTree();
+      this.initFields();
+
+      console.log("设计器字段===>", this.fieldTreeData);
+
+      // 加载当前字段计算公式tags
+      this.refreshFormula();
+      const code = this.formula;
+      this.formulaDialogVisible = true;
+
+      //==== codeMirror 挂载视图 ====
+      this.$nextTick(() => {
+        this.codeMirror = new EditorView({
+          state: EditorState.create({
+            doc: code,
+            extensions: [basicSetup, javascript(), [baseTheme, [], placeholders]],
+          }),
+          parent: this.$refs.cmRef,
+        });
+        console.log("编辑器实例==>", this.codeMirror);
+      });
+    },
+
+    // 保存计算公式
+    getFormulaForView(formula) {
+      const matchResult = formula?.match(FORMULA_REG_EXP);
+      if (!matchResult) {
+        return {
+          formula: formula,
+          showFormula: formula,
+        };
+      }
+
+      return {
+        showFormula: this.formulaForView,
+        formula: formula,
+      };
+    },
+    saveFormula() {
+      this.formula = this.codeMirror.state.doc.text.join("");
+      let resultObj = this.getFormulaForView(this.formula);
+      this.option.confirm && this.option.confirm(resultObj);
+      this.dialogClose();
+    },
+    getClass(type) {
+      if (type === this.i18nt("designer.hint.formulaNumber")) {
+        return "warning";
+      }
+      if (type === this.i18nt("designer.hint.formulaChar")) {
+        return "";
+      }
+      if (type === this.i18nt("designer.hint.formulaObject")) {
+        return "danger";
+      }
+    },
+
+    resetIntro() {
+      this.introTitle = this.i18nt("designer.hint.formulaFunctionExplain");
+      this.introduction = {
+        title: this.i18nt("designer.hint.formulaPleaseSelect"),
+        content:
+          '<span class="cg">' +
+          this.i18nt("designer.hint.formulaSample") +
+          '：</span><span class="fname">SUM</span><span class="cg">(</span><span class="cs">参数1</span><span class="cg">,</span><span class="cs">参数2</span><span class="cg">)</span>',
+      };
+    },
+
+    showIntro(name, title, content) {
+      content = '<span class="cg">' + content + "</span>";
+      this.introduction = {
+        title: title,
+        content: content,
+      };
+      this.introTitle = name;
+    },
+
+    /**
+     * 校验计算公式是否正确
+     * @param s
+     * @returns {boolean}
+     */
+    isValid(s) {
+      let a = []; //存储左括号出现的地方
+      let l = s.length;
+      let k = 0;
+      let flag = 1;
+      let j;
+      for (let i = 0; i < l && flag; i++) {
+        switch (s[i]) {
+          case "(":
+            a[k] = i;
+            k++;
+            break;
+          case ")":
+            j = a[k - 1];
+            if (s[j] === "(") {
+              a[k] = 0;
+              k--;
+            } else {
+              flag = 0;
+            }
+            break;
+          case "{":
+            a[k] = i;
+            k++;
+            break;
+          case "}":
+            j = a[k - 1];
+            if (s[j] === "{") {
+              a[k] = 0;
+              k--;
+            } else {
+              flag = 0;
+            }
+            break;
+          case "[":
+            a[k] = i;
+            k++;
+            break;
+          case "]":
+            j = a[k - 1];
+            if (s[j] === "[") {
+              a[k] = 0;
+              k--;
+            } else {
+              flag = 0;
+            }
+            break;
+        }
+      }
+      if (k !== 0) {
+        flag = 0;
+      }
+      return flag !== 0;
+    },
+  },
+};
+</script>
+
+<style lang="scss" scoped>
+:deep(.cm-editor) {
+  height: 100%;
+}
+
+li {
+  list-style: none;
+}
+
+/*去掉li前面的点*/
+.el-input-group {
+  cursor: pointer;
+}
+
+.header {
+  width: 97%;
+  border: 1px solid #ccc;
+  border-top-left-radius: 10px;
+  border-top-right-radius: 10px;
+  height: 31px;
+  line-height: 31px;
+  padding-left: 15px;
+}
+
+.editor {
+  margin-left: 10px;
+  margin-right: 10px;
+  height: 200px;
+  border: 1px solid #ccc;
+  border-radius: 6px;
+}
+
+.editor-top {
+  //margin-left: 10px;
+  height: 130px;
+  width: 100%;
+  padding: 8px;
+  position: relative;
+  overflow-x: hidden;
+  overflow-y: scroll;
+}
+
+.editor-bottom {
+  border-left: 1px solid #ccc;
+  display: flex;
+  flex-wrap: wrap;
+  padding: 5px;
+  align-content: flex-start;
+}
+
+.body-right-button {
+  width: 60px;
+  height: 40px;
+}
+
+.group-form {
+  margin-top: 15px;
+  display: flex;
+  justify-content: space-between;
+  height: 350px;
+}
+
+.group-item-left {
+  height: 350px;
+  border: 1px solid #ccc;
+  border-top-left-radius: 6px;
+  border-bottom-left-radius: 6px;
+  margin-bottom: 5px;
+  padding: 0;
+  width: 100%;
+}
+
+.group-item-right-top {
+  height: 350px;
+  border: 1px solid #ccc;
+  border-radius: 0;
+  margin-bottom: 5px;
+  width: 100%;
+}
+
+.group-item-right-bottom {
+  height: 350px;
+  border: 1px solid #ccc;
+  border-top-right-radius: 6px;
+  border-bottom-right-radius: 6px;
+  margin-bottom: 5px;
+  width: 100%;
+}
+
+.item-header {
+  border-bottom: 1px solid #ccc;
+  height: 29px;
+  line-height: 29px;
+  padding-left: 15px;
+  font-weight: bold;
+}
+
+.item-body-left {
+  height: 320px;
+  overflow-y: auto;
+}
+
+.function-list {
+  height: 320px;
+  overflow-y: auto;
+
+  :deep(.el-collapse-item__header) {
+    font-weight: normal !important;
+  }
+}
+
+.item-body-right-bottom {
+  height: 152px;
+  overflow-y: auto;
+}
+
+.el-collapse {
+  border: none;
+}
+
+:deep(.el-dialog) {
+  margin-top: 10px !important;
+}
+
+:deep(.el-collapse-item__header) {
+  padding-left: 10px;
+  border: none;
+}
+
+:deep(.el-collapse-item__wrap) {
+  border: none;
+}
+
+:deep(.el-collapse-item__arrow) {
+  margin-left: 8px;
+}
+
+.field-item {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  height: 32px;
+  padding-left: 30px;
+  padding-right: 15px;
+  cursor: pointer;
+}
+
+.field-item:hover {
+  background-color: #f8f8f8;
+}
+
+p::before {
+  content: "●  ";
+  color: #0a5d7c;
+}
+
+p {
+  height: 24px;
+  line-height: 24px;
+  padding: 0 15px;
+  font-size: 16px;
+  color: #0a5d7c;
+}
+
+.intro-content {
+  padding-left: 30px;
+}
+
+.cg {
+  color: #0a5d7c;
+}
+
+.fname {
+  display: inline-block;
+  border-radius: 2px;
+  padding: 0 5px;
+  margin: 1px;
+  font-size: 12px;
+  line-height: 20px;
+  color: #708;
+  background: #fff;
+}
+
+.cs {
+  display: inline-block;
+  border-radius: 2px;
+  padding: 0 5px;
+  margin: 1px;
+  color: #fff;
+  font-size: 12px;
+  line-height: 20px;
+  background: #178cdf;
+}
+
+:deep(.el-dialog__body) {
+  padding: 0;
+}
+
+.small-padding-dialog {
+  /* margin-top: 0px; */
+}
+</style>

package/src/components/xform/form-designer/form-widget/field-widget/fieldMixin.js

@@ -295,7 +295,7 @@ modules = {
                   if (searchDialogConfig.valueSourceField) valueSourceField = searchDialogConfig.valueSourceField
                   if (searchDialogConfig.labelSourceField) labelSourceField = searchDialogConfig.labelSourceField
                 }
-                this.setValue(userInfo[valueSourceField] ?? null);
+                this.initValue(userInfo[valueSourceField] ?? null);
                 this.setShowValue(userInfo[labelSourceField] ?? null);
               } else if (this.field.options.saleOrgDefaultVabSearch) {
                 let saleOrgDTO = this.getFormRef().getDefaultSaleOrgDTO();
@@ -306,7 +306,7 @@ modules = {
                     if (searchDialogConfig.valueSourceField) valueSourceField = searchDialogConfig.valueSourceField
                     if (searchDialogConfig.labelSourceField) labelSourceField = searchDialogConfig.labelSourceField
                   }
-                  this.setValue(saleOrgDTO[valueSourceField] ?? null);
+                  this.initValue(saleOrgDTO[valueSourceField] ?? null);
                   this.setShowValue(saleOrgDTO[labelSourceField] ?? null);
                 }
               }
@@ -314,12 +314,12 @@ modules = {
             if (!this.tableParam) {
               //主表
               if (this.isNotNullVal(defaultValue)) {
-                this.setValue(defaultValue);
+                this.initValue(defaultValue);
               }
             } else {
               //明细
               if (!this.tableParam.row.id && this.isNotNullVal(defaultValue)) {
-                this.setValue(defaultValue);
+                this.initValue(defaultValue);
               }
             }
           } else {
@@ -329,7 +329,7 @@ modules = {
             } else {
               //明细
               if (!this.tableParam.row.id && this.isNotNullVal(defaultValue)) {
-                this.setValue(defaultValue);
+                this.initValue(defaultValue);
               }
             }
           }
@@ -1341,6 +1341,19 @@ modules = {
     getFieldEditor: function () {
       return this.$refs["fieldEditor"];
     },
+    initValue: function (e) {
+        let value = e ?? null;
+        let currentData =
+          this.tableParam && this.tableParam.row
+            ? this.tableParam.row
+            : this.formModel;
+        if (void 0 === currentData[this.fieldKeyName]) {
+          this.$set(currentData, this.fieldKeyName, null);
+        }
+        this.fieldModel = value;
+        this.initFileList();
+        this.syncUpdateFormModel(value);
+    },
     setValue: function (e) {
       if (this.field.formItemFlag) {
         let value = e ?? null;

package/src/components/xform/form-render/index.vue

@@ -90,6 +90,11 @@
       :visiable.sync="formulaDialogVisible"
       :option="formulaDialogOption"
     ></formulaDialog>
+    <baseFormulaDialog
+      v-if="baseFormulaDialogVisible"
+      :visiable.sync="baseFormulaDialogVisible"
+      :option="baseFormulaDialogOption"
+    ></baseFormulaDialog>
   </div>
 </template>
 

package/src/components/xform/form-render/indexMixin.js

@@ -41,6 +41,7 @@ import '@base/components/xform/utils/directive'
 import html2Canvas from 'html2canvas'
 import JsPDF from 'jspdf'
 import formulaDialog from '@base/components/xform/form-designer/form-widget/dialog/formulaDialog.vue'
+import baseFormulaDialog from '@base/components/xform/form-designer/form-widget/dialog/baseFormulaDialog.vue'
 
 let modules = {};
 const baseRefUtil = {
@@ -69,7 +70,8 @@ const baseRefUtil = {
 modules = {
   componentName: 'VFormRender',
   components: {
-    formulaDialog
+    formulaDialog,
+    baseFormulaDialog
   },
   mixins: [baseRefUtil.emitter, baseRefUtil.i18n, scriptHttpMixin, defaultHandleMixin],
   props: {
@@ -203,7 +205,9 @@ modules = {
       showFileReferenceDialog:false,
 
       formulaDialogOption:null,
-      formulaDialogVisible:false
+      formulaDialogVisible:false,
+      baseFormulaDialogOption:null,
+      baseFormulaDialogVisible:false
     };
   },
   computed: {
@@ -3186,6 +3190,10 @@ let dom4 = clonedElement.querySelector(".designer-view")
     openFormulaDialog(option) {
       this.formulaDialogOption = option
       this.formulaDialogVisible = true;
+    },
+    openBaseFormulaDialog(option) {
+      this.baseFormulaDialogOption = option
+      this.baseFormulaDialogVisible = true;
     }
   }
 };

package/src/components/xform/mixins/defaultHandle.js

@@ -1,6 +1,7 @@
 import dayjs from "dayjs";
 import {
-  calculateFormula2
+  calculateFormula2,
+  baseCalculateFormula
 } from '@base/components/xform/utils/formula-util'
 
 let modules = {};
@@ -333,6 +334,9 @@ modules = {
     //2个数组的行号处理 end
     calculateFormula(formula,data){
       return calculateFormula2(formula, data, this)
+    },
+    baseCalculateFormula(formula){
+      return baseCalculateFormula(formula, this)
     }
 
   }

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

@@ -121,7 +121,122 @@ export function calculateFormula(VFR, DSV, formulaJs, formulaFieldRef, changedFi
   }
 
   const formulaValue = evalFn(formula, DSV, VFR, formulaJs)
-  formulaFieldRef.setValue(formulaValue)
+  if(formulaFieldRef)formulaFieldRef.setValue(formulaValue)
+  return formulaValue
+}
+
+export function baseCalculateFormula(formulaStr, data, that /* VFR, DSV, formulaJs, formulaFieldRef, changedFieldRef */) {
+
+  if(!formulaStr)return
+  let formula = formulaStr;
+  let VFR = that.getFormRef();
+  let DSV = that.getGlobalDsv()
+  let formulaJs = formulajs
+  let formulaFieldRef = that;
+  if (formulaFieldRef.tableParam) {
+  } else if (!!formulaFieldRef.subFormItemFlag && !!changedFieldRef.subFormItemFlag) {
+    /* 子表单字段变化，只能触发子表单同一行字段的计算公式重新计算！！ */
+    /* if (changedFieldRef.subFormRowId !== formulaFieldRef.subFormRowId) {
+      return
+    } */
+  }
+
+  formula = baseReplaceFieldsAndFunctionsOfFormula(VFR, formulaFieldRef,formula)  //替换字段值
+  if (!formula) {
+    return
+  }
+
+  //替换formula-js函数
+  const matchResult = formula.match(/[A-Za-z]*/g)
+  let matchedList = []
+  if (!!matchResult) {
+    matchResult.forEach(mi => {
+      if (!!mi && (findCalFunStartIndex(mi) !== -1) && !matchedList.includes(mi)) {
+        const funcName = mi.toUpperCase()
+        formula = formula.replaceAll(mi, 'formulaJs.' + funcName)
+        matchedList.push(mi)
+      }
+    })
+  }
+
+  const formulaValue = evalFn(formula, DSV, VFR, formulaJs)
+  return formulaValue
+}
+
+/**
+ * 替换计算公式中的字段值
+ * @param VFR
+ * @param formulaFieldRef
+ * @returns {*}
+ */
+export function baseReplaceFieldsAndFunctionsOfFormula(VFR, formulaFieldRef, formula) {
+  // let formula = formulaFieldRef.field.options.formula
+  const matchResult = formula.match(FORMULA_REG_EXP)
+  if (!matchResult) {
+    return formula
+  }
+
+  let resultFormula = formula
+  let quitFlag = false
+  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)
+      return
+    }
+
+    const firstPart = mi.split('.')[0]
+    const fieldId = firstPart.substring(2, firstPart.length)
+    const fieldSchema = getFieldWidgetById(VFR.formJsonObj.widgetList, fieldId, false)
+    if (!!fieldSchema) {
+      let fieldRef = VFR.getWidgetRef(fieldSchema.options.name)
+      if (!!fieldRef) {
+        //是否要考虑字符串值的替换？？
+        resultFormula = resultFormula.replace(mi, fieldRef.getValue())
+      } else {  //getWidgetRef找不到，则可能是子表单字段
+        const subFormNameOfField = VFR.getSubFormNameOfWidget(fieldSchema.options.name)
+        if (!!formulaFieldRef.subFormItemFlag || formulaFieldRef.tableParam) {
+          /* 如果当前计算字段是子表单字段，要判断公式中的子表单字段是否和当前计算字段是否属于同一子表单！！ */
+
+
+          if (subFormNameOfField === formulaFieldRef?.parentWidget?.options?.name) {
+            let subFormRowId = formulaFieldRef.tableParam.row._X_ROW_KEY
+            fieldRef = VFR.getWidgetRef(fieldSchema.options.name + '_' + subFormRowId)
+            if (!!fieldRef) {
+              resultFormula = resultFormula.replaceAll(mi, fieldRef.getValue())
+            } 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.getValue())
+            } else {
+              quitFlag = true
+              console.error('Field not found: ' + fieldSchema.options.label)
+            }
+          } else {
+            console.error('Invalid formula!')
+          }
+        } else {
+          /* 在主表单字段的计算公式中使用子表单字段，应将子表单所有记录同字段的值代入！！ */
+          const subFormValue = VFR.formDataModel[subFormNameOfField]
+          let allSubFieldValues = ''
+          // const subFieldName = fieldSchema.options.name
+          const subFieldName = fieldKeyName(fieldSchema)
+          subFormValue.forEach((vi, idx) => {
+            allSubFieldValues = (idx === 0) ? vi[subFieldName] : allSubFieldValues + ', ' + vi[subFieldName]
+          })
+          resultFormula = resultFormula.replaceAll(mi, allSubFieldValues)
+        }
+      }
+    }
+  })
+
+  return quitFlag ? null : resultFormula
 }
 
 export function calculateFormula2(formulaStr, data, that) {