@ibiz-template/runtime 0.4.17-dev.0 → 0.4.17-dev.1

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

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

@@ -1,171 +1,16 @@
-import { IHttpResponse } from '@ibiz-template/core';
-import {
-  IDETreeDataSetNode,
-  IDETreeNode,
-  IDETreeNodeRS,
-} from '@ibiz/model-core';
-import { isArray } from 'qx-util';
-import { ITreeNodeData } from '../../../interface';
-
-import { ControlVO, TreeDataSetNodeData, UIMapField } from '../../../service';
-import { TreeFetchOpts, TreeService } from '../tree/tree.service';
+import { IDETreeGridEx } from '@ibiz/model-core';
+import { TreeService } from '../tree/tree.service';
 
 /**
  * 树表格增强部件服务
  *
- * @author zk
- * @date 2023-09-25 05:09:52
+ * @author lxm
+ * @date 2023-12-21 10:50:35
  * @export
- * @class TreeGridService
- * @extends {TreeService}
+ * @class TreeGridExService
+ * @extends {TreeService<T>}
+ * @template T
  */
-export class TreeGridExService extends TreeService {
-  /**
-   * 表格列映射关系
-   *
-   * @author zk
-   * @date 2023-09-25 05:09:11
-   * @type {Map<string, Map<string, UIMapField>>}
-   * @memberof TreeGridService
-   */
-  multipleUiMap: Map<string, Map<string, UIMapField>> = new Map();
-
-  /**
-   * 初始化节点属性映射
-   *
-   * @author lxm
-   * @date 2022-08-31 18:08:37
-   */
-  initUIDataMap(): void {
-    super.initUIDataMap();
-    this.model.detreeNodes?.forEach((item: IDETreeNode) => {
-      const dataMap: Map<string, UIMapField> = new Map();
-      item.detreeNodeDataItems?.forEach(dataItem => {
-        const uiKey = dataItem.id!.toLowerCase();
-        const deField = dataItem.appDEFieldId!;
-        // 后台实体属性
-        const deFieldKey = deField.toLowerCase();
-        const mapField = new UIMapField(uiKey, deFieldKey, {
-          isOriginField: true,
-          dataType: dataItem.dataType,
-        });
-        dataMap.set(uiKey, mapField);
-      });
-      this.multipleUiMap.set(item.id!, dataMap);
-    });
-  }
-
-  /**
-   * 获取实体数据集数据
-   *
-   * @protected
-   * @param {TreeNodeRSModel} nodeRS
-   * @param {TreeFetchOpts} opts
-   * @returns {*}
-   * @memberof TreeService
-   */
-  protected async getDENodeDatas(
-    nodeModel: IDETreeDataSetNode,
-    nodeRS: IDETreeNodeRS | undefined,
-    parentNodeData: ITreeNodeData | undefined,
-    opts: TreeFetchOpts,
-  ): Promise<TreeDataSetNodeData[]> {
-    const { appDEDataSetId, appDataEntityId } = nodeModel;
-
-    // 处理查询参数,没有关系的时候不处理参数了
-    const { context, params, navContext, navParams } = nodeRS
-      ? this.getNodeRSFilterParams(nodeRS, parentNodeData, opts)
-      : {
-          context: opts.context,
-          params: opts.params,
-          navContext: {},
-          navParams: {},
-        };
-
-    // 设置查询长度
-    params.size = nodeModel.maxSize || 1000;
-    // 排序属性
-    if (nodeModel.sortAppDEFieldId && nodeModel.sortDir) {
-      Object.assign(params, {
-        sort: `${nodeModel.sortAppDEFieldId.toLowerCase()},${nodeModel.sortDir.toLowerCase()}`,
-      });
-    }
-
-    // 请求实体数据
-    const response = await this.app.deService.exec(
-      appDataEntityId!,
-      appDEDataSetId!,
-      context,
-      params,
-    );
-
-    if (response.data.length) {
-      const { data } = this.handleResponseForMultiple(response, nodeModel.id!);
-      const nodeDatas = data.map((item: ControlVO) => {
-        return new TreeDataSetNodeData(nodeModel, parentNodeData, {
-          data: item,
-          leaf: !!opts.leaf,
-          navContext,
-          navParams,
-        });
-      });
-      return nodeDatas;
-    }
-    return [];
-  }
-
-  /**
-   * 处理多数据源响应
-   *
-   * @author zk
-   * @date 2023-09-21 04:09:06
-   * @param {IHttpResponse} response
-   * @param {string} tag 多数据源dataUIMap标识
-   * @return {*}  {IHttpResponse}
-   * @memberof TreeGridService
-   */
-  handleResponseForMultiple(
-    response: IHttpResponse,
-    tag: string,
-  ): IHttpResponse {
-    const res = super.handleResponse(response) as IHttpResponse<
-      IData[] | IData
-    >;
-    if (res.headers) {
-      if (res.headers['x-page']) {
-        res.page = Number(res.headers['x-page']);
-      }
-      if (res.headers['x-per-page']) {
-        res.size = Number(res.headers['x-per-page']);
-      }
-      if (res.headers['x-total']) {
-        res.total = Number(res.headers['x-total']);
-      }
-    }
-    if (res.ok) {
-      if (isArray(res.data)) {
-        res.data = (res.data as IData[]).map(item =>
-          this.toUIDataForMultiple(item, tag),
-        );
-      } else {
-        res.data = this.toUIDataForMultiple(res.data, tag);
-      }
-    }
-    return res;
-  }
-
-  /**
-   * 实体数据转ui数据
-   *
-   * @author zk
-   * @date 2023-09-21 06:09:06
-   * @param {IData} entityData 实体数据
-   * @param {string} tag 多数据源dataUIMap标识
-   * @return {*}  {ControlVO}
-   * @memberof TreeGridService
-   */
-  toUIDataForMultiple(entityData: IData, tag: string): ControlVO {
-    const dataUIMap = this.multipleUiMap.get(tag);
-    return new ControlVO(entityData, dataUIMap);
-  }
-}
+export class TreeGridExService<
+  T extends IDETreeGridEx = IDETreeGridEx,
+> extends TreeService<T> {}

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

