@ibiz-template/runtime 0.5.0-beta.5 → 0.5.1-beta.1

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

@@ -305,7 +305,7 @@ export class TreeController<
 
     // 有父节点绑定到父节点数据上，无父节点替换rootNodes
     if (parentNode) {
-      parentNode.children = nodes;
+      parentNode._children = nodes;
     } else {
       this.state.rootNodes = nodes;
     }
@@ -349,7 +349,7 @@ export class TreeController<
   ): Promise<void> {
     // 节点有配置常用操作的上下文菜单时，触发界面行为，后续逻辑都不走
     const clickActionItem =
-      this.contextMenuInfos[nodeData.nodeId]?.clickTBUIActionItem;
+      this.contextMenuInfos[nodeData._nodeId]?.clickTBUIActionItem;
     if (clickActionItem) {
       return this.doUIAction(
         clickActionItem.uiactionId!,
@@ -361,7 +361,7 @@ export class TreeController<
 
     // 导航的时候，没有导航视图的时候，节点后续点击逻辑都不走，也不选中
     if (this.state.navigational) {
-      const nodeModel = this.getNodeModel(nodeData.nodeId);
+      const nodeModel = this.getNodeModel(nodeData._nodeId);
       if (!nodeModel?.navAppViewId) {
         return;
       }
@@ -372,7 +372,7 @@ export class TreeController<
       // 选中相关处理
       const { selectedData } = this.state;
       // 选中里没有则添加，有则删除
-      const filterArr = selectedData.filter(item => item.id !== nodeData.id);
+      const filterArr = selectedData.filter(item => item._id !== nodeData._id);
       if (filterArr.length === selectedData.length) {
         this.setSelection(
           this.state.singleSelect
@@ -398,11 +398,11 @@ export class TreeController<
    * @param {boolean} isExpand true为展开，false为折叠
    */
   onExpandChange(nodeData: ITreeNodeData, isExpand: boolean): void {
-    const hasKey = this.state.expandedKeys.includes(nodeData.id);
+    const hasKey = this.state.expandedKeys.includes(nodeData._id);
     if (isExpand && !hasKey) {
-      this.state.expandedKeys.push(nodeData.id);
+      this.state.expandedKeys.push(nodeData._id);
     } else if (!isExpand && hasKey) {
-      const index = this.state.expandedKeys.indexOf(nodeData.id);
+      const index = this.state.expandedKeys.indexOf(nodeData._id);
       if (index !== -1) {
         this.state.expandedKeys.splice(index, 1);
       }
@@ -427,13 +427,13 @@ export class TreeController<
     return this._evt.emit('onActive', { ...nodeParams, nodeData: item });
   }
 
-  setSelection(selection: IData[]): void {
+  setSelection(selection: { _id: string }[]): void {
     // todo 当自己点选中时，父节点选不选中，如果选中需要在这边优化
 
     // 通过id过滤出原始的树节点数据，避免外部使用的时候传入的选中数据有问题。
-    const selectionIds = selection.map(item => item.id);
+    const selectionIds = selection.map(item => item._id);
     const filterArr = this.state.items.filter(item =>
-      selectionIds.includes(item.id),
+      selectionIds.includes(item._id),
     );
     super.setSelection(filterArr);
   }
@@ -457,7 +457,7 @@ export class TreeController<
    * @return {*}  {(ITreeNodeData | undefined)}
    */
   getNodeData(key: string): ITreeNodeData | undefined {
-    const find = this.state.items.find(item => item.id === key);
+    const find = this.state.items.find(item => item._id === key);
     if (find) {
       return find;
     }
@@ -526,9 +526,9 @@ export class TreeController<
     params: IParams;
   } {
     return {
-      data: [{ ...nodeData, ...(nodeData.deData || {}) }],
-      context: Object.assign(this.context.clone(), nodeData.context || {}),
-      params: { ...this.params, ...(nodeData.params || {}) },
+      data: [{ ...nodeData, ...(nodeData._deData || {}) }],
+      context: Object.assign(this.context.clone(), nodeData._context || {}),
+      params: { ...this.params, ...(nodeData._params || {}) },
     };
   }
 
@@ -546,8 +546,8 @@ export class TreeController<
 
     // 计算加载回来的里面带的默认展开
     recursiveIterate({ children: nodes }, (node: ITreeNodeData) => {
-      if (node.children?.length) {
-        expandedKeys.push(node.id);
+      if (node._children?.length) {
+        expandedKeys.push(node._id);
       }
     });
 
@@ -565,10 +565,10 @@ export class TreeController<
    * @return {*}  {Promise<void>}
    */
   async refreshNodeChildren(
-    nodeData: ITreeNodeData | IData,
+    nodeData: { _id?: string; srfkey?: string },
     refreshParent = false,
   ): Promise<void> {
-    const key = nodeData.srfkey ? 'srfkey' : 'id';
+    const key = nodeData.srfkey ? 'srfkey' : '_id';
     const currentNode = this.state.items.find(
       item => item[key] === nodeData[key],
     );
@@ -579,18 +579,18 @@ export class TreeController<
 
     // 刷新父，但是没父，刷新根
     if (refreshParent) {
-      const { parent } = currentNode;
+      const { _parent } = currentNode;
       // 没有父，或者父是不显示的根节点，那么刷新所有
       if (
-        !parent ||
-        (!this.model.rootVisible && this.state.rootNodes.includes(parent))
+        !_parent ||
+        (!this.model.rootVisible && this.state.rootNodes.includes(_parent))
       ) {
-        this.refresh();
+        await this.refresh();
         return;
       }
     }
 
-    const targetNode = refreshParent ? currentNode.parent! : currentNode;
+    const targetNode = refreshParent ? currentNode._parent! : currentNode;
 
     const nodes = await this.loadNodes(targetNode);
     this._evt.emit('onAfterRefreshParent', {
@@ -609,7 +609,7 @@ export class TreeController<
 
     // 找到已存在的要展开的节点
     const existNodes = this.state.items.filter(item =>
-      noExpandKeys.includes(item.id),
+      noExpandKeys.includes(item._id),
     );
 
     // 补充所有未展开的节点标识，查询过程中会自动加载后续展开
@@ -634,7 +634,7 @@ export class TreeController<
    * @return {*}  {boolean}
    */
   calcAllowDrag(draggingNode: ITreeNodeData): boolean {
-    const nodeModel = this.getNodeModel(draggingNode.nodeId);
+    const nodeModel = this.getNodeModel(draggingNode._nodeId);
     return nodeModel?.allowDrag === true;
   }
 
@@ -652,30 +652,30 @@ export class TreeController<
     dropNode: ITreeNodeData,
     type: 'inner' | 'prev' | 'next',
   ): boolean {
-    const draggingNodeModel = this.getNodeModel(draggingNode.nodeId)!;
+    const draggingNodeModel = this.getNodeModel(draggingNode._nodeId)!;
     // * 移入的情况
     if (type === 'inner') {
       return !!this.findDropNodeRS(
-        dropNode.nodeId!,
+        dropNode._nodeId!,
         draggingNodeModel.appDataEntityId!,
       );
     }
     // * 前后的情况
 
     // 父相同的情况下,就是排序，看当前节点是否能排序
-    if (draggingNode.parent?.id === dropNode.parent?.id) {
-      const currentNodeModel = this.getNodeModel(dropNode.nodeId)!;
+    if (draggingNode._parent?._id === dropNode._parent?._id) {
+      const currentNodeModel = this.getNodeModel(dropNode._nodeId)!;
       return currentNodeModel?.allowOrder === true;
     }
 
     // 没有父就是根节点，根节点没有上层关系，无法换父
-    if (!dropNode.parent) {
+    if (!dropNode._parent) {
       return false;
     }
 
     // 父不一样的时候需要判断能否移入到对方的父节点内
     return !!this.findDropNodeRS(
-      dropNode.parent!.nodeId!,
+      dropNode._parent!._nodeId!,
       draggingNodeModel.appDataEntityId!,
     );
   }
@@ -714,31 +714,31 @@ export class TreeController<
   ): Promise<void> {
     if (
       dropType === 'inner' &&
-      !dropNode.leaf &&
-      dropNode.children === undefined
+      !dropNode._leaf &&
+      dropNode._children === undefined
     ) {
-      await this.expandNodeByKey([dropNode.id]);
+      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)!;
+    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
+      dropNode._parent?._id !== draggingNode._parent?._id
     ) {
       const dropNodeRs = this.findDropNodeRS(
-        dropInNode.nodeId,
+        dropInNode._nodeId,
         draggingNodeModel.appDataEntityId!,
       );
       if (dropNodeRs) {
         // 修改关系属性的值为父节点的主键和树节点id
-        draggingNode.deData![dropNodeRs.pickupDEFName] = dropInNode.value;
+        draggingNode._deData![dropNodeRs.pickupDEFName] = dropInNode._value;
         modifiedNodeDatas.push(draggingNode);
         orderNodeModel = this.getNodeModel(dropNodeRs.childDETreeNodeId)!;
       }
@@ -746,33 +746,33 @@ export class TreeController<
 
     // *修改节点数据
     // 所有情况都先从原来的父的子集合里删除自己
-    const originArr = draggingNode.parent!.children!;
+    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);
+      if (!dropNode._children) {
+        dropNode._children = [];
+        dropNode._leaf = true;
+        this.state.expandedKeys.push(dropNode._id);
       }
 
-      dropNode.children.push(draggingNode);
+      dropNode._children.push(draggingNode);
     } else {
       // 非插入时，放入指定节点前后
-      let insertIndex = dropInNode.children!.indexOf(dropNode);
+      let insertIndex = dropInNode._children!.indexOf(dropNode);
       if (dropType === 'next') {
         insertIndex += 1;
       }
-      dropInNode.children!.splice(insertIndex, 0, draggingNode);
+      dropInNode._children!.splice(insertIndex, 0, draggingNode);
     }
 
     //* 变更父节点后的，拖动节点调整
     if (dropType === 'inner' || isChangedParent) {
       // 更改父节点
-      draggingNode.parent = dropInNode;
+      draggingNode._parent = dropInNode;
       // 修改指向的节点模型
-      draggingNode.nodeId = orderNodeModel.id!;
+      draggingNode._nodeId = orderNodeModel.id!;
       // 维护拖拽的节点和其子孙的展开，维护拖入节点的展开
       this.state.expandedKeys = this.calcExpandedKeys([dropInNode]);
     }
@@ -788,7 +788,7 @@ export class TreeController<
       const sortField = sortAppDEFieldId.toLowerCase();
       const isAsc = sortDir === 'ASC';
 
-      const changedArr = [...dropInNode.children!];
+      const changedArr = [...dropInNode._children!];
 
       // 降序把数组反转,保证两个数组都是从小到大排
       if (!isAsc) {
@@ -812,7 +812,7 @@ export class TreeController<
 
       let lastSort: number;
       changedArr.forEach((item, index) => {
-        const deData = item.deData!;
+        const deData = item._deData!;
         if (lastSort === undefined) {
           // 第一次出现要调整顺序的时候一定是从拖拽节点开始
           if (item === draggingNode) {
@@ -821,7 +821,7 @@ export class TreeController<
               lastSort = 100;
             } else {
               // 最后一个时，把前一个的排序值加100
-              lastSort = getNextSort(getSort(changedArr[index - 1].deData!));
+              lastSort = getNextSort(getSort(changedArr[index - 1]._deData!));
             }
             deData[sortField] = lastSort;
 
@@ -859,8 +859,8 @@ export class TreeController<
     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 model = this.getNodeModel(node._nodeId)!;
+        const deData = node._deData!;
         // 往上下文添加主键
         const deName = calcDeCodeNameById(model.appDataEntityId!);
         const tempContext = this.context.clone();
@@ -876,7 +876,7 @@ export class TreeController<
 
         // 更新完之后更新state里的数据。
         if (res.data) {
-          node.deData = res.data;
+          node._deData = res.data;
         }
       }),
     );
@@ -891,15 +891,15 @@ export class TreeController<
    * @return {*}  {Promise<void>}
    */
   async modifyNodeText(nodeData: ITreeNodeData, text: string): Promise<void> {
-    const model = this.getNodeModel(nodeData.nodeId)! as IDETreeDataSetNode;
+    const model = this.getNodeModel(nodeData._nodeId)! as IDETreeDataSetNode;
     if (!model.allowEditText) {
       throw new RuntimeModelError(model, '树节点没有配置编辑模式：名称');
     }
-    if (!nodeData.deData) {
+    if (!nodeData._deData) {
       throw new RuntimeError('不是实体树节点数据');
     }
-    nodeData.text = text;
-    nodeData.deData[model.textAppDEFieldId!] = text;
+    nodeData._text = text;
+    nodeData._deData[model.textAppDEFieldId!] = text;
     await this.updateDeNodeData([nodeData]);
   }
 }

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

@@ -99,7 +99,7 @@ export class TreeService<
     } else {
       // 有父节点的计算节点关系查询对应节点数据并合并
       const childNodeRSs = getChildNodeRSs(this.model, {
-        parentId: parentNodeData?.nodeId,
+        parentId: parentNodeData?._nodeId,
         hasQuery,
       });
 
@@ -201,14 +201,14 @@ export class TreeService<
             (expanded && // 全展开合只展开首节点expanded都为true
               (!expandFirstOnly || (expandFirstOnly && index === 0))) ||
             (opts.defaultExpandedKeys?.length &&
-              opts.defaultExpandedKeys.includes(childNode.id)) || // 外部回显给的默认展开节点集合有的展开
+              opts.defaultExpandedKeys.includes(childNode._id)) || // 外部回显给的默认展开节点集合有的展开
             isExpandedRoot
           ) {
             const subChildrenNodes = await this.fetchChildNodes(
               childNode,
               opts,
             );
-            childNode.children = subChildrenNodes;
+            childNode._children = subChildrenNodes;
           }
         }),
       );
@@ -275,7 +275,7 @@ export class TreeService<
     // 合并部件上下文和父节点资源上下文
     const context = {
       ...opts.context,
-      ...(parentNodeData?.context || {}),
+      ...(parentNodeData?._context || {}),
     };
 
     // 计算关系过滤用到的实体数据
@@ -285,18 +285,18 @@ export class TreeService<
     if (parentNodeData) {
       parentData = parentNodeData;
       for (let index = 1; index < parentValueLevel!; index++) {
-        parentData = parentData?.parent;
+        parentData = parentData?._parent;
       }
     }
     let derValue;
     let deName;
     if (parentData) {
-      data = parentData.deData || {};
-      const parentNodeModel = getTreeNode(this.model, parentData.nodeId);
+      data = parentData._deData || {};
+      const parentNodeModel = getTreeNode(this.model, parentData._nodeId);
       if (parentNodeModel.appDataEntityId) {
         deName = calcDeCodeNameById(parentNodeModel.appDataEntityId);
       }
-      derValue = parentData.value;
+      derValue = parentData._value;
     }
 
     // 导航相关参数处理

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

@@ -1,6 +1,81 @@
-import { ITreeGridController } from '../../../interface';
+import { IDEGridFieldColumn, IDETreeGrid } from '@ibiz/model-core';
+import { RuntimeModelError } from '@ibiz-template/core';
+import {
+  ITreeGridController,
+  ITreeGridEvent,
+  ITreeGridState,
+} from '../../../interface';
 import { GridController } from '../grid';
 
-export class TreeGridController
-  extends GridController
-  implements ITreeGridController {}
+export class TreeGridController<
+    T extends IDETreeGrid = IDETreeGrid,
+    S extends ITreeGridState = ITreeGridState,
+    E extends ITreeGridEvent = ITreeGridEvent,
+  >
+  extends GridController<T, S, E>
+  implements ITreeGridController<T, S, E>
+{
+  /**
+   * 树表格值属性名称
+   *
+   */
+  treeGridValueField: string = '';
+
+  /**
+   * 树表格父属性名称
+   *
+   */
+  treeGridParentField: string = '';
+
+  protected initState(): void {
+    super.initState();
+    this.state.showTreeGrid = true;
+  }
+
+  /**
+   * 初始化方法
+   *
+   * @author lxm
+   * @date 2022-08-18 22:08:17
+   * @protected
+   * @returns {*}  {Promise<void>}
+   */
+  protected async onCreated(): Promise<void> {
+    await super.onCreated();
+
+    this.initTreeGridField();
+  }
+
+  /**
+   * 初始化树表格字段
+   * @return {*}
+   * @author: zhujiamin
+   */
+  protected initTreeGridField(): void {
+    const treeGridParent: IDEGridFieldColumn | undefined =
+      this.model.degridColumns?.find((item: IDEGridFieldColumn) => {
+        return item.treeColumnMode === 4 || item.treeColumnMode === 12;
+      });
+    const treeGridValue: IDEGridFieldColumn | undefined =
+      this.model.degridColumns?.find((item: IDEGridFieldColumn) => {
+        return item.treeColumnMode === 2 || item.treeColumnMode === 3;
+      });
+    if (!treeGridParent) {
+      throw new RuntimeModelError(this.model, '树表格无值列模式');
+    }
+    if (!treeGridValue) {
+      throw new RuntimeModelError(this.model, '树表格无父值列模式');
+    }
+    this.treeGridValueField = treeGridValue.appDEFieldId!.toLowerCase();
+    this.treeGridParentField = treeGridParent.appDEFieldId!.toLowerCase();
+  }
+
+  /**
+   * 切换树表格显示
+   * @return {*}
+   * @author: zhujiamin
+   */
+  switchTreeGridShow(): void {
+    this.state.showTreeGrid = !this.state.showTreeGrid;
+  }
+}

package/src/interface/common/i-app-hub-service/i-app-hub-service.ts

@@ -165,4 +165,11 @@ export interface IAppHubService {
    * @return {*}  {IAppService[]}
    */
   getAllApps(): IAppService[];
+
+  /**
+   * 重置清空基座
+   * @author lxm
+   * @date 2024-01-03 06:46:57
+   */
+  reset(): void;
 }

package/src/interface/controller/controller/control/i-grid.controller.ts

@@ -13,8 +13,11 @@ import { CodeListItem } from '../../../service';
  * @interface IGridController
  * @extends {IMDControlController}
  */
-export interface IGridController
-  extends IMDControlController<IDEGrid, IGridState, IGridEvent> {
+export interface IGridController<
+  T extends IDEGrid = IDEGrid,
+  S extends IGridState = IGridState,
+  E extends IGridEvent = IGridEvent,
+> extends IMDControlController<T, S, E> {
   /**
    * 新建行
    *

package/src/interface/controller/controller/control/i-tree-grid.controller.ts

@@ -1,4 +1,7 @@
+import { IDETreeGrid } from '@ibiz/model-core';
 import { IGridController } from './i-grid.controller';
+import { ITreeGridState } from '../../state';
+import { ITreeGridEvent } from '../../event';
 
 /**
  * 树表格部件控制器
@@ -9,4 +12,16 @@ import { IGridController } from './i-grid.controller';
  * @interface ITreeGridController
  * @extends {IMDControlController<IDETreeGrid, ITreeGridState, ITreeGridEvent>}
  */
-export interface ITreeGridController extends IGridController {}
+export interface ITreeGridController<
+  T extends IDETreeGrid = IDETreeGrid,
+  S extends ITreeGridState = ITreeGridState,
+  E extends ITreeGridEvent = ITreeGridEvent,
+> extends IGridController<T, S, E> {
+  /**
+   * 切换树表格显示
+   * @return {*}
+   * @author: zhujiamin
+   *
+   */
+  switchTreeGridShow(): void;
+}

package/src/interface/controller/state/control/i-gantt.state.ts

@@ -108,7 +108,7 @@ export interface IGanttNodeData extends ITreeNodeData {
    * @date 2023-12-11 18:12:16
    * @type {(IGanttNodeData[] | undefined)}
    */
-  children?: IGanttNodeData[] | undefined;
+  _children?: IGanttNodeData[] | undefined;
 
   /**
    * 父节点数据对象
@@ -116,5 +116,5 @@ export interface IGanttNodeData extends ITreeNodeData {
    * @type {IGanttNodeData}
    * @memberof IGanttNodeData
    */
-  parent?: IGanttNodeData;
+  _parent?: IGanttNodeData;
 }

package/src/interface/controller/state/control/i-tree-grid.state.ts

@@ -9,4 +9,10 @@ import { IGridState } from './i-grid.state';
  * @interface ITreeGridState
  * @extends {IMDControlState}
  */
-export interface ITreeGridState extends IGridState {}
+export interface ITreeGridState extends IGridState {
+  /**
+   * 树表格是否显示树形结构(默认为true)
+   *
+   */
+  showTreeGrid: boolean;
+}