@ibiz-template/runtime 0.4.17-dev.0 → 0.5.0-beta.0

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

@@ -0,0 +1,121 @@
+import { IDETreeColumn } from '@ibiz/model-core';
+import { TreeGridExController } from '../../tree-grid-ex.controller';
+
+/**
+ * 树表格（增强）列控制器
+ * @author lxm
+ * @date 2023-12-21 02:03:28
+ * @export
+ * @class TreeGridExColumnController
+ * @template T
+ */
+export class TreeGridExColumnController<
+  T extends IDETreeColumn = IDETreeColumn,
+> {
+  /**
+   * 树表格（增强）列模型对象
+   *
+   * @author lxm
+   * @date 2022-09-05 19:09:07
+   * @type {T}
+   */
+  readonly model: T;
+
+  /**
+   * 树表格（增强）控制器
+   *
+   * @author lxm
+   * @date 2022-08-24 22:08:59
+   * @type {GridController}
+   */
+  readonly treeGrid: TreeGridExController;
+
+  /**
+   * 是否是自适应列
+   * @author lxm
+   * @date 2023-07-07 11:20:16
+   * @type {boolean}
+   */
+  isAdaptiveColumn: boolean = false;
+
+  /**
+   * 是否是脚本代码
+   * @return {*}
+   * @author: zhujiamin
+   * @Date: 2023-08-15 10:51:25
+   */
+  isCustomCode: boolean = false;
+
+  /**
+   * 上下文
+   *
+   * @author lxm
+   * @date 2022-09-05 19:09:24
+   * @readonly
+   * @type {IContext}
+   */
+  get context(): IContext {
+    return this.treeGrid.context;
+  }
+
+  /**
+   * 视图参数
+   *
+   * @author lxm
+   * @date 2022-09-05 19:09:00
+   * @readonly
+   * @type {IParams}
+   */
+  get params(): IParams {
+    return this.treeGrid.params;
+  }
+
+  /**
+   * 是否是第一个显示的树表格列
+   * @author lxm
+   * @date 2023-12-22 03:28:10
+   * @readonly
+   * @type {boolean}
+   */
+  get isFirstShowColumn(): boolean {
+    const firstColumn = this.treeGrid.state.columnStates.find(
+      item => !item.hidden,
+    );
+    return firstColumn?.key === this.model.codeName;
+  }
+
+  /**
+   * Creates an instance of GridFieldColumnController.
+   * @author lxm
+   * @date 2022-08-24 20:08:22
+   * @param {T} model
+   */
+  constructor(model: T, treeGrid: TreeGridExController) {
+    this.model = model;
+    this.treeGrid = treeGrid;
+    this.isAdaptiveColumn = model.widthUnit === 'STAR';
+  }
+
+  /**
+   * 子类不可覆盖或重写此方法，在 init 时需要重写的使用 onInit 方法。
+   *
+   * @author lxm
+   * @date 2022-08-18 22:08:30
+   * @returns {*}  {Promise<void>}
+   */
+  async init(): Promise<void> {
+    await this.onInit();
+  }
+
+  /**
+   * 初始化方法
+   *
+   * @author lxm
+   * @date 2022-09-28 15:09:15
+   * @protected
+   * @returns {*}  {Promise<void>}
+   */
+  protected async onInit(): Promise<void> {
+    // 初始化操作
+  }
+}

package/src/controller/control/tree-grid-ex/tree-grid-ex-column/tree-grid-ex-field-column/tree-grid-ex-field-column.controller.ts

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { IDETreeDEFColumn } from '@ibiz/model-core';
+import { TreeGridExColumnController } from '../tree-grid-ex-column/tree-grid-ex-column.controller';
+
+/**
+ * 树表格（增强）属性列控制器
+ * @author lxm
+ * @date 2023-12-21 02:02:36
+ * @export
+ * @class TreeGridExFieldColumnController
+ * @extends {TreeGridExColumnController<IDETreeDEFColumn>}
+ */
+export class TreeGridExFieldColumnController extends TreeGridExColumnController<IDETreeDEFColumn> {}

package/src/controller/control/tree-grid-ex/tree-grid-ex-column/tree-grid-ex-ua-column/tree-grid-ex-ua-column.controller.ts

