@epxing/business 0.0.0-stage → 5.3.0-beta.2

package/dist/src/views/ExcelDesign.vue.js

@@ -0,0 +1,2165 @@
+import { mapGetters, mapState } from "vuex";
+const ADD_META = "ADD_META";
+const letterToNumber = (str) => {
+  let result = 0;
+  for (let i = 0; i < str.length; i++) {
+    const charCode = str.charCodeAt(i) - 65;
+    result = result * 26 + charCode;
+  }
+  return result;
+};
+const DEFAULT_ROW_NUM = 84;
+const DEFAULT_COLUMN_NUM = 60;
+const MAX_ROW_NUM = 5e3;
+const MAX_COLUMN_NUM = 1e3;
+const NumberToLetter = (num) => {
+  let result = "";
+  while (num > 0) {
+    const remainder = num % 26;
+    result = String.fromCharCode(65 + remainder) + result;
+    num = Math.floor(num / 26);
+  }
+  return result;
+};
+const _sfc_main = {
+  name: "epx-excel-design",
+  navConfigs: {
+    flag: false
+  },
+  data() {
+    return {
+      editName: false,
+      globalSetting: false,
+      formData: {},
+      activeCell: null,
+      // 表格行列数（与 luckysheet 当前 sheet 保持同步，随内容一起存入 CONTENT）
+      gridSize: {
+        row: DEFAULT_ROW_NUM,
+        column: DEFAULT_COLUMN_NUM
+      },
+      // 右侧快捷加列
+      addColumnVisible: false,
+      addColumnNum: 10,
+      leftCellWay: "default",
+      topCellWay: "default",
+      relyCellWay: "default",
+      excelInfo: {},
+      dataSource: [],
+      dataSourceModal: false,
+      setting: {
+        height: 500
+      },
+      dataSourceInfo: {},
+      linkEntityTree: [],
+      allFields: [],
+      fields: [],
+      defaultExpandKey: [],
+      defaultProps: {
+        children: "children",
+        label: "text"
+      },
+      initCondition: [],
+      searchParams: [],
+      formParam: {},
+      formParams: [],
+      formParamModal: false,
+      editFormParamId: "",
+      showFormParamsDialog: false,
+      previewParams: {},
+      isImportExcel: false,
+      showFilterConditionDialog: false,
+      filterConditionForm: {},
+      editFilterConditionIndex: null,
+      showConditionPropertyItemDialog: false,
+      conditionPropertyItems: [],
+      showConditionPropertyItemNameDialog: false,
+      conditionPropertyItemNameForm: {},
+      currentConditionPropertyItem: {},
+      showConditionPropertyItemConditionDialog: false,
+      conditionPropertyItemConditionForm: {},
+      fieldRelation: [],
+      watermarkFieldsConfigs: [],
+      otherFieldsConfigs: [],
+      processParams: [],
+      searchText: "",
+      showLogField: false,
+      showSubField: true,
+      currentLanguage: this.defaultLanguage,
+      languageContent: {},
+      showMultiValueDialog: false,
+      entityDataMap: {},
+      printChecks: [],
+      checkRuleDialog: false,
+      editingCheckIndex: -1,
+      checkRuleForm: {
+        name: "",
+        expression: "",
+        errorInfo: "",
+        enable: true
+      },
+      formulaDialog: false
+    };
+  },
+  computed: {
+    ...mapState({
+      systemVariableList: (state) => state.config.systemVariableList,
+      // 当前导航菜单
+      showMenu: (state) => state.config.showMenu,
+      showAppNav: (state) => state.config.showAppNav
+    }),
+    ...mapGetters(["getMetaViewFields"]),
+    // 父格/依赖格下拉的列名，跟随表格实际列数
+    columnList() {
+      const len = Math.max(this.gridSize.column || 0, DEFAULT_COLUMN_NUM);
+      return new Array(len).fill(0).map((item, index) => this.NumToString(index + 1));
+    },
+    // 父格/依赖格下拉的行号，跟随表格实际行数
+    rowList() {
+      const len = Math.max(this.gridSize.row || 0, 500);
+      return new Array(len).fill(0).map((item, index) => index + 1 + "");
+    },
+    variableTree() {
+      return [{
+        value: "customParams",
+        type: "folder",
+        name: "自定义参数",
+        children: this.formParams.map((item) => ({
+          ...item,
+          name: item.NAME,
+          value: item.CODE
+        }))
+      }, {
+        value: "systemVariable",
+        type: "folder",
+        name: "系统变量",
+        children: this.systemVariableList
+      }, {
+        value: "processParams",
+        type: "folder",
+        name: "流程参数",
+        children: this.processParams
+      }];
+    },
+    conditionPropertyItemConditionFormLeft: {
+      get() {
+        return this.conditionPropertyItemConditionForm.left ? JSON.stringify({
+          el: `#{${this.conditionPropertyItemConditionForm.left}}`,
+          elText: this.conditionPropertyItemConditionForm.left
+        }) : "";
+      },
+      set(v) {
+        if (v) {
+          const regExp = /#\{(.+)\}/g;
+          const el = JSON.parse(v).el;
+          const expression = regExp.exec(el)[1];
+          this.conditionPropertyItemConditionForm.left = expression;
+        } else {
+          this.conditionPropertyItemConditionForm.left = "";
+        }
+      }
+    },
+    activeCellExpression: {
+      get() {
+        return this.activeCell.v ? JSON.stringify({
+          el: `#{${this.activeCell.v}}`,
+          elText: this.activeCell.v
+        }) : "";
+      },
+      set(v) {
+        if (v) {
+          const regExp = /#\{(.+)\}/g;
+          const el = JSON.parse(v).el;
+          const expression = regExp.exec(el)[1];
+          this.activeCell.v = expression;
+        } else {
+          this.activeCell.v = "";
+        }
+      }
+    },
+    ruleVariableTree() {
+      return [{
+        value: "datasoure",
+        type: "folder",
+        text: "表单数据源",
+        children: this.dataSource.map((item) => ({
+          ...item,
+          text: item.name
+        }))
+      }];
+    },
+    leftCellColumn: {
+      get() {
+        const {
+          leftCell
+        } = this.activeCell;
+        if (leftCell === "root") {
+          return "无";
+        }
+        if (leftCell) {
+          const arr = /^([A-Z]*)(\d*)$/.exec(leftCell);
+          return arr[1] || "";
+        }
+        return "";
+      },
+      set(v) {
+        if (v === "root") {
+          this.activeCell.leftCell = v;
+        } else {
+          this.activeCell.leftCell = v + this.leftCellRow;
+        }
+      }
+    },
+    leftCellRow: {
+      get() {
+        const {
+          leftCell
+        } = this.activeCell;
+        if (leftCell && leftCell !== "root") {
+          const arr = /^([A-Z]*)(\d*)$/.exec(leftCell);
+          return arr[2] || "";
+        }
+        return "";
+      },
+      set(v) {
+        this.activeCell.leftCell = this.leftCellColumn + v;
+        this.activeCell.leftCell = this.leftCellColumn + v;
+      }
+    },
+    topCellColumn: {
+      get() {
+        const {
+          topCell
+        } = this.activeCell;
+        if (topCell === "root") {
+          return "无";
+        }
+        if (topCell && topCell !== "root") {
+          const arr = /^([A-Z]*)(\d*)$/.exec(topCell);
+          return arr[1] || "";
+        }
+        return "";
+      },
+      set(v) {
+        if (v === "root") {
+          this.activeCell.topCell = v;
+        } else {
+          this.activeCell.topCell = v + this.topCellRow;
+        }
+      }
+    },
+    topCellRow: {
+      get() {
+        const {
+          topCell
+        } = this.activeCell;
+        if (topCell && topCell !== "root") {
+          const arr = /^([A-Z]*)(\d*)$/.exec(topCell);
+          return arr[2] || "";
+        }
+        return "";
+      },
+      set(v) {
+        this.activeCell.topCell = this.topCellColumn + v;
+      }
+    },
+    relyCellColumn: {
+      get() {
+        const {
+          relyCell
+        } = this.activeCell;
+        if (relyCell === "root") {
+          return "无";
+        }
+        if (relyCell && relyCell !== "root") {
+          const arr = /^([A-Z]*)(\d*)$/.exec(relyCell);
+          return arr[1] || "";
+        }
+        return "";
+      },
+      set(v) {
+        if (v === "root") {
+          this.activeCell.relyCell = v;
+        } else {
+          this.activeCell.relyCell = v + this.relyCellRow;
+        }
+      }
+    },
+    relyCellRow: {
+      get() {
+        const {
+          relyCell
+        } = this.activeCell;
+        if (relyCell && relyCell !== "root") {
+          const arr = /^([A-Z]*)(\d*)$/.exec(relyCell);
+          return arr[2] || "";
+        }
+        return "";
+      },
+      set(v) {
+        this.activeCell.relyCell = this.relyCellColumn + v;
+      }
+    },
+    objectFieldList() {
+      const {
+        dataSource
+      } = this.activeCell || {};
+      if (dataSource) {
+        const item = this.dataSource.find((item2) => item2.id === dataSource) || {};
+        if (item && item.children[0]) {
+          return item.children[0].children;
+        }
+      }
+      return [];
+    },
+    defineDynamicParams() {
+      return this.formParams.map((item) => ({
+        id: "${" + item.CODE + "}",
+        name: item.NAME
+      }));
+    },
+    sortFields: {
+      get() {
+        let {
+          SORT = "[]"
+        } = this.dataSourceInfo;
+        if (SORT === "undefined" || SORT === "" || SORT === null) SORT = "[]";
+        return JSON.parse(SORT);
+      },
+      set(v) {
+        this.dataSourceInfo.SORT = JSON.stringify(v);
+      }
+    },
+    groupSortFields: {
+      get() {
+        let {
+          GROUP_ORDER_FIELD = ""
+        } = this.dataSourceInfo;
+        if (GROUP_ORDER_FIELD === "undefined" || GROUP_ORDER_FIELD === "" || GROUP_ORDER_FIELD === null) GROUP_ORDER_FIELD = "";
+        return GROUP_ORDER_FIELD;
+      },
+      set(v) {
+        this.dataSourceInfo.GROUP_ORDER_FIELD = v;
+      }
+    },
+    loadRelationEntity: {
+      get() {
+        return this.dataSourceInfo.LOAD_RELATION_ENTITY || "1";
+      },
+      set(v) {
+        this.dataSourceInfo.LOAD_RELATION_ENTITY = v;
+      }
+    },
+    linkEntityCheckedKeys() {
+      const flags = this.dataSourceInfo.LINK_ENTITY;
+      return flags ? flags.split(",").filter(Boolean) : [];
+    },
+    linkEntityLabel() {
+      const keys = this.linkEntityCheckedKeys;
+      if (!keys.length) return "";
+      const titles = [];
+      const walk = (nodes) => {
+        if (!nodes) return;
+        nodes.forEach((node) => {
+          if (keys.includes(node.flag)) titles.push(node.title);
+          if (node.childrens) walk(node.childrens);
+        });
+      };
+      walk(this.linkEntityTree);
+      return titles.length ? titles.join(",") : this.dataSourceInfo["LINK_ENTITY#"] || "";
+    },
+    showDataSource() {
+      const formatFields = (fields) => {
+        return fields.filter((item) => {
+          if (!this.showLogField && ["ID", "LOG_C_TIME", "LOG_C_USER", "LOG_U_TIME", "LOG_U_USER"].includes(item.code)) {
+            return false;
+          }
+          if (!this.showSubField && (item.relationType === "1" || item.isSub)) {
+            return false;
+          }
+          if (item.children) {
+            item.children = formatFields(item.children);
+          }
+          return true;
+        });
+      };
+      return this.dataSource.map((item) => {
+        if (this.entityDataMap[item.id]) {
+          const fields = this.$_.cloneDeep(this.entityDataMap[item.id]);
+          item.children = formatFields(fields);
+        }
+        return item;
+      });
+    },
+    languageFlag() {
+      const {
+        LANGUAGE_FLAG: languageFlag
+      } = this.clientConfig;
+      return languageFlag;
+    },
+    defaultLanguage() {
+      const {
+        LANGUAGE_DEFAULT: defaultLanguage
+      } = this.clientConfig;
+      return defaultLanguage;
+    },
+    currentLanguageName() {
+      const language = this.languageList.find((item) => item.id === this.currentLanguage) || {};
+      return language.name || "默认";
+    },
+    languageList() {
+      const {
+        LANGUAGES: languages = "",
+        "LANGUAGES#": languageNames = ""
+      } = this.clientConfig;
+      if (!languages) return [];
+      const languageIdList = languages.split(",");
+      const languageNameList = languageNames.split(",");
+      const languageList = languageIdList.map((item, index) => ({
+        id: item,
+        name: languageNameList[index]
+      }));
+      return languageList;
+    },
+    getText() {
+      return (field) => {
+        const getLabel = (arr) => {
+          for (const item of arr) {
+            if ((item.linkCode || item.code) === field) return item.text;
+            if (item.children) {
+              const label = getLabel(item.children);
+              if (label) return label;
+            }
+          }
+        };
+        return getLabel(this.allFields) || field;
+      };
+    },
+    // 自定义校验公式编辑器的参数库：只取主数据源（无主则取第一个），按 数据源 → 对象 → 字段 组织成树。
+    // getEntityMetaView 返回的 children 是一层 type==='meta' 节点的扁平数组：
+    //   无 linkFlag 的 meta 节点为主对象（其 children 即主对象字段），有 linkFlag 的为关联对象。
+    // 变量规则：主对象字段 token = 字段编号；关联对象字段 token = 关联标识符大写_字段编号。
+    checkParamList() {
+      const source = this.dataSource.find((item) => item.isMain) || this.dataSource[0];
+      if (!source || !source.children || !source.children.length) return [];
+      const bare = (v) => String(v == null ? "" : v).split("|").pop();
+      const toField = (f, prefix) => ({
+        code: prefix ? `${prefix}_${bare(f.code)}` : bare(f.code),
+        text: f.text || f.name,
+        type: f.dataType || "string"
+      });
+      const objects = [];
+      source.children.forEach((node) => {
+        if (node.type !== "meta") return;
+        const flag = bare(node.linkFlag || node.flag).toUpperCase();
+        const leaves = (node.children || []).filter((f) => f.type !== "meta" && bare(f.code));
+        if (!leaves.length) return;
+        if (flag) {
+          objects.push({
+            code: flag,
+            text: node.text || node.name,
+            type: "object",
+            children: leaves.map((f) => toField(f, flag))
+          });
+        } else {
+          objects.unshift({
+            code: node.code || "MAIN",
+            text: node.text || node.name,
+            type: "object",
+            children: leaves.map((f) => toField(f, ""))
+          });
+        }
+      });
+      if (!objects.length) return [];
+      return [{
+        code: source.sourceId || source.key,
+        text: source.name,
+        children: objects
+      }];
+    }
+  },
+  watch: {
+    activeCell: {
+      handler: function(v, oldVal) {
+        const {
+          rowIndex,
+          columnIndex,
+          ...props
+        } = v;
+        if (this.leftCellWay === "default") props.leftCell = "";
+        if (this.topCellWay === "default") props.topCell = "";
+        if (this.relyCellWay === "default") props.relyCell = "";
+        if (props.cellType && props.cellType === "expression") {
+          props.m = props.v;
+        }
+        luckysheet.setCellValue(rowIndex, columnIndex, props);
+      },
+      deep: true
+    },
+    globalSetting(v) {
+      if (v) {
+        this.$nextTick(() => {
+          this.initTitleEditor();
+          setTimeout(() => {
+            this.initWatermarkEditor();
+          }, 500);
+        });
+      }
+    },
+    "dataSourceInfo.ENTITY": {
+      handler(v) {
+        if (v) {
+          const meta = this.metas[v];
+          if (!meta) {
+            this.$store.dispatch({
+              // 加回调
+              type: ADD_META,
+              metaId: v
+            }).then((data) => {
+              if (data) {
+                const relations = data.getRelations();
+                this.getAllFields(relations);
+              }
+            });
+          } else {
+            const relations = meta.getRelations();
+            this.getAllFields(relations);
+          }
+          this.getLinkEntityTree(v);
+        } else {
+          this.linkEntityTree = [];
+        }
+      },
+      deep: true
+    },
+    "formData.WATER_MARK_TYPE"(v) {
+      if (v === "text") {
+        this.$nextTick(() => {
+          this.initWatermarkEditor();
+        });
+      }
+    },
+    searchText(v) {
+      if (this.timer) {
+        this.timer = null;
+        clearTimeout(this.timer);
+      }
+      this.timer = setTimeout(() => {
+        this.$refs.fieldTree.filter(this.searchText);
+        clearTimeout(this.timer);
+        this.timer = null;
+      }, 200);
+    },
+    showLogField() {
+      this.$nextTick(() => {
+        this.$refs.fieldTree.filter(this.searchText);
+      });
+    },
+    showSubField() {
+      this.$nextTick(() => {
+        this.$refs.fieldTree.filter(this.searchText);
+      });
+    }
+  },
+  methods: {
+    backConfirm() {
+      this.saveContent();
+      let changeFlag = this.content !== this.initContent;
+      if (this.content && this.initContent) {
+        const content = JSON.parse(this.content)[0];
+        const initContent = JSON.parse(this.initContent)[0];
+        changeFlag = !this.$_.isEqual(content.celldata, initContent.celldata) || content.row !== initContent.row || content.column !== initContent.column;
+      }
+      if (!changeFlag) {
+        for (const key in this.languageContent) {
+          const content = this.languageContent[key] ? JSON.parse(this.languageContent[key])[0].celldata : null;
+          const initContent = this.initLanguageContent[key] ? JSON.parse(this.initLanguageContent[key])[0].celldata : null;
+          if (!this.$_.isEqual(content, initContent)) {
+            changeFlag = true;
+            break;
+          }
+        }
+      }
+      if (changeFlag) {
+        this.$confirm("检测到您当前的报表配置还未进行保存操作，点击保存按钮即可执行保存操作", "操作提示", {
+          confirmButtonText: "保存",
+          cancelButtonText: "不保存",
+          type: "warning"
+        }).then(() => {
+          this.saveExcelData(this.backPage);
+        }).catch(() => {
+          this.backPage();
+        });
+      } else {
+        this.backPage();
+      }
+    },
+    switchLanguage(v) {
+      if (this.currentLanguage === v) return;
+      this.$confirm("切换语种后，进入该语种报表内容配置页面，当前页面的配置内容可通过切换再次展示，继续操作请点击确认。", "操作提示", {
+        confirmButtonText: "确定",
+        cancelButtonText: "取消",
+        type: "warning"
+      }).then(() => {
+        this.saveContent();
+        this.currentLanguage = v;
+        const content = v === this.defaultLanguage ? this.content : this.languageContent[v];
+        const nullSheet = [{
+          name: "Sheet1",
+          index: 0,
+          order: 0,
+          status: 1,
+          celldata: []
+        }];
+        luckysheet.destroy();
+        this.createExcel(content ? JSON.parse(content) : nullSheet);
+      });
+    },
+    saveContent() {
+      const sheets = luckysheet.getluckysheetfile();
+      sheets[0].celldata = luckysheet.transToCellData(sheets[0].data);
+      const content = JSON.stringify(sheets);
+      if (!this.currentLanguage || this.currentLanguage === this.defaultLanguage) {
+        this.content = content;
+      } else {
+        this.languageContent[this.currentLanguage] = content;
+      }
+    },
+    filterNode(value, data) {
+      if (!value) return true;
+      return data.text && data.text.indexOf(value) !== -1;
+    },
+    $refeshData() {
+      this.createExcel();
+    },
+    getData() {
+      this.$http.get({
+        entityId: "FM_FORM",
+        id: this.$query.id
+      }).then((data) => {
+        this.excelInfo = data.data;
+        this.formData = {
+          ...data.data
+        };
+        const defaultValue = {
+          WATER_MARK_TYPE: "none",
+          WATER_MARK_LEAN: 40,
+          WATER_MARK_DENSITY: "2"
+        };
+        for (const key in defaultValue) {
+          if (!this.formData[key]) {
+            this.formData[key] = defaultValue[key];
+          }
+        }
+        this.oldFormData = {
+          ...this.formData
+        };
+        this.parsePrintCheck();
+        this.content = data.data.CONTENT;
+        this.languageContent = data.data.LANGUAGE_PARAM ? data.data.LANGUAGE_PARAM.CONTENT || {} : {};
+        this.initContent = data.data.CONTENT;
+        this.initLanguageContent = this.$_.cloneDeep(this.languageContent);
+        this.createExcel();
+      });
+    },
+    getFieldRelation() {
+      this.$http.$post({
+        action: "getFieldRelation",
+        entityId: "FM_ATTRIBUTE_RELATION",
+        metaId: this.$metaId
+      }).then((data) => {
+        this.fieldRelation = data.field_relation;
+      });
+    },
+    getFieldConfigs() {
+      this.$FieldFactory.createFields({
+        meta: this.$meta,
+        metaId: this.$metaId,
+        pageType: "EDIT",
+        fields: ["PRINT_PAGE_SIZE", "PRINT_PAGE_DIRECTION", "LEFT_MARGIN", "RIGHT_MARGIN", "TOP_MARGIN", "BOTTOM_MARGIN", "IS_PAGE_NUMBER", "PAGE_NUMBER_FORMAT", "PAGE_NUMBER_TOP", "PAGE_NUMBER_START", "PAGE_NUMBER_ALIGN"]
+      }).then((data) => {
+        this.fieldsConfigs = [...data];
+      });
+      this.$FieldFactory.createFields({
+        meta: this.$meta,
+        metaId: this.$metaId,
+        pageType: "EDIT",
+        defaultFieldConfigs: {
+          WATER_MARK_TYPE: {
+            value: "none"
+          },
+          WATER_MARK_LEAN: {
+            value: 40
+          },
+          WATER_MARK_DENSITY: {
+            value: "2"
+          }
+        },
+        fields: [{
+          attriName: "WATER_MARK_TYPE",
+          value: "none"
+        }, "WATER_MARK_PICTURE", "WATER_MARK_PIC_HEIGHT", "WATER_MARK_PIC_WIDTH", "WATER_MARK_TEXT", "WATER_MARK_FONT_SIZE", "WATER_MARK_FONT_COLOR", "WATER_MARK_FONT_BLOD", "WATER_MARK_LEAN", "WATER_MARK_SPARENCY", "WATER_MARK_DENSITY"]
+      }).then((data) => {
+        this.watermarkFieldsConfigs = [...data];
+      });
+      this.$FieldFactory.createFields({
+        meta: this.$meta,
+        metaId: this.$metaId,
+        pageType: "EDIT",
+        fields: [{
+          attriName: "PROCESS",
+          scopeParams: [{
+            field: "CATEGORY",
+            values: "1"
+          }]
+        }, "BUSINESS_KEY"]
+      }).then((data) => {
+        this.otherFieldsConfigs = [...data];
+      });
+    },
+    excelCoord(row, column) {
+      return this.NumToString(column + 1) + row;
+    },
+    async initTitleEditor() {
+      const that = this;
+      if (this.titleEditor) this.titleEditor.remove();
+      const editor = this.$refs.titleEditor;
+      await this.$util.usePlugin("tinymce");
+      globalThis.tinymce.init({
+        target: editor,
+        height: 80,
+        autoresize_min_height: 80,
+        plugins: "data",
+        menubar: false,
+        toolbar: false,
+        contextmenu: "data",
+        language: "zh_CN",
+        dataSource: this.dataSource,
+        statusbar: false,
+        content_style: "p {margin: 2px 0}",
+        promotion: false
+      }).then((editors) => {
+        this.titleEditor = editors[0];
+        if (this.titleEditor) {
+          const frame = this.titleEditor.iframeElement.contentWindow;
+          const editorContainer = frame.document.querySelector("body");
+          editorContainer.ondragover = (e) => {
+            e.preventDefault();
+          };
+          editorContainer.ondrop = (e) => {
+            const type = e.dataTransfer.getData("type");
+            if (type === "variable" || type === "process") {
+              const variableCode = e.dataTransfer.getData("variableCode");
+              const variableName = e.dataTransfer.getData("variableName");
+              const span = document.createElement("span");
+              span.contentEditable = "false";
+              span.setAttribute("data-name", "variable");
+              span.setAttribute("data-value", variableCode);
+              span.innerHTML = `<label>{${variableName}}</label>`;
+              if (e.target.innerHTML === '<br data-mce-bogus="1">') {
+                e.target.innerHTML = "";
+              }
+              e.target.appendChild(span);
+            } else {
+              const fieldId = e.dataTransfer.getData("fieldId");
+              const sourceName = e.dataTransfer.getData("sourceName") || "";
+              const fieldName = e.dataTransfer.getData("fieldName");
+              if (fieldId) {
+                const span = document.createElement("span");
+                span.contentEditable = "false";
+                span.setAttribute("data-name", "datasource");
+                span.setAttribute("data-datasource", sourceName);
+                span.setAttribute("data-field", fieldId);
+                span.innerHTML = `<label>{${sourceName}.${fieldName}}</label>`;
+                if (e.target.innerHTML === '<br data-mce-bogus="1">') {
+                  e.target.innerHTML = "";
+                }
+                e.target.appendChild(span);
+                const value = this.titleEditor.getContent();
+                that.formData = {
+                  ...that.formData,
+                  TITLE: value
+                };
+              } else {
+                return true;
+              }
+            }
+          };
+          this.titleEditor.setContent(this.formData.TITLE || "");
+        }
+      });
+    },
+    async initWatermarkEditor() {
+      const that = this;
+      const editor = this.$refs.watermarkEditor;
+      if (!editor) return;
+      if (this.watermarkEditor) this.watermarkEditor.remove();
+      await this.$util.usePlugin("tinymce");
+      globalThis.tinymce.init({
+        target: editor,
+        height: 80,
+        autoresize_min_height: 80,
+        plugins: "data",
+        menubar: false,
+        toolbar: false,
+        contextmenu: "data",
+        language: "zh_CN",
+        dataSource: [...this.dataSource, {
+          type: "variable",
+          name: "系统变量",
+          children: this.systemVariableList
+        }],
+        statusbar: false,
+        content_style: "p {margin: 2px 0}",
+        promotion: false
+      }).then((editors) => {
+        this.watermarkEditor = editors[0];
+        if (this.watermarkEditor) {
+          const frame = this.titleEditor.iframeElement.contentWindow;
+          const editorContainer = frame.document.querySelector("body");
+          editorContainer.ondragover = (e) => {
+            e.preventDefault();
+          };
+          editorContainer.ondrop = (e) => {
+            const type = e.dataTransfer.getData("type");
+            if (type === "variable" || type === "process") {
+              const variableCode = e.dataTransfer.getData("variableCode");
+              const variableName = e.dataTransfer.getData("variableName");
+              const span = document.createElement("span");
+              span.contentEditable = "false";
+              span.setAttribute("data-name", "variable");
+              span.setAttribute("data-value", variableCode);
+              span.innerHTML = `<label>{${variableName}}</label>`;
+              if (e.target.innerHTML === '<br data-mce-bogus="1">') {
+                e.target.innerHTML = "";
+              }
+              e.target.appendChild(span);
+            } else {
+              const fieldId = e.dataTransfer.getData("fieldId");
+              const sourceName = e.dataTransfer.getData("sourceName") || "";
+              const fieldName = e.dataTransfer.getData("fieldName");
+              if (fieldId) {
+                const span = document.createElement("span");
+                span.contentEditable = "false";
+                span.setAttribute("data-name", "datasource");
+                span.setAttribute("data-datasource", sourceName);
+                span.setAttribute("data-field", fieldId);
+                span.innerHTML = `<label>{${sourceName}.${fieldName}}</label>`;
+                if (e.target.innerHTML === '<br data-mce-bogus="1">') {
+                  e.target.innerHTML = "";
+                }
+                e.target.appendChild(span);
+                const value = this.watermarkEditor.getContent();
+                that.formData = {
+                  ...that.formData,
+                  WATER_MARK_TEXT: value
+                };
+              } else {
+                return true;
+              }
+            }
+          };
+          this.watermarkEditor.setContent(this.formData.WATER_MARK_TEXT || "");
+        }
+      });
+    },
+    NumToString(i) {
+      var s = "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z";
+      var sArray = s.split(" ");
+      if (i < 1) return "";
+      if (parseInt(i / 26 + "") === 0) return sArray[i % 26 - 1];
+      else {
+        if (i % 26 === 0) return this.NumToString(parseInt(i / 26 + "") - 1) + sArray[26 - 1];
+        else return sArray[parseInt(i / 26 + "") - 1] + sArray[i % 26 - 1];
+      }
+    },
+    getDataSource() {
+      const {
+        id
+      } = this.$query;
+      this.$http.list({
+        entityId: "FM_FORM_SOURCE",
+        "scope.FORM": id
+      }).then(async (data) => {
+        this.dataSource = data.entitys.map((item) => ({
+          key: item.ID,
+          id: item.ENTITY,
+          name: item.NAME,
+          loadRelationEntity: item.LOAD_RELATION_ENTITY,
+          isMain: item.IS_MAIN_SOUCE === "1",
+          root: true,
+          sourceId: item.ID
+        }));
+        for (let index = 0; index < data.entitys.length; index++) {
+          const item = data.entitys[index];
+          if (item.ENTITY) {
+            if (!this.entityDataMap[item.ID]) {
+              this.$store.dispatch({
+                type: ADD_META,
+                metaId: item.ENTITY
+              });
+              this.dataSource[index] = {
+                ...this.dataSource[index],
+                load: true
+              };
+              const entityData = await this.getAttribute(item, {
+                id: item.ENTITY,
+                name: item.NAME,
+                root: true,
+                sourceId: item.ID
+              });
+              this.entityDataMap[item.ID] = entityData;
+              this.dataSource[index] = {
+                ...this.dataSource[index],
+                children: entityData,
+                load: false
+              };
+            }
+          } else {
+            this.dataSource[index] = {
+              ...this.dataSource[index],
+              children: this.entityDataMap[item.ID]
+            };
+          }
+        }
+      });
+    },
+    getAttribute(item, source) {
+      const {
+        ENTITY,
+        ENTITY_VIEW,
+        LOAD_RELATION_ENTITY
+      } = item;
+      return this.$http.get({
+        action: "getEntityMetaView",
+        entityId: "FM_ENTITY_VIEW",
+        metaId: ENTITY,
+        metaViewId: ENTITY_VIEW,
+        allSub: LOAD_RELATION_ENTITY !== "0"
+      }).then((data) => {
+        if (data[0]) data[0].isMain = true;
+        const formatData = (arr) => {
+          arr.forEach((item2) => {
+            if (item2.type === "folder") item2.isMain = true;
+            item2.field = item2.linkCode || item2.code;
+            item2.relationSort = item2.relationType;
+            if (!item2.codeKey) item2.codeKey = item2.relatedEntity;
+            item2.id = item2.field;
+            item2.name = item2.text;
+            item2.meta = item2.meta ? item2.meta.id : "";
+            if (item2.type === "meta" && item2.relationType === "1") item2.isSub = true;
+            if (item2.children) formatData(item2.children);
+          });
+        };
+        formatData(data);
+        return data;
+      });
+    },
+    setFormName() {
+      this.$http.update({
+        entityId: "FM_FORM",
+        "bean.ID": this.excelInfo.ID,
+        "bean.NAME": this.excelInfo.NAME
+      }).then(() => {
+        this.editName = false;
+      }).catch((err) => {
+        this.$message.error(err.errorText);
+      });
+    },
+    updateForm() {
+      const params = {};
+      this.syncPrintCheck();
+      this.formData.TITLE = this.titleEditor.getContent();
+      if (this.watermarkEditor) this.formData.WATER_MARK_TEXT = this.watermarkEditor.getContent();
+      for (const key in this.formData) {
+        if (!key.includes("#")) {
+          params[`bean.${key}`] = this.formData[key];
+        }
+      }
+      delete params["bean.CONTENT"];
+      this.$http.update({
+        entityId: "FM_FORM",
+        "bean.ID": this.excelInfo.ID,
+        ...params
+      }).then(() => {
+        this.globalSetting = false;
+        this.$message.success("保存成功");
+        this.titleEditor.remove();
+        if (this.oldFormData.PROCESS !== this.formData.PROCESS) {
+          this.getProcessParams();
+        }
+        this.oldFormData = {
+          ...this.formData
+        };
+      }).catch((err) => {
+        this.$message.error(err.errorText);
+        this.titleEditor.remove();
+      });
+    },
+    globalSettingCancel() {
+      this.globalSetting = false;
+      this.titleEditor.remove();
+    },
+    // 从 formData.PRINT_CHECK 解析出规则列表
+    parsePrintCheck() {
+      const raw = this.formData.PRINT_CHECK;
+      let list = [];
+      if (raw) {
+        try {
+          const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+          if (Array.isArray(parsed)) {
+            list = parsed.map((item) => ({
+              name: item.name || "",
+              expression: item.expression || "",
+              errorInfo: item.errorInfo || "",
+              enable: item.enable !== false
+            }));
+          }
+        } catch (e) {
+          list = [];
+        }
+      }
+      this.printChecks = list;
+    },
+    // 把规则列表同步回 formData.PRINT_CHECK（随全局设置一起保存）
+    syncPrintCheck() {
+      this.formData.PRINT_CHECK = JSON.stringify(this.printChecks);
+    },
+    // 表达式预览：去掉 #{...} 外层包裹
+    exprPreview(expr) {
+      if (!expr) return "";
+      return String(expr).replace(/^#\{([\s\S]*)\}$/, "$1");
+    },
+    // 打开规则表单弹窗（index < 0 为新增）
+    openCheckRule(index) {
+      this.editingCheckIndex = index;
+      if (index >= 0) {
+        const r = this.printChecks[index];
+        this.checkRuleForm = {
+          name: r.name,
+          expression: r.expression,
+          errorInfo: r.errorInfo,
+          enable: r.enable
+        };
+      } else {
+        this.checkRuleForm = {
+          name: "自定义校验 " + (this.printChecks.length + 1),
+          expression: "",
+          errorInfo: "",
+          enable: true
+        };
+      }
+      this.checkRuleDialog = true;
+    },
+    // 确定规则表单
+    confirmCheckRule() {
+      const {
+        name,
+        expression
+      } = this.checkRuleForm;
+      if (!name || !name.trim()) {
+        this.$message.warning("请输入规则名");
+        return;
+      }
+      if (!expression || !expression.trim()) {
+        this.$message.warning("请配置校验表达式");
+        return;
+      }
+      const rule = {
+        name: name.trim(),
+        expression: expression.trim(),
+        errorInfo: (this.checkRuleForm.errorInfo || "").trim(),
+        enable: this.checkRuleForm.enable !== false
+      };
+      if (this.editingCheckIndex >= 0) {
+        this.printChecks.splice(this.editingCheckIndex, 1, rule);
+      } else {
+        this.printChecks.push(rule);
+      }
+      this.syncPrintCheck();
+      this.checkRuleDialog = false;
+    },
+    // 删除规则
+    deleteCheckRule(index) {
+      this.$confirm("确定删除该校验规则？", "提示", {
+        type: "warning"
+      }).then(() => {
+        this.printChecks.splice(index, 1);
+        this.syncPrintCheck();
+      }).catch(() => {
+      });
+    },
+    // 打开公式编辑器
+    openFormulaDialog() {
+      this.formulaDialog = true;
+    },
+    // 公式编辑器确定回填表达式
+    confirmFormula(payload) {
+      if (payload && payload.el) {
+        this.checkRuleForm.expression = payload.el;
+      }
+      this.formulaDialog = false;
+    },
+    openAddDataSourceModal() {
+    },
+    updateDataSourceInfo(v) {
+      this.dataSourceInfo = {
+        ...this.dataSourceInfo,
+        ...v
+      };
+    },
+    updateFormParam(v) {
+      this.formParam = {
+        ...this.formParam,
+        ...v
+      };
+    },
+    getAllFields(relations) {
+      const fields = this.getMetaViewFields(this.dataSourceInfo.ENTITY);
+      if (fields) {
+        this.allFields = fields;
+        this.defaultExpandKey = [fields[0].code];
+      } else {
+        this.$store.dispatch({
+          type: "ADD_META_VIEW_FIELDS",
+          metaId: this.dataSourceInfo.ENTITY
+        }).then((fields2) => {
+          this.allFields = fields2.filter((item) => item.relationType !== "1");
+          this.defaultExpandKey = [fields2[0].code];
+        });
+      }
+    },
+    addSortField(field) {
+      if (!field.leaf) return;
+      const code = field.linkCode || field.code;
+      const sortField = this.sortFields.find((item) => item.code === code);
+      if (!sortField) {
+        this.sortFields = [...this.sortFields, {
+          code,
+          text: field.text,
+          sort: "asc"
+        }];
+      }
+    },
+    addGroupSortField(field) {
+      if (!field.leaf) return;
+      const code = field.linkCode || field.code;
+      this.groupSortFields = code;
+    },
+    changeSort(field) {
+      const sortFieldIndex = this.sortFields.findIndex((item) => item.code === field.code);
+      if (sortFieldIndex !== -1) {
+        const sortField = this.sortFields.find((item) => item.code === field.code);
+        const sortFields = [...this.sortFields];
+        sortFields.splice(sortFieldIndex, 1, {
+          ...sortField,
+          sort: sortField.sort === "asc" ? "desc" : "asc"
+        });
+        this.sortFields = [...sortFields];
+      }
+    },
+    deleteSort(field) {
+      const sortFieldIndex = this.sortFields.findIndex((item) => item.code === field.code);
+      if (sortFieldIndex !== -1) {
+        const sortFields = [...this.sortFields];
+        sortFields.splice(sortFieldIndex, 1);
+        this.sortFields = [...sortFields];
+      }
+    },
+    deleteGroupSort(field) {
+      this.groupSortFields = "";
+    },
+    getLinkEntityTree(mainEntity) {
+      this.$http.$get({
+        entityId: "FM_ENTITY_RELATION",
+        action: "getAllEntityRelationTree",
+        mainEntity
+      }).then((data) => {
+        this.linkEntityTree = Array.isArray(data) ? data : data && data.data ? data.data : [];
+      }).catch(() => {
+        this.linkEntityTree = [];
+      });
+    },
+    onLinkEntityCheck() {
+      const tree = this.$refs.linkEntityTree;
+      if (!tree) return;
+      const checked = tree.getCheckedNodes();
+      this.dataSourceInfo.LINK_ENTITY = checked.map((item) => item.flag).join(",");
+      this.dataSourceInfo["LINK_ENTITY#"] = checked.map((item) => item.title).join(",");
+    },
+    formatSearchParams() {
+      const params = {};
+      this.searchParams.map((item, i) => {
+        if (i < this.searchParams.length - 1) {
+          params[`search.link${i + 1}`] = item.link || "and";
+        }
+        params[`search.leftBrace${i + 1}`] = item.leftBrace || "";
+        params[`search.field${i + 1}`] = "";
+        params[`search.value${i + 1}`] = item.value;
+        if (item.dateType) params[`search.dateType${i + 1}`] = item.dateType;
+        params[`search.attriName${i + 1}`] = (item.field || item.attriName).replace("#", "").replace(/\|/g, ".");
+        params[`search.relation${i + 1}`] = item.relation;
+        params[`search.realRelation${i + 1}`] = item.relation;
+        params[`search.realValue${i + 1}`] = item.realValue || item.value;
+        params[`search.rightBrace${i + 1}`] = item.rightBrace || "";
+        params[`search.metaId${i + 1}`] = this.$metaId;
+        params[`search.inputMode${i + 1}`] = item.inputMode || "";
+      });
+      params.size = this.searchParams.length;
+      return params;
+    },
+    dropDataSource(node, current, type, event) {
+      const str = this.showDataSource.reduce((str2, item, index) => str2 += item.sourceId + ":" + index + ",", "");
+      const params = {
+        action: "moveList",
+        entityId: "FM_FORM_SOURCE",
+        orderString: str
+      };
+      this.$http.$post(params).then((data) => {
+      });
+    },
+    allowDrop(draggingNode, dropNode, type) {
+      return draggingNode.data.root && dropNode.data.root && type !== "inner";
+    },
+    submitDataSource() {
+      const {
+        id
+      } = this.$query;
+      const {
+        ENTITY,
+        ENTITY_VIEW,
+        LINK_ENTITY,
+        NAME,
+        SORT,
+        GROUP_ORDER_FIELD,
+        IS_MAIN_SOUCE,
+        SUB_SOURCE,
+        DATA_SCOPE,
+        LOAD_RELATION_ENTITY
+      } = this.dataSourceInfo;
+      this.$http.save({
+        action: this.editDataSourceId ? "update" : "save",
+        entityId: "FM_FORM_SOURCE",
+        "bean.ID": this.editDataSourceId ? this.editDataSourceId : "",
+        "bean.FORM": id || "",
+        "bean.ENTITY": ENTITY || "",
+        "bean.ENTITY_VIEW": ENTITY_VIEW || "",
+        "bean.LINK_ENTITY": LINK_ENTITY || "",
+        "bean.NAME": NAME || "",
+        "bean.SORT": SORT || "",
+        "bean.GROUP_ORDER_FIELD": GROUP_ORDER_FIELD || "",
+        "bean.SUB_SOURCE": SUB_SOURCE || "",
+        "bean.DATA_SCOPE": DATA_SCOPE || "",
+        "bean.IS_MAIN_SOUCE": IS_MAIN_SOUCE || "0",
+        "bean.LOAD_RELATION_ENTITY": LOAD_RELATION_ENTITY || "1",
+        "bean.CLIENT": this.excelInfo.CLIENT,
+        "bean.SYSTEM": this.excelInfo.SYSTEM
+      }).then((data) => {
+        this.dataSourceModal = false;
+        this.searchParams = [];
+        this.dataSourceInfo = {};
+        const sourceId = this.editDataSourceId || data;
+        let index = -1;
+        if (!this.editDataSourceId) {
+          this.dataSource.push({
+            key: data,
+            id: ENTITY,
+            name: NAME,
+            loadRelationEntity: LOAD_RELATION_ENTITY,
+            root: true,
+            sourceId: data
+          });
+          index = this.dataSource.length - 1;
+        } else {
+          index = this.dataSource.findIndex((item) => item.sourceId === this.editDataSourceId);
+          if (index !== -1) {
+            if (NAME !== this.dataSource[index].name) {
+              this.dataSource.splice(index, 1, {
+                ...this.dataSource[index],
+                name: NAME
+              });
+            }
+            if (LOAD_RELATION_ENTITY !== this.dataSource[index].loadRelationEntity) {
+              this.getAttribute({
+                ENTITY,
+                ENTITY_VIEW,
+                LOAD_RELATION_ENTITY
+              }).then((entityData) => {
+                this.entityDataMap[sourceId] = entityData;
+                this.dataSource[index] = {
+                  ...this.dataSource[index],
+                  loadRelationEntity: LOAD_RELATION_ENTITY,
+                  children: entityData
+                };
+              });
+            }
+          }
+        }
+        if (ENTITY) {
+          if (!this.entityDataMap[sourceId]) {
+            this.$store.dispatch({
+              type: ADD_META,
+              metaId: ENTITY
+            });
+            this.getAttribute({
+              ENTITY,
+              ENTITY_VIEW,
+              LOAD_RELATION_ENTITY
+            }).then((entityData) => {
+              this.entityDataMap[sourceId] = entityData;
+              this.dataSource[index] = {
+                ...this.dataSource[index],
+                children: entityData
+              };
+            });
+          }
+        }
+        this.editDataSourceId = "";
+      }).catch((err) => {
+        this.$message.error(err.message);
+      });
+    },
+    clickDataSource(data) {
+      if (data.root) {
+        this.editDataSourceId = data.sourceId;
+      }
+    },
+    addDataSource() {
+      this.editDataSourceId = "";
+      this.searchParams = [];
+      this.dataSourceInfo = {};
+      this.fields = [];
+      this.dataSourceModal = true;
+    },
+    editDataSource(data) {
+      this.$http.get({
+        entityId: "FM_FORM_SOURCE",
+        id: this.editDataSourceId
+      }).then((data2) => {
+        if (data2 && data2.data) {
+          this.dataSourceInfo = {
+            ...data2.data
+          };
+        }
+        this.dataSourceModal = true;
+      }).catch(() => {
+        this.dataSourceModal = true;
+      });
+    },
+    deleteDataSource() {
+      if (!this.editDataSourceId) {
+        this.$message.error("请选择要删除的数据源");
+        return;
+      }
+      this.$http.removeMulti({
+        entityId: "FM_FORM_SOURCE",
+        ids: this.editDataSourceId
+      }).then((data) => {
+        if (data !== false) {
+          this.$message.success("删除成功");
+          const index = this.dataSource.findIndex((item) => item.sourceId === this.editDataSourceId);
+          if (index !== -1) {
+            this.dataSource.splice(index, 1);
+          }
+        } else {
+          this.$message.err("删除失败");
+        }
+      });
+    },
+    getFormParams() {
+      const {
+        id
+      } = this.$query;
+      this.$http.list({
+        entityId: "FM_FORM_PARAM",
+        "scope.FORM": id
+      }).then((data) => {
+        this.formParams = [...data.entitys];
+      });
+      if (this.systemVariableList.length === 0) {
+        this.$store.dispatch("GET_SYSTEM_VARIABLE");
+      }
+      this.getProcessParams();
+    },
+    getProcessParams() {
+      const {
+        id
+      } = this.$query;
+      this.$http.list({
+        action: "getProcessParam",
+        entityId: "FM_FORM",
+        id
+      }).then((data) => {
+        this.processParams = data.map((item) => {
+          if (item.childrens) item.children = item.childrens;
+          delete item.childrens;
+          return item;
+        });
+      });
+    },
+    saveFormParam() {
+      const {
+        id
+      } = this.$query;
+      const {
+        CODE,
+        NAME
+      } = this.formParam;
+      this.$http.save({
+        action: this.editFormParamId ? "update" : "save",
+        entityId: "FM_FORM_PARAM",
+        "bean.ID": this.editFormParamId ? this.editFormParamId : "",
+        "bean.FORM": id,
+        "bean.CODE": CODE,
+        "bean.CLIENT": this.excelInfo.CLIENT,
+        "bean.SYSTEM": this.excelInfo.SYSTEM,
+        "bean.NAME": NAME
+      }).then(() => {
+        this.formParamModal = false;
+        this.editFormParamId = "";
+        this.formParam = {};
+        this.getFormParams();
+      }).catch((err) => {
+        this.$message.error(err.message || err.msg || "处理失败");
+      });
+    },
+    addFormParam() {
+      this.editFormParamId = "";
+      this.formParam = {};
+      this.formParamModal = true;
+    },
+    editFormParam(param) {
+      this.editFormParamId = param.ID;
+      this.formParamModal = true;
+      this.formParam = {
+        ...param
+      };
+    },
+    deleteFormParam(param) {
+      this.$http.removeMulti({
+        entityId: "FM_FORM_PARAM",
+        ids: param.ID
+      }).then((data) => {
+        this.$message.success("删除成功");
+        this.getFormParams();
+      });
+    },
+    drag(e, data, node) {
+      if (node.parent) {
+        let parent = node.parent;
+        let nodeText = "";
+        while (parent.parent && parent.data.root !== true) {
+          if (!parent.data.isMain) {
+            nodeText = parent.data.text + "." + nodeText;
+          }
+          parent = parent.parent;
+        }
+        const field = {
+          sourceId: parent.data.id,
+          sourceName: parent.data.name,
+          fieldId: node.data.id,
+          fieldName: nodeText ? nodeText + node.data.text : node.data.text
+        };
+        for (const key in field) {
+          e.dataTransfer.setData(key, field[key]);
+          e.dataTransfer.dropEffect = "copy";
+          e.dataTransfer.effectAllowed = "copy";
+        }
+        this.dragField = field;
+      }
+    },
+    dragDataSource(node, e) {
+      if (node.data.root || node.data.type === "meta") return;
+      if (node.parent) {
+        let parent = node.parent;
+        let nodeText = "";
+        while (parent.parent && parent.data.root !== true) {
+          if (!parent.data.isMain) {
+            nodeText = parent.data.text + "." + nodeText;
+          }
+          parent = parent.parent;
+        }
+        const field = {
+          sourceId: parent.data.id,
+          sourceName: parent.data.name,
+          fieldId: node.data.id,
+          fieldName: nodeText ? nodeText + node.data.text : node.data.text
+        };
+        for (const key in field) {
+          e.dataTransfer.setData(key, field[key]);
+          e.dataTransfer.dropEffect = "copy";
+          e.dataTransfer.effectAllowed = "copy";
+        }
+        this.dragField = field;
+      }
+    },
+    dragVariableFn(e, data, node) {
+      e.dataTransfer.setData("type", data.type);
+      e.dataTransfer.setData("variableName", data.name);
+      e.dataTransfer.setData("variableCode", data.code);
+      e.dataTransfer.dropEffect = "copy";
+      e.dataTransfer.effectAllowed = "copy";
+      this.dragVariable = {
+        value: data.value,
+        name: data.name
+      };
+    },
+    dragProcessParamFn(e, data, node) {
+      e.dataTransfer.setData("type", data.type);
+      e.dataTransfer.setData("variableName", data.name);
+      e.dataTransfer.setData("variableCode", data.code);
+      e.dataTransfer.dropEffect = "copy";
+      e.dataTransfer.effectAllowed = "copy";
+      this.dragProcessParam = {
+        value: data.value,
+        name: data.name
+      };
+    },
+    async createExcel(content) {
+      const that = this;
+      const {
+        CONTENT
+      } = this.excelInfo;
+      let data = null;
+      if (CONTENT) {
+        data = JSON.parse(CONTENT);
+      }
+      const {
+        FORM_EXTEND_FONTS = ""
+      } = this.clientConfig;
+      await this.$util.usePlugin("luckysheet");
+      const fontList = [{
+        fontName: "方正小标宋简体"
+      }];
+      if (FORM_EXTEND_FONTS) {
+        fontList.push(...FORM_EXTEND_FONTS.split(";").map((item) => ({
+          fontName: item
+        })));
+      }
+      luckysheet.create({
+        container: "luckysheetEl",
+        // 设定DOM容器的id
+        title: "Luckysheet Demo",
+        // 设定表格名称
+        lang: "zh",
+        // 设定表格语言
+        plugins: ["chart"],
+        data: content !== void 0 ? content : data,
+        // sheet 自身未记录行列数时（如新建报表）使用当前设置的行列数
+        row: this.gridSize.row,
+        column: this.gridSize.column,
+        showsheetbar: false,
+        fontList,
+        hook: {
+          cellMousedown: function(cell, position, sheetFile, ctx) {
+            if (cell && cell.leftCell) {
+              that.leftCellWay = "custom";
+            } else {
+              that.leftCellWay = "default";
+            }
+            if (cell && cell.topCell) {
+              that.topCellWay = "custom";
+            } else {
+              that.topCellWay = "default";
+            }
+            if (cell && cell.relyCell) {
+              that.relyCellWay = "custom";
+            } else {
+              that.relyCellWay = "default";
+            }
+            const {
+              r,
+              c
+            } = position;
+            that.activeCell = {
+              rowIndex: r,
+              columnIndex: c,
+              wrapCompute: "1",
+              heightAuto: "1",
+              ...cell || {}
+            };
+            that.globalSetting = false;
+          },
+          cellDragStop: function(cell, position, sheetFile, ctx) {
+            const {
+              r,
+              c
+            } = position;
+            if (that.dragField) {
+              const {
+                sourceName,
+                fieldName,
+                sourceId,
+                fieldId
+              } = that.dragField;
+              luckysheet.setCellValue(r, c, {
+                v: `{${sourceName}.${fieldName}}`,
+                cellType: "dataset",
+                dataSource: sourceId,
+                field: fieldId,
+                aggregate: "select",
+                expand: "Down"
+              });
+              that.dragField = null;
+            } else if (that.dragVariable) {
+              const {
+                name,
+                value
+              } = that.dragVariable;
+              luckysheet.setCellValue(r, c, {
+                v: `{${name}}`,
+                cellType: "system-variable",
+                variable: value
+              });
+              that.dragVariable = null;
+            } else if (that.dragProcessParam) {
+              const {
+                name,
+                value
+              } = that.dragProcessParam;
+              luckysheet.setCellValue(r, c, {
+                v: `{${name}}`,
+                cellType: "process-variable",
+                variable: value
+              });
+              that.dragProcessParam = null;
+            }
+          },
+          cellEditBefore: function(range, position, sheetFile, ctx) {
+            const selects = luckysheet.getRangeValuesWithFlatte();
+            const cell = selects[0];
+            if (cell && (cell.cellType === "dataset" || cell.cellType === "system-variable")) {
+              that.$message.warning(cell.cellType === "system-variable" ? "系统变量不允许编辑" : "数据源不允许编辑");
+              const functionInput = document.querySelectorAll(".luckysheet-functionbox-cell-input");
+              const cellInput = document.querySelectorAll(".luckysheet-cell-input");
+              const inputList = [...functionInput, ...cellInput];
+              const timer = setTimeout(() => {
+                inputList.map((input) => input.blur());
+                clearTimeout(timer);
+              }, 80);
+            }
+            return false;
+          },
+          cellUpdated(v) {
+          },
+          updated(operate) {
+            var _a, _b;
+            if (operate.type === "delRC" || operate.type === "deleteCell" || operate.type === "addRC") {
+              const sheet = luckysheet.getSheet();
+              const {
+                data: data2
+              } = sheet;
+              const celldata = luckysheet.transToCellData(data2);
+              const updateRelyCell = (cell, prop) => {
+                const relyCell = cell.v[prop];
+                if (!relyCell || !relyCell.match(/\d+/g)) return;
+                const row = Number(relyCell.match(/\d+/g)[0]);
+                const columnName = relyCell.match(/[A-Z]+/g)[0];
+                const column = letterToNumber(columnName);
+                if (operate.type === "delRC") {
+                  const {
+                    rc,
+                    index
+                  } = operate.ctrlValue;
+                  if (rc === "r") {
+                    if (row >= index + 1) {
+                      luckysheet.setCellValue(cell.r, cell.c, {
+                        [prop]: row === index + 1 ? "" : `${columnName}${row - 1}`
+                      });
+                    }
+                  } else if (operate.ctrlValue.rc === "c") {
+                    if (column >= index) {
+                      luckysheet.setCellValue(cell.r, cell.c, {
+                        [prop]: column === index ? "" : `${NumberToLetter(column - 1)}${row}`
+                      });
+                    }
+                  }
+                } else if (operate.type === "deleteCell") {
+                  const {
+                    type,
+                    stc,
+                    str,
+                    edc,
+                    edr
+                  } = operate.ctrl;
+                  if (row >= str + 1 && row <= edr + 1 && column >= stc && column <= edc) {
+                    if (column >= stc && column <= edc) {
+                      luckysheet.setCellValue(cell.r, cell.c, {
+                        [prop]: ""
+                      });
+                    }
+                  } else if (column > edc && row >= str + 1 && row <= edr + 1 && type === "moveLeft") {
+                    const newColumn = column - 1 - (edc - stc);
+                    luckysheet.setCellValue(cell.r, cell.c, {
+                      [prop]: `${NumberToLetter(newColumn)}${row}`
+                    });
+                  } else if (row > edr + 1 && column >= stc && column <= edc && type === "moveUp") {
+                    const newRow = row - 1 - (edr - str);
+                    luckysheet.setCellValue(cell.r, cell.c, {
+                      [prop]: `${columnName}${newRow}`
+                    });
+                  }
+                } else if (operate.type === "addRC") {
+                  const {
+                    index,
+                    len,
+                    direction,
+                    rc
+                  } = operate.ctrlValue;
+                  if (rc === "c") {
+                    if (column > index || column === index && direction === "lefttop") {
+                      const newColumn = column + len;
+                      luckysheet.setCellValue(cell.r, cell.c, {
+                        [prop]: `${NumberToLetter(newColumn)}${row}`
+                      });
+                    }
+                  } else if (rc === "r") {
+                    if (row > index + 1 || row === index + 1 && direction === "lefttop") {
+                      const newRow = row + len;
+                      luckysheet.setCellValue(cell.r, cell.c, {
+                        [prop]: `${columnName}${newRow}`
+                      });
+                    }
+                  }
+                }
+              };
+              for (const cell of celldata) {
+                if ((_a = cell.v) == null ? void 0 : _a.leftCell) {
+                  updateRelyCell(cell, "leftCell");
+                }
+                if ((_b = cell.v) == null ? void 0 : _b.topCell) {
+                  updateRelyCell(cell, "topCell");
+                }
+              }
+              that.syncGridSize();
+            }
+          }
+        }
+      });
+      const luckysheetCell = document.getElementsByClassName("luckysheet-cell-flow-col")[0];
+      for (let i = 0; i < 10; i++) {
+        const hr = document.createElement("hr");
+        hr.style = `width:100% ;height: 0px;border-top: 1px dashed rgb(153, 153, 153);position: absolute;left: 0;top: ${(i + 1) * 840.51}pt;z-index: 10;`;
+        luckysheetCell.appendChild(hr);
+      }
+      this.syncGridSize();
+    },
+    // 从 luckysheet 读取当前 sheet 的行列数
+    syncGridSize() {
+      let sheet = null;
+      try {
+        sheet = typeof luckysheet === "undefined" ? null : luckysheet.getSheet();
+      } catch (e) {
+        sheet = null;
+      }
+      if (!sheet) return;
+      const data = sheet.data;
+      this.gridSize = {
+        row: data && data.length ? data.length : sheet.row || DEFAULT_ROW_NUM,
+        column: data && data.length && data[0] ? data[0].length : sheet.column || DEFAULT_COLUMN_NUM
+      };
+    },
+    // 统计已使用到的最大行列（含合并单元格、自定义行高列宽），避免缩小行列时丢配置
+    getUsedGridSize(sheet, celldata) {
+      let row = 1;
+      let column = 1;
+      celldata.forEach((cell) => {
+        if (cell.v === null || cell.v === void 0) return;
+        row = Math.max(row, cell.r + 1);
+        column = Math.max(column, cell.c + 1);
+      });
+      const config = sheet.config || {};
+      const merge = config.merge || {};
+      for (const key in merge) {
+        const {
+          r,
+          c,
+          rs = 1,
+          cs = 1
+        } = merge[key];
+        row = Math.max(row, r + rs);
+        column = Math.max(column, c + cs);
+      }
+      for (const key in config.rowlen || {}) {
+        row = Math.max(row, Number(key) + 1);
+      }
+      for (const key in config.columnlen || {}) {
+        column = Math.max(column, Number(key) + 1);
+      }
+      return {
+        row,
+        column
+      };
+    },
+    // 右侧「+ 列」：在表格末尾追加列
+    async addColumns() {
+      const num = Number(this.addColumnNum);
+      if (!num || num < 1) {
+        this.$message.warning("请输入要添加的列数");
+        return;
+      }
+      const column = this.gridSize.column + num;
+      if (column > MAX_COLUMN_NUM) {
+        this.$message.warning(`最多支持 ${MAX_COLUMN_NUM} 列，当前 ${this.gridSize.column} 列`);
+        return;
+      }
+      this.addColumnVisible = false;
+      const ok = await this.resizeGrid(this.gridSize.row, column);
+      if (ok) {
+        this.$message.success(`已添加 ${num} 列，当前共 ${column} 列（末列 ${this.NumToString(column)}），点击右上角「保存」生效`);
+      }
+    },
+    // 按新行列数重建整表，成功返回 true
+    async resizeGrid(row, column) {
+      if (!row || !column || row < 1 || column < 1 || row > MAX_ROW_NUM || column > MAX_COLUMN_NUM) {
+        this.$message.warning(`行数取值 1~${MAX_ROW_NUM}，列数取值 1~${MAX_COLUMN_NUM}`);
+        return false;
+      }
+      const sheets = luckysheet.getluckysheetfile();
+      const content = sheets.map((item) => {
+        const {
+          data,
+          ...props
+        } = item;
+        return {
+          ...props,
+          celldata: data ? luckysheet.transToCellData(data) : item.celldata || []
+        };
+      });
+      const used = this.getUsedGridSize(sheets[0], content[0].celldata);
+      if (row < used.row || column < used.column) {
+        this.$message.warning(`当前表格已使用到第 ${used.row} 行、${this.NumToString(used.column)} 列，行列数不能小于该范围`);
+        return false;
+      }
+      content[0].row = row;
+      content[0].column = column;
+      const newContent = JSON.parse(JSON.stringify(content));
+      this.gridSize = {
+        row,
+        column
+      };
+      luckysheet.destroy();
+      await this.createExcel(newContent);
+      this.saveContent();
+      return true;
+    },
+    deleteCell(evt) {
+      console.log(evt);
+    },
+    importExcel(props) {
+      const file = props.file || props;
+      this.isImportExcel = true;
+      this.$http.$post({
+        action: "upload",
+        file
+      }, {
+        requestType: "formData"
+      }).then((data) => {
+        if (data) {
+          if (data.bean) {
+            this.getExcelDataByFile(data.bean);
+          } else if (data.fileCheck) {
+            this.$message.error(data.fileCheck.checkResult);
+            this.isImportExcel = false;
+          }
+        }
+      }).catch((err) => {
+        this.$message.error(err.message);
+        this.isImportExcel = false;
+      });
+    },
+    getExcelDataByFile(fileId) {
+      this.$http.save({
+        action: "importExcel",
+        entityId: "FM_FORM",
+        fileId
+      }).then((data) => {
+        const sheets = JSON.parse(data) || [];
+        const {
+          celldata
+        } = sheets[0] || {};
+        sheets[0].data = luckysheet.transToData(celldata);
+        luckysheet.destroy();
+        this.createExcel(sheets);
+        this.isImportExcel = false;
+      }).catch((err) => {
+        this.$message.error(err.message);
+        this.isImportExcel = false;
+      });
+    },
+    saveExcelData(cb) {
+      this.saveContent();
+      this.$http.update({
+        entityId: "FM_FORM",
+        "bean.ID": this.$query.id,
+        "bean.CONTENT": this.content,
+        "bean.LANGUAGE_PARAM": {
+          CONTENT: this.languageContent
+        }
+      }).then((data) => {
+        this.$message.success("保存成功");
+        this.initContent = this.content;
+        this.initLanguageContent = this.$_.cloneDeep(this.languageContent);
+        cb && cb();
+      });
+    },
+    preview() {
+      this.showFormParamsDialog = false;
+      this.$createPage({
+        component: "excel-preview-page",
+        name: this.excelInfo.NAME,
+        code: this.excelInfo.CODE,
+        params: this.previewParams
+      });
+    },
+    defaultLeftCell() {
+      this.activeCell.leftCell = "";
+    },
+    defaultTopCell() {
+      this.activeCell.topCell = "";
+    },
+    defaultRelyCell() {
+      this.activeCell.relyCell = "";
+    },
+    addFilterCondition() {
+      this.showFilterConditionDialog = true;
+    },
+    editFilterCondition(item, index) {
+      this.filterConditionForm = {
+        ...item
+      };
+      this.editFilterConditionIndex = index;
+      this.showFilterConditionDialog = true;
+    },
+    deleteFilterCondition(index) {
+      const {
+        filterCondition
+      } = this.activeCell;
+      filterCondition.splice(index, 1);
+      this.activeCell[index] = filterCondition;
+    },
+    saveFilterCondition() {
+      let {
+        filterCondition
+      } = this.activeCell;
+      if (!filterCondition) filterCondition = [];
+      if (!this.filterConditionForm.propertyId) {
+        this.$message.error("请填写属性id");
+        return;
+      }
+      if (!this.filterConditionForm.op) {
+        this.$message.error("请填写操作符");
+        return;
+      }
+      if (!this.filterConditionForm.condition) {
+        this.$message.error("请填写值表达式");
+        return;
+      }
+      const item = this.objectFieldList.find((item2) => item2.code === this.filterConditionForm.propertyId) || {
+        text: this.filterConditionForm.propertyId
+      };
+      const condition = {
+        ...this.filterConditionForm,
+        propertyName: item.text,
+        text: `${this.editFilterConditionIndex > 0 || filterCondition.length > 0 ? this.getConditionOpText(this.filterConditionForm.join) || "" : ""} ${item.text} ${this.getConditionOpText(this.filterConditionForm.op)} ${this.filterConditionForm.condition}`
+      };
+      if (this.editFilterConditionIndex !== null) {
+        filterCondition.splice(this.editFilterConditionIndex, 1, condition);
+        this.editFilterConditionIndex = null;
+      } else {
+        filterCondition.push(condition);
+      }
+      this.activeCell.filterCondition = filterCondition;
+      this.showFilterConditionDialog = false;
+      this.filterConditionForm = {};
+    },
+    addConditionPropertyItem() {
+      this.currentConditionPropertyItem = {};
+      this.showConditionPropertyItemDialog = true;
+      const {
+        conditionPropertyItems
+      } = this.activeCell;
+      if (conditionPropertyItems && conditionPropertyItems.length) {
+        this.conditionPropertyItems = conditionPropertyItems;
+        this.currentConditionPropertyItem = conditionPropertyItems[0];
+      }
+    },
+    saveConditionPropertyItemName() {
+      let {
+        conditionPropertyItems
+      } = this.activeCell;
+      if (!conditionPropertyItems) conditionPropertyItems = [];
+      if (!this.conditionPropertyItemNameForm.name) {
+        this.$message.error("请输入条件项名称");
+        return;
+      }
+      let item = null;
+      if (this.conditionPropertyItemNameForm.uid) {
+        item = this.conditionPropertyItems.find((i) => i.uid === this.conditionPropertyItemNameForm.uid);
+        item.name = this.conditionPropertyItemNameForm.name;
+      } else {
+        const guid = (/* @__PURE__ */ new Date()).getTime().toString(32);
+        item = {
+          uid: guid,
+          name: this.conditionPropertyItemNameForm.name,
+          conditions: [],
+          cellStyle: {},
+          newValueFlag: false,
+          newValue: ""
+        };
+        this.conditionPropertyItems.push(item);
+      }
+      this.activeCell.conditionPropertyItems = this.conditionPropertyItems;
+      this.showConditionPropertyItemNameDialog = false;
+      this.conditionPropertyItemNameForm = {};
+      this.currentConditionPropertyItem = item;
+    },
+    saveConditionPropertyItemCondition() {
+      if (!this.conditionPropertyItemConditionForm.type) {
+        this.$message.error("请选择条件左值");
+        return;
+      }
+      if (!this.conditionPropertyItemConditionForm.op) {
+        this.$message.error("请选择操作符");
+        return;
+      }
+      if (!this.conditionPropertyItemConditionForm.condition) {
+        this.$message.error("请输入值表达式");
+        return;
+      }
+      if (this.conditionPropertyItemConditionForm.uid) {
+        const c = this.currentConditionPropertyItem.conditions.find((i) => i.uid === this.conditionPropertyItemConditionForm.uid);
+        c.type = this.conditionPropertyItemConditionForm.type;
+        c.op = this.conditionPropertyItemConditionForm.op;
+        c.join = this.conditionPropertyItemConditionForm.join;
+        c.condition = this.conditionPropertyItemConditionForm.condition;
+        c.left = this.conditionPropertyItemConditionForm.left;
+      } else {
+        const guid = (/* @__PURE__ */ new Date()).getTime().toString(32);
+        const item = {
+          uid: guid,
+          type: this.conditionPropertyItemConditionForm.type,
+          op: this.conditionPropertyItemConditionForm.op,
+          join: this.conditionPropertyItemConditionForm.join,
+          condition: this.conditionPropertyItemConditionForm.condition,
+          left: this.conditionPropertyItemConditionForm.left
+        };
+        if (!this.currentConditionPropertyItem.conditions) this.currentConditionPropertyItem.conditions = [];
+        this.currentConditionPropertyItem.conditions.push(item);
+      }
+      this.activeCell.conditionPropertyItems = this.conditionPropertyItems;
+      this.showConditionPropertyItemConditionDialog = false;
+      this.conditionPropertyItemConditionForm = {};
+    },
+    saveConditionPropertyItem() {
+      this.activeCell.conditionPropertyItems = this.conditionPropertyItems;
+      this.showConditionPropertyItemDialog = false;
+      this.currentConditionPropertyItem = {};
+      this.conditionPropertyItems = [];
+    },
+    clickConditionPropertyItem(item) {
+      this.currentConditionPropertyItem = item;
+    },
+    deleteConditionPropertyItem(item) {
+      const {
+        conditionPropertyItems
+      } = this.activeCell;
+      this.conditionPropertyItems = conditionPropertyItems.filter((i) => i.uid !== item.uid);
+      this.activeCell.conditionPropertyItems = this.conditionPropertyItems;
+      this.currentConditionPropertyItem = {};
+    },
+    editConditionPropertyItem() {
+      this.conditionPropertyItemNameForm = {
+        ...this.currentConditionPropertyItem
+      };
+      this.showConditionPropertyItemNameDialog = true;
+    },
+    deleteConditionPropertyCondition(item) {
+      this.currentConditionPropertyItem.conditions = this.currentConditionPropertyItem.conditions.filter((i) => i.uid !== item.uid);
+    },
+    editConditionPropertyCondition(item) {
+      this.conditionPropertyItemConditionForm = {
+        ...item
+      };
+      this.conditionPropertyItemConditionForm.index = this.currentConditionPropertyItem.conditions.indexOf(item);
+      this.showConditionPropertyItemConditionDialog = true;
+    },
+    getConditionOpText(p) {
+      let text = "";
+      switch (p) {
+        case "==":
+          text = "等于";
+          break;
+        case ">":
+          text = "大于";
+          break;
+        case ">=":
+          text = "大于等于";
+          break;
+        case "<":
+          text = "小于";
+          break;
+        case "<=":
+          text = "小于等于";
+          break;
+        case "!=":
+          text = "不等于";
+          break;
+        case "in":
+          text = "在集合中";
+          break;
+        case "not in":
+          text = "不在集合中";
+          break;
+        case "like":
+          text = "相似";
+          break;
+        case "not like":
+          text = "不相似";
+          break;
+        case "and":
+          text = "并且";
+          break;
+        case "or":
+          text = "或者";
+          break;
+      }
+      return text;
+    }
+  },
+  mounted() {
+    this.$refs.luckysheet.setAttribute("id", "luckysheetEl");
+    this.getData();
+  },
+  created() {
+    this.currentLanguage = this.defaultLanguage;
+    if (this.showMenu) {
+      this.changeMenuFlag = true;
+      this.$store.commit("SWITCH_MENU_SHOW", false);
+    }
+    if (this.showAppNav) {
+      this.changeAppNavFlag = true;
+      this.$store.commit("SWITCH_APP_NAV_SHOW", false);
+    }
+    this.getDataSource();
+    this.getFormParams();
+    this.getFieldRelation();
+    this.getFieldConfigs();
+  },
+  beforeUnmount() {
+    if (this.changeMenuFlag) {
+      this.$store.commit("SWITCH_MENU_SHOW", true);
+    }
+    if (this.changeAppNavFlag) {
+      this.$store.commit("SWITCH_APP_NAV_SHOW", true);
+    }
+    this.$refs.luckysheet.removeAttribute("id");
+    const morebtn = document.getElementById("luckysheet-icon-morebtn-div");
+    if (morebtn) {
+      morebtn.style = "none";
+    }
+    luckysheet.destroy();
+  }
+};
+export {
+  _sfc_main as default
+};