@ibiz-template/runtime 0.4.12 → 0.4.14

package/src/controller/control/kanban/kanban.controller.ts

@@ -5,6 +5,7 @@ import {
   IDragChangeInfo,
   IKanbanController,
   IKanbanEvent,
+  IKanbanGroupState,
   IKanbanState,
   MDCtrlLoadParams,
 } from '../../../interface';
@@ -122,6 +123,86 @@ export class KanbanController
     return super.handleDataGroup();
   }
 
+  /**
+   * 处理自动分组
+   *
+   * @memberof KanbanController
+   */
+  handleAutoGroup(): void {
+    const { groupAppDEFieldId } = this.model;
+    if (groupAppDEFieldId) {
+      const { items } = this.state;
+      const groupMap: Map<string, IData[]> = new Map();
+      items.forEach((item: IData) => {
+        const groupVal = item[groupAppDEFieldId];
+        if (isNil(groupVal)) {
+          // 分组无值的不显示
+          return;
+        }
+
+        if (!groupMap.has(groupVal)) {
+          groupMap.set(groupVal, []);
+        }
+        groupMap.get(groupVal)!.push(item);
+      });
+      const groups: IKanbanGroupState[] = [];
+      groupMap.forEach((value: IData[], key: string) => {
+        // 标题
+        const codeListItem = this.groupCodeListItems!.find(
+          item => item.value === key,
+        )!;
+        groups.push({
+          caption: codeListItem.text,
+          color: codeListItem.color,
+          key: codeListItem.value,
+          children: [...value],
+        });
+      });
+      this.state.groups = groups;
+    }
+  }
+
+  /**
+   * 处理代码表分组
+   *
+   * @return {*}  {Promise<void>}
+   * @memberof KanbanController
+   */
+  async handleCodeListGroup(): Promise<void> {
+    const { groupAppDEFieldId, groupCodeListId } = this.model;
+    if (!groupCodeListId) {
+      throw new RuntimeModelError(this.model, '分组代码表没有配置');
+    }
+    const { items } = this.state;
+    const groupMap: Map<string | number, IData[]> = new Map();
+    this.groupCodeListItems!.forEach(item => {
+      groupMap.set(item.value, []);
+    });
+    items.forEach((item: IData) => {
+      const groupVal = item[groupAppDEFieldId!];
+      const groupArr = groupMap.get(groupVal);
+      if (groupArr) {
+        groupArr.push(item);
+      }
+      // 不在代码表里数据忽略
+    });
+
+    const groups: IKanbanGroupState[] = [];
+    groupMap.forEach((arr, key) => {
+      // 标题
+      const codeListItem = this.groupCodeListItems!.find(
+        item => item.value === key,
+      )!;
+      groups.push({
+        caption: codeListItem.text,
+        color: codeListItem.color,
+        key: codeListItem.value,
+        children: arr,
+      });
+    });
+    this.state.groups = groups;
+  }
+
   /**
    * 拖拽变更事件处理回调
    * @author lxm

package/src/controller/control/report-panel/generator/user-generator.ts

@@ -50,7 +50,7 @@ export class UserReportPanelGenerator extends ReportPanelBaseGenerator {
           },
         ],
         nodeDataHook:
-          "{{ data.forEach(node => { const type = node.data.source_lables || node.data.target_lables; Object.assign(node, { label: node.data.name, size: 66, style: { fill: node.color },donutAttrs: { prop1: 10000, prop2: 10 },donutColorMap: { prop1: node.color, prop2: node.color },icon: {show: true,img: type === 'NEO4J_ZT' ? resource.dir('/assets/images/user-avatar.png') : resource.dir('/assets/images/phone.png'),width: 40,height: 40}})})}}",
+          "{{ data.forEach(node => { const type = node.data.source_lables || node.data.target_lables; Object.assign(node, { label: node.data.name, size: 66, style: { fill: node.color },donutAttrs: { prop1: 10000, prop2: 10 },donutColorMap: { prop1: node.color, prop2: node.color },icon: {show: true,img: type === 'NEO4J_ZT' ? resource.dir('assets/images/user-avatar.png') : resource.dir('assets/images/phone.png'),width: 40,height: 40}})})}}",
         edgeDataHook:
           '{{ data.forEach(edge => {Object.assign(edge, { label: edge.name })}) }}',
       },

package/src/controller/control/search-bar/search-bar.controller.ts

@@ -174,6 +174,7 @@ export class SearchBarController
         children: [{ leaf: true, field: null, valueOP: null, value: null }],
       },
     ];
+    this.evt.emit('onSearch', undefined);
   }
 
   /**
@@ -236,7 +237,7 @@ export class SearchBarController
         condtype: 'GROUP',
         condop: node.logicType,
         bnotmode: false,
-        searchcondlist: node.children.map(item => this.formatFilters(item)),
+        searchconds: node.children.map(item => this.formatFilters(item)),
       };
     }
 

package/src/controller/control/toolbar/toolbar.controllerr.ts

@@ -4,6 +4,7 @@ import {
   IDEToolbarItem,
   IDETBUIActionItem,
   IControlLogic,
+  IDETBGroupItem,
 } from '@ibiz/model-core';
 import { ViewCallTag, ViewMode } from '../../../constant';
 import {
@@ -241,4 +242,32 @@ export class ToolbarController<
     );
     super.initControlScheduler(actualLogics);
   }
+
+  /**
+   * 转换各类多语言
+   *
+   * @date 2023-05-18 02:57:00
+   * @protected
+   */
+  protected convertMultipleLanguages(): void {
+    const convertItemCaption = (items: IDEToolbarItem[]): void => {
+      items.forEach(item => {
+        if (item.capLanguageRes && item.capLanguageRes.lanResTag) {
+          item.caption = ibiz.i18n.t(
+            item.capLanguageRes.lanResTag,
+            item.caption,
+          );
+        }
+        if (
+          item.itemType === 'ITEMS' &&
+          (item as IDETBGroupItem).detoolbarItems
+        ) {
+          convertItemCaption((item as IDETBGroupItem).detoolbarItems!);
+        }
+      });
+    };
+    if (this.model.detoolbarItems && this.model.detoolbarItems.length > 0) {
+      convertItemCaption(this.model.detoolbarItems);
+    }
+  }
 }

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