@@ -0,0 +1,76 @@
+/* eslint-disable no-param-reassign */
+import { RuntimeModelError } from '@ibiz-template/core';
+import { IDETreeUAColumn, IUIActionGroupDetail } from '@ibiz/model-core';
+import { UIActionUtil } from '../../../../../ui-action';
+import { ButtonContainerState, UIActionButtonState } from '../../../../utils';
+import { TreeGridExColumnController } from '../tree-grid-ex-column/tree-grid-ex-column.controller';
+import { ITreeGridExRowState } from '../../../../../interface';
+
+/**
+ * 树表格（增强）操作列控制器
+ * @author lxm
+ * @date 2023-12-21 02:04:05
+ * @export
+ * @class TreeGridExUAColumnController
+ * @extends {TreeGridExColumnController<IDETreeUAColumn>}
+ */
+export class TreeGridExUAColumnController extends TreeGridExColumnController<IDETreeUAColumn> {
+  /**
+   * 给rowController初始化操作列的状态
+   *
+   * @author lxm
+   * @date 2022-09-07 21:09:43
+   * @param {ITreeGridExRowState} row
+   */
+  initActionStates(row: ITreeGridExRowState): void {
+    // 操作列按钮状态控制
+    const { deuiactionGroup } = this.model;
+    if (!deuiactionGroup) {
+      throw new RuntimeModelError(this.model, '操作列没有配置界面行为组');
+    }
+    if (!deuiactionGroup.uiactionGroupDetails?.length) {
+      ibiz.log.debug('操作列界面行为组没有配置界面行为');
+      return;
+    }
+    const containerState = new ButtonContainerState();
+    deuiactionGroup.uiactionGroupDetails.forEach(detail => {
+      const actionid = detail.uiactionId;
+      if (actionid) {
+        const buttonState = new UIActionButtonState(
+          detail.id!,
+          this.treeGrid.context.srfappid!,
+          actionid,
+        );
+        containerState.addState(detail.id!, buttonState);
+      }
+    });
+    row.uaColStates[this.model.codeName!] = containerState;
+  }
+
+  /**
+   * 触发操作列点击事件
+   *
+   * @author lxm
+   * @date 2022-09-07 22:09:46
+   * @param {IPSUIActionGroupDetail} detail
+   * @param {MouseEvent} event
+   */
+  async onActionClick(
+    detail: IUIActionGroupDetail,
+    row: ITreeGridExRowState,
+    event: MouseEvent,
+  ): Promise<void> {
+    const actionId = detail.uiactionId;
+    await UIActionUtil.execAndResolved(
+      actionId!,
+      {
+        context: this.context,
+        params: this.params,
+        data: [row.data],
+        view: this.treeGrid.view,
+        event,
+      },
+      detail.appId,
+    );
+  }
+}

package/src/controller/control/tree-grid-ex/tree-grid-ex-row.state.ts

@@ -0,0 +1,37 @@
+import {
+  IButtonContainerState,
+  ITreeGridExRowState,
+  ITreeNodeData,
+} from '../../../interface';
+import { TreeGridExController } from './tree-grid-ex.controller';
+
+/**
+ * 树表格（增强）行数据状态类
+ *
+ * @author lxm
+ * @date 2023-12-22 10:39:01
+ * @export
+ * @class TreeGridExRowState
+ * @implements {ITreeGridExRowState}
+ */
+export class TreeGridExRowState implements ITreeGridExRowState {
+  data: ITreeNodeData;
+
+  /**
+   * 操作列状态(p是操作列的标识)
+   *
+   * @author lxm
+   * @date 2022-09-07 22:09:38
+   * @type {({ [p: string]: IButtonContainerState })}
+   */
+  uaColStates: { [p: string]: IButtonContainerState } = {};
+
+  constructor(data: ITreeNodeData, treeGrid: TreeGridExController) {
+    this.data = data;
+
+    // 初始化操作列状态
+    Object.values(treeGrid.uaColumns).forEach(column => {
+      column.initActionStates(this);
+    });
+  }
+}

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

@@ -1,24 +1,26 @@
+import { IDETreeColumn, IDETreeGridEx } from '@ibiz/model-core';
 import { recursiveIterate } from '@ibiz-template/core';
