cloud-web-corejs 1.0.54-dev.781 → 1.0.54-dev.783

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

@@ -52,9 +52,19 @@ import formulaDialog from "@base/components/xform/form-designer/form-widget/dial
 import baseFormulaDialog from "@base/components/xform/form-designer/form-widget/dialog/baseFormulaDialog.vue";
 import QRCode from "qrcode";
 import { openLuckysheetDialog } from "@base/components/luckysheet";
-import {
-  openComponentDialog as mountComponentDialog,
-} from "@base/utils/componentDialog";
+import {
+  openComponentDialog as mountComponentDialog,
+} from "@base/utils/componentDialog";
+import {
+  buildTreeSubmitData,
+  copyTreeData,
+  getTreeLoadState,
+  isTemporaryTreeKey,
+  resolveTreeCopyConfig,
+  resolveTreeFields,
+  resolveTreeIdentityConfig,
+  resolveTreeSubmitConfig,
+} from "../utils/treeTableUtil";
 
 let modules = {};
 const baseRefUtil = {
@@ -1283,12 +1293,12 @@ modules = {
 
       return hasModifyItem;
     },
-    loadFormData(options) {
-      let config = options.config || {};
+    loadFormData(options = {}) {
+      let config = options.config || {};
       let that = this;
       let formConfig = this.formConfig;
       let entity = formConfig.entity;
-      let dataId = this.dataId;
+      let dataId = options.dataId ?? this.dataId;
       let reportTemplate = this.reportTemplate;
       let scriptCode = formConfig.formScriptCode || "getOne";
 
@@ -1317,11 +1327,13 @@ modules = {
               ...formScriptParam,
             },
           },
-          ...defaultOption,
-          success: (res) => {
-            formData = res.objx || {};
-            this.setFormData(formData);
-            options.callback && options.callback(formData);
+          ...defaultOption,
+          success: (res) => {
+            formData = res.objx || {};
+            this.setFormData(formData, {
+              replace: options.replace === true,
+            });
+            options.callback && options.callback(formData);
           },
           ...config,
         });
@@ -1989,12 +2001,22 @@ modules = {
         n
       );
     },
-    setFormData: function (e) {
-      let t = this;
+    setFormData: function (e, options = {}) {
+      let t = this;
       /*Object.keys(this.formDataModel).forEach(function (i) {
         e && e.hasOwnProperty(i) && (t.formDataModel[i] = baseRefUtil.deepClone(e[i]));
       });*/
-      Object.assign(t.formDataModel, baseRefUtil.deepClone(e));
+      let nextFormData = baseRefUtil.deepClone(e || {});
+      if (options.replace === true) {
+        Object.keys(t.formDataModel).forEach((key) => {
+          t.$delete(t.formDataModel, key);
+        });
+        Object.keys(nextFormData).forEach((key) => {
+          t.$set(t.formDataModel, key, nextFormData[key]);
+        });
+      } else {
+        Object.assign(t.formDataModel, nextFormData);
+      }
       this.currentFormData = e || {};
       this.broadcast("ContainerItem", "setFormData", this.formDataModel),
         this.broadcast("FieldWidget", "setFormData", this.formDataModel);
@@ -3971,13 +3993,206 @@ modules = {
             reject(msg);
           });
       });
