@ibiz-template/runtime 0.4.11 → 0.4.13

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

@@ -156,7 +156,7 @@ export class SearchBarController
     // 搜索过滤器
     const filters = this.calcFilters();
     if (filters) {
-      params.filters = filters;
+      params.searchconds = filters;
     }
     return params;
   }
@@ -174,6 +174,7 @@ export class SearchBarController
         children: [{ leaf: true, field: null, valueOP: null, value: null }],
       },
     ];
+    this.evt.emit('onSearch', undefined);
   }
 
   /**
@@ -218,7 +219,7 @@ export class SearchBarController
       }
     });
     if (hasFilter && !hasError) {
-      const filter = this.formatFilters(this.state.filterNodes[0]);
+      const filter = [this.formatFilters(this.state.filterNodes[0])];
       return filter;
     }
   }
@@ -233,15 +234,18 @@ export class SearchBarController
   formatFilters(node: IFilterNode): IData {
     if (!node.leaf) {
       return {
-        [`$${node.logicType.toLowerCase()}`]: node.children.map(item =>
-          this.formatFilters(item),
-        ),
+        condtype: 'GROUP',
+        condop: node.logicType,
+        bnotmode: false,
+        searchconds: node.children.map(item => this.formatFilters(item)),
       };
     }
+
     return {
-      [`${node.field}`]: {
-        [`$${node.valueOP!.toLowerCase()}`]: node.value,
-      },
+      condtype: 'DEFIELD',
+      fieldname: node.field,
+      condop: node.valueOP,
+      value: node.value,
     };
   }
 }

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,10 @@
 /* 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 { IDETree, IDETreeDataSetNode, IDETreeNode } from '@ibiz/model-core';
 import {
   ITreeState,
   ITreeEvent,
@@ -12,6 +16,13 @@ import { UIActionUtil } from '../../../ui-action';
 import { MDControlController } from '../../common';
 import { ContextMenuController } from '../context-menu';
 import { TreeService } from './tree.service';
+import { calcDeCodeNameById, getChildNodeRSs } from '../../../model';
+
+export type DropNodeRS = {
+  minorEntityId: string;
+  pickupDEFName: string;
+  childDETreeNodeId: string;
+};
 
 /**
  * 树部件控制器
@@ -44,6 +55,13 @@ export class TreeController
    */
   enableQuickSearch: boolean = false;
 
+  /**
+   * 拖入节点关系处理
+   * @author lxm
+   * @date 2023-12-14 03:05:38
+   */
+  dropNodeRss = new Map<string, DropNodeRS[]>();
+
   protected initState(): void {
     super.initState();
     // 根节点初始化
@@ -87,6 +105,8 @@ export class TreeController
       }
     }
 
+    this.initDropNodeRss();
+
     this.service = new TreeService(this.model);
     await this.service.init(this.context);
 
@@ -108,6 +128,41 @@ 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);
+      }
+    });
+  }
+
   /**
    * 树部件加载，从根节点开始重新加载
    *
@@ -451,4 +506,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

@@ -29,4 +29,12 @@ export interface IGlobalViewConfig {
    * @type {string}
    */
   expCacheMode: string;
+
+  /**
+   * 首页是否不采用分页导航模式
+   * @return {*}
+   * @author: zhujiamin
+   * @Date: 2023-12-12 17:40:44
+   */
+  disableHomeTabs: boolean;
 }

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

@@ -60,6 +60,22 @@ export interface IControlController<
    */
   endLoading(): Promise<void>;
 
+  /**
+   * 部件激活，主要用于用户可见时设置为激活状态
+   *
+   * @author chitanda
+   * @date 2023-12-13 11:12:04
+   */
+  onActivated(): void;
+
+  /**
+   * 部件暂停激活，主要用于用户不可见时设置为非激活状态
+   *
+   * @author chitanda
+   * @date 2023-12-13 11:12:06
+   */
+  onDeactivated(): void;
+
   /**
    * 在不改变引用的前提下，更新上下文和导航参数
    * 并处理如自定义导航参数的后续处理

package/src/interface/controller/controller/view/i-view.controller.ts

@@ -162,4 +162,20 @@ export interface IViewController<
    * @date 2022-09-19 14:09:09
    */
   endLoading(): void;
+
+  /**
+   * 视图激活，主要用于用户可见时设置为激活状态
+   *
+   * @author chitanda
+   * @date 2023-12-13 11:12:04
+   */
+  onActivated(): void;
+
+  /**
+   * 视图暂停激活，主要用于用户不可见时设置为非激活状态
+   *
+   * @author chitanda
+   * @date 2023-12-13 11:12:06
+   */
+  onDeactivated(): 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-control.state.ts

@@ -1,6 +1,15 @@
 import { IControllerState } from '../common/i-controller.state';
 
 export interface IControlState extends IControllerState {
+  /**
+   * 当前部件是否为激活状态(缓存下的激活状态，一般与框架的生命周期相同)
+   *
+   * @author chitanda
+   * @date 2023-12-13 11:12:30
+   * @type {boolean}
+   */
+  activated: boolean;
+
   /**
    * 是否是简单模式
    * @author zjm

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;
 }

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

@@ -73,6 +73,16 @@ export interface IGridRowState {
    */
   uaColStates: { [p: string]: IButtonContainerState };
 
+  /**
+   * 界面行为组状态(p是界面行为的标识)
+   *
+   * @author zk
+   * @date 2023-12-15 10:12:42
+   * @type {{ [p: string]: IButtonContainerState }}
+   * @memberof IGridRowState
+   */
+  uiActionGroupStates: { [p: string]: IButtonContainerState };
+
   /**
    * 编辑列的状态
    *

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

@@ -1,4 +1,5 @@
 import { IDataViewControlState } from './i-data-view-control.state';
+import { IMDControlGroupState } from './i-md-control.state';
 
 /**
  * 看板部件（kanban）部件状态
@@ -23,4 +24,29 @@ export interface IKanbanState extends IDataViewControlState {
    * @type {boolean}
    */
   updating: boolean;
+
+  /**
+   * 分组数据
+   *
+   * @type {IKanbanGroupState[]}
+   * @memberof IKanbanState
+   */
+  groups: IKanbanGroupState[];
+}
+
+/**
+ * 看板部件分组数据
+ *
+ * @export
+ * @interface IKanbanGroupState
+ * @extends {IMDControlGroupState}
+ */
+export interface IKanbanGroupState extends IMDControlGroupState {
+  /**
+   * 颜色
+   *
+   * @type {string}
+   * @memberof IKanbanGroupState
+   */
+  color?: string;
 }