-import { IDETree, IDETreeColumn } from '@ibiz/model-core';
 import {
-  MDCtrlLoadParams,
-  ITreeNodeData,
   ITreeGridExController,
-  IGridColumnProvider,
   ITreeGridExState,
   ITreeGridExEvent,
+  ITreeGridExColumnProvider,
+  ITreeGridExRowState,
+  ITreeNodeData,
 } from '../../../interface';
-import { getGridColumnProvider } from '../../../register';
-import { MDControlController } from '../../common';
-import {
-  GridColumnController,
-  GridFieldColumnController,
-  GridUAColumnController,
-} from '../grid';
+import { getTreeGridExColumnProvider } from '../../../register';
+
 import { TreeGridExService } from './tree-grid-ex.service';
+import { TreeController } from '../tree/tree.controller';
+import {
+  TreeGridExColumnController,
+  TreeGridExFieldColumnController,
+  TreeGridExUAColumnController,
+} from './tree-grid-ex-column';
+import { TreeGridExRowState } from './tree-grid-ex-row.state';
 
 /**
- * 树表格部件控制器
+ * 树表格（增强）部件控制器
  *
  * @author zk
  * @date 2023-09-21 06:09:46
@@ -27,70 +29,97 @@ import { TreeGridExService } from './tree-grid-ex.service';
  * @extends {MDControlController<IDETree, ITreeGridState, ITreeGridEvent>}
  * @implements {ITreeGridExController}
  */
