@ibiz-template/runtime 0.4.10 → 0.4.12

package/src/controller/control/form/form-detail/form-druipart/form-druipart.controller.ts

@@ -53,7 +53,7 @@ export class FormDRUIPartController extends FormDetailController<IDEFormDRUIPart
   refreshItems: string[] = ['srfkey'];
 
   /**
-   * 参数项名称
+   * 参数项名称（这个模型暂不使用，相关场景可以通过配置导航参数实现）
    *
    * @author lxm
    * @date 2022-09-15 19:09:36

package/src/controller/control/form/form-detail/form-item/form-item.controller.ts

@@ -106,6 +106,21 @@ export class FormItemController
     return undefined;
   }
 
+  /**
+   * 标签标题
+   * @author lxm
+   * @date 2023-12-12 09:48:21
+   * @readonly
+   * @type {(string | undefined)}
+   */
+  get labelCaption(): string | undefined {
+    const { captionItemName } = this.model;
+    if (captionItemName) {
+      return this.data[captionItemName];
+    }
+    return this.model.caption;
+  }
+
   /**
    * Creates an instance of FormItemController.
    *
@@ -268,11 +283,6 @@ export class FormItemController
 
     // 计算启用条件
     this.calcEnableCond();
-
-    // 触发默认值
-    if (state === FormNotifyState.LOAD) {
-      this.setDefaultValue(false);
-    }
   }
 
   protected calcDynamicLogic(names: string[], mustCalc: boolean = false): void {

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

@@ -1,4 +1,4 @@
-import { RuntimeError, mergeDefaultInLeft } from '@ibiz-template/core';
+import { RuntimeError } from '@ibiz-template/core';
 import { IDESearchForm } from '@ibiz/model-core';
 import {
   ISearchFormController,
@@ -77,9 +77,6 @@ export class SearchFormController
   async load(): Promise<IData> {
     const queryParams = { ...this.params };
 
-    // 新建默认值给到graft接口，接口会回来
-    const params = await this.getDraftParams();
-    Object.assign(queryParams, params);
     await this.evt.emit('onBeforeLoadDraft', { params: queryParams });
     let res;
     try {
@@ -91,7 +88,6 @@ export class SearchFormController
       throw error;
     }
     this.state.data = res.data;
-    mergeDefaultInLeft(this.data, params);
     this.state.isLoaded = true;
     this.formStateNotify(FormNotifyState.DRAFT);
     this.actionNotification('GETDRAFTSUCCESS');

package/src/controller/control/form/search-form/search-form.service.ts

@@ -1,6 +1,7 @@
 import { IHttpResponse, recursiveIterate } from '@ibiz-template/core';
 import { IDESearchForm, IDEFormDetail } from '@ibiz/model-core';
-import { ControlService, ControlVO, UIMapField } from '../../../../service';
+import { ControlVO, UIMapField } from '../../../../service';
+import { FormService } from '../form/form.service';
 
 /**
  * 搜索表单服务
@@ -14,7 +15,7 @@ import { ControlService, ControlVO, UIMapField } from '../../../../service';
  */
 export class SearchFormService<
   T extends IDESearchForm = IDESearchForm,
