@ibiz-template/runtime 0.0.3-beta.1 → 0.0.3-beta.3

package/src/service/service/widget/kanban-service.ts

@@ -0,0 +1,34 @@
+import { KanbanModel } from '@ibiz-template/model';
+import { UIMapField } from '../../vo/ui-map-field';
+import { MDControlService } from './md-control-service';
+
+export class KanbanService extends MDControlService<KanbanModel> {
+  /**
+   * 初始化属性映射
+   *
+   * @author lxm
+   * @date 2022-08-31 18:08:37
+   */
+  initUIDataMap() {
+    super.initUIDataMap();
+    // *初始化表格数据项的属性映射
+    this.model.source.getPSDEDataViewDataItems()?.forEach(column => {
+      const uiKey = column.name.toLowerCase();
+      const deField = column.getPSAppDEField();
+      let mapField: UIMapField;
+      // 后台实体属性
+      if (deField) {
+        const deFieldKey = deField.codeName.toLowerCase();
+        mapField = new UIMapField(uiKey, deFieldKey, {
+          isOriginField: true,
+        });
+      } else {
+        // 前台属性
+        mapField = new UIMapField(uiKey, uiKey, {
+          isRequestNeed: false,
+        });
+      }
+      this.dataUIMap.set(uiKey, mapField);
+    });
+  }
+}

package/src/service/service/widget/tree-service.ts

@@ -1,14 +1,15 @@
 import {
-  IPSDETreeCodeListNode,
-  IPSDETreeDataSetNode,
-  IPSDETreeNode,
-  IPSDETreeStaticNode,
+  TreeDataSetNodeModel,
   TreeModel,
+  TreeNodeRSModel,
+  TreeStaticNodeModel,
 } from '@ibiz-template/model';
-import { TreeNodeData } from '../../vo/tree-node-data';
+import { convertNavData } from '../../../utils';
+import { ITreeNodeData } from '../../interface/i-tree-node-data/i-tree-node-data';
+import { TreeDataSetNodeData, TreeStaticNodeData } from '../../vo';
 import { MDControlService } from './md-control-service';
 