-export class TreeGridExController
-  extends MDControlController<IDETree, ITreeGridExState, ITreeGridExEvent>
-  implements ITreeGridExController
+export class TreeGridExController<
+    T extends IDETreeGridEx = IDETreeGridEx,
+    S extends ITreeGridExState = ITreeGridExState,
+    E extends ITreeGridExEvent = ITreeGridExEvent,
+  >
+  extends TreeController<T, S, E>
+  implements ITreeGridExController<T, S, E>
 {
   declare service: TreeGridExService;
 
   /**
-   * 表格列的适配器
+   * 树表格（增强）列的适配器
    *
    * @author zk
    * @date 2023-09-21 06:09:04
-   * @type {{ [key: string]: IGridColumnProvider }}
+   * @type {{ [key: string]: ITreeGridExColumnProvider }}
    * @memberof TreeGridExController
    */
-  providers: { [key: string]: IGridColumnProvider } = {};
+  providers: { [key: string]: ITreeGridExColumnProvider } = {};
 
   /**
-   * 所有表格列控制器集合
+   * 所有树表格（增强）列控制器集合
    *
    * @author zk
    * @date 2023-09-21 06:09:10
-   * @type {{ [key: string]: GridColumnController }}
+   * @type {{ [key: string]: TreeGridExColumnController }}
    * @memberof TreeGridExController
    */
-  columns: { [key: string]: GridColumnController } = {};
+  columns: { [key: string]: TreeGridExColumnController } = {};
 
   /**
-   * 所有表格属性列的控制器
+   * 所有树表格（增强）属性列的控制器
    *
    * @author zk
    * @date 2023-09-21 06:09:16
-   * @type {{ [key: string]: GridFieldColumnController }}
+   * @type {{ [key: string]: TreeGridExFieldColumnController }}
    * @memberof TreeGridExController
    */
-  fieldColumns: { [key: string]: GridFieldColumnController } = {};
+  fieldColumns: { [key: string]: TreeGridExFieldColumnController } = {};
 
   /**
-   * 所有表格操作列的控制器
+   * 所有树表格（增强）操作列的控制器
    *
    * @author zk
    * @date 2023-09-21 06:09:21
-   * @type {{ [key: string]: GridUAColumnController }}
+   * @type {{ [key: string]: TreeGridExUAColumnController }}
    * @memberof TreeGridExController
    */
-  uaColumns: { [key: string]: GridUAColumnController } = {};
+  uaColumns: { [key: string]: TreeGridExUAColumnController } = {};
+
+  /**
+   * 是否有配置宽度自适应列
+   *
+   * @type {boolean}
+   * @memberof GridController
+   */
+  get hasAdaptiveColumn(): boolean {
+    return !!Object.values(this.columns).find(item => item.isAdaptiveColumn);
+  }
+
+  /**
+   * 单元格超出呈现模式
+   * @author lxm
+   * @date 2023-11-17 01:56:26
+   * @readonly
+   * @type {('wrap' | 'ellipsis')}
+   */
+  get overflowMode(): 'wrap' | 'ellipsis' {
+    return ibiz.config.grid.overflowMode;
+  }
 
   protected initState(): void {
     super.initState();
-    // 根节点初始化
-    this.state.size = 0;
     this.state.columnStates = [];
-    this.state.defaultExpandedKeys = [];
+    this.state.rows = {};
   }
 
   protected async onCreated(): Promise<void> {
     await super.onCreated();
-    this.service = new TreeGridExService(this.model);
-    await this.service.init(this.context);
+
     this.initColumnStates();
     await this.initGridColumns();
   }
 
+  protected async initService(): Promise<void> {
+    this.service = new TreeGridExService(this.model);
+    await this.service.init(this.context);
+  }
+
   /**
-   * 初始化表格属性列，操作列，编辑项控制器
+   * 初始化树表格（增强）属性列，操作列，编辑项控制器
    *
    * @author zk
    * @date 2023-09-21 06:09:28
@@ -109,7 +138,7 @@ export class TreeGridExController
   }
 
   /**
-   * 初始化表格属性列，操作列，编辑项控制器
+   * 初始化树表格（增强）属性列，操作列，编辑项控制器
    *
    * @author zk
    * @date 2023-09-21 06:09:37
@@ -120,27 +149,28 @@ export class TreeGridExController
    */
   protected async initColumnsController(column: IDETreeColumn): Promise<void> {
     // 初始化适配器
-    const provider = await getGridColumnProvider(column);
+    const provider = await getTreeGridExColumnProvider(column);
     if (!provider) {
       return;
     }
     this.providers[column.codeName!] = provider;
 
-    // 初始化表格列控制器
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const controller = await provider.createController(column, this as any);
-    this.columns[column.codeName!] = controller as GridColumnController;
+    // 初始化树表格（增强）列控制器
+    const controller = await provider.createController(column, this);
+
     // 分类存放控制器
+    this.columns[column.codeName!] = controller as TreeGridExColumnController;
     if (column.columnType === 'DEFGRIDCOLUMN') {
       this.fieldColumns[column.codeName!] =
-        controller as GridFieldColumnController;
+        controller as TreeGridExFieldColumnController;
     } else if (column.columnType === 'UAGRIDCOLUMN') {
-      this.uaColumns[column.codeName!] = controller as GridUAColumnController;
+      this.uaColumns[column.codeName!] =
+        controller as TreeGridExUAColumnController;
     }
   }
 
   /**
-   * 初始化表格列状态
+   * 初始化树表格（增强）列状态
    *
    * @author zk
    * @date 2023-09-21 06:09:43
@@ -148,20 +178,15 @@ export class TreeGridExController
    * @memberof TreeGridExController
    */
   protected initColumnStates(): void {
-    recursiveIterate(
-      this.model,
-      (column: IDETreeColumn) => {
-        if (column.columnType !== 'GROUPGRIDCOLUMN') {
-          this.state.columnStates.push({
-            key: column.codeName!,
-            caption: column.caption!,
-            hidden: !!column.hideDefault,
-            uaColumn: column.columnType === 'UAGRIDCOLUMN',
-          });
-        }
-      },
-      { childrenFields: ['detreeColumns'] },
-    );
+    this.model.detreeColumns?.forEach(column => {
+      this.state.columnStates.push({
+        key: column.codeName!,
+        caption: column.caption!,
+        hidden: !!column.hideDefault,
+        uaColumn: column.columnType === 'UAGRIDCOLUMN',
+      });
+    });
+
     this.calcColumnFixed();
   }
 
@@ -174,111 +199,62 @@ export class TreeGridExController
    * @memberof TreeGridExController
    */
   protected calcColumnFixed(): void {
+    // 过滤出当前显示的列
     const showColumns = this.state.columnStates.filter(
       column => !column.hidden,
     );
     const allNum = showColumns.length;
     showColumns.forEach((column, index) => {
       if (column.uaColumn) {
+        // 操作列根据在中间列的那一侧，固定在最左侧或最右侧
         column.fixed = index + 1 <= Math.floor(allNum / 2) ? 'left' : 'right';
-      } else {
-        column.fixed = 'right';
       }
     });
   }
 
   /**
-   * 树部件加载，从根节点开始重新加载
-   *
-   * @author zk
-   * @date 2023-09-21 06:09:56
-   * @param {MDCtrlLoadParams} [args={}]
-   * @return {*}  {Promise<ITreeNodeData[]>}
-   * @memberof TreeGridExController
+   * 获取树表格行数据
+   * @author lxm
+   * @date 2023-12-22 02:23:44
+   * @param {string} key 可以是节点id也可以是_uuid
+   * @return {*}  {(ITreeGridExRowState | undefined)}
    */
-  async load(args: MDCtrlLoadParams = {}): Promise<ITreeNodeData[]> {
-    const isInitialLoad = args.isInitialLoad === true;
-    const nodes = await this.loadNodes();
-    this.state.expandedKeys = this.calcExpandedKeys(nodes);
-    await this.afterLoad(args, nodes);
-    this.state.isLoaded = true;
-    await this.evt.emit('onLoadSuccess', {
-      isInitialLoad,
-    });
-
-    return nodes;
-  }
-
-  /**
-   * 加载子节点数据
-   *
-   * @author zk
-   * @date 2023-09-21 06:09:02
-   * @param {ITreeNodeData} [parentNode]
-   * @return {*}  {Promise<ITreeNodeData[]>}
-   * @memberof TreeGridExController
-   */
-  async loadNodes(parentNode?: ITreeNodeData): Promise<ITreeNodeData[]> {
-    const params = await this.getFetchParams();
-    const hasQuery = !!params.query;
-    const defaultExpandedKeys = !parentNode
-      ? this.state.defaultExpandedKeys
-      : undefined;
-
-    // 请求服务获取子节点数据
-    await this.startLoading();
-    let nodes;
-    try {
-      nodes =
-        (await this.service.fetchChildNodes(parentNode, {
-          context: this.context.clone(),
-          params,
-          hasQuery,
-          defaultExpandedKeys,
-        })) || [];
-    } finally {
-      await this.endLoading();
-    }
-
-    // 有父节点绑定到父节点数据上，无父节点替换rootNodes
-    if (parentNode) {
-      parentNode.children = nodes;
-    } else {
-      this.state.rootNodes = nodes;
+  getRowState(key: string): ITreeGridExRowState | undefined {
+    const nodeData = this.getNodeData(key);
+    if (nodeData) {
+      return this.state.rows[nodeData._uuid];
     }
+  }
 
-    // 更新items
-    this.state.items = [];
-    recursiveIterate(
-      { children: this.state.rootNodes },
-      (node: ITreeNodeData) => {
-        this.state.items.push(node);
-      },
-    );
+  async afterLoadNodes(nodes: ITreeNodeData[]): Promise<void> {
+    await super.afterLoadNodes(nodes);
 
-    return nodes;
+    // 封装更新树表格行数据
+    recursiveIterate({ children: nodes }, (node: ITreeNodeData) => {
+      this.state.rows[node._uuid] = new TreeGridExRowState(node, this);
+    });
   }
 
   /**
-   * 计算展开节点集合
+   * 转换各类多语言
    *
-   * @author zk
-   * @date 2023-09-21 06:09:07
-   * @param {ITreeNodeData[]} nodes
-   * @return {*}  {string[]}
-   * @memberof TreeGridExController
+   * @date 2023-05-18 02:57:00
+   * @protected
    */
-  protected calcExpandedKeys(nodes: ITreeNodeData[]): string[] {
-    let expandedKeys: string[] = [];
-    recursiveIterate({ children: nodes }, (node: ITreeNodeData) => {
-      if (node.children?.length) {
-        expandedKeys.push(node.id);
-      }
-    });
-    if (this.state.defaultExpandedKeys.length) {
-      expandedKeys.push(...this.state.defaultExpandedKeys);
-      expandedKeys = Array.from(new Set(expandedKeys));
+  protected convertMultipleLanguages(): void {
+    // *转换列标题的多语言
+    const convertColumnCaption = (columns: IDETreeColumn[]): void => {
+      columns.forEach((column: IDETreeColumn) => {
+        if (column.capLanguageRes && column.capLanguageRes.lanResTag) {
+          column.caption = ibiz.i18n.t(
+            column.capLanguageRes.lanResTag,
+            column.caption,
+          );
+        }
+      });
+    };
+    if (this.model.detreeColumns && this.model.detreeColumns.length > 0) {
+      convertColumnCaption(this.model.detreeColumns);
     }
-    return expandedKeys;
   }
 }