-> extends ControlService<T> {
+> extends FormService<T> {
   /**
    * 执行获取草稿方法
    *
@@ -25,12 +26,16 @@ export class SearchFormService<
    * @returns {*}  {Promise<IHttpResponse>}
    */
   async getDraft(
-    _context: IParams,
+    context: IParams,
     params: IParams = {},
   ): Promise<IHttpResponse<ControlVO>> {
     const tempData = this.getFilteredData({ ...params });
     let res = { ok: true, status: 200, data: tempData } as IHttpResponse;
     res = this.handleResponse(res);
+    // 设置默认值
+    if (res.ok && res.data) {
+      this.setDefault(res.data, context, params, 'create');
+    }
     return res as IHttpResponse<ControlVO>;
   }
 

package/src/controller/control/gantt/gantt.controller.ts

@@ -1,7 +1,16 @@
+/* eslint-disable no-param-reassign */
+import { recursiveIterate } from '@ibiz-template/core';
 import { IDEGantt } from '@ibiz/model-core';
-import { IGanttController, IGanttEvent, IGanttState } from '../../../interface';
+import {
+  IGanttController,
+  IGanttEvent,
+  IGanttNodeData,
+  IGanttState,
+  MDCtrlLoadParams,
+} from '../../../interface';
 import { MDControlController } from '../../common';
 import { GanttService } from './gantt.service';
+import { ContextMenuController } from '../context-menu';
 
 /**
  * 甘特图控制器
@@ -19,9 +28,178 @@ export class GanttController
 {
   declare service: GanttService;
 
+  /**
+   * 上下文菜单控制器
+   *
+   * @author tony001
+   * @date 2023-12-11 16:12:57
+   * @type {{ [p: string]: ContextMenuController }}
+   */
+  contextMenus: { [p: string]: ContextMenuController } = {};
+
+  /**
+   * 是否启用快速搜索
+   *
+   * @author tony001
+   * @date 2023-12-11 16:12:13
+   * @type {boolean}
+   */
+  enableQuickSearch: boolean = false;
+
+  /**
+   * 初始化状态
+   *
+   * @author tony001
+   * @date 2023-12-11 16:12:20
+   * @protected
+   */
+  protected initState(): void {
+    super.initState();
+    this.state.size = 0;
+    this.state.query = '';
+  }
+
   protected async onCreated(): Promise<void> {
     await super.onCreated();
+
+    // 快速搜索
+    if (this.model.detreeNodes?.[0].enableQuickSearch) {
+      this.enableQuickSearch = true;
+    }
+
+    // 计算快速搜索占位符
+    if (this.dataEntity) {
+      const searchFields = this.dataEntity.appDEFields?.filter(field => {
+        return field.enableQuickSearch;
+      });
+      const placeHolders: string[] = [];
+      searchFields?.forEach(searchField => {
+        if (searchField?.lnlanguageRes && searchField.lnlanguageRes.lanResTag) {
+          placeHolders.push(
+            ibiz.i18n.t(
+              searchField.lnlanguageRes.lanResTag,
+              searchField.logicName,
+            ),
+          );
+        } else if (searchField?.logicName) {
+          placeHolders.push(searchField.logicName);
+        }
+      });
+      if (placeHolders.length > 0) {
+        this.state.placeHolder = placeHolders.join('、');
+      }
+    }
+
     this.service = new GanttService(this.model);
     await this.service.init(this.context);
+
+    // 初始化上下文菜单控制器
+    this.model.detreeNodes!.forEach(node => {
+      if (node.decontextMenu?.detoolbarItems?.length) {
+        this.contextMenus[node.decontextMenu.id!] = new ContextMenuController(
+          node.decontextMenu,
+          this.context,
+          this.params,
+          this.ctx,
+        );
+      }
+    });
+
+    // 上下文菜单控制器初始化
+    await Promise.all(
+      Object.values(this.contextMenus).map(menu => menu.created()),
+    );
+  }
+
+  /**
+   * 加载
+   *
+   * @author tony001
+   * @date 2023-12-12 11:12:08
+   * @param {MDCtrlLoadParams} [args={}]
+   * @return {*}  {Promise<IGanttNodeData[]>}
+   */
+  async load(args: MDCtrlLoadParams = {}): Promise<IGanttNodeData[]> {
+    const isInitialLoad = args.isInitialLoad === true;
+    if (isInitialLoad) {
+      await this.startLoading();
+    }
+    let nodes;
+    try {
+      nodes = await this.loadNodes();
+    } finally {
+      if (isInitialLoad) {
+        await this.endLoading();
+      }
+    }
+    await this.afterLoad(args, nodes);
+    this.state.isLoaded = true;
+    await this.evt.emit('onLoadSuccess', {
+      isInitialLoad,
+    });
+
+    return nodes;
+  }
+
+  /**
+   * 获取查询参数
+   *
+   * @author tony001
+   * @date 2023-12-12 11:12:22
+   * @param {IParams} [extraParams]
+   * @return {*}  {Promise<IParams>}
+   */
+  async getFetchParams(extraParams?: IParams): Promise<IParams> {
+    const params = await super.getFetchParams(extraParams);
+    if (this.state.query) {
+      params.query = this.state.query;
+    }
+    return params;
+  }
+
+  /**
+   * 加载节点
+   *
+   * @author tony001
+   * @date 2023-12-12 11:12:33
+   * @param {IGanttNodeData} [parentNode]
+   * @return {*}  {Promise<IGanttNodeData[]>}
+   */
+  async loadNodes(parentNode?: IGanttNodeData): Promise<IGanttNodeData[]> {
+    const params = await this.getFetchParams();
+    const hasQuery = !!params.query;
+
+    this.state.isLoading = true;
+
+    let nodes: IGanttNodeData[] | undefined;
+    try {
+      // 请求服务获取子节点数据
+      nodes =
+        (await this.service.fetchGanttChildNodes(parentNode, {
+          context: this.context.clone(),
+          params,
+          hasQuery,
+          defaultExpandedKeys: [],
+        })) || [];
+    } finally {
+      this.state.isLoading = false;
+    }
+
+    // 有父节点绑定到父节点数据上，无父节点替换rootNodes
+    if (parentNode) {
+      parentNode.children = nodes;
+    } else {
+      this.state.rootNodes = nodes;
+    }
+
+    // 更新items
+    this.state.items = [];
+    recursiveIterate(
+      { children: this.state.rootNodes },
+      (node: IGanttNodeData) => {
+        this.state.items.push(node);
+      },
+    );
+    return nodes;
   }
 }

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

@@ -1,13 +1,312 @@
-import { IDEGantt } from '@ibiz/model-core';
-import { MDControlService } from '../../../service';
+import {
+  IDETreeCodeListNode,
+  IDETreeDataSetNode,
+  IDETreeNode,
+  IDETreeNodeRS,
+} from '@ibiz/model-core';
+import { ModelError } from '@ibiz-template/core';
+import { IGanttNodeData } from '../../../interface';
+import { getChildNodeRSs, getRootNode, getTreeNode } from '../../../model';
+import { handleAllSettled } from '../../../utils';
+import { TreeFetchOpts, TreeService } from '../tree';
+import {
+  GanttCodeListNodeData,
+  GanttDataSetNodeData,
+  GanttStaticNodeData,
+} from '../../../service';
 
 /**
  * 甘特图服务
  *
- * @author zhanghengfeng
- * @date 2023-12-08 15:12:34
+ * @author tony001
+ * @date 2023-12-11 16:12:57
  * @export
  * @class GanttService
- * @extends {MDControlService<IDEGantt>}
+ * @extends {TreeService}
  */
-export class GanttService extends MDControlService<IDEGantt> {}
+export class GanttService extends TreeService {
+  /**
+   * 获取子节点数据
+   *
+   * @author tony001
+   * @date 2023-12-11 18:12:58
+   * @param {(IGanttNodeData | undefined)} parentNodeData
+   * @param {TreeFetchOpts} opts
+   * @return {*}  {(Promise<IGanttNodeData[] | undefined>)}
+   */
+  async fetchGanttChildNodes(
+    parentNodeData: IGanttNodeData | undefined,
+    opts: TreeFetchOpts,
+  ): Promise<IGanttNodeData[] | undefined> {
+    const { hasQuery } = opts;
+
+    let childrenNodes: IGanttNodeData[] = [];
+    if (!parentNodeData) {
+      // 没有父节点的加载根节点数据
+      const rootNode = getRootNode(this.model);
+      childrenNodes = await this.fetchGanttNodeDatasByType(
+        rootNode,
+        undefined,
+        undefined,
+        opts,
+      );
+    } else {
+      // 有父节点的计算节点关系查询对应节点数据并合并
+      const childNodeRSs = getChildNodeRSs(this.model, {
+        parentId: parentNodeData.nodeId,
+        hasQuery,
+      });
+
+      if (childNodeRSs.length === 0) {
+        return;
+      }
+      const results = await handleAllSettled(
+        childNodeRSs.map(async childNodeRS => {
+          const childNode = getTreeNode(
+            this.model,
+            childNodeRS.childDETreeNodeId!,
+          );
+          return this.fetchGanttNodeDatasByType(
+            childNode,
+            childNodeRS,
+            parentNodeData,
+            opts,
+          );
+        }),
+        false,
+      );
+
+      results.forEach(result => {
+        childrenNodes.push(...result);
+      });
+    }
+    return childrenNodes;
+  }
+
+  /**
+   * 通过节点类型加载节点数据
+   *
+   * @author tony001
+   * @date 2023-12-11 18:12:35
+   * @protected
+   * @param {IDETreeNode} nodeModel
+   * @param {(IDETreeNodeRS | undefined)} nodeRS
+   * @param {(ITreeNodeData | undefined)} parentNodeData
+   * @param {TreeFetchOpts} opts
+   * @return {*}  {Promise<IGanttNodeData[]>}
+   */
+  protected async fetchGanttNodeDatasByType(
+    nodeModel: IDETreeNode,
+    nodeRS: IDETreeNodeRS | undefined,
+    parentNodeData: IGanttNodeData | undefined,
+    opts: TreeFetchOpts,
+  ): Promise<IGanttNodeData[]> {
+    // 有没有下级
+    const leaf =
+      getChildNodeRSs(this.model, {
+        parentId: nodeModel.id,
+        hasQuery: opts.hasQuery,
+      }).length === 0;
+    const tempOpts = { ...opts, leaf };
+
+    // 根据类型查询节点数据
+    let result: IGanttNodeData[] = [];
+    switch (nodeModel.treeNodeType) {
+      case 'STATIC':
+        {
+          const nodeData = await this.getStaticGanttNodeData(
+            nodeModel,
+            nodeRS,
+            parentNodeData,
+            tempOpts,
+          );
+          result = [nodeData];
+        }
+        break;
+      case 'DE':
+        result = await this.getDEGanttNodeDatas(
+          nodeModel as IDETreeDataSetNode,
+          nodeRS,
+          parentNodeData,
+          tempOpts,
+        );
+        break;
+      case 'CODELIST':
+        result = await this.getCodeListGanttNodeDatas(
+          nodeModel as IDETreeCodeListNode,
+          nodeRS,
+          parentNodeData,
+          tempOpts,
+        );
+        break;
+      default:
+        throw new ModelError(
+          nodeModel,
+          `${nodeModel.treeNodeType}节点类型未支持`,
+        );
+    }
+    // *查询回来之后,如果有子节点，看默认展开相关配置有时每个节点数据走一遍展开逻辑
+    const { expandFirstOnly, expanded, rootNode } = nodeModel;
+    const isExpandedRoot = rootNode && !this.model.rootVisible; // root节点不显示的时候默认展开其子节点
+    if (!leaf) {
+      await Promise.all(
+        result.map(async (childNode, index) => {
+          if (
+            (expanded && // 全展开合只展开首节点expanded都为true
+              (!expandFirstOnly || (expandFirstOnly && index === 0))) ||
+            isExpandedRoot
+          ) {
+            const subChildrenNodes = await this.fetchGanttChildNodes(
+              childNode,
+              opts,
+            );
+            childNode.children = subChildrenNodes;
+          }
+        }),
+      );
+    }
+    return result;
+  }
+
+  /**
+   * 获取静态节点数据
+   *
+   * @author tony001
+   * @date 2023-12-11 18:12:06
+   * @protected
+   * @param {IDETreeNode} nodeModel
+   * @param {(IDETreeNodeRS | undefined)} nodeRS
+   * @param {(IGanttNodeData | undefined)} parentNodeData
+   * @param {TreeFetchOpts} opts
+   * @return {*}  {Promise<IGanttNodeData>}
+   */
+  protected async getStaticGanttNodeData(
+    nodeModel: IDETreeNode,
+    nodeRS: IDETreeNodeRS | undefined,
+    parentNodeData: IGanttNodeData | undefined,
+    opts: TreeFetchOpts,
+  ): Promise<IGanttNodeData> {
+    const nodeData: IGanttNodeData = new GanttStaticNodeData(
+      this.model,
+      nodeModel,
+      parentNodeData,
+      { parentValueLevel: nodeRS?.parentValueLevel, leaf: !!opts.leaf },
+    );
+    return nodeData;
+  }
+
+  /**
+   * 获取实体数据集数据
+   *
+   * @author tony001
+   * @date 2023-12-11 18:12:23
+   * @protected
+   * @param {IDETreeDataSetNode} nodeModel
+   * @param {(IDETreeNodeRS | undefined)} nodeRS
+   * @param {(IGanttNodeData | undefined)} parentNodeData
+   * @param {TreeFetchOpts} opts
+   * @return {*}  {Promise<IGanttNodeData[]>}
+   */
+  protected async getDEGanttNodeDatas(
+    nodeModel: IDETreeDataSetNode,
+    nodeRS: IDETreeNodeRS | undefined,
+    parentNodeData: IGanttNodeData | undefined,
+    opts: TreeFetchOpts,
+  ): Promise<IGanttNodeData[]> {
+    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) {
+      Object.assign(params, {
+        sort: `${nodeModel.sortAppDEFieldId.toLowerCase()},${
+          nodeModel.sortDir ? nodeModel.sortDir.toLowerCase() : 'asc'
+        }`,
+      });
+    }
+
+    // 请求实体数据
+    const response = await this.app.deService.exec(
+      appDataEntityId!,
+      appDEDataSetId!,
+      context,
+      params,
+    );
+    if (response.data.length) {
+      const nodeDatas = response.data.map((item: IData) => {
+        return new GanttDataSetNodeData(this.model, nodeModel, parentNodeData, {
+          data: item,
+          leaf: !!opts.leaf,
+          navContext,
+          navParams,
+        });
+      });
+      return nodeDatas;
+    }
+    return [];
+  }
+
+  /**
+   * 获取代码表节点数据
+   *
+   * @author tony001
+   * @date 2023-12-11 18:12:35
+   * @protected
+   * @param {IDETreeCodeListNode} nodeModel
+   * @param {(IDETreeNodeRS | undefined)} nodeRS
+   * @param {(IGanttNodeData | undefined)} parentNodeData
+   * @param {TreeFetchOpts} opts
+   * @return {*}  {Promise<IGanttNodeData[]>}
+   */
+  protected async getCodeListGanttNodeDatas(
+    nodeModel: IDETreeCodeListNode,
+    nodeRS: IDETreeNodeRS | undefined,
+    parentNodeData: IGanttNodeData | undefined,
+    opts: TreeFetchOpts,
+  ): Promise<IGanttNodeData[]> {
+    // 处理查询参数,没有关系的时候不处理参数了
+    const { context, params, navContext, navParams } = nodeRS
+      ? this.getNodeRSFilterParams(nodeRS, parentNodeData, opts)
+      : {
+          context: opts.context,
+          params: opts.params,
+          navContext: {},
+          navParams: {},
+        };
+
+    // 请求实体数据
+    const items = await this.app.codeList.get(
+      nodeModel.codeListId!,
+      context,
+      params,
+    );
+    if (items.length) {
+      const nodeDatas = items.map(item => {
+        return new GanttCodeListNodeData(
+          this.model,
+          nodeModel,
+          parentNodeData,
+          {
+            data: item,
+            leaf: !!opts.leaf,
+            navContext,
+            navParams,
+          },
+        );
+      });
+      return nodeDatas;
+    }
+    return [];
+  }
+}

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;
   }
@@ -218,7 +218,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 +233,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,
+        searchcondlist: 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,
     };
   }
 }