-interface TreeFetchOpts {
+export interface TreeFetchOpts {
   /**
    * 是否有过滤搜索
    *
@@ -56,50 +57,46 @@ export class TreeService extends MDControlService<TreeModel> {
   /**
    * 获取子节点数据
    *
-   * @param {TreeNodeData} [parentNode] 父节点数据
+   * @param {ITreeNodeData} [parentNodeData] 父节点数据
    * @param {boolean} [hasQuery=false] 是否搜索
    * @returns {*}
    * @memberof TreeService
    */
   async fetchChildNodes(
-    parentNode: TreeNodeData | undefined,
+    parentNodeData: ITreeNodeData | undefined,
     opts: TreeFetchOpts,
   ) {
-    const childNodeModels = this.model.getChildNodes(
-      parentNode?.nodeId || this.model.rootNode.id,
+    const childNodeRSs = this.model.getChildNodeRSs(
+      parentNodeData?.nodeId || this.model.rootNode.id,
       opts.hasQuery,
     );
 
-    if (childNodeModels.length === 0) {
+    if (childNodeRSs.length === 0) {
       return;
     }
 
     const results = await Promise.allSettled(
-      childNodeModels.map(async childNode => {
+      childNodeRSs.map(async childNodeRS => {
+        const { childNode } = childNodeRS;
         if (childNode.treeNodeType === 'STATIC') {
           const nodeData = await this.getStaticNodeData(
-            childNode.source as IPSDETreeStaticNode,
+            childNodeRS,
+            parentNodeData,
             opts,
           );
           return [nodeData];
         }
         if (childNode.treeNodeType === 'DE') {
-          return this.getDENodeDatas(
-            childNode.source as IPSDETreeDataSetNode,
-            opts,
-          );
+          return this.getDENodeDatas(childNodeRS, parentNodeData, opts);
         }
         if (childNode.treeNodeType === 'CODELIST') {
-          return this.getCodeListNodeDatas(
-            childNode.source as IPSDETreeCodeListNode,
-            opts,
-          );
+          return this.getCodeListNodeDatas(childNodeRS, parentNodeData, opts);
         }
-        return null;
+        return undefined;
       }),
     );
 
-    const childrenNodes: TreeNodeData[] = [];
+    const childrenNodes: ITreeNodeData[] = [];
     results.forEach(result => {
       if (result.status === 'fulfilled' && result.value) {
         childrenNodes.push(...result.value);
@@ -111,37 +108,27 @@ export class TreeService extends MDControlService<TreeModel> {
     // todo 查询回来之后，看是否默认打开，默认展开继续递归加载子节点。
   }
 
-  getBaseNodeData(nodeModel: IPSDETreeNode, opts: TreeFetchOpts) {
-    const nodeData: TreeNodeData = {
-      nodeId: nodeModel.nodeType,
-      id: nodeModel.nodeType,
-      text: '',
-      leaf:
-        this.model.getChildNodes(nodeModel.nodeType, opts.hasQuery).length ===
-        0,
-    };
-    if (nodeData.leaf === false) {
-      nodeData.children = [];
-      // nodeData.loading = false;
-    }
-    return nodeData;
-  }
-
   /**
    * 获取静态节点数据
    *
    * @protected
-   * @param {IPSDETreeStaticNode} nodeModel
+   * @param {TreeStaticNodeModel} nodeModel
    * @param {boolean} [hasQuery=false]
    * @returns {*}
    * @memberof TreeService
    */
   protected async getStaticNodeData(
-    nodeModel: IPSDETreeStaticNode,
+    nodeRS: TreeNodeRSModel,
+    parentNodeData: ITreeNodeData | undefined,
     opts: TreeFetchOpts,
-  ): Promise<TreeNodeData> {
-    const nodeData: TreeNodeData = this.getBaseNodeData(nodeModel, opts);
-    nodeData.text = nodeModel.text;
+  ): Promise<ITreeNodeData> {
+    const nodeModel = nodeRS.childNode as TreeStaticNodeModel;
+    const nodeData: ITreeNodeData = new TreeStaticNodeData(
+      nodeModel,
+      opts,
+      nodeRS,
+      parentNodeData,
+    );
 
     // todo 仅展开首节点
     if (nodeModel.expanded) {
@@ -151,28 +138,96 @@ export class TreeService extends MDControlService<TreeModel> {
     return nodeData;
   }
 
+  /**
+   * 获取节点关系过滤的上下文和视图参数
+   *
+   * @param {TreeNodeRSModel} nodeRS 节点关系模型
+   * @param {(ITreeNodeData | undefined)} parentNodeData 父节点数据
+   * @returns {*}  {(IParams | undefined)}
+   * @memberof TreeService
+   */
+  getNodeRSFilterParams(
+    nodeRS: TreeNodeRSModel,
+    parentNodeData: ITreeNodeData | undefined,
+    opts: TreeFetchOpts,
+  ): { context: IContext; params: IParams } {
+    // 处理父值过滤项
+    const { parentValueLevel, navContexts, navParams, pickupDEFName } = nodeRS;
+
+    const params = { ...opts.params };
+
+    // 合并部件上下文和父节点资源上下文
+    const context = {
+      ...opts.context,
+      ...(parentNodeData?.context || {}),
+    };
+
+    // 计算关系过滤用到的实体数据
+    let data: IData = {};
+    let parentData: ITreeNodeData | undefined;
+    if (parentNodeData) {
+      // 根据父值级别查找父数据
+      parentData = parentNodeData;
+      for (let index = 1; index < parentValueLevel; index++) {
+        parentData = parentData?.parent;
+      }
+      if (parentData?.deData) {
+        data = parentData.deData;
+      }
+    }
+
+    // 处理父值关系过滤参数
+    if (parentData && pickupDEFName) {
+      params[`n_${pickupDEFName}_eq`] = parentData.value;
+    }
+
+    // 处理自定义关系过滤参数
+    const tempContext = convertNavData(navContexts, context, params, data);
+    const tempParams = convertNavData(navParams, context, params, data);
+    Object.assign(context, tempContext);
+    Object.assign(params, tempParams);
+
+    return { context, params };
+  }
+
   /**
    * 获取实体数据集数据
    *
    * @protected
-   * @param {IPSDETreeDataSetNode} nodeModel
-   * @param {boolean} [_hasQuery=false]
+   * @param {TreeNodeRSModel} nodeRS
+   * @param {TreeFetchOpts} opts
+   * @returns {*}
    * @memberof TreeService
    */
   protected async getDENodeDatas(
-    nodeModel: IPSDETreeDataSetNode,
+    nodeRS: TreeNodeRSModel,
+    parentNodeData: ITreeNodeData | undefined,
     opts: TreeFetchOpts,
   ) {
-    const appde = nodeModel.getPSAppDataEntity();
-    await appde!.fill();
-    const methodName = nodeModel.getPSAppDEDataSet()!.codeName;
+    const nodeModel = nodeRS.childNode as TreeDataSetNodeModel;
+    const { methodName, appEntity } = nodeModel;
+    const service = await this.app.es.getService(appEntity.codeName);
+
+    // 处理查询参数
+    const { context, params } = this.getNodeRSFilterParams(
+      nodeRS,
+      parentNodeData,
+      opts,
+    );
 
-    const service = await this.app.es.getService(appde!.codeName);
-    const response = await service.exec(methodName, opts.context, opts.params);
-    const baseNodeData: TreeNodeData = this.getBaseNodeData(nodeModel, opts);
+    // 请求实体数据
+    const response = await service.exec(methodName, context, params);
     if (response.data.length) {
       const nodeDatas = response.data.map((item: IData) => {
-        return { ...baseNodeData, id: item.srfkey, text: item.srfmajortext };
+        return new TreeDataSetNodeData(
+          nodeModel,
+          {
+            ...opts,
+            data: item,
+          },
+          nodeRS,
+          parentNodeData,
+        );
       });
       return nodeDatas;
     }
@@ -183,12 +238,13 @@ export class TreeService extends MDControlService<TreeModel> {
    * 获取代码表节点数据
    *
    * @protected
-   * @param {IPSDETreeCodeListNode} _nodeModel
+   * @param {TreeCodeListNodeModel} _nodeModel
    * @param {TreeFetchOpts} _opts
    * @memberof TreeService
    */
   protected async getCodeListNodeDatas(
-    _nodeModel: IPSDETreeCodeListNode,
+    _nodeRS: TreeNodeRSModel,
+    _parentNodeData: ITreeNodeData | undefined,
     _opts: TreeFetchOpts,
   ) {
     // todo 代码表查询

package/src/service/service/widget/wizard-panel-service.ts

@@ -0,0 +1,54 @@
+import { IHttpResponse } from '@ibiz-template/core';
+import { WizardPanelModel } from '@ibiz-template/model';
+import { ControlService } from './control-service';
+
+/**
+ * 向导面板服务
+ *
+ * @author lxm
+ * @date 2023-02-16 04:11:13
+ * @export
+ * @class WizardPanelService
+ * @extends {ControlService<T>}
+ * @template T
+ */
+export class WizardPanelService<
+  T extends WizardPanelModel = WizardPanelModel,
+> extends ControlService<T> {
+  /**
+   * 执行向导初始化
+   * 服务调用之前确认是否有初始化实体行为
+   *
+   * @author lxm
+   * @date 2022-08-31 17:08:41
+   * @param {IContext} context 上下文
+   * @param {IParams} [params={}] 视图参数
+   * @returns {*}  {Promise<IHttpResponse>}
+   */
+  async initialize(
+    context: IContext,
+    params: IParams = {},
+  ): Promise<IHttpResponse<IData>> {
+    let res = await this.exec(this.model.initAction!, context, params);
+    res = this.handleResponse(res);
+    return res as IHttpResponse<IData>;
+  }
+
+  /**
+   * 执行向导完成
+   *
+   * @author lxm
+   * @date 2022-08-31 17:08:41
+   * @param {IContext} context 上下文
+   * @param {IParams} [params={}] 视图参数
+   * @returns {*}  {Promise<IHttpResponse>}
+   */
+  async finish(
+    context: IContext,
+    params: IParams = {},
+  ): Promise<IHttpResponse<IData>> {
+    let res = await this.exec(this.model.finishAction, context, params);
+    res = this.handleResponse(res);
+    return res as IHttpResponse<IData>;
+  }
+}

package/src/service/service-util.ts

@@ -4,7 +4,6 @@ import {
   ModelService,
 } from '@ibiz-template/model';
 import { EntityService } from './service';
-import { ServicePathUtil } from './utils';
 
 /**
  * 应用服务工具类
@@ -72,10 +71,7 @@ export class ServiceUtil {
    * @param {IContext} [context] 上下文,用于计算模型所属沙箱环境
    * @return {*}  {Promise<EntityService>}
    */
-  async getService(
-    entityCodeName: string,
-    context?: IContext,
-  ): Promise<EntityService> {
+  async getService(entityCodeName: string): Promise<EntityService> {
     if (!this.cache.has(entityCodeName)) {
       await this.initAllEntities();
       const entity = this.allEntities.get(entityCodeName);
@@ -85,10 +81,8 @@ export class ServiceUtil {
       await entity.fill(true);
       const entityModel = new AppEntityModel(entity);
       await entityModel.init();
-      const paths = await ServicePathUtil.calcPaths(
-        context || {},
-        entityCodeName,
-      );
+      const app = ibiz.hub.getApp(this.modelService.app);
+      const paths = app.resourcePathUtil.calcPaths(entityCodeName);
       const service = await new EntityService(entityModel, paths);
       this.cache.set(entityCodeName, service);
     }

package/src/service/utils/index.ts

@@ -3,11 +3,11 @@ export * from './de-dq-cond';
 export { DEDQCondUtil } from './de-dq-cond-util/de-dq-cond-util';
 export { DynamicCodeListCache } from './dynamic-code-list/dynamic-code-list';
 export { EntityCache } from './entity-cache/entity-cache';
+export { calcResPath } from './res-path/res-path';
+export { calcRouteContext } from './route-context/route-context';
 export { SearchFilter } from './search-filter/search-filter';
 export {
   ServicePathDeep,
   ServicePathItem,
   ServicePathUtil,
 } from './service-path-util/service-path-util';
-export { IBizVerify } from './ibiz-verify/ibiz-verify';
-export * from './res-path/res-path';

package/src/service/utils/route-context/route-context.ts

@@ -0,0 +1,75 @@
+import { IPSAppView, ViewType } from '@ibiz-template/model';
+import { ServicePathItem } from '../service-path-util/service-path-util';
+
+/**
+ * 计算资源上下文时，需要排除自身实体codeName的视图（导航类视图和多数据视图）
+ * @return {*}
+ * @author: zhujiamin
+ * @Date: 2023-02-20 15:45:46
+ */
+export const excludeViewTypes: string[] = [
+  ViewType.DE_GRID_VIEW,
+  ViewType.DE_GRID_EXP_VIEW,
+  ViewType.DE_LIST_VIEW,
+  ViewType.DE_LIST_EXP_VIEW,
+  ViewType.DE_DATA_VIEW,
+  ViewType.DE_DATAVIEW_EXP_VIEW,
+  ViewType.DE_CALENDAR_VIEW,
+  ViewType.DE_CALENDAR_EXP_VIEW,
+  ViewType.DE_CHART_VIEW,
+  ViewType.DE_CHART_EXP_VIEW,
+  ViewType.DE_KANBAN_VIEW,
+];
+
+/**
+ * 计算放置到路径中的资源上下文参数
+ *
+ * @author chitanda
+ * @date 2023-01-10 14:01:51
+ * @export
+ * @param {IContext} context
+ * @param {ServicePathItem[][]} pathItems
+ * @return {*}  {Record<string, unknown>}
+ */
+export function calcRouteContext(
+  context: IContext,
+  pathItems: ServicePathItem[][],
+  appView?: IPSAppView,
+): Record<string, unknown> {
+  let paths: string[][][] = [];
+  pathItems.forEach(items => {
+    const values: string[][] = [];
+    for (let i = 0; i < items.length; i++) {
+      const arr: string[] = [];
+      const item = items[i];
+      if (
+        appView &&
+        appView.viewType &&
+        excludeViewTypes.includes(appView.viewType)
+      ) {
+        // 排除导航类视图和多数据视图自身
+        const deName = appView.getPSAppDataEntity()?.codeName.toLowerCase();
+        if (deName === item.name) {
+          return;
+        }
+      }
+      const val = context[item.name];
+      if (val) {
+        arr.push(item.name);
+        arr.push(val);
+        values.push(arr);
+      }
+    }
+    paths.push(values);
+  });
+  paths = paths.sort((a, b) => b.length - a.length);
+  const [pathArr] = paths;
+  if (pathArr) {
+    const obj: Record<string, unknown> = {};
+    pathArr.forEach(([key, val]) => {
+      obj[key] = val;
+    });
+    return obj;
+  }
+  return {};
+}

package/src/service/utils/service-path-util/service-path-util.ts

@@ -1,5 +1,5 @@
 import { pluralLower } from '@ibiz-template/core';
-import { IPSAppDERS } from '@ibiz-template/model';
+import { IPSAppDERS, ModelService } from '@ibiz-template/model';
 
 /**
  * 获取服务拼接递归对象
@@ -45,7 +45,7 @@ export type ServicePathItem = {
  * @class ServicePathUtil
  */
 export class ServicePathUtil {
-  protected static allDERss: IPSAppDERS[] = [];
+  protected allDERss: IPSAppDERS[] = [];
 
   /**
    * 应用实体关系
@@ -55,7 +55,7 @@ export class ServicePathUtil {
    * @protected
    * @type {Map<string, IPSAppDERS[]>} <应用实体, 应用实体父关系>
    */
-  protected static entityRsMap: Map<string, IPSAppDERS[]> = new Map();
+  protected entityRsMap: Map<string, IPSAppDERS[]> = new Map();
 
   /**
    * 实体资源路径
@@ -65,24 +65,30 @@ export class ServicePathUtil {
    * @protected
    * @type {Map<string, ServicePathItem[][]>}
    */
-  protected static entityRsPathMap: Map<string, ServicePathItem[][]> =
-    new Map();
+  protected entityRsPathMap: Map<string, ServicePathItem[][]> = new Map();
+
+  /**
+   * Creates an instance of ServicePathUtil.
+   *
+   * @author chitanda
+   * @date 2023-01-10 16:01:18
+   * @param {ModelService} modelService 当前应用所归属的模型服务
+   */
+  constructor(protected modelService: ModelService) {}
 
   /**
    * 初始化工具参数
    *
    * @author chitanda
    * @date 2022-08-22 21:08:47
-   * @protected
    * @param {IContext} context
    * @return {*}  {Promise<void>}
    */
-  protected static async init(context: IContext): Promise<void> {
+  async init(): Promise<void> {
     if (this.allDERss.length > 0) {
       return;
     }
-    const service = await ibiz.model.getModelService(context);
-    const { app } = service;
+    const { app } = this.modelService;
     const allPSAppEntities = app.getAllPSAppDataEntities() || [];
     this.allDERss = app.getAllPSAppDERSs() || [];
     allPSAppEntities.forEach(entity => {
@@ -105,30 +111,32 @@ export class ServicePathUtil {
    * @author chitanda
    * @date 2022-08-22 22:08:54
    * @param {IParams} context
-   * @param {string} deName
-   * @return {*}  {Promise<string[][]>} 返回顺序为 [祖父实体，爷爷实体，父实体，当前实体]
+   * @param {string} codeName
+   * @return {*}  {Promise<ServicePathItem[][]>} 返回顺序为 [祖父实体，爷爷实体，父实体，当前实体]
    */
-  static async calcPaths(
-    context: IParams,
-    deName: string,
-  ): Promise<ServicePathItem[][]> {
-    if (this.entityRsPathMap.has(deName)) {
-      return this.entityRsPathMap.get(deName)!;
+  calcPaths(codeName: string): ServicePathItem[][] {
+    if (this.entityRsPathMap.has(codeName)) {
+      return this.entityRsPathMap.get(codeName)!;
     }
-    await this.init(context);
-    const deRss = this.entityRsMap.get(deName);
+    const deRss = this.entityRsMap.get(codeName);
     if (deRss) {
       const arr = this.calcDeepPath(deRss);
-      this.deepFillPath(deName, [deName], arr);
-      const paths = this.entityRsPathMap.get(deName);
+      this.deepFillPath(codeName, [codeName], arr);
+      const paths = this.entityRsPathMap.get(codeName);
       if (paths) {
         const sortedPaths = this.sortPath(paths);
-        this.entityRsPathMap.set(deName, sortedPaths);
+        this.entityRsPathMap.set(codeName, sortedPaths);
         return sortedPaths;
       }
     }
     return [
-      [{ deName, name: deName.toLowerCase(), plural: pluralLower(deName) }],
+      [
+        {
+          deName: codeName,
+          name: codeName.toLowerCase(),
+          plural: pluralLower(codeName),
+        },
+      ],
     ];
   }
 
@@ -141,7 +149,7 @@ export class ServicePathUtil {
    * @param {IPSAppDERS[]} deRss
    * @return {*}  {ServicePathDeep[]}
    */
-  protected static calcDeepPath(
+  protected calcDeepPath(
     deRss: IPSAppDERS[],
     num: number = 0,
   ): ServicePathDeep[] {
@@ -167,7 +175,7 @@ export class ServicePathUtil {
    * @param {string[]} pathNames
    * @param {ServicePathDeep[]} items
    */
-  protected static deepFillPath(
+  protected deepFillPath(
     deName: string,
     pathNames: string[],
     items: ServicePathDeep[],
@@ -211,7 +219,7 @@ export class ServicePathUtil {
    * @param {ServicePathItem[][]} paths
    * @return {*}  {ServicePathItem[][]}
    */
-  protected static sortPath(paths: ServicePathItem[][]): ServicePathItem[][] {
+  protected sortPath(paths: ServicePathItem[][]): ServicePathItem[][] {
     return paths.sort((a, b) => {
       return b.length - a.length;
     });

package/src/service/vo/control.vo.ts

@@ -80,11 +80,13 @@ export class ControlVO {
 
     Object.defineProperty(this, '$origin', {
       enumerable: false,
+      configurable: true,
       value: $origin || {},
     });
 
     Object.defineProperty(this, '$dataUIMap', {
       enumerable: false,
+      configurable: true,
       value: $dataUIMap || new Map(),
     });
 
@@ -126,7 +128,10 @@ export class ControlVO {
     }
 
     // 后台数据存在$origin里，其他存在ControlVo上
-    if (isOriginField) {
+    if (
+      isOriginField ||
+      Object.prototype.hasOwnProperty.call(this.$origin, uiKey)
+    ) {
       Object.defineProperty(this, uiKey, {
         enumerable: true,
         configurable: true,

package/src/service/vo/index.ts

@@ -0,0 +1,2 @@
+export * from './control.vo';
+export * from './tree-node-data';

package/src/service/vo/tree-node-data/index.ts

@@ -0,0 +1,2 @@
+export { TreeDataSetNodeData } from './tree-data-set-node-data';
+export { TreeStaticNodeData } from './tree-static-node-data';

package/src/service/vo/tree-node-data/tree-data-set-node-data.ts

@@ -0,0 +1,44 @@
+import { TreeDataSetNodeModel, TreeNodeRSModel } from '@ibiz-template/model';
+import { ITreeNodeData } from '../../interface';
+import { TreeNodeData } from './tree-node-data';
+
+/**
+ * 实体数据集树节点数据
+ *
+ * @export
+ * @class TreeDataSetNodeData
+ * @extends {TreeNodeData}
+ * @implements {ITreeNodeData}
+ */
+export class TreeDataSetNodeData extends TreeNodeData implements ITreeNodeData {
+  text: string;
+
+  id: string;
+
+  value: string;
+
+  deData: IData;
+
+  constructor(
+    model: TreeDataSetNodeModel,
+    opts: { hasQuery: boolean; data: IData },
+    nodeRS?: TreeNodeRSModel,
+    parentNodeData?: ITreeNodeData,
+  ) {
+    super(model, opts, nodeRS, parentNodeData);
+    const { data } = opts;
+    this.deData = data;
+    this.text = data.srfmajortext;
+    this.value = data.srfkey;
+    this.id = parentNodeData
+      ? `${parentNodeData.id}:${data.srfkey}`
+      : data.srfkey;
+    // id小写
+    this.id = this.id.toLowerCase();
+
+    // 实体节点额外添加上自己的实体上下文
+    Object.assign(this.context, {
+      [model.appEntity.deName]: data.srfkey,
+    });
+  }
+}