@ibiz-template/runtime 0.6.1-dev.0 → 0.6.1-dev.2

package/src/controller/control/tree/tree.controller.ts

@@ -1,950 +0,0 @@
-/* eslint-disable no-param-reassign */
-import {
-  RuntimeError,
-  RuntimeModelError,
-  recursiveIterate,
-} from '@ibiz-template/core';
-import {
-  IDETBUIActionItem,
-  IDEToolbarItem,
-  IDETree,
-  IDETreeDataSetNode,
-  IDETreeNode,
-} from '@ibiz/model-core';
-import {
-  ITreeState,
-  ITreeEvent,
-  ITreeController,
-  MDCtrlLoadParams,
-  ITreeNodeData,
-} from '../../../interface';
-import { UIActionUtil } from '../../../ui-action';
-import { MDControlController } from '../../common';
-import { ContextMenuController } from '../context-menu';
-import { TreeService } from './tree.service';
-import { calcDeCodeNameById, getChildNodeRSs } from '../../../model';
-import { ControllerEvent } from '../../utils';
-import { AppCounter, CounterService } from '../../../service';
-
-export type DropNodeRS = {
-  minorEntityId: string;
-  pickupDEFName: string;
-  childDETreeNodeId: string;
-};
-
-/**
- * 树部件控制器
- * @author lxm
- * @date 2023-05-26 08:20:46
- * @export
- * @class TreeController
- * @extends {MDControlController<IDETree, ITreeState, ITreeEvent>}
- * @implements {ITreeController}
- */
-export class TreeController<
-    T extends IDETree = IDETree,
-    S extends ITreeState = ITreeState,
-    E extends ITreeEvent = ITreeEvent,
-  >
-  extends MDControlController<T, S, E>
-  implements ITreeController<T, S, E>
-{
-  declare service: TreeService;
-
-  protected get _evt(): ControllerEvent<ITreeEvent> {
-    return this.evt;
-  }
-
-  /**
-   * 上下文菜单控制器
-   * @author lxm
-   * @date 2023-08-21 10:56:24
-   * @type {{ [p: string]: ContextMenuController }}
-   */
-  contextMenus: { [p: string]: ContextMenuController } = {};
-
-  /**
-   * 是否启用快速搜索
-   * @author lxm
-   * @date 2023-12-04 03:33:32
-   * @type {boolean}
-   */
-  enableQuickSearch: boolean = false;
-
-  /**
-   * 拖入节点关系处理
-   * @author lxm
-   * @date 2023-12-14 03:05:38
-   */
-  dropNodeRss = new Map<string, DropNodeRS[]>();
-
-  /**
-   * 节点上下文解析后信息`
-   * @author lxm
-   * @date 2023-12-29 10:38:37
-   */
-  contextMenuInfos: {
-    [p: string]: {
-      /**
-       * 上下文菜单里第一个行为级别为常用操作的项
-       */
-      clickTBUIActionItem?: IDETBUIActionItem;
-      onlyOneActionItem: boolean;
-    };
-  } = {};
-
-  /**
-   * 计数器对象
-   * @author lxm
-   * @date 2024-01-18 05:12:35
-   * @type {AppCounter}
-   */
-  counter?: AppCounter;
-
-  protected initState(): void {
-    super.initState();
-    // 根节点初始化
-    this.state.defaultExpandedKeys = [];
-    this.state.expandedKeys = [];
-    this.state.navigational = false;
-    this.state.size = 0;
-    this.state.query = '';
-  }
-
-  protected async onCreated(): Promise<void> {
-    await super.onCreated();
-
-    this.state.expandedKeys = [...this.state.defaultExpandedKeys];
-
-    // 快速搜索
-    if (this.model.detreeNodes?.[0].enableQuickSearch) {
-      this.enableQuickSearch = true;
-    }
-
-    // 计算快速搜索占位符
-    if (this.dataEntity) {
-      const searchFields = this.dataEntity.appDEFields?.filter(field => {
-        return field.enableQuickSearch;
-      });
-      const placeHolders: string[] = [];
-      searchFields?.forEach(searchField => {
-        if (searchField?.lnlanguageRes && searchField.lnlanguageRes.lanResTag) {
-          placeHolders.push(
-            ibiz.i18n.t(
-              searchField.lnlanguageRes.lanResTag,
-              searchField.logicName,
-            ),
-          );
-        } else if (searchField?.logicName) {
-          placeHolders.push(searchField.logicName);
-        }
-      });
-      if (placeHolders.length > 0) {
-        this.state.placeHolder = placeHolders.join('、');
-      }
-    }
-
-    this.initDropNodeRss();
-    this.initNodeClickTBUIActionItem();
-
-    await this.initService();
-    await this.initCounter();
-
-    // 初始化上下文菜单控制器
-    this.model.detreeNodes!.forEach(node => {
-      if (node.decontextMenu?.detoolbarItems?.length) {
-        this.contextMenus[node.decontextMenu.id!] = new ContextMenuController(
-          node.decontextMenu,
-          this.context,
-          this.params,
-          this.ctx,
-        );
-      }
-    });
-
-    // 上下文菜单控制器初始化
-    await Promise.all(
-      Object.values(this.contextMenus).map(menu => menu.created()),
-    );
-  }
-
-  protected async onDestroyed(): Promise<void> {
-    await super.onDestroyed();
-    if (this.counter) {
-      this.counter.destroy();
-    }
-  }
-
-  /**
-   * 初始化对应类型的部件服务
-   * @author lxm
-   * @date 2023-12-21 11:25:33
-   * @protected
-   * @return {*}  {Promise<void>}
-   */
-  protected async initService(): Promise<void> {
-    this.service = new TreeService(this.model);
-    await this.service.init(this.context);
-  }
-
-  /**
-   * 初始化计数器
-   * @author lxm
-   * @date 2024-01-18 05:12:02
-   * @protected
-   * @return {*}  {Promise<void>}
-   */
-  protected async initCounter(): Promise<void> {
-    const { appCounterRefs } = this.model;
-    const appCounterRef = appCounterRefs?.[0];
-    if (appCounterRef) {
-      this.counter = await CounterService.getCounterByRef(
-        appCounterRef,
-        this.context,
-      );
-    }
-  }
-
-  /**
-   * 初始化节点拖入关系处理
-   * @author lxm
-   * @date 2023-12-14 03:13:42
-   * @protected
-   */
-  protected initDropNodeRss(): void {
-    this.model.detreeNodes?.forEach(node => {
-      if (!node.allowDrop) {
-        return;
-      }
-      const infos: Array<DropNodeRS> = [];
-      const nodeRSs = getChildNodeRSs(this.model, {
-        parentId: node.id,
-        hasQuery: false,
-      });
-      nodeRSs.forEach(nodeRS => {
-        if (nodeRS.parentDER1N?.pickupDEFName) {
-          const childNode = this.getNodeModel(nodeRS.childDETreeNodeId!);
-          if (childNode?.treeNodeType === 'DE' && childNode.appDataEntityId) {
-            infos.push({
-              minorEntityId: childNode.appDataEntityId,
-              pickupDEFName: nodeRS.parentDER1N.pickupDEFName.toLowerCase(),
-              childDETreeNodeId: nodeRS.childDETreeNodeId!,
-            });
-          }
-        }
-      });
-
-      if (infos.length > 0) {
-        this.dropNodeRss.set(node.id!, infos);
-      }
-    });
-  }
-
-  /**
-   * 初始化节点点击后触发的第一个常用操作的上下文菜单项
-   * @author lxm
-   * @date 2023-12-19 03:18:43
-   * @protected
-   */
-  protected initNodeClickTBUIActionItem(): void {
-    this.model.detreeNodes?.forEach(node => {
-      const contextMenu = node.decontextMenu;
-      if (contextMenu?.detoolbarItems?.length) {
-        let itemNum = 0;
-        const items: IDETBUIActionItem[] = [];
-
-        recursiveIterate(
-          contextMenu,
-          (item: IDEToolbarItem) => {
-            if (item.itemType === 'DEUIACTION') {
-              itemNum += 1;
-              const uiItem = item as IDETBUIActionItem;
-              if (uiItem.actionLevel === 200) {
-                items.push(uiItem);
-              }
-            }
-          },
-          { childrenFields: ['detoolbarItems'] },
-        );
-
-        this.contextMenuInfos[node.id!] = {
-          onlyOneActionItem: itemNum === 1,
-          clickTBUIActionItem: items[0],
-        };
-      }
-    });
-  }
-
-  /**
-   * 树部件加载，从根节点开始重新加载
-   *
-   * @author lxm
-   * @date 2022-08-19 14:08:50
-   */
-  async load(args: MDCtrlLoadParams = {}): Promise<ITreeNodeData[]> {
-    const isInitialLoad = args.isInitialLoad === true;
-    if (isInitialLoad) {
-      await this.startLoading();
-    }
-    let nodes;
-    try {
-      nodes = await this.loadNodes();
-    } finally {
-      if (isInitialLoad) {
-        await this.endLoading();
-      }
-    }
-    await this.afterLoad(args, nodes);
-    this.state.isLoaded = true;
-    await this._evt.emit('onLoadSuccess', {
-      isInitialLoad,
-    });
-
-    return nodes;
-  }
-
-  async getFetchParams(extraParams?: IParams): Promise<IParams> {
-    const params = await super.getFetchParams(extraParams);
-    if (this.state.query) {
-      params.query = this.state.query;
-    }
-    return params;
-  }
-
-  /**
-   * 加载子节点数据
-   *
-   * @param {(ITreeNodeData | undefined)} parentNode
-   * @returns {*}
-   * @memberof TreeController
-   */
-  async loadNodes(parentNode?: ITreeNodeData): Promise<ITreeNodeData[]> {
-    const params = await this.getFetchParams();
-    const hasQuery = !!params.query;
-
-    this.state.isLoading = true;
-
-    let nodes;
-    try {
-      // 请求服务获取子节点数据
-      nodes =
-        (await this.service.fetchChildNodes(parentNode, {
-          context: this.context.clone(),
-          params,
-          hasQuery,
-          defaultExpandedKeys: this.state.expandedKeys,
-        })) || [];
-    } finally {
-      this.state.isLoading = false;
-    }
-
-    // 有父节点绑定到父节点数据上，无父节点替换rootNodes
-    if (parentNode) {
-      parentNode._children = nodes;
-    } else {
-      this.state.rootNodes = nodes;
-    }
-
-    await this.afterLoadNodes(nodes);
-
-    return nodes;
-  }
-
-  /**
-   * loadNodes加载完子数据之后的处理
-   * @author lxm
-   * @date 2023-12-22 02:37:50
-   * @param {ITreeNodeData[]} nodes 加载回来的子数据
-   * @return {*}  {Promise<void>}
-   */
-  async afterLoadNodes(nodes: ITreeNodeData[]): Promise<void> {
-    // 更新items
-    this.state.items = [];
-    recursiveIterate(
-      { _children: this.state.rootNodes },
-      (node: ITreeNodeData) => {
-        this.state.items.push(node);
-      },
-      { childrenFields: ['_children'] },
-    );
-
-    // 重新计算展开节点标识
-    this.state.expandedKeys = this.calcExpandedKeys(nodes);
-  }
-
-  /**
-   * 树节点点击事件
-   *
-   * @param {ITreeNodeData} nodeData
-   * @returns {*}  {Promise<void>}
-   * @memberof TreeController
-   */
-  async onTreeNodeClick(
-    nodeData: ITreeNodeData,
-    event: MouseEvent,
-  ): Promise<void> {
-    // 节点有配置常用操作的上下文菜单时，触发界面行为，后续逻辑都不走
-    const clickActionItem =
-      this.contextMenuInfos[nodeData._nodeId]?.clickTBUIActionItem;
-    if (clickActionItem) {
-      return this.doUIAction(
-        clickActionItem.uiactionId!,
-        nodeData,
-        event,
-        clickActionItem.appId,
-      );
-    }
-
-    // 导航的时候，没有导航视图的时候，节点后续点击逻辑都不走，也不选中
-    if (this.state.navigational) {
-      const nodeModel = this.getNodeModel(nodeData._nodeId);
-      if (!nodeModel?.navAppViewId) {
-        return;
-      }
-    }
-
-    // 单选时，单击才会触发选中逻辑,禁止选择的时候不触发
-    if (this.state.singleSelect && !nodeData._disableSelect) {
-      // 选中相关处理
-      const { selectedData } = this.state;
-      // 选中里没有则添加，有则删除
-      const filterArr = selectedData.filter(item => item._id !== nodeData._id);
-      if (filterArr.length === selectedData.length) {
-        this.setSelection(
-          this.state.singleSelect
-            ? [nodeData]
-            : selectedData.concat([nodeData]),
-        );
-      } else {
-        this.setSelection(filterArr);
-      }
-    }
-
-    // 激活事件
-    if (this.state.mdctrlActiveMode === 1) {
-      await this.setActive(nodeData);
-    }
-  }
-
-  /**
-   * 树节点数据变更事件处理
-   * @author lxm
-   * @date 2023-09-28 01:48:05
-   * @param {ITreeNodeData} nodeData
-   * @param {boolean} isExpand true为展开，false为折叠
-   */
-  onExpandChange(nodeData: ITreeNodeData, isExpand: boolean): void {
-    const hasKey = this.state.expandedKeys.includes(nodeData._id);
-    if (isExpand && !hasKey) {
-      this.state.expandedKeys.push(nodeData._id);
-    } else if (!isExpand && hasKey) {
-      const index = this.state.expandedKeys.indexOf(nodeData._id);
-      if (index !== -1) {
-        this.state.expandedKeys.splice(index, 1);
-      }
-    }
-  }
-
-  /**
-   * 树节点双击事件
-   * @author lxm
-   * @date 2023-05-29 10:01:36
-   * @param {ITreeNodeData} nodeData
-   * @return {*}  {Promise<void>}
-   */
-  async onDbTreeNodeClick(nodeData: ITreeNodeData): Promise<void> {
-    if (this.state.mdctrlActiveMode === 2) {
-      await this.setActive(nodeData);
-    }
-  }
-
-  setActive(item: ITreeNodeData): Promise<void> {
-    const nodeParams = this.parseTreeNodeData(item);
-    return this._evt.emit('onActive', { ...nodeParams, nodeData: item });
-  }
-
-  setSelection(selection: { _id: string }[]): void {
-    // todo 当自己点选中时，父节点选不选中，如果选中需要在这边优化
-
-    // 通过id过滤出原始的树节点数据，避免外部使用的时候传入的选中数据有问题。
-    const selectionIds = selection.map(item => item._id);
-    const filterArr = this.state.items.filter(item =>
-      selectionIds.includes(item._id),
-    );
-    super.setSelection(filterArr);
-  }
-
-  /**
-   * 获取节点模型
-   * @author lxm
-   * @date 2023-07-27 10:47:58
-   * @param {string} id
-   * @return {*}  {(IDETreeNode | undefined)}
-   */
-  getNodeModel(id: string): IDETreeNode | undefined {
-    return this.model.detreeNodes?.find(item => item.id === id);
-  }
-
-  /**
-   * 通过标识获取节点数据
-   * @author lxm
-   * @date 2023-12-22 02:21:38
-   * @param {string} key 可以是节点_id也可以是_uuid
-   * @return {*}  {(ITreeNodeData | undefined)}
-   */
-  getNodeData(key: string): ITreeNodeData | undefined {
-    const find = this.state.items.find(item => item._id === key);
-    if (find) {
-      return find;
-    }
-    return this.state.items.find(item => item._uuid === key);
-  }
-
-  /**
-   * 执行界面行为
-   *
-   * @author chitanda
-   * @date 2023-12-07 15:12:26
-   * @param {string} uiActionId
-   * @param {ITreeNodeData} nodeData
-   * @param {MouseEvent} event
-   * @param {string} appId
-   * @return {*}  {Promise<void>}
-   */
-  async doUIAction(
-    uiActionId: string,
-    nodeData: ITreeNodeData,
-    event: MouseEvent,
-    appId: string,
-  ): Promise<void> {
-    const eventArgs = this.getEventArgs();
-    const nodeParams = this.parseTreeNodeData(nodeData);
-    const result = await UIActionUtil.exec(
-      uiActionId!,
-      {
-        ...eventArgs,
-        ...nodeParams,
-        event,
-      },
-      appId,
-    );
-    if (result.closeView) {
-      this.view.closeView();
-    } else if (result.refresh) {
-      switch (result.refreshMode) {
-        // 刷新当前节点的子
-        case 1:
-          this.refreshNodeChildren(nodeData);
-          break;
-        // 刷新当前节点的父节点的子
-        case 2:
-          this.refreshNodeChildren(nodeData, true);
-          break;
-        // 刷新所有节点数据
-        case 3:
-          this.refresh();
-          break;
-        default:
-      }
-    }
-  }
-
-  /**
-   * 解析树节点获取通用数据，和完整的上下文和视图参数。
-   * @author lxm
-   * @date 2023-08-09 11:45:34
-   * @protected
-   * @param {ITreeNodeData} nodeData
-   */
-  protected parseTreeNodeData(nodeData: ITreeNodeData): {
-    data: IData[];
-    context: IContext;
-    params: IParams;
-  } {
-    let tempData = null;
-    if (nodeData._nodeType === 'DE') {
-      tempData = nodeData;
-    } else {
-      tempData = { ...nodeData, ...(nodeData._deData || {}) };
-    }
-    return {
-      data: [tempData],
-      context: Object.assign(this.context.clone(), nodeData._context || {}),
-      params: { ...this.params, ...(nodeData._params || {}) },
-    };
-  }
-
-  /**
-   * 计算展开节点集合(根据加载的子节点计算所有的展开节点标识集合)
-   * @author lxm
-   * @date 2023-08-09 05:19:36
-   * @param {ITreeNodeData[]} nodes
-   * @param {boolean} [isRoot=false]
-   * @return {*}  {string[]}
-   */
-  calcExpandedKeys(nodes: ITreeNodeData[]): string[] {
-    // 用户操作的添加的要保留
-    let expandedKeys: string[] = [...this.state.expandedKeys];
-
-    // 计算加载回来的里面带的默认展开
-    recursiveIterate(
-      { _children: nodes },
-      (node: ITreeNodeData) => {
-        if (node._children?.length) {
-          expandedKeys.push(node._id);
-        }
-      },
-      { childrenFields: ['_children'] },
-    );
-
-    // 去重
-    expandedKeys = Array.from(new Set(expandedKeys));
-    return expandedKeys;
-  }
-
-  /**
-   * 刷新指定树节点的子节点数据
-   * @author lxm
-   * @date 2023-08-23 08:23:59
-   * @param {(ITreeNodeData | IData)} nodeData 指定树节点数据，可以是节点数据，也可以是对应的实体数据
-   * @param {boolean} [refreshParent=false] 是否是刷新给定节点数据的父节点的子节点数据
-   * @return {*}  {Promise<void>}
-   */
-  async refreshNodeChildren(
-    nodeData: { _id?: string; srfkey?: string },
-    refreshParent = false,
-  ): Promise<void> {
-    const key = nodeData.srfkey ? 'srfkey' : '_id';
-    const currentNode = this.state.items.find(
-      item => item[key] === nodeData[key],
-    );
-    if (!currentNode) {
-      ibiz.log.error('找不到对应的树节点数据', nodeData);
-      return;
-    }
-
-    // 刷新父，但是没父，刷新根
-    if (refreshParent) {
-      const { _parent } = currentNode;
-      // 没有父，或者父是不显示的根节点，那么刷新所有
-      if (
-        !_parent ||
-        (!this.model.rootVisible && this.state.rootNodes.includes(_parent))
-      ) {
-        await this.refresh();
-        return;
-      }
-    }
-
-    const targetNode = refreshParent ? currentNode._parent! : currentNode;
-
-    const nodes = await this.loadNodes(targetNode);
-    this._evt.emit('onAfterRefreshParent', {
-      parentNode: targetNode,
-      children: nodes,
-    });
-  }
-
-  async expandNodeByKey(expandKeys: string[]): Promise<void> {
-    const noExpandKeys = expandKeys.filter(
-      key => !this.state.expandedKeys.includes(key),
-    );
-    if (noExpandKeys.length === 0) {
-      return;
-    }
-
-    // 找到已存在的要展开的节点
-    const existNodes = this.state.items.filter(item =>
-      noExpandKeys.includes(item._id),
-    );
-
-    // 补充所有未展开的节点标识，查询过程中会自动加载后续展开
-    this.state.expandedKeys.push(...noExpandKeys);
-
-    if (existNodes.length === 0) {
-      return;
-    }
-    // 展开加载节点
-    await Promise.all(
-      existNodes.map(node => {
-        return this.loadNodes(node);
-      }),
-    );
-  }
-
-  /**
-   * 计算是否允许拖动
-   * @author lxm
-   * @date 2023-12-14 11:28:07
-   * @param {ITreeNodeData} draggingNode
-   * @return {*}  {boolean}
-   */
-  calcAllowDrag(draggingNode: ITreeNodeData): boolean {
-    const nodeModel = this.getNodeModel(draggingNode._nodeId);
-    return nodeModel?.allowDrag === true;
-  }
-
-  /**
-   * 计算是否允许拖入
-   * @author lxm
-   * @date 2023-12-14 02:04:15
-   * @param {ITreeNodeData} draggingNode
-   * @param {ITreeNodeData} dropNode
-   * @param {('inner' | 'prev' | 'next')} type
-   * @return {*}  {boolean}
-   */
-  calcAllowDrop(
-    draggingNode: ITreeNodeData,
-    dropNode: ITreeNodeData,
-    type: 'inner' | 'prev' | 'next',
-  ): boolean {
-    const draggingNodeModel = this.getNodeModel(draggingNode._nodeId)!;
-    // * 移入的情况
-    if (type === 'inner') {
-      return !!this.findDropNodeRS(
-        dropNode._nodeId!,
-        draggingNodeModel.appDataEntityId!,
-      );
-    }
-    // * 前后的情况
-
-    // 父相同的情况下,就是排序，看当前节点是否能排序
-    if (draggingNode._parent?._id === dropNode._parent?._id) {
-      const currentNodeModel = this.getNodeModel(dropNode._nodeId)!;
-      return currentNodeModel?.allowOrder === true;
-    }
-
-    // 没有父就是根节点，根节点没有上层关系，无法换父
-    if (!dropNode._parent) {
-      return false;
-    }
-
-    // 父不一样的时候需要判断能否移入到对方的父节点内
-    return !!this.findDropNodeRS(
-      dropNode._parent!._nodeId!,
-      draggingNodeModel.appDataEntityId!,
-    );
-  }
-
-  /**
-   * 找到指定父节点下的节点关系里面
-   * 配置的实体关系的子实体是指定实体的
-   * @author lxm
-   * @date 2023-12-14 01:43:41
-   * @protected
-   * @param {string} parentId 父节点模型id
-   * @param {string} appDataEntityId
-   * @return {*}  {(IDETreeNodeRS | undefined)}
-   */
-  protected findDropNodeRS(
-    parentId: string,
-    appDataEntityId: string,
-  ): DropNodeRS | undefined {
-    const nodeRSs = this.dropNodeRss.get(parentId);
-    return nodeRSs?.find(item => item.minorEntityId === appDataEntityId);
-  }
-
-  /**
-   * 处理节点拖入事件
-   * @author lxm
-   * @date 2023-12-15 04:23:29
-   * @param {ITreeNodeData} draggingNode
-   * @param {ITreeNodeData} dropNode
-   * @param {('inner' | 'prev' | 'next')} dropType
-   * @return {*}  {Promise<void>}
-   */
-  async onNodeDrop(
-    draggingNode: ITreeNodeData,
-    dropNode: ITreeNodeData,
-    dropType: 'inner' | 'prev' | 'next',
-  ): Promise<void> {
-    if (
-      dropType === 'inner' &&
-      !dropNode._leaf &&
-      dropNode._children === undefined
-    ) {
-      await this.expandNodeByKey([dropNode._id]);
-    }
-
-    /** 修改的树节点数据 */
-    const modifiedNodeDatas: ITreeNodeData[] = [];
-    const draggingNodeModel = this.getNodeModel(draggingNode._nodeId)!;
-    const dropInNode = dropType === 'inner' ? dropNode : dropNode._parent!;
-    const isChangedParent = dropNode?._id !== draggingNode._parent?._id;
-    let orderNodeModel = this.getNodeModel(dropNode._nodeId)!;
-
-    // * 处理切换父节点
-    if (
-      dropType === 'inner' ||
-      dropNode._parent?._id !== draggingNode._parent?._id
-    ) {
-      const dropNodeRs = this.findDropNodeRS(
-        dropInNode._nodeId,
-        draggingNodeModel.appDataEntityId!,
-      );
-      if (dropNodeRs) {
-        // 修改关系属性的值为父节点的主键和树节点id
-        draggingNode._deData![dropNodeRs.pickupDEFName] = dropInNode._value;
-        modifiedNodeDatas.push(draggingNode);
-        orderNodeModel = this.getNodeModel(dropNodeRs.childDETreeNodeId)!;
-      }
-    }
-
-    // *修改节点数据
-    // 所有情况都先从原来的父的子集合里删除自己
-    const originArr = draggingNode._parent!._children!;
-    originArr.splice(originArr.indexOf(draggingNode), 1);
-
-    if (dropType === 'inner') {
-      // 移入时放到最后
-      if (!dropNode._children) {
-        dropNode._children = [];
-        dropNode._leaf = true;
-        this.state.expandedKeys.push(dropNode._id);
-      }
-
-      dropNode._children.push(draggingNode);
-    } else {
-      // 非插入时，放入指定节点前后
-      let insertIndex = dropInNode._children!.indexOf(dropNode);
-      if (dropType === 'next') {
-        insertIndex += 1;
-      }
-      dropInNode._children!.splice(insertIndex, 0, draggingNode);
-    }
-
-    //* 变更父节点后的，拖动节点调整
-    if (dropType === 'inner' || isChangedParent) {
-      // 更改父节点
-      draggingNode._parent = dropInNode;
-      // 修改指向的节点模型
-      draggingNode._nodeId = orderNodeModel.id!;
-      // 维护拖拽的节点和其子孙的展开，维护拖入节点的展开
-      this.state.expandedKeys = this.calcExpandedKeys([dropInNode]);
-    }
-
-    // *处理排序
-    const { sortAppDEFieldId, sortDir, allowOrder } =
-      orderNodeModel as IDETreeDataSetNode;
-    if (allowOrder === true) {
-      // 有排序属性才处理排序
-      if (!sortAppDEFieldId) {
-        throw new RuntimeModelError(orderNodeModel, '缺少配置排序属性');
-      }
-      const sortField = sortAppDEFieldId.toLowerCase();
-      const isAsc = sortDir === 'ASC';
-
-      const changedArr = [...dropInNode._children!];
-
-      // 降序把数组反转,保证两个数组都是从小到大排
-      if (!isAsc) {
-        changedArr.reverse();
-      }
-
-      /**
-       * 获取下一个100的倍数
-       * @author lxm
-       * @date 2023-09-11 10:03:46
-       * @param {number} num
-       * @return {*}  {number}
-       */
-      const getNextSort = (num: number): number => {
-        return num + (100 - (num % 100));
-      };
-
-      const getSort = (deData: IData): number => {
-        return (deData[sortField] as number) || 0;
-      };
-
-      let lastSort: number;
-      changedArr.forEach((item, index) => {
-        const deData = item._deData!;
-        if (lastSort === undefined) {
-          // 第一次出现要调整顺序的时候一定是从拖拽节点开始
-          if (item === draggingNode) {
-            // 如果时第一个，则排序值为100
-            if (index === 0) {
-              lastSort = 100;
-            } else {
-              // 最后一个时，把前一个的排序值加100
-              lastSort = getNextSort(getSort(changedArr[index - 1]._deData!));
-            }
-            deData[sortField] = lastSort;
-
-            // 修改父的时候可能已经加入进去了
-            if (modifiedNodeDatas.indexOf(item) === -1) {
-              modifiedNodeDatas.push(item);
-            }
-          }
-        } else {
-          if (lastSort >= getSort(deData)) {
-            deData[sortField] = getNextSort(lastSort);
-            modifiedNodeDatas.push(item);
-          }
-          // 更新上一个排序值
-          lastSort = getSort(deData);
-        }
-      });
-    }
-
-    await this.updateDeNodeData(modifiedNodeDatas);
-
-    // *通知界面修改移入的父节点的子节点数据
-    this._evt.emit('onAfterNodeDrop', { isChangedParent });
-  }
-
-  /**
-   * 更新实体节点数据
-   * @author lxm
-   * @date 2023-12-15 04:19:36
-   * @protected
-   * @param {ITreeNodeData[]} nodeDatas 节点数据集合
-   * @return {*}  {Promise<void>}
-   */
-  async updateDeNodeData(nodeDatas: ITreeNodeData[]): Promise<void> {
-    const app = ibiz.hub.getApp(this.context.srfappid);
-    await Promise.all(
-      nodeDatas.map(async node => {
-        const model = this.getNodeModel(node._nodeId)!;
-        const deData = node._deData!;
-        // 往上下文添加主键
-        const deName = calcDeCodeNameById(model.appDataEntityId!);
-        const tempContext = this.context.clone();
-        tempContext[deName] = deData.srfkey;
-
-        // 调用接口修改数据
-        const res = await app.deService.exec(
-          model.appDataEntityId!,
-          'update',
-          tempContext,
-          deData,
-        );
-
-        // 更新完之后更新state里的数据。
-        if (res.data) {
-          node._deData = res.data;
-        }
-      }),
-    );
-  }
-
-  /**
-   * 修改节点文本
-   * @author lxm
-   * @date 2023-12-15 04:32:52
-   * @param {ITreeNodeData} nodeData
-   * @param {string} text
-   * @return {*}  {Promise<void>}
-   */
-  async modifyNodeText(nodeData: ITreeNodeData, text: string): Promise<void> {
-    const model = this.getNodeModel(nodeData._nodeId)! as IDETreeDataSetNode;
-    if (!model.allowEditText) {
-      throw new RuntimeModelError(model, '树节点没有配置编辑模式：名称');
-    }
-    if (nodeData._nodeType !== 'DE') {
-      throw new RuntimeError('不是实体树节点数据');
-    }
-    nodeData._text = text;
-    await this.updateDeNodeData([nodeData]);
-  }
-}