@@ -1,6 +1,15 @@
 /* eslint-disable no-param-reassign */
-import { recursiveIterate } from '@ibiz-template/core';
-import { IDETree, IDETreeNode } from '@ibiz/model-core';
+import {
+  RuntimeError,
+  RuntimeModelError,
+  recursiveIterate,
+} from '@ibiz-template/core';
+import {
+  IDETBUIActionItem,
+  IDETree,
+  IDETreeDataSetNode,
+  IDETreeNode,
+} from '@ibiz/model-core';
 import {
   ITreeState,
   ITreeEvent,
@@ -12,6 +21,17 @@ import { UIActionUtil } from '../../../ui-action';
 import { MDControlController } from '../../common';
 import { ContextMenuController } from '../context-menu';
 import { TreeService } from './tree.service';
+import {
+  calcDeCodeNameById,
+  getChildNodeRSs,
+  getUIActionItemsByActionLevel,
+} from '../../../model';
+
+export type DropNodeRS = {
+  minorEntityId: string;
+  pickupDEFName: string;
+  childDETreeNodeId: string;
+};
 
 /**
  * 树部件控制器
@@ -44,6 +64,20 @@ export class TreeController
    */
   enableQuickSearch: boolean = false;
 
+  /**
+   * 拖入节点关系处理
+   * @author lxm
+   * @date 2023-12-14 03:05:38
+   */
+  dropNodeRss = new Map<string, DropNodeRS[]>();
+
+  /**
+   * 节点对应的上下文菜单里第一个行为级别为常用操作的项
+   * @author lxm
+   * @date 2023-12-19 03:14:03
+   */
+  nodeClickTBUIActionItem = new Map<string, IDETBUIActionItem>();
+
   protected initState(): void {
     super.initState();
     // 根节点初始化
@@ -87,6 +121,9 @@ export class TreeController
       }
     }
 
+    this.initDropNodeRss();
+    this.initNodeClickTBUIActionItem();
+
     this.service = new TreeService(this.model);
     await this.service.init(this.context);
 
@@ -108,6 +145,58 @@ export class TreeController
     );
   }
 
+  /**
+   * 初始化节点拖入关系处理
+   * @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 => {
+      if (node.decontextMenu?.detoolbarItems?.length) {
+        const items = getUIActionItemsByActionLevel(node.decontextMenu, 200);
+        if (items.length > 0) {
+          this.nodeClickTBUIActionItem.set(node.id!, items[0]);
+        }
+      }
+    });
+  }
+
   /**
    * 树部件加载，从根节点开始重新加载
    *
@@ -199,7 +288,16 @@ export class TreeController
    * @returns {*}  {Promise<void>}
    * @memberof TreeController
    */
-  async onTreeNodeClick(nodeData: ITreeNodeData): Promise<void> {
+  async onTreeNodeClick(
+    nodeData: ITreeNodeData,
+    event: MouseEvent,
+  ): Promise<void> {
+    // 节点有配置常用操作的上下文菜单时，触发界面行为，后续逻辑都不走
+    if (this.nodeClickTBUIActionItem.has(nodeData.nodeId)) {
+      const item = this.nodeClickTBUIActionItem.get(nodeData.nodeId)!;
+      return this.doUIAction(item.uiactionId!, nodeData, event, item.appId);
+    }
+
     // 导航的时候，没有导航视图的时候，节点后续点击逻辑都不走，也不选中
     if (this.state.navigational) {
       const nodeModel = this.getNodeModel(nodeData.nodeId);
@@ -451,4 +549,274 @@ export class TreeController
       }),
     );
   }