-    },
-    getSubData2(flag) {
+    },
+    getTreeTableUtilContext(tableTarget, $grid, source) {
+      let treeConfig = $grid?.treeConfig || {};
+      let originOption
+        = $grid?.params?.originOption || $grid?.originOption || {};
+      let fields = resolveTreeFields(treeConfig, {
+        strict: true,
+      });
+      let identityConfig = resolveTreeIdentityConfig(
+        treeConfig,
+        originOption.treeIdentityConfig || {}
+      );
+      let copyConfig = resolveTreeCopyConfig(
+        fields,
+        identityConfig,
+        originOption.treeCopyConfig || {}
+      );
+      let submitConfig = resolveTreeSubmitConfig(
+        originOption.treeSubmitConfig || {}
+      );
+      let temporaryKeyRegistry
+        = tableTarget?.treeTemporaryKeyRegistry || new Set();
+      let knownFormalKeyRegistry
+        = tableTarget?.treeKnownFormalKeyRegistry || new Set();
+
+      this.collectTreeRuntimeRows(source || [], treeConfig).forEach((row) => {
+        let rowValue = row[fields.rowField];
+        let marker = row._X_TREE_TEMP_KEY;
+        if (marker !== undefined && marker !== null) {
+          temporaryKeyRegistry.add(marker);
+        }
+        if (
+          rowValue !== undefined
+          && rowValue !== null
+          && rowValue !== ""
+          && !isTemporaryTreeKey(row, fields.rowField, identityConfig)
+        ) {
+          knownFormalKeyRegistry.add(rowValue);
+        }
+      });
+
+      return {
+        fields,
+        identityConfig,
+        copyConfig,
+        submitConfig,
+        temporaryKeyRegistry,
+        knownFormalKeyRegistry,
+      };
+    },
+    collectTreeRuntimeRows(rows, treeConfig) {
+      let result = [];
+      let visited = new WeakSet();
+      let childrenFields = [
+        treeConfig?.children,
+        treeConfig?.mapChildren || "_X_ROW_CHILD",
+      ].filter(Boolean);
+      let visit = (items) => {
+        if (!Array.isArray(items)) return;
+        items.forEach((item) => {
+          if (!item || typeof item !== "object" || visited.has(item)) return;
+          visited.add(item);
+          result.push(item);
+          childrenFields.forEach((field) => {
+            visit(item[field]);
+          });
+        });
+      };
+      visit(rows);
+      return result;
+    },
+    getTreeRuntimeSource($grid, source) {
+      let result = Array.isArray(source) ? source.slice() : [];
+      let runtimeSources = [
+        $grid?.getTableData?.()?.fullData,
+        $grid?.$refs?.xTable?.tableFullTreeData,
+      ];
+      runtimeSources.forEach((rows) => {
+        if (!Array.isArray(rows)) return;
+        rows.forEach((row) => {
+          if (!result.includes(row)) result.push(row);
+        });
+      });
+      return result;
+    },
+    getTreeUnloadedRows($grid, treeConfig) {
+      let xTable = $grid?.$refs?.xTable;
+      let fullData = this.getTreeRuntimeSource($grid, []);
+      return this.collectTreeRuntimeRows(fullData, treeConfig).filter(
+        (row) =>
+          getTreeLoadState(row, {
+            fields: resolveTreeFields(treeConfig),
+            isTreeNodeLoaded:
+              typeof xTable?.isTreeExpandLoaded === "function"
+                ? (targetRow) => xTable.isTreeExpandLoaded(targetRow)
+                : null,
+          }).requiresLoad
+      );
+    },
+    async ensureTreeTableLoadState(formTemplateTableDTO, operation) {
+      let tableTarget = this.getWidgetRef(formTemplateTableDTO.uniqueName);
+      let $grid = tableTarget?.getGridTable?.();
+      let treeConfig = $grid?.treeConfig;
+      if (!$grid || !treeConfig?.lazy) return;
+
+      let treeContext = this.getTreeTableUtilContext(
+        tableTarget,
+        $grid,
+        this.formDataModel[formTemplateTableDTO.name] || []
+      );
+      let strategy = operation === "copy"
+        ? treeContext.copyConfig.lazyStrategy
+        : treeContext.submitConfig.unloadedChildrenStrategy;
+      if (operation === "submit" && strategy === "omit") return;
+
+      let xTable = $grid.$refs?.xTable;
+      if (
+        !xTable
+        || typeof xTable.isTreeExpandLoaded !== "function"
+        || typeof $grid.setTreeExpand !== "function"
+      ) {
+        throw new Error(
+          `[${formTemplateTableDTO.tableAlias}]无法读取树节点加载状态`
+        );
+      }
+
+      let unloadedRows = this.getTreeUnloadedRows($grid, treeConfig);
+      if (!unloadedRows.length) return;
+      if (strategy !== "loadAll") {
+        let action = operation === "copy" ? "复制" : "保存";
+        throw new Error(
+          `[${formTemplateTableDTO.tableAlias}]存在尚未加载的树节点，请先展开后再${action}`
+        );
+      }
+
+      let loopCount = 0;
+      while (unloadedRows.length) {
+        if (loopCount++ > 100) {
+          throw new Error(
+            `[${formTemplateTableDTO.tableAlias}]树节点层级过深，无法完成加载`
+          );
+        }
+        let currentRows = unloadedRows;
+        await Promise.all(
+          currentRows.map((row) => $grid.setTreeExpand(row, true))
+        );
+        unloadedRows = this.getTreeUnloadedRows($grid, treeConfig);
+        if (
+          unloadedRows.length === currentRows.length
+          && unloadedRows.every((row) => currentRows.includes(row))
+        ) {
+          throw new Error(
+            `[${formTemplateTableDTO.tableAlias}]树节点加载未完成，已停止保存`
+          );
+        }
+      }
+    },
+    async ensureTreeTableReadyForSubmit(formTemplateTableDTO) {
+      return this.ensureTreeTableLoadState(
+        formTemplateTableDTO,
+        "submit"
+      );
+    },
+    async prepareTreeTablesForCopy() {
+      let treeTables = this.getFormTemplateTableDTOs().filter(
+        (item) => item.isTreeTable
+      );
+      for (let index = 0; index < treeTables.length; index++) {
+        await this.ensureTreeTableLoadState(treeTables[index], "copy");
+      }
+    },
+    async buildSubmitPayload(option) {
+      let treeTables = this.getFormTemplateTableDTOs().filter(
+        (item) => item.isTreeTable
+      );
+      for (let index = 0; index < treeTables.length; index++) {
+        await this.ensureTreeTableReadyForSubmit(treeTables[index]);
+      }
+      let formDataSnapshot = this.$baseLodash.cloneDeep(this.formDataModel);
+      let subData = this.getSubData2(false, {
+        mode: "submit",
+        formDataModel: formDataSnapshot,
+      });
+      if (option) {
+        let realFormData = {};
+        Object.keys(option).forEach((key) => {
+          realFormData[option[key]] = subData[key];
+        });
+        return realFormData;
+      }
+      return subData;
+    },
+    getSubData2(flag, context = {}) {
       let that = this;
       let formCode = this.reportTemplate.formCode;
       let tableFiledMap = this.getTableFiledMap();
       let formTemplateTableDTOs = this.getFormTemplateTableDTOs();
-      let formDataModel = this.formDataModel;
+      let formDataModel
+        = context.formDataModel
+        || this.$baseLodash.cloneDeep(this.formDataModel);
       let formConfig = this.formConfig;
 
       let res = {};
@@ -4012,63 +4227,32 @@ modules = {
           newFormData[tableAlias] = item ?? null;
         } else {
           if (formTemplateTableDTO.isTreeTable) {
-            let tableTarget = this.getWidgetRef(
-              formTemplateTableDTO.uniqueName
-            );
-            let $grid = tableTarget.getGridTable();
-            let parentField = $grid.treeConfig.parentField;
-            let treeTaBm = newFormData.treeTaBm || [];
-            treeTaBm.push(formTemplateTableDTO.tableAlias);
-            newFormData.treeTaBm = treeTaBm;
-            // 树的主键以 treeConfig.rowField 为准：transform 模式下 vxe 是用它
-            // (xe-utils toArrayTree 的 key) 建树的，根节点判定必须与之同源，
-            // 否则判出来的顶层节点和表格里的实际层级对不上。
-            let idField = $grid.treeConfig.rowField || "id";
-            let tableDatas = this.$baseLodash.cloneDeep(
-              formDataModel[formTemplateTableDTO.name] || []
-            );
-            // 根节点判定必须在下面清空临时 id 之前完成：新增子行的父 id 是
-            // "row_xxx"，清空后变成空值，之后再判定就会被误判成根节点，既提交成
-            // 顶层节点又已嵌在父行的 children 里，造成重复与层级错乱。
-            // 判定口径与 toArrayTree 一致：父值为空(null/undefined/""/0/"0")视为
-            // 根；父值非空但父行不在本表数据里（过滤/查询后的孤儿行）也要收进顶层
-            // 数组，否则整棵子树被静默丢弃——它的 parentField 原值保留不清空，
-            // 后端据此重新挂接到既有父节点。
-            let idSet = new Set();
-            tableDatas.forEach((tableData) => {
-              let id = tableData[idField];
-              if (id !== null && id !== undefined && id !== "") {
-                idSet.add(String(id));
-              }
-            });
-            let isRootFlags = tableDatas.map((tableData) => {
-              let parentValue = tableData[parentField];
-              if ([null, undefined, "", 0, "0"].includes(parentValue)) {
-                return true;
-              }
-              return !idSet.has(String(parentValue));
-            });
-            // 临时 id 要连字面量 id 一起清：新增行(addTreeRow)把 "row_xxx" 写在
-            // row.id 上，复制(handleCopyTreeData)写在 rowField 上，来源不同，
-            // 只清一个会把临时 id 提交给后端。rowField 缺省时两者是同一字段。
-            let clearTempValue = (tableData, field) => {
-              let value = tableData[field];
-              if (value && value.startsWith && value.startsWith("row_")) {
-                tableData[field] = null;
-              }
-            };
-            tableDatas.forEach((tableData) => {
-              clearTempValue(tableData, idField);
-              if (idField !== "id") {
-                clearTempValue(tableData, "id");
-              }
-              clearTempValue(tableData, parentField);
-              if (tableData[parentField] === undefined)
-                tableData[parentField] = null;
-            });
-            tableDatas = tableDatas.filter((item, index) => isRootFlags[index]);
-            newFormData[tableAlias] = tableDatas;
-          } else {
+            let tableTarget = this.getWidgetRef(
+              formTemplateTableDTO.uniqueName
+            );
+            let $grid = tableTarget.getGridTable();
+            let treeTaBm = newFormData.treeTaBm || [];
+            treeTaBm.push(formTemplateTableDTO.tableAlias);
+            newFormData.treeTaBm = treeTaBm;
+            let modelRows = formDataModel[formTemplateTableDTO.name];
+            let sourceRows = Array.isArray(modelRows) ? modelRows : [];
+            let treeContext = this.getTreeTableUtilContext(
+              tableTarget,
+              $grid,
+              sourceRows
+            );
+            newFormData[tableAlias] = buildTreeSubmitData(sourceRows, {
+              ...treeContext,
+              submitConfig:
+                context.mode === "submit"
+                  ? treeContext.submitConfig
+                  : {
+                      ...treeContext.submitConfig,
+                      orphanParentStrategy: "preserve",
+                    },
+              strict: context.mode === "submit",
+            });
+          } else {
             newFormData[tableAlias] =
               formDataModel[formTemplateTableDTO.name] ?? null;
           }
@@ -4265,10 +4449,10 @@ modules = {
         this.$baseReload();
       }
     },
-    reloadForm(option) {
-      let target1 = this.$attrs["parent-target"];
-      let target2 = target1?.$attrs["parent-target"];
-      let target = !target2 ? this : target1;
+    reloadForm(option) {
+      let target1 = this.$attrs["parent-target"];
+      let target2 = target1?.$attrs["parent-target"];
+      let target = !target2 ? this : target1;
       /* if (this.$attrs['reloadDialog'] !== true) {
         target = this.$attrs['parent-target'];
       }else{
@@ -4278,8 +4462,44 @@ modules = {
       for (let key in updateParam) {
         target.$emit("update:" + key, updateParam[key]);
       }*/
-      target.$baseReload(option);
-    },
+      try {
+        let reloadListener = target?.$listeners?.reload;
+        if (Array.isArray(reloadListener)) {
+          return Promise.all(
+            reloadListener.map((listener) => listener(target, option))
+          );
+        }
+        if (typeof reloadListener === "function") {
+          return Promise.resolve(reloadListener(target, option));
+        }
+        return Promise.resolve(target.$baseReload(option));
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+    async reloadSavedFormData(option = {}) {
+      let updateParam = option.updateParam || {};
+      let nextDataId = updateParam.dataId ?? this.dataId;
+      let nextFormCode = updateParam.formCode;
+      if (nextDataId === undefined || nextDataId === null || nextDataId === "") {
+        throw new Error("缺少保存后的数据 ID，无法重新加载表单。");
+      }
+      let response = await this.loadFormData({
+        dataId: nextDataId,
+        replace: true,
+      });
+      if (!response || response.type !== "success") {
+        throw new Error(response?.content || "保存后的表单数据重新加载失败。");
+      }
+      if (nextDataId !== undefined && nextDataId !== null) {
+        this.$emit("update:dataId", nextDataId);
+      }
+      if (nextFormCode) {
+        this.$emit("update:formCode", nextFormCode);
+      }
+      await new Promise((resolve) => this.$nextTick(resolve));
+      return response;
+    },
     saveForm(callback) {
       this.validateForm((valid) => {
         if (!valid) return;
@@ -4674,181 +4894,69 @@ modules = {
     getFormRef() {
       return this;
     },
-    isObject(value) {
-      return Object.prototype.toString.call(value) === "[object Object]";
-    },
-    handleCopyTreeData(value, widget) {
-      if (!value || !widget || !Array.isArray(value) || value.length === 0)
-        return;
-
-      // 获取树形表格配置
-      const widgetName = widget.options.name;
-      const gridRef = this.getWidgetRef(widgetName);
-      const $grid = gridRef.getGridTable();
-      const treeConfig = $grid.treeConfig;
-      const idField = treeConfig.rowField || "id";
-      const parentField = treeConfig.parentField;
-      const childrenField = treeConfig.children;
-
-      // 初始化 id 生成器
-      const baseTime = new Date().valueOf();
-      let counter = 0;
-      const idMap = {}; // 旧 id 到新 id 的映射
-
-      // 生成新的 id（以 'row_' 开头）
-      const generateNewId = () => {
-        counter++;
-        return `row_${baseTime}_${counter}_${Math.floor(
-          Math.random() * 1000000
-        )}`;
-      };
-
-      // 收集所有节点（包括扁平数组和嵌套结构中的节点），使用 Set 去重
-      const allNodes = [];
-      const processedNodes = new WeakSet(); // 使用 WeakSet 来跟踪已处理的节点，避免重复处理
-
-      const collectAllNodes = (nodes) => {
-        if (!Array.isArray(nodes)) return;
-        nodes.forEach((node) => {
-          if (node && this.isObject(node) && !processedNodes.has(node)) {
-            processedNodes.add(node);
-            allNodes.push(node);
-            // 递归收集嵌套在 childrenField 中的节点
-            if (node[childrenField] && Array.isArray(node[childrenField])) {
-              collectAllNodes(node[childrenField]);
-            }
-          }
-        });
-      };
-      collectAllNodes(value);
-
-      // 第一步：为所有节点生成新的 id 并建立映射
-      // 注意：即使 id 为 null，也要生成新 id
-      allNodes.forEach((node) => {
-        if (node[idField] !== undefined && node[idField] !== null) {
-          // 如果节点已有 id，记录映射关系
-          const oldId = node[idField];
-          const newId = generateNewId();
-          idMap[oldId] = newId;
-          node[idField] = newId;
-        } else {
-          // 如果节点 id 为 null 或 undefined，直接生成新 id
-          const newId = generateNewId();
-          node[idField] = newId;
-        }
-      });
-
-      // 第二步：更新所有节点的 parentField（使用映射的新 id）
-      allNodes.forEach((node) => {
-        if (
-          node[parentField] !== undefined &&
-          node[parentField] !== null &&
-          node[parentField] !== 0
-        ) {
-          const oldParentId = node[parentField];
-          // 如果父节点的旧 id 在映射中，更新为新 id
-          if (idMap[oldParentId]) {
-            node[parentField] = idMap[oldParentId];
-          } else {
-            // 如果父节点不在映射中（可能是外部引用或已处理），尝试在 allNodes 中查找
-            const parentNode = allNodes.find((n) => n[idField] === oldParentId);
-            if (parentNode) {
-              node[parentField] = parentNode[idField];
-            } else {
-              // 找不到父节点，设置为 0（根节点）
-              node[parentField] = 0;
-            }
-          }
-        }
-      });
-
-      // 第三步：更新嵌套的 childrenField 结构中的 parentField
-      const updateNestedChildrenParent = (node) => {
-        if (
-          !node ||
-          !node[childrenField] ||
-          !Array.isArray(node[childrenField]) ||
-          node[childrenField].length === 0
-        ) {
-          return;
-        }
-
-        node[childrenField].forEach((child) => {
-          if (child && node[idField]) {
-            child[parentField] = node[idField];
-          }
-          updateNestedChildrenParent(child);
-        });
-      };
-      allNodes.forEach((node) => updateNestedChildrenParent(node));
-
-      // 第四步：处理节点中的其他数组字段（如子表单、附件列表等）
-      // 注意：需要跳过树形结构相关的字段，避免误处理
-      const treeRelatedFields = new Set([
-        idField,
-        parentField,
-        childrenField,
-        "_X_ROW_KEY",
-        "_X_ROW_CHILD",
-        "f_wbs",
-      ]);
-      const processedArrayNodes = new WeakSet(); // 跟踪已处理的数组节点，避免重复处理
-
-      const processNodeArrayFields = (node) => {
-        if (!node || !this.isObject(node)) return;
-
-        // 如果节点已经在 allNodes 中（是树形节点），跳过处理，避免覆盖已生成的 id
-        if (processedNodes.has(node)) {
-          return;
-        }
-
-        Object.keys(node).forEach((key) => {
-          // 跳过树形结构相关字段
-          if (treeRelatedFields.has(key)) {
-            return;
-          }
-
-          const fieldValue = node[key];
-
-          // 处理数组字段
-          if (Array.isArray(fieldValue) && fieldValue.length > 0) {
-            fieldValue.forEach((item) => {
-              if (this.isObject(item)) {
-                // 如果这个对象是树形节点（在 allNodes 中），跳过处理
-                if (processedNodes.has(item)) {
-                  return;
-                }
-
-                // 只有非树形节点的数组元素才需要清空 id
-                if (item.id !== undefined) {
-                  item.id = null;
-                }
-                this.handleCopyDefaultData(item);
-
-                // 标记已处理，避免重复处理
-                if (!processedArrayNodes.has(item)) {
-                  processedArrayNodes.add(item);
-                  processNodeArrayFields(item);
-                }
-              }
-            });
-            return;
-          }
-
-          // 处理嵌套对象
-          if (this.isObject(fieldValue)) {
-            // 如果这个对象是树形节点，跳过处理
-            if (!processedNodes.has(fieldValue)) {
-              processNodeArrayFields(fieldValue);
-            }
-          }
-        });
-      };
-
-      // 处理所有节点中的其他数组字段
-      allNodes.forEach((node) => processNodeArrayFields(node));
-    },
-    handleCopyDefaultData(data) {
+    isObject(value) {
+      return Object.prototype.toString.call(value) === "[object Object]";
+    },
+    handleCopyTreeData(value, widget) {
+      if (!Array.isArray(value) || !widget) return;
+
+      let widgetName = widget.options.name;
+      let gridRef = this.getWidgetRef(widgetName);
+      let $grid = gridRef?.getGridTable?.();
+      if (!$grid) {
+        throw new Error(`[${widgetName}]树表尚未初始化`);
+      }
+      if (
+        $grid.treeConfig?.lazy
+        && this.getTreeUnloadedRows($grid, $grid.treeConfig).length
+      ) {
+        throw new Error(
+          `[${widgetName}]存在尚未加载的树节点，无法复制不完整子树`
+        );
+      }
+
+      // prepareTreeTablesForCopy 会在深拷贝及 copyDataHandle 之前完成 loadAll，
+      // 此处只消费准备好的副本；不能再混入 VXE 活对象，否则会覆盖脚本修改并产生同键冲突。
+      let sourceRows = value;
+      if (!sourceRows.length) return;
+
+      let treeContext = this.getTreeTableUtilContext(
+        gridRef,
+        $grid,
+        sourceRows
+      );
+      let copiedRows = copyTreeData(sourceRows, {
+        ...treeContext,
+        temporaryKeyRegistry: new Set(
+          treeContext.temporaryKeyRegistry
+        ),
+        targetRows: [],
+      });
+      let fields = treeContext.fields;
+      let ignoredFields = new Set([
+        fields.rowField,
+        fields.parentField,
+        fields.childrenField,
+        fields.mapChildrenField,
+        fields.hasChildField,
+        treeContext.identityConfig.physicalIdField,
+        "_X_ROW_KEY",
+        "_X_ROW_CHILD",
+        "_X_TREE_TEMP_KEY",
+        "f_wbs",
+      ]);
+
+      copiedRows.forEach((row) => {
+        this.handleCopyDefaultData(row);
+        Object.keys(row).forEach((key) => {
+          if (ignoredFields.has(key) || !Array.isArray(row[key])) return;
+          this.handleCopyData(row[key], key);
+        });
+      });
+
+      value.splice(0, value.length, ...copiedRows);
+    },
+    handleCopyDefaultData(data) {
       data.create_by = null;
       data._create_by = null;
       data.create_date = null;
@@ -4903,14 +5011,22 @@ modules = {
         });
       }
     },
-    openCopyEditTab(copyData) {
-      let formData = this.$baseLodash.cloneDeep(copyData || this.formDataModel);
-      if (formData) {
-        this.handleCopyData(formData);
-      }
-
-      this.$emit("openCopyEditTab", formData);
-    },
+    async openCopyEditTab(copyData) {
+      try {
+        await this.prepareTreeTablesForCopy();
+        let formData = this.$baseLodash.cloneDeep(
+          copyData || this.formDataModel
+        );
+        if (formData) {
+          this.handleCopyData(formData);
+        }
+        this.$emit("openCopyEditTab", formData);
+        return true;
+      } catch (error) {
+        this.$message.error(error?.message || "树表数据尚未准备完成");
+        return false;
+      }
+    },
 
     async exportPdf() {
       // statusEl.style.display = 'block';