cloud-web-corejs 1.0.93 → 1.0.95

package/src/components/xform/form-render/container-item/data-table-mixin2.js

@@ -0,0 +1,2169 @@
+import emitter from "../../../../components/xform/utils/emitter";
+import i18n from "../../../../components/xform/utils/i18n";
+import refMixin from "../../../../components/xform/form-render/refMixin";
+import containerItemMixin from "./containerItemMixin";
+
+import * as formatUtil from "../../../../components/xform/utils/format.js";
+import tableConfig from "../../../../components/table/config.js";
+import {extendDeeply} from "../../../../utils/index.js";
+import {
+  assembleAxiosConfig,
+  getReportGlobalMap,
+  generateId,
+} from "../../../../components/xform/utils/util";
+import {tableTreeMixins} from "../../../../mixins/tableTree/index.js";
+
+let modules = {};
+const baseRefUtil = {
+  emitter,
+  i18n,
+  refMixin,
+  containerItemMixin,
+  formatUtil,
+  assembleAxiosConfig,
+  tableConfig,
+  getReportGlobalMap,
+};
+
+modules = {
+  mixins: [
+    baseRefUtil.emitter,
+    baseRefUtil.i18n,
+    baseRefUtil.refMixin,
+    baseRefUtil.containerItemMixin,
+    tableTreeMixins,
+  ],
+  componentName: "ContainerItem",
+  props: {
+    widget: Object,
+    parentWidget: Object,
+    parentList: Array,
+    indexOfParentList: Number,
+    subFormRowIndex: {
+      type: Number,
+      default: -1,
+    },
+    subFormColIndex: {
+      type: Number,
+      default: -1,
+    },
+    subFormRowId: {
+      type: String,
+      default: "",
+    },
+  },
+  inject: [
+    "refList",
+    "sfRefList",
+    "globalModel",
+    "getFormConfig",
+    "getGlobalDsv",
+    "previewState",
+  ],
+  data: function () {
+    let that = this;
+    return {
+      fieldModel: [],
+      selectedIndices: [],
+      pageSize: this.widget.options.pagination.pageSize,
+      pageSizes: this.widget.options.pagination.pageSizes,
+      currentPage: this.widget.options.pagination.currentPage,
+      total: this.widget.options.pagination.total,
+      formData: {
+        saleOrgName: "",
+        loginAccount: "",
+        mobile: "",
+        enabled: 1,
+      },
+      vxeOption: {},
+      requestAccess: null,
+      columnFormatMap: {
+        editInput: "input",
+        editNumber: "number",
+        editDate: "date",
+        editSelect: "select",
+        editSearch: "vabsearch",
+        editAttachment: "baseAttachment",
+        editStatus: "status",
+        aText: "a-text",
+        aLink: "a-link",
+        editDelete: "a-link",
+        editButton: "a-link",
+        button: "button",
+        addSiblingEditRow: "a-link",
+        addChildTreeRow: "a-link",
+        moveUpRow: "a-link",
+        moveDownRow: "a-link",
+        removeTreeRow: "a-link",
+        text: "text",
+        checkbox: "checkbox",
+        radio: "radio",
+      },
+      dataTableConfig: {},
+      widgets: [],
+      editWidgets: [],
+
+      sortParentRow: null,
+      sortRows: [],
+      showTreeMoveDialog: false,
+      tableConfig: {},
+      showTableFormDialogContent: true,
+      widgetMap: {},
+      rowWidgetList: []
+    };
+  },
+  watch: {
+    fieldModel(val) {
+      this.formModel[this.fieldKeyName] = val || [];
+    },
+  },
+  computed: {
+    hasWf() {
+      return this.getFormRef().hasWf || false;
+    },
+    tableDatas: {
+      cache: !1,
+      get: function () {
+        return this.globalModel.formModel[this.fieldKeyName] || [];
+      },
+    },
+    formConfig: function () {
+      return this.getFormConfig();
+    },
+    paginationLayout: function () {
+      return this.widget.options.smallPagination
+        ? "prev, pager, next"
+        : "total, sizes, prev, pager, next, jumper";
+    },
+    customClass: function () {
+      return this.widget.options.customClass || "";
+    },
+    singleRowSelectFlag: function () {
+      return !this.widget.options.showCheckBox;
+    },
+    buttonsColumnFixed: function () {
+      return void 0 === this.widget.options.buttonsColumnFixed
+        ? "right"
+        : !!this.widget.options.buttonsColumnFixed &&
+        this.widget.options.buttonsColumnFixed;
+    },
+    formModel: {
+      cache: !1,
+      get: function () {
+        return this.globalModel.formModel;
+      },
+    },
+    formDataId() {
+      let formRef = this.getFormRef();
+      return formRef.dataId;
+    },
+  },
+  created: function () {
+    if (!this.formModel[this.fieldKeyName])
+      this.formModel[this.fieldKeyName] = [];
+    this.initRefList();
+    this.handleOnCreated();
+  },
+  mounted: async function () {
+    this.handleOnMounted();
+    this.initTableList();
+  },
+  beforeDestroy: function () {
+    this.unregisterFromRefList();
+  },
+  methods: {
+    getRowRefKey(row, name) {
+      let keyVal = row._X_ROW_KEY;
+      let key = name + "_" + keyVal;
+      return key;
+    },
+    getWidgetByTableRow(index, name) {
+      let target = this.getWidgetRefByTableRow(index, name)
+      let widget = target.field || target.widget;
+      return widget
+    },
+    getWidgetRefByTableRow(index, name) {
+      let row = this.getGridTable().getTableData().fullData[index];
+      let key = this.getRowRefKey(row, name);
+      return this.getWidgetRef(key);
+    },
+    getWidgetRefByTableParam(tableParam) {
+      let index = tableParam.rowIndex;
+      let params = tableParam.column.params;
+      let name = params.widget.options.name;
+      return this.getWidgetRefByTableRow(index, name);
+    },
+    getRowWidget(rowParam, fieldWidget) {
+      let row = rowParam.row;
+      let params = rowParam.column.params;
+      let name = fieldWidget ? fieldWidget.options.name : params.widget.options.name;
+      let key = this.getRowRefKey(row, name);
+      let widget = this.widgetMap[key];
+      if (!widget) {
+        this.$set(
+          this.widgetMap,
+          key,
+          this.$baseLodash.cloneDeep(fieldWidget ? fieldWidget : params.widget)
+        );
+      }
+
+      return this.widgetMap[key];
+    },
+    loopHandleWidgetByName(name, callback) {
+      let rows = this.getValue();
+      rows.forEach((row, index) => {
+        let target = this.getWidgetRefByTableRow(index, name)
+        if (target) {
+          let widget = target.field || target.widget;
+          callback(row, widget, target)
+        }
+      })
+    },
+    getRowWidgetOption(rowParam, fieldWidget) {
+      let widget = this.getRowWidget(rowParam, fieldWidget);
+      let field = widget.category == 'container' ? 'widget' : 'field'
+      let option = {
+        [field]: widget
+      }
+      return option
+    },
+    getRowWidgetKey(rowParam, fieldWidget) {
+      let row = rowParam.row;
+      let params = rowParam.column.params;
+      let name = fieldWidget ? fieldWidget.options.name : params.widget.options.name;
+      let key = this.getRowRefKey(row, name);
+      return key;
+    },
+    getGridTableName() {
+      let formCode = this.getFormRef().reportTemplate.formCode;
+      let tableName = formCode + "_" + this.widget.options.name;
+      return tableName;
+    },
+    updateFormField: function () {
+      let rows = this.fieldModel || [];
+      let formRows = this.formModel[this.fieldKeyName];
+      if (formRows) {
+        this.formModel[this.fieldKeyName].splice(0, formRows.length);
+        this.formModel[this.fieldKeyName].push(...rows);
+      } else {
+        this.formModel[this.fieldKeyName] = rows;
+      }
+    },
+    setValue(val) {
+      // console.log("rows:",val);
+      this.clearRowWidgets()
+      let rows = val || [];
+      this.formModel[this.fieldKeyName] = rows;
+      let $grid = this.getGridTable();
+      this.fieldModel = rows;
+      // $grid.loadData(rows);
+    },
+    getValue() {
+      return this.formModel[this.fieldKeyName];
+    },
+    getFieldKeyName(widget) {
+      let o = widget.options.name;
+      return (widget.options.keyNameEnabled && widget.options.keyName) || o;
+    },
+    selectWidget: function (e) {
+      this.designer.setSelected(e);
+    },
+    formatterValue: function ({cellValue, row, column}) {
+      if (cellValue === null || cellValue === undefined) return cellValue;
+
+      if (column.params && column.params.formatS)
+        switch (column.params.formatS) {
+          case "d1":
+            return baseRefUtil.formatUtil.formatDate1(cellValue);
+          case "d2":
+            return baseRefUtil.formatUtil.formatDate2(cellValue);
+          case "d3":
+            return baseRefUtil.formatUtil.formatDate3(cellValue);
+          case "d4":
+            return baseRefUtil.formatUtil.formatDate4(cellValue);
+          case "d5":
+            return baseRefUtil.formatUtil.formatDate4(cellValue);
+          case "n1":
+            return baseRefUtil.formatUtil.formatNumber1(cellValue);
+          case "n2":
+            return baseRefUtil.formatUtil.formatNumber2(cellValue);
+          case "n3":
+            return baseRefUtil.formatUtil.formatNumber3(cellValue);
+          case "n4":
+            return baseRefUtil.formatUtil.formatNumber4(cellValue);
+          case "n5":
+            return baseRefUtil.formatUtil.formatNumber5(cellValue);
+          case "n6":
+            return baseRefUtil.formatUtil.formatNumber6(cellValue);
+          case "n7":
+            return baseRefUtil.formatUtil.formatNumber7(cellValue);
+        }
+      return cellValue;
+    },
+    getRowIndex: function (e) {
+      return this.widget.options.tableData.lastIndexOf(e);
+    },
+    setTableColumns: function (e) {
+      var t = this;
+      (this.widget.options.tableColumns = e),
+        this.$nextTick(function () {
+          t.$refs.dataTable.doLayout();
+        });
+    },
+    setTableColumn: function (e) {
+      this.setTableColumns(e);
+    },
+    getTableData: function () {
+      return this.widget.options.tableData;
+    },
+    resetForm(options) {
+      let formData = this.formModel;
+      let ignoreFields = options?.ignoreFields || [];
+      this.widget.widgetList.forEach((subWidget) => {
+        if (
+          !ignoreFields.length ||
+          !ignoreFields.includes(subWidget.options.name)
+        ) {
+          let widgetRef = this.getWidgetRef(subWidget.options.name);
+          if (widgetRef && widgetRef.setValue) widgetRef.setValue(null);
+        }
+      });
+    },
+    searchEvent() {
+      this.getGridTable().commitProxy("reload");
+    },
+    async resetEvent(options) {
+      this.resetForm(options);
+      this.getGridTable().commitProxy("reload");
+    },
+    handleSearchClick() {
+      if (this.widget.options.onSearchTable) {
+        this.handleCustomEvent(this.widget.options.onSearchTable);
+        return;
+      }
+      this.searchEvent();
+    },
+    handleResetClick() {
+      if (this.widget.options.onResetTable) {
+        this.handleCustomEvent(this.widget.options.onResetTable);
+        return;
+      }
+      this.resetEvent();
+    },
+    openEditDialog(row, param) {
+      let formRef = this.getFormRef();
+      let parentTarget = formRef.$attrs["parent-target"];
+      parentTarget &&
+      parentTarget.$attrs.openEditDialog &&
+      parentTarget.$attrs.openEditDialog(row, param);
+    },
+    importExcel() {
+    },
+    getGrid(that, tableRef) {
+      var $grid;
+      if (Array.isArray(that.$refs[tableRef])) {
+        $grid = that.$refs[tableRef][0];
+      } else {
+        $grid = that.$refs[tableRef];
+      }
+      return $grid;
+    },
+    getTableCondition: function () {
+      if (this.widget.options.tableCondition) {
+        var e = new Function(this.widget.options.tableCondition);
+        return e.call(this);
+      }
+    },
+    getSearchCondition: function () {
+      let extraAccessData = this.extraAccessData || {};
+      let searchFormData = this.getSearchFormData();
+      let defaultData = {};
+
+      // let globalReqData = baseRefUtil.getReportGlobalMap();//全局请求参数
+      let tableCondition = this.getTableCondition();
+      let conditions = {
+        ...defaultData,
+        ...tableCondition,
+        ...searchFormData,
+        ...extraAccessData,
+        // ...globalReqData
+      };
+      return conditions;
+    },
+    createColumns() {
+      let rowWidgetList = [];
+      let tableColumns = this.widget.options.tableColumns;
+      let newColumns = [];
+      if (!this.widget.options.hideGridCheckBox) {
+        newColumns.push({
+          type: "checkbox",
+          width: 48,
+          resizable: false,
+          fixed: "left",
+        });
+      }
+
+      let tableWidgetName = this.widget.options.name;
+      const createColumn = (t, isChild) => {
+
+        let col = {
+          fixed: !!t.fixed && t.fixed,
+          field: t.prop,
+          title: this.getI18nLabel(t.label),
+          sortable: t.sortable,
+          align: t.align ? t.align : "center",
+          formatter: this.formatterValue,
+          params: {
+            formatS: t.formatS,
+            columnId: t.columnId,
+            exportType: t.exportType,
+            isItemLine: t.isItemLine,
+            footerDataType: t.footerDataType,
+            footerMethodConfg: t.footerMethodConfg,
+            widgetList: t.widgetList,
+            tableWidgetName
+          },
+          visible: t.show,
+          slots: {},
+        };
+        if (t.treeNode) {
+          col.treeNode = true;
+        }
+        if (t.children && t.children.length) {
+          col.align = "center";
+          delete col.field;
+          let childColumns = t.children.map((child) => {
+            return createColumn(child, true);
+          });
+          col.children = childColumns;
+
+          col.sortable = false;
+          col.filterType = false;
+        } else {
+          col.width = t.width;
+          if (isChild) {
+            if (col.title && col.field) {
+              col.filters = [
+                {
+                  data: {},
+                },
+              ];
+              col.filterRender = {
+                name: "FilterContent",
+              };
+            }
+          }
+        }
+        col = addColumProperty(col, t);
+
+        if (col.params.widget) {
+          rowWidgetList.push(col.params.widget)
+        }
+        if (col.params.editWidget) {
+          rowWidgetList.push(col.params.editWidget)
+        }
+        if (col.params.widgetList && col.params.widgetList.length) {
+          col.params.widgetList.forEach((item) => {
+            rowWidgetList.push(item)
+          })
+
+        }
+        return col;
+      };
+
+      const addColumProperty = (col, t) => {
+        let columnOption;
+        let widget;
+        let columnWidgetConfig = this.getColumnWidgetConfig(t);
+        let {columnSelectedWidget, columnEditFields} = columnWidgetConfig;
+        if (columnSelectedWidget) {
+          widget = columnSelectedWidget;
+          columnOption = widget.options;
+        } else {
+          columnOption = {};
+        }
+
+        let {columnSelectedWidget: editWidget} = this.getColumnWidgetConfig(
+          t,
+          true
+        );
+
+        let params = {
+          ...columnOption,
+          widget: widget,
+          formatS: t.formatS,
+          required: t.required || false,
+          columnConfig: t,
+          editWidget,
+        };
+        Object.assign(col.params, params);
+        if (!col.children || !col.children.length) {
+          if (t.formatS == "render") {
+            let r = t.render ? new Function("params", "h", t.render) : null;
+            col.slots.default = (params, h) => {
+              return r ? r.call(this, params, h) : "";
+            };
+          } else if (columnSelectedWidget) {
+            // col.slots.default = columnSelectedWidget.id;
+            col.slots.default = "widget";
+          } else if (t.formatS == "editTreeButtonGroup") {
+            col.slots.default = "editTreeButtonGroup";
+          } else if (t.formatS == "widgetRender") {
+            col.slots.default = "widgetList";
+          }
+
+          if (editWidget) {
+            col.editRender = {name: "input"};
+            // col.slots.edit = editWidget.id;
+            col.slots.edit = "editWidget";
+          }
+        }
+        if (t.tableColumnConfig) {
+          let tableColumnConfig =
+            this.handleCustomEvent(t.tableColumnConfig) || {};
+          col = extendDeeply(col, tableColumnConfig);
+        }
+        return col;
+      };
+
+      let formRef = this.getFormRef();
+      tableColumns.forEach((t) => {
+        let col = createColumn(t);
+        newColumns.push(col);
+      });
+
+      if (
+        baseRefUtil.tableConfig &&
+        baseRefUtil.tableConfig.className == "list-table"
+      ) {
+        if (tableColumns.length) {
+          let tableColumn = [tableColumns.length - 1];
+          if (tableColumn.fixed != "right") {
+            newColumns.push({
+              width: 47,
+              title: "",
+              fixed: "right",
+              sortable: false,
+            });
+          }
+        }
+      }
+      this.rowWidgetList = rowWidgetList;
+      return this.$baseLodash.cloneDeep(newColumns);
+    },
+    initTableList() {
+      let that = this;
+      let path = null;
+      let paramFun = null;
+      // let mainDataSetDTO = null;
+      let requestAccess = this.requestAccess;
+      let tableRef = this.getTableRef();
+      let formDataModel = this.getFormRef().formDataModel;
+      let isQueryTable = this.widget.options.isQueryTable || false;
+      let isDataPage = this.widget.options.accessReturnType == "2";
+      let reportTemplate = this.getFormRef().reportTemplate;
+      let formCode = reportTemplate.formCode;
+      let dataId = this.formDataId;
+      let accessScript = this.widget.options.accessScript;
+      let searchColumns = null;
+
+      if (isQueryTable) {
+        path = "#";
+        paramFun = () => {
+          let conditions = this.getSearchCondition();
+          let $grid = this.getGridTable();
+          if (this.widget.options.showPagination) {
+            let proxyInfo = $grid.getProxyInfo();
+            let searchCount = true;
+            let isQueryAllPage = $grid.isQueryAllPage;
+            if (isQueryAllPage == false) {
+              searchCount = false;
+            }
+            let pager = proxyInfo ? proxyInfo.pager : null;
+            if (pager) {
+              conditions.current = pager.currentPage;
+              conditions.size = pager.pageSize;
+              conditions.searchCount = searchCount;
+            }
+          }
+
+          /*let formData = {
+            accessCode: requestAccess.accessCode,
+            conditions: conditions
+          };*/
+          let formData = conditions;
+          return formData;
+        };
+
+        searchColumns = [];
+        let widgetList = this.widget.widgetList;
+
+        let getDateItem = (widget) => {
+          let options = widget.options;
+
+          let dateConfig = {
+            format: options.format,
+            valueFormat: options.valueFormat ?? null,
+          };
+          let typeMap = {
+            input: {type: "input"},
+            number: {type: "number"},
+            inputBatch: {type: "inputBatch"},
+            date: {
+              type: "date",
+              widgetType: options.type,
+              widgetConfig: dateConfig,
+            },
+            time: {
+              type: "time",
+              widgetConfig: {
+                ...dateConfig,
+                valueFormat: "HH:mm:ss",
+              },
+            },
+            "date-range": {
+              type: "date",
+              widgetType: "daterange",
+              widgetConfig: {...dateConfig, isRange: true},
+            },
+            "time-range": {
+              type: "time",
+              widgetConfig: {
+                ...dateConfig,
+                isRange: true,
+                valueFormat: "HH:mm:ss",
+              },
+            },
+          };
+          let item = typeMap[widget.type] || {};
+          return item;
+        };
+
+        widgetList.forEach((widget) => {
+          if ("container" !== widget.category) {
+            let options = widget.options;
+            let item = getDateItem(widget);
+            let type = item.type ?? null;
+            // let widgetType = item.widgetType ?? widgetType;
+            // let isRange = item.isRange || false;
+            searchColumns.push({
+              title: this.getI18nLabel(options.label),
+              field: this.getFieldKeyName(widget),
+              // type,
+              // widgetType,
+              // isRange,
+              common: true,
+              disabled: options.disabled,
+              defaultValueEnabled: !!type,
+              slot: options.name,
+              widget: widget,
+              formItem: false,
+              ...item,
+            });
+          }
+        });
+      }
+
+      let formRef = this.getFormRef();
+      let dataTableConfig = formRef.$attrs.dataTableOption || {};
+      this.dataTableConfig = dataTableConfig;
+
+      let columns = this.createColumns();
+      this.widgets = columns
+        .filter((column) => !!column?.params?.widget)
+        .map((column) => column.params.widget);
+      this.editWidgets = columns
+        .filter((column) => !!column?.params?.editWidget)
+        .map((column) => column.params.editWidget);
+
+      let height =
+        this.widget.options.tableHeight || (isQueryTable ? "auto" : null);
+      if (
+        !this.widget.options.tableHeight &&
+        isQueryTable &&
+        this.previewState
+      ) {
+        height = "550px";
+      }
+
+      let formConfig = this.formConfig;
+      let scriptCode = this.getScriptCode();
+
+      let otherParam = {};
+      let attachmentType = this.getAttachmentType();
+      if (attachmentType.length) {
+        otherParam.attachmentType = attachmentType;
+      }
+      let thirdtabm = this.getThirdtabm();
+      if (thirdtabm.length) {
+        otherParam.thirdtabm = thirdtabm;
+      }
+
+      let pagerConfig = {};
+      let editDefaultRow, treeNodeParam, treeConfig;
+      let isTreeTable = this.widget.options.isTreeTable;
+      if (isTreeTable) {
+        pagerConfig.pagerClass = "is--hidden";
+        if (this.widget.options.editDefaultRow) {
+          editDefaultRow = this.handleCustomEvent(
+            this.widget.options.editDefaultRow
+          );
+        }
+        treeNodeParam = (row) => {
+          return {
+            [this.widget.options.parentField]: row.id,
+          };
+        };
+        treeConfig = {
+          lazy: false,
+          children: "f_children",
+          hasChild: "f_has_child", // 设置是否有子节点标识
+          parentField: "f_parent",
+          transform: true,
+          expandAll: true,
+          loadMethod({$table, row}) {
+            // 模拟后台接口
+            let $grid = that.getGridTable();
+            let parentField = $grid.treeConfig.parentField;
+            return new Promise((resolve, reject) => {
+              let treeParam = that.widget.options.tableConfig?.treeNodeParam;
+              let reqPram = {};
+              if (treeParam) {
+                reqPram = treeParam(row) || {};
+              }
+              Object.assign(reqPram, {
+                [parentField]: row.id,
+              });
+              let accessParam = this.getAccessParam() || {};
+              let defaultOption = that.getHttpConfigForUser();
+              that.formHttp({
+                scriptCode: scriptCode,
+                data: {
+                  formCode: formCode,
+                  formVersion: reportTemplate.formVersion,
+                  taBm: that.fieldKeyName,
+                  data: {
+                    ...reqPram,
+                    ...otherParam,
+                    ...accessParam,
+                  },
+                },
+                callback: (res) => {
+                  if (res.type == "success") {
+                    let rows = res.objx
+                      ? res.objx.records || res.objx || []
+                      : [];
+
+                    let hasChildField = $grid.treeConfig.hasChild;
+                    if (row[hasChildField] && !rows.length) {
+                      row[hasChildField] = false;
+                    }
+
+                    resolve(rows);
+                    let treeCallback =
+                      that.widget.options.tableConfig?.treeCallback;
+                    if (treeCallback) {
+                      that.$nextTick(() => {
+                        setTimeout(function () {
+                          treeCallback(rows);
+                        }, 0);
+                      });
+                    }
+                  } else {
+                    reject(res);
+                  }
+                },
+              });
+            });
+          },
+        };
+      }
+      let editOpts = {};
+      if (this.widget.options.isEditTable) {
+        editOpts = {
+          keepSource: true,
+          editConfig: {
+            trigger: "manual",
+            mode: "row",
+            showStatus: true,
+            autoClear: false,
+          },
+        };
+      }
+      let showFooter = this.widget.options.showGridFooter || false;
+      let otherConfig = {};
+      if (this.widget.options.hideGridCheckBox) {
+        otherConfig.checkBoxRequired = false;
+      }
+      let tableOption = {
+        // vue: this,
+        tableRef: tableRef,
+        tableName: this.getGridTableName(),
+        param: paramFun,
+        columns: columns,
+        searchColumns: searchColumns,
+        vform: true,
+        config: {
+          height: height,
+          showFooter,
+          pagerConfig,
+          treeConfig,
+          ...editOpts,
+          ...dataTableConfig.config,
+
+        },
+        exportAjax: (param) => {
+          let $grid = this.getGridTable();
+          let pageSize = param.size;
+          let currentPage = param.current;
+          let page = {pageSize, currentPage};
+          let customParam = {
+            config: {
+              modal: false,
+            },
+          };
+          return $grid.$options.propsData.proxyConfig.ajax.query.call(this, {
+            page,
+            param,
+            customParam,
+          });
+        },
+        // treeNodeUrl,
+        editDefaultRow,
+        treeNodeParam,
+        ...otherConfig
+      };
+
+      if (isQueryTable) {
+        /*if(this.widget.options.isTreeTable){
+          tableOption.config.pagerConfig.autoHidden = false;
+        }*/
+        tableOption.path = path;
+        tableOption.config.proxyConfig = {
+          props: {
+            result: isDataPage ? "objx.records" : "objx", // 配置响应结果列表字段
+            total: isDataPage ? "objx.total" : "objx.length", // 配置响应结果总页数字段
+          },
+          ajax: {
+            // 接收 Promise 对象
+            query: ({page, sorts, filters, form, param, customParam}) => {
+              let formData = tableOption.param ? tableOption.param() || {} : {};
+              const queryParams = Object.assign({}, formData);
+
+              // 处理排序条件
+              /*if (sorts) {
+                const firstSort = sorts[0];
+                if (firstSort) {
+                  queryParams.sort = firstSort.property;
+                  queryParams.order = firstSort.order;
+                }
+              }*/
+
+              // 处理筛选条件
+              if (filters) {
+                filters.forEach(({property, values}) => {
+                  queryParams[property] = values.join(",");
+                });
+              }
+
+              if (page.pageSize !== undefined) {
+                queryParams["size"] = page.pageSize;
+                queryParams["current"] = page.currentPage;
+              }
+
+              let $grid = this.getGridTable();
+              let isQueryAllPage = $grid.isQueryAllPage;
+              let pathStr1 = "";
+              if (isQueryAllPage === false) {
+                queryParams.searchCount = false;
+              }
+              Object.assign(queryParams, param);
+
+              // let formRef = that.getFormRef();
+              // let dataTableConfig = formRef.$attrs.dataTableOption || {};
+              if (that.dataTableConfig.queryParam) {
+                Object.assign(queryParams, that.dataTableConfig.queryParam);
+              }
+
+              var reqPath = typeof path == "function" ? path() : path;
+              let accessReturnType = this.widget.options.accessReturnType || 2;
+              let scriptCode = this.getScriptCode();
+              return new Promise((resolve, reject) => {
+                let reqData = {
+                  ...queryParams,
+                };
+                if (scriptCode) {
+                  let index = 0;
+                  let toDo = () => {
+                    // let f = new Function("dataId", "formCode", "param", "done", accessScript);
+                    let done = (res) => {
+                      this.clearRowWidgets();
+                      resolve(res);
+                      if (res.type == "success") {
+                        let rows = res.objx
+                          ? res.objx.records || res.objx || []
+                          : [];
+                        if (that.widget.options.isTreeTable) {
+                          if (rows.length > 0) {
+                            let fullAllDataRowMap =
+                              $grid.$refs.xTable.fullAllDataRowMap;
+                            let parentField = $grid.treeConfig.parentField;
+                            let expandAll = $grid.treeConfig.expandAll || false;
+                            let isLazy = $grid.treeConfig.lazy;
+                            let expandIds = rows
+                              .filter((item) => item[parentField])
+                              .map((item) => item[parentField]);
+                            let expandRows = expandIds.length
+                              ? rows.filter((item) =>
+                                expandIds.includes(item.id)
+                              )
+                              : [];
+                            if (expandAll && expandRows.length) {
+                              that.$nextTick(() => {
+                                setTimeout(function () {
+                                  $grid.treeConfig.lazy = false;
+                                  $grid.setTreeExpand(expandRows, true);
+                                  expandRows.forEach((lineData) => {
+                                    if (
+                                      $grid.$refs.xTable.isTreeExpandByRow(
+                                        lineData
+                                      )
+                                    ) {
+                                      let rest =
+                                        fullAllDataRowMap.get(lineData);
+                                      rest.treeLoaded = true;
+                                    }
+                                  });
+
+                                  $grid.treeConfig.lazy = isLazy;
+                                }, 0);
+                              });
+                            }
+
+                            let row = rows.find((item) => !item[parentField]);
+                            if (
+                              row &&
+                              (!expandAll || !expandIds.includes(row.id))
+                            ) {
+                              let hasChild = $grid.treeConfig.hasChild;
+                              if (row[hasChild]) {
+                                that.$nextTick(() => {
+                                  setTimeout(function () {
+                                    $grid.setTreeExpand(row, true);
+                                  }, 0);
+                                });
+                              }
+                            }
+                          }
+                        }
+                        that.$nextTick(() => {
+                          setTimeout(function () {
+                            tableOption.callback && tableOption.callback(rows);
+                            that.handleCustomEvent(
+                              that.widget.options.formScriptCallback,
+                              ["rows"],
+                              [rows]
+                            );
+                          }, 0);
+                        });
+                      }
+                    };
+                    this.loadDefaultQueryList(reqData, done, customParam);
+                  };
+                  let loopHandle = () => {
+                    if (index < 500 && $grid.tableFormStop === true) {
+                      //阻塞列表查询，或者次数达到500时，自动释放
+                      index++;
+                      setTimeout(() => {
+                        loopHandle();
+                      }, 10);
+                    } else {
+                      if ($grid.tableFormStop) $grid.tableFormStop = false;
+                      toDo();
+                    }
+                  };
+                  loopHandle();
+                } else {
+                  resolve();
+                }
+              });
+            },
+          },
+        };
+        tableOption.callback = (rows) => {
+          // this.fieldModel = rows;
+          this.formModel[this.fieldKeyName] = rows;
+        };
+      }
+
+      if (isTreeTable) {
+        tableOption.filterType = false;
+      }
+
+      if (this.widget.options.tableConfig) {
+        let tableConfig =
+          this.handleCustomEvent(this.widget.options.tableConfig) || {};
+        tableOption = extendDeeply(tableOption, tableConfig);
+        this.tableConfig = tableConfig;
+      }
+
+      if (tableOption.config.showFooter && !tableOption.config.footerMethod) {
+        let footerColumnIds = columns
+          .filter((item) => !!item.params?.footerDataType)
+          .map((item) => item.params.columnId);
+        if (footerColumnIds.length) {
+          tableOption.config.footerMethod = (param) => {
+            let {columns: column1s, data} = param;
+            return [
+              column1s.map((column, columnIndex) => {
+                let columnId = column.params?.columnId;
+                if (columnId && footerColumnIds.includes(columnId)) {
+                  let footerDataType = column.params.footerDataType;
+                  if (footerDataType == "1") {
+                    //求和
+                    return this.sumNum(data, column.field);
+                  } else if (footerDataType == "2") {
+                    //求平均值
+                    return this.meanNum(data, column.field);
+                  } else if (footerDataType == "3") {
+                    if (column.params.footerMethodConfg) {
+                      let n = new Function(
+                        "dataId",
+                        "formCode",
+                        "param",
+                        column.params.footerMethodConfg
+                      );
+                      return n.call(this, dataId, formCode, param) ?? null;
+                    }
+                  }
+                }
+                return null;
+              }),
+            ];
+          };
+        }
+      }
+      tableOption.vue = this;
+
+      //合并单元格
+      let mergeRowEnabled = this.widget.options.mergeRowEnabled || false;
+      let unikey = this.widget.options.mergeRowKey;
+      if (mergeRowEnabled && unikey) {
+        tableOption.config.spanMethod = this.mergeRowMethod;
+      }
+
+      this.$vxeTableUtil.initVxeTable(tableOption).then((opts) => {
+        this.vxeOption = opts;
+        if (!isQueryTable) {
+          setTimeout(() => {
+            this.loadAccessData(1);
+          }, 20);
+        }
+      });
+    },
+    meanNum(list, field) {
+      let count = this.sumNum(list, field);
+      return this.$baseDiv(count, list.length);
+    },
+    sumNum(list, field) {
+      let count = 0;
+      list.forEach((item) => {
+        count = this.$baseAdd(count, item[field]);
+      });
+      return count;
+    },
+    getSearchFormData() {
+      let map = {condition: []};
+      let formData = this.globalModel.formModel;
+      let widgetList = this.widget.widgetList;
+      if (!!widgetList && widgetList.length > 0) {
+        let loop = (wItem) => {
+          if (wItem.category === "container") {
+            loop(wItem);
+          } else {
+            let formField = this.getFieldKeyName(wItem);
+            let vaule = formData[formField];
+            if (vaule !== null && vaule !== undefined && vaule !== "") {
+              if (!Array.isArray(vaule) || vaule.length > 0) {
+                let item = {
+                  value: vaule,
+                  field: formField,
+                  filter: null,
+                };
+                let wType = wItem.type;
+                if (["date-range", "time-range"].includes(wType)) {
+                  item.filter = "between";
+                } else if (
+                  ["input-batch", "checkbox"].includes(wType) ||
+                  (wType == "select" && wItem.options.multiple)
+                ) {
+                  item.filter = "in";
+                } else if (
+                  ["radio", "time", "date"].includes(wType) ||
+                  (wType == "select" && !wItem.options.multiple)
+                ) {
+                  item.filter = "eq";
+                } else {
+                  item.filter = "like";
+                }
+                map.condition.push(item);
+              }
+            }
+          }
+        };
+        widgetList.forEach((wItem) => {
+          loop(wItem);
+        });
+      }
+      return map;
+    },
+    getUrl() {
+      let accessUrl = this.widget.options.accessUrl;
+      return accessUrl || USER_PREFIX + `/form_ins/getFormInsData`;
+    },
+    getAttachmentType() {
+      let vailColumns = this.widget.options.tableColumns.filter(
+        (item) => item.prop && item.label
+      );
+      let result = vailColumns
+        .filter((item) => {
+          return item.formatS == "editAttachment";
+        })
+        .map((item) => item.prop);
+      return result;
+    },
+    getThirdtabm() {
+      let vailColumns = this.widget.options.tableColumns.filter(
+        (item) => item.prop && item.label
+      );
+      let result = vailColumns
+        .filter((item) => {
+          return (
+            item.formatS == "editSearch" && item.columnOption.multipleChoices
+          );
+        })
+        .map((item) => item.prop);
+      return result;
+    },
+
+    loadDefaultViewList() {
+      let dataId = this.formDataId;
+      let reportTemplate = this.getFormRef().reportTemplate;
+      let formCode = reportTemplate.formCode;
+      let accessParam = this.getAccessParam() || {};
+      let otherParam = {};
+      let attachmentType = this.getAttachmentType();
+      if (attachmentType.length) {
+        otherParam.attachmentType = attachmentType;
+      }
+      let thirdtabm = this.getThirdtabm();
+      if (thirdtabm.length) {
+        otherParam.thirdtabm = thirdtabm;
+      }
+      let scriptCode = this.getScriptCode();
+      return this.formHttp({
+        /*url: "/" + reportTemplate.serviceName + "/form_ins/getList",*/
+        scriptCode: scriptCode,
+        data: {
+          formCode: formCode,
+          formVersion: reportTemplate.formVersion,
+          taBm: this.fieldKeyName,
+          data: {
+            id: dataId,
+            ...otherParam,
+            ...accessParam,
+          },
+        },
+        callback: (res) => {
+          let $grid = this.getGridTable();
+          let rows = res.objx ? res.objx.records || res.objx || [] : [];
+          let defaultRow = this.createNewTableData();
+          rows = rows.map((row) => {
+            return {
+              ...defaultRow,
+              ...row,
+            };
+          });
+          this.setValue(rows);
+          this.$nextTick(() => {
+            /*if (this.widget.options.isTreeTable) {
+              let $grid = this.getGridTable();
+              $grid.treeConfig.lazy = false;
+              $grid.setAllTreeExpand(true);
+            }*/
+            this.tableConfig.callback && this.tableConfig.callback(rows);
+            this.handleCustomEvent(
+              this.widget.options.formScriptCallback,
+              ["rows"],
+              [rows]
+            );
+            this.$forceUpdate();
+          });
+        },
+      });
+    },
+    getAccessParam() {
+      if (!this.widget.options.formScriptParam) return;
+      return this.handleCustomEvent(this.widget.options.formScriptParam);
+    },
+    getScriptCode() {
+      let accessReturnType = this.widget.options.accessReturnType;
+      let defaultScriptCode = "getList";
+      if (accessReturnType == 1) {
+        defaultScriptCode = "getList";
+      } else if (accessReturnType == 2) {
+        defaultScriptCode = "getPage";
+      }
+      let scriptCode = this.widget.options.formScriptCode || defaultScriptCode;
+      return scriptCode;
+    },
+    loadDefaultQueryList(reqData, done, customParam) {
+      let reportTemplate = this.getFormRef().reportTemplate;
+      let prefix = "/" + reportTemplate.serviceName;
+      let formCode = reportTemplate.formCode;
+      let formConfig = this.formConfig;
+      let accessReturnType = this.widget.options.accessReturnType;
+      let scriptCode = this.getScriptCode();
+      let accessParam = this.getAccessParam() || {};
+
+      let otherParam = {};
+      let attachmentType = this.getAttachmentType();
+      if (attachmentType.length) {
+        otherParam.attachmentType = attachmentType;
+      }
+
+      let defaultOption = this.getHttpConfigForUser();
+
+      let ajaxConfig = customParam?.config || {};
+
+      let requestData = {
+        ...reqData,
+        ...otherParam
+      };
+      requestData = extendDeeply(requestData, accessParam);
+
+      return this.formHttp({
+        // url: prefix + "/form_ins/getPage",
+        scriptCode: scriptCode,
+        data: {
+          formCode: formCode,
+          formVersion: reportTemplate.formVersion,
+          taBm: this.fieldKeyName,
+          data: requestData,
+        },
+        isLoading: false,
+        ...defaultOption,
+        ...ajaxConfig,
+        callback: (res) => {
+          done(res);
+        },
+      });
+    },
+    loadAccessData(flag) {
+      if (flag === 1) {
+        let tableConfig = this.tableConfig;
+        let accessEnabled = tableConfig.accessEnabled ?? true;
+        if (accessEnabled === false) {
+          return;
+        }
+        if (this.formConfig.isLoadEntity && !this.formDataId) {
+          return;
+        }
+      }
+
+      let scriptCode = this.getScriptCode();
+      if (scriptCode) {
+        this.loadDefaultViewList();
+      }
+    },
+    getReqParam(item, dataId, billData) {
+      let param = {};
+      if (item.accessParam) {
+        if (typeof item.accessParam === "string") {
+          let n = new Function("billData", item.accessParam);
+          param = n.call(this, billData);
+        } else {
+          param = item.accessParam;
+        }
+      } else {
+        param = {id: dataId};
+      }
+      return param;
+    },
+    getTableRef() {
+      let tableRef = this.widget.id;
+      return tableRef;
+    },
+    exportData(option) {
+      let tableRef = this.getTableRef();
+      let serviceName = this.getFormRef().reportTemplate.serviceName;
+      option.prefix = option.prefix || "/" + serviceName;
+      this.$excelExport({targetRef: tableRef, ...option});
+    },
+    async deleteRow(row, rowIndex) {
+      let isTreeTable = this.widget.options.isTreeTable;
+      if (isTreeTable) {
+        this.removeTreeRow({row});
+        return;
+      }
+      let $grid = this.getGridTable();
+      $grid.remove(row);
+      let tableData = $grid.getTableData();
+      let isEditTable = this.widget.options.isEditTable;
+      let fullData = !isEditTable ? tableData.fullData : tableData.tableData;
+      await this.$nextTick(() => {
+        this.formModel[this.fieldKeyName] = fullData;
+        this.fieldModel = fullData;
+      });
+      this.$nextTick(() => {
+        this.handleWbs();
+      });
+      this.deleteRowWidgets(row)
+    },
+    createNewTableData(isEdit) {
+      let vailColumns = this.widget.options.tableColumns.filter(
+        (item) => item.prop && item.label
+      );
+      let newData = {};
+      vailColumns.forEach((item) => {
+        let formatS = !isEdit ? item.formatS : item.editFormatS;
+        let columnOption = !isEdit ? item.columnOption : item.editColumnOption;
+        if (formatS == "editSearch") {
+          newData[item.prop] = null;
+          let vabSearchName = item?.columnOption?.vabSearchName;
+          if (vabSearchName) newData[vabSearchName] = null;
+        }
+        if (formatS == "editAttachment") {
+          newData[item.prop] = [];
+        } else {
+          newData[item.prop] = null;
+          if (
+            columnOption &&
+            columnOption.defaultValue !== undefined &&
+            columnOption.defaultValue !== null &&
+            columnOption.defaultValue !== ""
+          ) {
+            newData[item.prop] = columnOption.defaultValue;
+          }
+        }
+      });
+      return newData;
+    },
+    addTableData(rows, field) {
+      let $grid = this.getGridTable();
+      let formDataModel = this.formModel;
+      let tableRows = formDataModel[this.fieldKeyName] || [];
+      let fullData = $grid.getTableData().fullData;
+      let items;
+      if (field) {
+        let keys = fullData.map((item) => {
+          return item[field] + "";
+        });
+        items = rows.filter((item) => {
+          let value = item[field] + "";
+          return !keys.includes(value);
+        });
+      } else {
+        items = rows;
+      }
+      if (items) {
+        if (items.length) {
+          items.forEach((row) => {
+            let newData = this.createNewTableData();
+            Object.assign(newData, row);
+
+            tableRows.push(newData);
+          });
+        }
+      } else {
+        let newData = this.createNewTableData();
+        tableRows.push(newData);
+      }
+      // this.formModel[this.fieldKeyName] = this.$baseLodash(this.fieldModel)
+      // this.fieldModel = tableRows
+      this.setValue(tableRows);
+      this.$nextTick(() => {
+        this.handleWbs();
+      });
+      // $grid.loadData(tableRows);
+    },
+    getColumnWidgetConfig(row, isEdit) {
+      let formatS = isEdit ? row.editFormatS : row.formatS;
+      let formRef = this.getFormRef();
+      let columnSelectedWidget = null;
+      let columnEditFields = null;
+
+      let type = this.columnFormatMap[formatS];
+
+      if (type) {
+        columnSelectedWidget = this.$baseLodash.cloneDeep(
+          formRef.getFieldWidgetByType(type)
+        );
+        let tmpId = generateId();
+        let idVal = row.prop ? row.prop : type + tmpId;
+        columnSelectedWidget.id = idVal;
+        columnSelectedWidget.options.name = idVal;
+
+        let columnOption;
+        if (!isEdit) {
+          columnOption = row.columnOption;
+        } else {
+          columnOption = row.editColumnOption;
+        }
+
+        if (columnOption && Object.keys(columnOption).length) {
+          columnOption.required = row.required || false;
+          columnSelectedWidget.options = columnOption;
+          if ("editDelete" == formatS) {
+            columnSelectedWidget.options.hiddenByWf =
+              columnSelectedWidget.options.hiddenByWf ?? true;
+            columnSelectedWidget.options.prefixIcon =
+              columnSelectedWidget.options.prefixIcon || "el-icon-delete";
+          } else if ("editButton" == formatS) {
+            columnSelectedWidget.options.prefixIcon =
+              columnSelectedWidget.options.prefixIcon || "el-icon-edit";
+          }
+        } else {
+          columnSelectedWidget.options.required = row.required || false;
+          if ("editDelete" == formatS) {
+            columnSelectedWidget.options.prefixIcon = "el-icon-delete";
+            columnSelectedWidget.options.label = "删除";
+            columnSelectedWidget.options.labelHidden = true;
+            columnSelectedWidget.options.hiddenByWf = true;
+            columnSelectedWidget.options.onClick =
+              "let tableParam = this.tableParam;\nlet tableRef = this.getWidgetRef(this.parentWidget.options.name);\ntableRef.deleteRow(tableParam.row,tableParam.rowIndex);";
+          } else if ("editButton" == formatS) {
+            columnSelectedWidget.options.prefixIcon = "el-icon-edit";
+            columnSelectedWidget.options.label = "查看";
+            columnSelectedWidget.options.labelHidden = true;
+            columnSelectedWidget.options.onClick =
+              "let tableParam = this.tableParam;\nlet tableRef = this.getWidgetRef(this.parentWidget.options.name);\ntableRef.openEditDialog(tableParam.row)";
+          } else if ("addSiblingEditRow" == formatS) {
+            columnSelectedWidget.options.prefixIcon = "el-icon-plus";
+            columnSelectedWidget.options.label = "新增兄弟节点";
+            columnSelectedWidget.options.labelHidden = false;
+            columnSelectedWidget.options.onClick =
+              "let tableParam = this.tableParam;\nthis.getParentTarget().addSiblingTreeRow(null,tableParam);";
+          } else if ("addChildTreeRow" == formatS) {
+            columnSelectedWidget.options.prefixIcon = "el-icon-plus";
+            columnSelectedWidget.options.label = "新增子节点";
+            columnSelectedWidget.options.labelHidden = false;
+            columnSelectedWidget.options.onClick =
+              "let tableParam = this.tableParam;\nthis.getParentTarget().addChildTreeRow(null,tableParam);";
+          } else if ("moveUpRow" == formatS) {
+            // columnSelectedWidget.options.prefixIcon = "el-icon-plus";
+            columnSelectedWidget.options.label = "↑上移";
+            columnSelectedWidget.options.labelHidden = false;
+            columnSelectedWidget.options.onClick =
+              "let tableParam = this.tableParam;\nthis.getParentTarget().moveUpRow(tableParam);";
+          } else if ("moveDownRow" == formatS) {
+            // columnSelectedWidget.options.prefixIcon = "el-icon-plus";
+            columnSelectedWidget.options.label = "↓下移";
+            columnSelectedWidget.options.labelHidden = false;
+            columnSelectedWidget.options.onClick =
+              "let tableParam = this.tableParam;\nthis.getParentTarget().moveDownRow(tableParam);";
+          } else if ("removeTreeRow" == formatS) {
+            columnSelectedWidget.options.prefixIcon = "el-icon-delete";
+            columnSelectedWidget.options.label = "删除";
+            columnSelectedWidget.options.labelHidden = true;
+            columnSelectedWidget.options.onClick =
+              "let tableParam = this.tableParam;\nthis.getParentTarget().removeTreeRow(tableParam);";
+          }
+          columnOption = columnSelectedWidget.options;
+        }
+        if (columnSelectedWidget.options.hasOwnProperty("keyName")) {
+          columnSelectedWidget.options.keyName = row.prop;
+          columnSelectedWidget.options.keyNameEnabled = true;
+        } else {
+          columnSelectedWidget.options.name = row.prop;
+        }
+        if (type != "button" && type != "a-link") {
+          columnSelectedWidget.options.label = row.label;
+          columnSelectedWidget.options.labelHidden = true;
+        }
+      }
+      return {columnSelectedWidget, columnEditFields};
+    },
+    getColumnProp(widget, obj, isEdit) {
+      if (!widget) {
+        return "false";
+      }
+      /*if(isEdit){
+        return "false"
+      }*/
+
+      let fieldKeyName = this.getFieldKeyName(widget);
+      let rowIndex = Math.max(obj.rowIndex, 0);
+      let isQueryTable = this.widget.options.isQueryTable || false;
+      if (isEdit || !isQueryTable) {
+        let propName =
+          fieldKeyName + "." + rowIndex + "." + obj.column.property;
+        let lineWidget = !isEdit
+          ? obj.column.params.widget
+          : obj.column.params.editWidget;
+        if (!lineWidget) {
+          return "false";
+        }
+        if (this.isVabsearchFlagWidget(lineWidget)) {
+          let fieldName =
+            lineWidget.options.vabSearchName ||
+            this.getFieldKeyName(lineWidget);
+          propName = fieldKeyName + "." + rowIndex + "." + fieldName;
+        }
+
+        return propName;
+      } else {
+        return "false";
+      }
+    },
+    isVabsearchFlagWidget(widget) {
+      let type = widget?.type;
+      return type == "vabsearch" || type == "singerSearch" || type == "multiSearch";
+    },
+    getColumnWidgetName(e) {
+      if (e && e.type) {
+        if (e.category == "container") {
+          return this.getContainerWidgetName(e);
+        } else {
+          return e.type + "-widget";
+        }
+      }
+    },
+    getGridTable() {
+      let $grid = this.$refs[this.getTableRef()];
+      return $grid;
+    },
+    getContainerWidgetName: function (e) {
+      return "grid" === e.type ? "grid-item" : e.type + "-item";
+    },
+    getWidgetName: function (e) {
+      return (e.targetType || e.type) + "-widget";
+    },
+    handleCheckboxChange(param) {
+      let mergeRowEnabled = this.widget.options.mergeRowEnabled || false;
+      let mergeRowKey = this.widget.options.mergeRowKey;
+      if (mergeRowEnabled && mergeRowKey) {
+        let grid = this.getGridTable();
+        let fullData = grid.getTableData().fullData;
+        let row = param.row;
+        let val = row[mergeRowKey];
+        let items = fullData.filter((item) => item[mergeRowKey] === val);
+        if (items.length) {
+          grid.setCheckboxRow(items, param.checked);
+        }
+      }
+      if (this.widget.options.onCheckboxChange) {
+        let t = new Function("param", this.widget.options.onCheckboxChange);
+        t.call(this, param);
+      }
+      let formRef = this.getFormRef();
+      let dataTableConfig = formRef.$attrs.dataTableOption || {};
+      dataTableConfig.onCheckboxChange &&
+      dataTableConfig.onCheckboxChange(param);
+    },
+    handleCheckboxAll(param) {
+      if (this.widget.options.onCheckboxAll) {
+        let t = new Function("param", this.widget.options.onCheckboxAll);
+        t.call(this, param);
+      }
+      let formRef = this.getFormRef();
+      let dataTableConfig = formRef.$attrs.dataTableOption || {};
+      dataTableConfig.onCheckboxAll && dataTableConfig.onCheckboxAll(param);
+    },
+    handleCellDblclick(param) {
+      if (this.widget.options.onCellDblclick) {
+        let t = new Function("param", this.widget.options.onCellDblclick);
+        t.call(this, param);
+      }
+      let formRef = this.getFormRef();
+      let dataTableConfig = formRef.$attrs.dataTableOption || {};
+      dataTableConfig.onCellDblclick && dataTableConfig.onCellDblclick(param);
+    },
+    advancedClear() {
+      let formModel = this.formModel;
+      let searchColumns = this.getGridTable().searchColumns;
+      searchColumns.forEach((form1Field) => {
+        if (!form1Field.common) {
+          let field = form1Field.field;
+          let options = form1Field.widget.options;
+          let value = formModel[field] ?? null;
+          let widgetRef = this.getWidgetRef(options.name);
+          widgetRef && widgetRef.setValue(value);
+        }
+      });
+      // this.getGridTable().$forceUpdate();
+    },
+    tableFormSettingConfirm() {
+      let formModel = this.formModel;
+      this.getFormRef().setFormData(formModel);
+    },
+
+    //editTable begin
+    saveEditRow(obj) {
+      let formRef = this.getFormRef();
+      let formConfig = this.formConfig;
+      let entity = formConfig.entity;
+      if (!entity) return;
+      let dataId = formRef?.dataId;
+      let reportTemplate = formRef?.reportTemplate;
+      let formCode = reportTemplate?.formCode;
+      let scriptCode = formConfig.saveScriptCode || "saveUpdate";
+
+      let that = this;
+      let $grid = obj.$table.$xegrid;
+      let originOption = $grid.originOption;
+
+      let formModel = this.formModel;
+      let dataMap = this.getGridTable().getTableData();
+
+      formRef.validate((valid) => {
+        if (valid) {
+          $grid.clearActived().then(() => {
+            $grid.setActiveRow(obj.row);
+            let mainData = commonDataUtil.handleForm(obj.row);
+
+            delete mainData._createNickName;
+            delete mainData._createMobile;
+            delete mainData._modifyNickName;
+            delete mainData._modifyMobile;
+            delete mainData._createBy;
+            delete mainData._modifyBy;
+
+            let formData = {
+              [entity]: mainData,
+            };
+
+            let reqData = {
+              formCode: formCode,
+              formVersion: reportTemplate.formVersion,
+              taBm: entity,
+              data: formData,
+            };
+
+            this.formHttp({
+              scriptCode: scriptCode,
+              data: reqData,
+              successMsg: true,
+              isConfirm: true,
+              confirmText: "您确定要保存吗？",
+              success: (res0) => {
+                this.getRowData(res0.objx, (res) => {
+                  if (obj.row.id == res.objx.id) {
+                    $grid.clearActived().then(() => {
+                      Object.assign(obj.row, res.objx);
+                    });
+                  } else {
+                    $grid.remove(obj.row);
+                    $grid.insertAt(res.objx);
+                  }
+                  delete obj.$table.editCloneRow;
+                });
+              },
+            });
+          });
+        }
+      });
+    },
+    getRowData(dataId, callback) {
+      let reportTemplate = this.getFormRef()?.reportTemplate;
+      let formCode = reportTemplate.formCode;
+      let formConfig = this.formConfig;
+      // let isLoadEntity = formConfig.isLoadEntity;
+      let entity = formConfig.entity;
+      let scriptCode = formConfig.formScriptCode || "getOne";
+      let defaultOption = this.getHttpConfigForUser();
+      this.formHttp({
+        scriptCode: scriptCode,
+        data: {
+          formCode: formCode,
+          formVersion: reportTemplate.formVersion,
+          taBm: entity,
+          data: {
+            id: dataId,
+          },
+        },
+        ...defaultOption,
+        success: (res) => {
+          callback && callback(res);
+        },
+      });
+    },
+    addChildTreeRow(rowData, obj, toTop) {
+      let toEnd = !toTop;
+      this.addTreeRow(rowData, obj, toEnd, null);
+    },
+    addTopTreeRow(rowData, toTop) {
+      let toEnd = !toTop;
+      this.addTreeRow(rowData, null, toEnd, null);
+    },
+    addSiblingTreeRow(rowData, obj) {
+      this.addTreeRow(rowData, obj, null, true);
+    },
+    addTreeRow(rowData, obj, toEnd, toSibling) {
+      let isEditTable = this.widget.options.isEditTable || false;
+      let parent = obj?.row;
+      let $grid = this.getGridTable();
+      if (isEditTable && this.hasEditingRow($grid, 1)) {
+        return false;
+      }
+      let parentField = $grid.treeConfig.parentField;
+      let newRow = {};
+      let originOption = $grid.originOption;
+      let editDefaultRow;
+      if (originOption.editDefaultRow) {
+        if (typeof originOption.editDefaultRow == "function") {
+          editDefaultRow = originOption.editDefaultRow() || {};
+        } else {
+          editDefaultRow = originOption.editDefaultRow || {};
+        }
+      }
+      // Object.assign(newRow, editDefaultRow, rowData);
+      newRow.id =
+        "row_" + new Date().valueOf() + Math.floor(Math.random() * 1000000);
+      if (!toSibling) {
+        newRow[parentField] = parent?.id || 0;
+      } else {
+        newRow[parentField] = obj?.row[parentField] || 0;
+      }
+
+      let newData = this.createNewTableData(isEditTable);
+      newRow = Object.assign({}, newData, newRow, editDefaultRow, rowData);
+
+      let tableRows = this.formModel[this.fieldKeyName] || [];
+      if (!parent) {
+        if (toEnd === true) {
+          tableRows.push(newRow);
+        } else if (toSibling === true) {
+          let addIndex =
+            tableRows.findIndex(
+              (item) => item._X_ROW_KEY == obj.row._X_ROW_KEY
+            ) + 1;
+          tableRows.splice(addIndex, 0, newRow);
+        } else {
+          tableRows.splice(0, 0, newRow);
+        }
+        this.setValue(tableRows);
+        this.$nextTick(() => {
+          this.handleWbs();
+          if (isEditTable) {
+            $grid.setActiveRow(newRow);
+          }
+        });
+
+        // $grid.insert(newRow).then(({row}) => $grid.setActiveRow(row));
+      } else {
+        $grid.setTreeExpand(obj.row, true).then(() => {
+          if (toEnd === true) {
+            tableRows.push(newRow);
+          } else if (toSibling === true) {
+            let addIndex =
+              tableRows.findIndex(
+                (item) => item._X_ROW_KEY == obj.row._X_ROW_KEY
+              ) + 1;
+            tableRows.splice(addIndex, 0, newRow);
+          } else {
+            tableRows.splice(0, 0, newRow);
+          }
+          this.setValue(tableRows);
+          this.$nextTick(() => {
+            this.handleWbs();
+            $grid.setTreeExpand(obj.row, true).then(() => {
+              if (isEditTable) {
+                $grid.setActiveRow(newRow);
+              }
+            });
+          });
+        });
+      }
+    },
+    removeTreeRow(obj) {
+      let row = obj.row;
+      let $grid = this.getGridTable();
+      let childrenField = $grid.treeConfig.children;
+      let tableRows = this.formModel[this.fieldKeyName];
+      // let index = tableRows.findIndex(item => item.id === row.id)
+      let delIds = [];
+      if (row[childrenField]) {
+        let loopDo = (item) => {
+          if (item.id) delIds.push(item.id);
+          item[childrenField] &&
+          item[childrenField].forEach((subItem) => {
+            loopDo(subItem);
+          });
+        };
+        loopDo(row);
+      }
+      delIds.forEach((id) => {
+        let index = tableRows.findIndex((item) => item.id === id);
+        let delRow = tableRows[index];
+        tableRows.splice(index, 1);
+        this.deleteRowWidgets(delRow)
+
+      });
+      this.$nextTick(() => {
+        this.handleWbs();
+      });
+    },
+    addSiblingEditRow(rowData, obj) {
+      this.addEditRow(rowData, obj, null, true);
+    },
+    addEditRow(rowData, obj, toEnd, toSibling) {
+      let isEditTable = this.widget.options.isEditTable || false;
+      let parent = obj?.row;
+      let $grid = this.getGridTable();
+      if (isEditTable && this.hasEditingRow($grid, 1)) {
+        return false;
+      }
+      let parentField = $grid.treeConfig.parentField;
+      let newRow = {};
+      let originOption = $grid.originOption;
+      let editDefaultRow;
+      if (originOption.editDefaultRow) {
+        if (typeof originOption.editDefaultRow == "function") {
+          editDefaultRow = originOption.editDefaultRow() || {};
+        } else {
+          editDefaultRow = originOption.editDefaultRow || {};
+        }
+      }
+      // Object.assign(newRow, editDefaultRow, rowData);
+      newRow.id =
+        "row_" + new Date().valueOf() + Math.floor(Math.random() * 1000000);
+      if (!toSibling) {
+        newRow[parentField] = parent?.id || 0;
+      } else {
+        newRow[parentField] = obj?.row[parentField] || 0;
+      }
+
+      let newData = this.createNewTableData(isEditTable);
+      newRow = Object.assign({}, newData, newRow, editDefaultRow, rowData);
+
+      let tableRows = this.formModel[this.fieldKeyName] || [];
+      if (!parent) {
+        if (toEnd === true) {
+          tableRows.push(newRow);
+        } else if (toSibling === true) {
+          let addIndex =
+            tableRows.findIndex(
+              (item) => item._X_ROW_KEY == obj.row._X_ROW_KEY
+            ) + 1;
+          tableRows.splice(addIndex, 0, newRow);
+        } else {
+          tableRows.splice(0, 0, newRow);
+        }
+        this.setValue(tableRows);
+        this.$nextTick(() => {
+          this.handleWbs();
+          if (isEditTable) {
+            $grid.setActiveRow(newRow);
+          }
+        });
+
+        // $grid.insert(newRow).then(({row}) => $grid.setActiveRow(row));
+      } else {
+        $grid.setTreeExpand(obj.row, true).then(() => {
+          if (toEnd === true) {
+            tableRows.push(newRow);
+          } else if (toSibling === true) {
+            let addIndex =
+              tableRows.findIndex(
+                (item) => item._X_ROW_KEY == obj.row._X_ROW_KEY
+              ) + 1;
+            tableRows.splice(addIndex, 0, newRow);
+          } else {
+            tableRows.splice(0, 0, newRow);
+          }
+          this.setValue(tableRows);
+          this.$nextTick(() => {
+            this.handleWbs();
+            $grid.setTreeExpand(obj.row, true).then(() => {
+              if (isEditTable) {
+                $grid.setActiveRow(newRow);
+              }
+            });
+          });
+        });
+      }
+    },
+    async removeEditRow(obj) {
+      this.removeTreeRow(obj);
+    },
+    //editTable end
+    getHttpConfigForUser() {
+      let defaultOption = {
+        addCreateInfo: true,
+        queryCreateInfo: window.$vueRoot.$store.getters.queryCreateInfo || "0",
+      };
+      return defaultOption;
+    },
+    handleWbs() {
+      if (this.widget.options.wbsEnabled) {
+        this.updateWbs();
+      }
+    },
+    updateWbs() {
+      let that = this;
+      let $grid = that.getGridTable();
+      let childrenField = $grid.treeConfig.children;
+      let fullData = $grid.getTableData().fullData;
+      let tableRows = this.formModel[that.fieldKeyName] || [];
+      let map = {};
+      let loopDo = (item, wbs) => {
+        item.f_wbs = wbs;
+        map[item._X_ROW_KEY] = wbs;
+        item[childrenField] &&
+        item[childrenField].forEach((subitem, subindex) => {
+          let sub_wbs = wbs + "." + (subindex + 1) + "";
+          loopDo(subitem, sub_wbs);
+        });
+      };
+      fullData.forEach((item, index) => {
+        let wbs = index + 1 + "";
+        loopDo(item, wbs);
+      });
+      $grid.updateData();
+    },
+    moveUpRow(obj) {
+      let row = obj.row;
+      let $grid = this.getGridTable();
+      let tableRows = this.formModel[this.fieldKeyName] || [];
+      let isTreeTable = this.widget.options.isTreeTable;
+      if (isTreeTable) {
+        let parentField = $grid.treeConfig.parentField;
+        let rowField = $grid.treeConfig.rowField || "id";
+        let paretValue = row[parentField];
+        let siblingRows = tableRows.filter(
+          (item) => item[parentField] === paretValue
+        );
+        if (siblingRows.length > 1) {
+          let currentIndex = tableRows.findIndex(
+            (item) => item[rowField] == row[rowField]
+          );
+          let index1 = siblingRows.findIndex(
+            (item) => item[rowField] == row[rowField]
+          );
+          if (index1 > 0) {
+            let prevRow = siblingRows[index1 - 1];
+            let prevIndex = tableRows.findIndex(
+              (item) => item[rowField] == prevRow[rowField]
+            );
+            tableRows.splice(currentIndex, 1);
+            tableRows.splice(prevIndex, 0, row);
+            this.setValue(tableRows);
+            this.$nextTick(() => {
+              this.handleWbs();
+            });
+          }
+        }
+      } else {
+        let rowIndex = $grid.getRowIndex(row);
+        if (rowIndex >= 0) {
+          tableRows.splice(rowIndex, 1);
+          tableRows.splice(rowIndex - 1, 0, row);
+          this.setValue(tableRows);
+          this.$nextTick(() => {
+            this.handleWbs();
+          });
+        }
+      }
+    },
+    moveDownRow(obj) {
+      let row = obj.row;
+      let $grid = this.getGridTable();
+      let tableRows = this.formModel[this.fieldKeyName] || [];
+      let isTreeTable = this.widget.options.isTreeTable;
+      if (isTreeTable) {
+        let parentField = $grid.treeConfig.parentField;
+        let rowField = $grid.treeConfig.rowField || "id";
+        let paretValue = row[parentField];
+        let siblingRows = tableRows.filter(
+          (item) => item[parentField] === paretValue
+        );
+        if (siblingRows.length > 1) {
+          let currentIndex = tableRows.findIndex(
+            (item) => item[rowField] == row[rowField]
+          );
+          let index1 = siblingRows.findIndex(
+            (item) => item[rowField] == row[rowField]
+          );
+          if (index1 < siblingRows.length - 1) {
+            let nextRow = siblingRows[index1 + 1];
+            let nextIndex = tableRows.findIndex(
+              (item) => item[rowField] == nextRow[rowField]
+            );
+            tableRows.splice(currentIndex, 1);
+            tableRows.splice(nextIndex, 0, row);
+            this.setValue(tableRows);
+            this.$nextTick(() => {
+              this.handleWbs();
+            });
+          }
+        }
+      } else {
+        let rowIndex = $grid.getRowIndex(row);
+        if (rowIndex < tableRows.length - 1) {
+          tableRows.splice(rowIndex, 1);
+          tableRows.splice(rowIndex + 1, 0, row);
+          this.setValue(tableRows);
+          this.$nextTick(() => {
+            this.handleWbs();
+          });
+        }
+      }
+    },
+
+    openSortRowDialog(obj) {
+      let $grid = this.getGridTable();
+      let parentField = $grid.treeConfig.parentField;
+      let rowField = $grid.treeConfig.rowField || "id";
+      let row = obj.row;
+      let tableRows = this.formModel[this.fieldKeyName] || [];
+
+      let sortParentRow = tableRows.find(
+        (item) => item[rowField] === row[parentField]
+      );
+      let sortRows = tableRows.filter(
+        (item) => item[parentField] === row[parentField]
+      );
+      this.sortRows = sortRows;
+      this.sortParentRow = sortParentRow;
+      this.showTreeMoveDialog = true;
+    },
+    confirmTreeMoveDialog(rows) {
+      if (this.widget.options.isEditTable) {
+        let reportTemplate = this.getFormRef().reportTemplate;
+        let formConfig = this.formConfig;
+        let entity = formConfig.entity;
+        let reqData = {
+          formCode: reportTemplate.formCode,
+          formVersion: reportTemplate.formVersion,
+          taBm: entity,
+          data: rows,
+        };
+        let scriptCode = this.widget.options.sortScriptCode;
+        this.formHttp({
+          scriptCode: scriptCode,
+          data: reqData,
+          successMsg: true,
+          isConfirm: true,
+          confirmText: "您确定要保存排序吗？",
+          success: (res) => {
+            this.getGridTable().reloadTreeExpand(this.sortParentRow);
+          },
+        });
+      } else {
+        let $grid = this.getGridTable();
+        let rowField = $grid.treeConfig.rowField || "id";
+        let tableRows = this.formModel[this.fieldKeyName] || [];
+
+        let ids = rows.map((item) => item[rowField]);
+        let index = tableRows.findIndex((item) => ids.includes(item[rowField]));
+        let items = tableRows.filter((item) => !ids.includes(item[rowField]));
+        rows.forEach((row, index1) => {
+          items.splice(index + index1, 0, row);
+        });
+        this.setValue(items);
+        this.$nextTick(() => {
+          this.handleWbs();
+        });
+      }
+    },
+    // 通用行合并函数（将相同多列数据合并为一行）
+    mergeRowMethod(tableParam) {
+      let {row, _rowIndex, column, visibleData} = tableParam;
+      let mergeRowEnabled = this.widget.options.mergeRowEnabled || false;
+      let unikey = this.widget.options.mergeRowKey;
+      const cellValue = row[unikey];
+      let isItemLine = column.params?.isItemLine || false;
+      if (mergeRowEnabled && unikey && !isItemLine) {
+        const prevRow = visibleData[_rowIndex - 1];
+        let nextRow = visibleData[_rowIndex + 1];
+        if (prevRow && prevRow[unikey] === cellValue) {
+          return {rowspan: 0, colspan: 0};
+        } else {
+          let countRowspan = 1;
+          while (nextRow && nextRow[unikey] === cellValue) {
+            nextRow = visibleData[++countRowspan + _rowIndex];
+          }
+          if (countRowspan > 1) {
+            return {rowspan: countRowspan, colspan: 1};
+          }
+        }
+      } else {
+        // return { rowspan: 1, colspan: 1 }
+      }
+    },
+    mergeRowMethod2({row, _rowIndex, column, visibleData}) {
+      const fields = ["key"];
+      const cellValue = row[column.field];
+      if (cellValue && fields.includes(column.field)) {
+        const prevRow = visibleData[_rowIndex - 1];
+        let nextRow = visibleData[_rowIndex + 1];
+        if (prevRow && prevRow[column.field] === cellValue) {
+          return {rowspan: 0, colspan: 0};
+        } else {
+          let countRowspan = 1;
+          while (nextRow && nextRow[column.field] === cellValue) {
+            nextRow = visibleData[++countRowspan + _rowIndex];
+          }
+          if (countRowspan > 1) {
+            return {rowspan: countRowspan, colspan: 1};
+          }
+        }
+      }
+    },
+
+    /**begin*/
+    /*initFieldSchemaData() {  //初始化fieldSchemaData！！！
+
+      let rowWidgetList = this.rowWidgetList
+      let rows = this.getValue();
+      let rowLength = rows.length
+      this.widgetMap = {}  //清除数组必须用splice，length=0不会响应式更新！！
+      if (rowLength > 0) {
+        for (let i = 0; i < rowLength; i++) {
+          let row = rows[i];
+          let fieldSchemas = []
+          rowWidgetList.forEach(swItem => {
+            fieldSchemas.push( this.cloneFieldSchema(swItem) )
+          })
+          let keyVal = row._X_ROW_KEY;
+          this.widgetMap[keyVal] = fieldSchemas;
+        }
+      }
+    },
+
+    addToFieldSchemaData(row) {
+      let fieldSchemas = []
+      this.rowWidgetList.forEach(swItem => {
+        fieldSchemas.push( this.cloneFieldSchema(swItem) )
+      })
+
+      let keyVal = row._X_ROW_KEY;
+      this.widgetMap[keyVal] = fieldSchemas;
+    },
+
+    deleteFromFieldSchemaData(row) {
+      let keyVal = row._X_ROW_KEY;
+      delete this.widgetMap[keyVal] ;
+    },
+
+    cloneFieldSchema(fieldWidget) {
+      let newFieldSchema = this.$baseLodash.cloneDeep(fieldWidget)
+      newFieldSchema.id = fieldWidget.type + generateId()
+      return newFieldSchema
+    },*/
+    clearRowWidgets() {
+      // this.widgetMap = {};
+    },
+    deleteRowWidgets(row) {
+      this.rowWidgetList.forEach(widget => {
+        let key = this.getRowRefKey(row, widget.options.name);
+        delete this.widgetMap[key];
+      })
+    }
+    /**end*/
+
+  },
+};
+
+export default modules;