@@ -67,6 +67,15 @@ export interface IGridController
    * @memberof IGridController
    */
   validate(row: IGridRowState): Promise<boolean>;
+
+  /**
+   * 设置点击分组后回显相关参数
+   * @param {IData} data
+   * @return {*}
+   * @author: zhujiamin
+   * @Date: 2023-12-21 10:54:45
+   */
+  setGroupParams(data: IData): void;
 }
 
 interface AdditionalProperties {

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

@@ -1,20 +1,19 @@
-import { IDETreeGrid } from '@ibiz/model-core';
+import { IDETreeGridEx } from '@ibiz/model-core';
 import { ITreeGridExEvent } from '../../event';
 import { ITreeGridExState } from '../../state';
-import { IMDControlController } from './i-md-control.controller';
+import { ITreeController } from './i-tree.controller';
 
 /**
  * 树表格(增强)部件控制器
  *
- * @author zk
- * @date 2023-09-21 11:09:17
+ * @author lxm
+ * @date 2023-12-21 11:04:25
  * @export
- * @interface ITreeGridController
- * @extends {IMDControlController<IDETreeGrid, ITreeGridState, ITreeGridEvent>}
+ * @interface ITreeGridExController
+ * @extends {ITreeController<T, S, E>}
  */
-export interface ITreeGridExController
-  extends IMDControlController<
-    IDETreeGrid,
-    ITreeGridExState,
-    ITreeGridExEvent
-  > {}
+export interface ITreeGridExController<
+  T extends IDETreeGridEx = IDETreeGridEx,
+  S extends ITreeGridExState = ITreeGridExState,
+  E extends ITreeGridExEvent = ITreeGridExEvent,
+> extends ITreeController<T, S, E> {}

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

@@ -11,8 +11,11 @@ import { IMDControlController } from './i-md-control.controller';
  * @interface ITreeController
  * @extends {IMDControlController}
  */
-export interface ITreeController
-  extends IMDControlController<IDETree, ITreeState, ITreeEvent> {
+export interface ITreeController<
+  T extends IDETree = IDETree,
+  S extends ITreeState = ITreeState,
+  E extends ITreeEvent = ITreeEvent,
+> extends IMDControlController<T, S, E> {
   /**
    * 树节点点击事件
    *

package/src/interface/controller/controller/control/index.ts

@@ -33,6 +33,7 @@ export * from './i-context-menu.controller';
 export * from './i-kanban.controller';
 export * from './i-tree-grid.controller';
 export * from './i-tree-grid-ex.controller';
+export * from './tree-grid-ex-column/index';
 export * from './i-medit-view-panel.controller';
 export * from './i-chart-exp-bar.controller';
 export * from './i-map.controller';

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

@@ -0,0 +1,12 @@
+import { ITreeGridExController } from '../i-tree-grid-ex.controller';
+
+/**
+ * 树表格（增强）列控制器
+ * @author lxm
+ * @date 2023-05-24 07:34:51
+ * @export
+ * @interface IGridColumnController
+ */
+export interface ITreeGridExColumnController {
+  treeGrid: ITreeGridExController;
+}

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

@@ -0,0 +1 @@
+export * from './i-tree-grid-ex-column.controller';

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

@@ -1,4 +1,4 @@
-import { IMDControlEvent } from './i-md-control.event';
+import { ITreeEvent } from './i-tree.event';
 
 /**
  * 树表格(增强)部件事件
@@ -9,4 +9,4 @@ import { IMDControlEvent } from './i-md-control.event';
  * @interface ITreeGridExEvent
  * @extends {IMDControlEvent}
  */
-export interface ITreeGridExEvent extends IMDControlEvent {}
+export interface ITreeGridExEvent extends ITreeEvent {}