+
+  /**
+   * 计算是否允许拖动
+   * @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) {
+      // 父不一样的时候需要判断能否移入到对方的父节点内
+      return !!this.findDropNodeRS(
+        dropNode.parent!.nodeId!,
+        draggingNodeModel.appDataEntityId!,
+      );
+    }
+    // 父相同的情况下,就是排序，看是否能排序
+    const parentNodeModel = this.getNodeModel(dropNode.nodeId)!;
+    return parentNodeModel?.allowOrder === true;
+  }
+
+  /**
+   * 找到指定父节点下的节点关系里面
+   * 配置的实体关系的子实体是指定实体的
+   * @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.parent?.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.deData) {
+      throw new RuntimeError('不是实体树节点数据');
+    }
+    nodeData.text = text;
+    nodeData.deData[model.textAppDEFieldId!] = text;
+    await this.updateDeNodeData([nodeData]);
+  }
 }

package/src/interface/common/i-global-config/i-global-view-config.ts

@@ -36,5 +36,5 @@ export interface IGlobalViewConfig {
    * @author: zhujiamin
    * @Date: 2023-12-12 17:40:44
    */
-  noNavTabs: boolean;
+  disableHomeTabs: boolean;
 }

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

@@ -20,7 +20,7 @@ export interface ITreeController
    * @returns {*}  {Promise<void>}
    * @memberof ITreeController
    */
-  onTreeNodeClick(nodeData: ITreeNodeData): Promise<void>;
+  onTreeNodeClick(nodeData: ITreeNodeData, event: MouseEvent): Promise<void>;
 
   /**
    * 树节点双击事件

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

@@ -1,3 +1,5 @@
+import { IGanttNodeData } from '../../state';
+import { EventBase } from '../argument';
 import { IMDControlEvent } from './i-md-control.event';
 
 /**
@@ -9,4 +11,38 @@ import { IMDControlEvent } from './i-md-control.event';
  * @interface IGanttEvent
  * @extends {IMDControlEvent}
  */
-export interface IGanttEvent extends IMDControlEvent {}
+export interface IGanttEvent extends IMDControlEvent {
+  /**
+   * 数据激活事件
+   *
+   * @type {({
+   *     event: EventBase & { nodeData: IGanttNodeData };
+   *     emitArgs: { data: IData[]; nodeData: IGanttNodeData };
+   *   })}
+   * @memberof IGanttEvent
+   */
+  onActive: {
+    event: EventBase & { nodeData: IGanttNodeData };
+    emitArgs: { data: IData[]; nodeData: IGanttNodeData };
+  };
+
+  /**
+   * 父节点刷新结束之后事件
+   *
+   * @type {({
+   *     event: EventBase & {
+   *       parentNode: IGanttNodeData;
+   *       children: IGanttNodeData[];
+   *     };
+   *     emitArgs: { parentNode: IGanttNodeData; children: IGanttNodeData[] };
+   *   })}
+   * @memberof IGanttEvent
+   */
+  onAfterRefreshParent: {
+    event: EventBase & {
+      parentNode: IGanttNodeData;
+      children: IGanttNodeData[];
+    };
+    emitArgs: { parentNode: IGanttNodeData; children: IGanttNodeData[] };
+  };
+}

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

@@ -35,4 +35,18 @@ export interface ITreeEvent extends IMDControlEvent {
     event: EventBase & { parentNode: ITreeNodeData; children: ITreeNodeData[] };
     emitArgs: { parentNode: ITreeNodeData; children: ITreeNodeData[] };
   };
+
+  /**
+   * 树节点拖入变更处理完成后事件
+   * @author lxm
+   * @date 2023-12-15 03:18:10
+   * @type {({
+   *     event: EventBase & { isChangedParent: boolean };
+   *     emitArgs: { isChangedParent: boolean };
+   *   })}
+   */
+  onAfterNodeDrop: {
+    event: EventBase & { isChangedParent: boolean };
+    emitArgs: { isChangedParent: boolean };
+  };
 }

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

@@ -1,3 +1,4 @@
+import { IColumnState } from './i-grid.state';
 import { IMDControlState } from './i-md-control.state';
 import { ITreeNodeData } from './i-tree.state';
 
@@ -13,6 +14,14 @@ import { ITreeNodeData } from './i-tree.state';
 export interface IGanttState extends IMDControlState {
   items: IGanttNodeData[];
 
+  /**
+   * 表格列状态数组
+   *
+   * @type {IColumnState[]}
+   * @memberof IGanttState
+   */
+  columnStates: IColumnState[];
+
   /**
    * 树的根节点
    *
@@ -111,4 +120,20 @@ export interface IGanttNodeData extends ITreeNodeData {
    * @type {(IGanttNodeData[] | undefined)}
    */
   children?: IGanttNodeData[] | undefined;
+
+  /**
+   * 父节点数据对象
+   *
+   * @type {IGanttNodeData}
+   * @memberof IGanttNodeData
+   */
+  parent?: IGanttNodeData;
+
+  /**
+   * 节点数据项
+   *
+   * @type {IData}
+   * @memberof IGanttNodeData
+   */
+  nodeDataItem?: IData;
 }