@ibiz-template/runtime 0.7.41-alpha.125 → 0.7.41-alpha.126

package/src/de-logic/de-logic.ts

@@ -1,44 +1,29 @@
 /* eslint-disable no-await-in-loop */
-import { ModelError, RuntimeModelError } from '@ibiz-template/core';
-import { IAppDELogic } from '@ibiz/model-core';
+import { IBizContext, RuntimeModelError } from '@ibiz-template/core';
+import { clone } from 'ramda';
+import { IAppDELogic, IAppDataEntity } from '@ibiz/model-core';
 import { ScriptFactory, ScriptFunction } from '../utils';
 import { DELogicContext } from './de-logic-context';
-import {
-  AppendParamNode,
-  BindParamNode,
-  CopyParamNode,
-  DataSetNode,
-  DEActionNode,
-  DebugParamNode,
-  DELogicNode,
-  EndNode,
-  PrepareParamNode,
-  RenewParamNode,
-  ResetParamNode,
-  SortParamNode,
-  StartNode,
-} from './de-logic-node';
-import { ThrowExceptionNode } from './de-logic-node/throw-exception-node/throw-exception-node';
 import { DELogicParam } from './de-logic-param/de-logic-param';
+import { IDeLogic, IDeLogicNode, IDeLogicParams } from '../interface';
+import { getDELogicNodeProvider } from '../register';
 
 /**
- * 界面逻辑
- *
- * @author lxm
- * @date 2023-02-07 16:02:48
+ * @description 实体逻辑
  * @export
  * @class DELogic
+ * @implements {IDELogic}
  */
-export class DELogic {
+export class DELogic implements IDeLogic {
   /**
    * 所有节点实例
    *
    * @author lxm
    * @date 2023-02-08 21:02:38
    * @protected
-   * @type {Map<string, DELogicNode>}
+   * @type {Map<string, IDeLogicNode>}
    */
-  protected nodes: Map<string, DELogicNode> = new Map();
+  protected nodes: Map<string, IDeLogicNode> = new Map();
 
   /**
    * 所有参数实例
@@ -61,87 +46,48 @@ export class DELogic {
 
   /**
    * Creates an instance of DELogic.
-   * @author lxm
-   * @date 2023-02-08 17:02:26
    * @param {IAppDELogic} model
+   * @param {IAppDataEntity} entity
+   * @memberof DELogic
    */
-  constructor(protected model: IAppDELogic) {
-    // 脚本代码模式
-    if (model.customCode) {
-      if (!model.scriptCode) {
+  constructor(
+    public model: IAppDELogic,
+    public entity: IAppDataEntity,
+  ) {}
+
+  /**
+   * @description 初始化
+   * @returns {*}  {Promise<void>}
+   * @memberof DELogic
+   */
+  async init(): Promise<void> {
+    if (this.model.customCode) {
+      if (!this.model.scriptCode)
         throw new RuntimeModelError(
-          model,
+          this.model,
           ibiz.i18n.t('runtime.deLogic.deLogicNode.noScriptCode'),
         );
-      }
-      this.scriptFn = ScriptFactory.createScriptFn([], model.scriptCode, {
+      this.scriptFn = ScriptFactory.createScriptFn([], this.model.scriptCode, {
         isAsync: true,
       });
       return;
     }
-
-    if (!model.delogicNodes?.length) {
+    if (!this.model.delogicNodes?.length) {
       throw new RuntimeModelError(
-        model,
+        this.model,
         ibiz.i18n.t('runtime.deLogic.deLogicNode.noConfigurationLogicNode'),
       );
     }
-    model.delogicNodes.forEach(node => {
-      const { logicNodeType } = node;
-      let logicNode;
-      switch (logicNodeType) {
-        case 'BEGIN': // 开始
-          logicNode = new StartNode(node);
-          break;
-        case 'END': // 结束
-          logicNode = new EndNode(node);
-          break;
-        case 'DEACTION': // 实体行为
-          logicNode = new DEActionNode(node);
-          break;
-        case 'PREPAREPARAM': // 准备参数
-          logicNode = new PrepareParamNode(node);
-          break;
-        case 'DEDATASET': // 实体数据集
-          logicNode = new DataSetNode(node);
-          break;
-        case 'THROWEXCEPTION': // 抛出异常
-          logicNode = new ThrowExceptionNode(node);
-          break;
-        case 'BINDPARAM': // 绑定参数
-          logicNode = new BindParamNode(node);
-          break;
-        case 'RESETPARAM': // 重置参数
-          logicNode = new ResetParamNode(node);
-          break;
-        case 'COPYPARAM': // 拷贝参数
-          logicNode = new CopyParamNode(node);
-          break;
-        case 'RENEWPARAM': // 重新建立参数
-          logicNode = new RenewParamNode(node);
-          break;
-        case 'APPENDPARAM': // 附加到数组参数
-          logicNode = new AppendParamNode(node);
-          break;
-        case 'SORTPARAM': // 排序数组参数
-          logicNode = new SortParamNode(node);
-          break;
-        case 'DEBUGPARAM': // 调试逻辑参数
-          logicNode = new DebugParamNode(node);
-          break;
-        default:
-          throw new ModelError(
-            node,
-            ibiz.i18n.t('runtime.deLogic.deLogicNode.unsupportedLogical', {
-              logicNodeType,
-            }),
-          );
-      }
-      this.nodes.set(node.id!, logicNode);
-    });
-    model.delogicParams?.forEach(param => {
-      this.params.set(param.id!, new DELogicParam(param));
-    });
+    await Promise.all(
+      this.model.delogicNodes.map(async node => {
+        const provider = await getDELogicNodeProvider(
+          node,
+          this.model,
+          this.entity,
+        );
+        if (provider) this.nodes.set(node.id!, provider);
+      }),
+    );
     // 将已经实例化的逻辑节点挂载到逻辑连接上
     this.nodes.forEach(node => {
       node.links.forEach(link => {
@@ -151,18 +97,16 @@ export class DELogic {
         }
       });
     });
+    this.model.delogicParams?.forEach(param => {
+      this.params.set(param.id!, new DELogicParam(param));
+    });
   }
 
   /**
-   * 初始化当前环境的逻辑参数的实例
-   *
-   * @author lxm
-   * @date 2023-02-08 21:02:58
+   * @description 初始化当前环境的逻辑参数的实例
    * @protected
    * @param {DELogicContext} ctx
-   * @param {IContext} context
-   * @param {IData} data
-   * @param {IParams} [opt]
+   * @memberof DELogic
    */
   protected initLogicParams(ctx: DELogicContext): void {
     this.params.forEach(param => {
@@ -174,24 +118,19 @@ export class DELogic {
   }
 
   /**
-   * 执行逻辑
-   *
-   * @author lxm
-   * @date 2023-02-08 21:02:09
-   * @param {IContext} context
-   * @param {IData} data
-   * @param {IParams} [opt]
-   * @return {*}  {Promise<IData>}
+   * @description 执行逻辑
+   * @param {IDeLogicParams} parameters 逻辑参数
+   * @returns {*}  {Promise<unknown>}
+   * @memberof DELogic
    */
-  async exec(
-    context: IContext,
-    data: IData | IData[],
-    params: IParams,
-  ): Promise<unknown> {
+  async exec(parameters: IDeLogicParams): Promise<unknown> {
+    // 克隆传入应用上下文参数和视图参数
+    parameters.context = IBizContext.create(parameters.context);
+    parameters.params = clone(parameters.params || {});
     if (this.scriptFn) {
-      return this.scriptFn.exec({ context, data, params });
+      return this.scriptFn.exec({ ...parameters });
     }
-    const ctx = new DELogicContext(this.params, context, data, params);
+    const ctx = new DELogicContext(this.params, parameters);
     this.initLogicParams(ctx);
     const { startDELogicNodeId } = this.model;
     if (startDELogicNodeId && this.nodes.has(startDELogicNodeId)) {
@@ -213,17 +152,15 @@ export class DELogic {
   }
 
   /**
-   * 开始根据连线递归执行逻辑
-   *
-   * @author lxm
-   * @date 2023-06-13 08:29:36
+   * @description 开始根据连线递归执行逻辑
    * @protected
-   * @param {DELogicNode} node 逻辑节点
-   * @param {DELogicContext} ctx 逻辑上下文
-   * @return {*}  {Promise<void>}
+   * @param {IDeLogicNode} node
+   * @param {DELogicContext} ctx
+   * @returns {*}  {Promise<void>}
+   * @memberof DELogic
    */
   protected async deepExec(
-    node: DELogicNode,
+    node: IDeLogicNode,
     ctx: DELogicContext,
   ): Promise<void> {
     // 执行逻辑节点

package/src/de-logic/index.ts

@@ -1,54 +1,37 @@
-import { HttpError, HttpResponse, RuntimeError } from '@ibiz-template/core';
-import { IAppDataEntity, IAppDELogic } from '@ibiz/model-core';
-import { isArray } from 'lodash-es';
 import { clone } from 'ramda';
+import { isArray } from 'lodash-es';
+import { IAppDataEntity, IAppDELogic } from '@ibiz/model-core';
+import { HttpError, HttpResponse, RuntimeError } from '@ibiz-template/core';
+import { IDELogicProvider } from '../interface';
+import { getDELogicProvider } from '../register';
 import { filterFieldLogics, findDELogic } from '../model';
-import { DELogic } from './de-logic';
 
 /**
  * 实体处理逻辑实例缓存
  */
-const deLogicMap: WeakMap<IAppDELogic, DELogic> = new Map();
-
-/**
- * 找到实体逻辑模型
- * @author lxm
- * @date 2023-08-04 02:47:16
- * @param {string} deDELogicId
- * @param {string} dataEntityId
- * @param {string} [appId]
- * @return {*}  {(Promise<IAppDELogic | undefined>)}
- */
-async function findDeLogic(
-  deDELogicId: string,
-  dataEntityId: string,
-  appId: string,
-): Promise<IAppDELogic | undefined> {
-  const appDataEntity = await ibiz.hub.getAppDataEntity(dataEntityId, appId);
-  return findDELogic(deDELogicId, appDataEntity);
-}
+const deLogicMap: WeakMap<IAppDELogic, IDELogicProvider> = new Map();
 
 /**
- * 执行实体处理逻辑
- *
- * @author lxm
- * @date 2023-02-09 11:02:23
+ * @description 执行实体逻辑
  * @export
- * @param {IAppDELogic} deDELogic
- * @param {IContext} context
- * @param {(IData)} data
- * @param {IParams} params
- * @param {IParams} [opt]
- * @return {*}  {Promise<HttpResponse<IData>>}
+ * @param {IAppDELogic} deDELogic 实体逻辑
+ * @param {IAppDataEntity} appDataEntity 应用实体
+ * @param {IContext} context 上下文
+ * @param {(IData | IData[])} [data={}] 数据
+ * @param {IParams} [params={}] 视图参数
+ * @returns {*}  {Promise<unknown>}
  */
 export async function execDELogic(
   deDELogic: IAppDELogic,
+  appDataEntity: IAppDataEntity,
   context: IContext,
   data: IData | IData[] = {},
   params: IParams = {},
 ): Promise<unknown> {
   if (!deLogicMap.has(deDELogic)) {
-    deLogicMap.set(deDELogic, new DELogic(deDELogic));
+    const provider = getDELogicProvider(deDELogic, appDataEntity);
+    await provider.init();
+    deLogicMap.set(deDELogic, provider);
   }
   ibiz.log.debug(
     ibiz.i18n.t('runtime.deLogic.deLogicNode.startExecuting', {
@@ -57,7 +40,11 @@ export async function execDELogic(
     }),
   );
   const deLogic = deLogicMap.get(deDELogic)!;
-  const result = await deLogic.exec(context, data, params);
+  const result = await deLogic.exec({
+    context,
+    data: Array.isArray(data) ? data : [data],
+    params,
+  });
   ibiz.log.debug(
     ibiz.i18n.t('runtime.deLogic.deLogicNode.endExecution', {
       id: deDELogic.id,
@@ -68,16 +55,14 @@ export async function execDELogic(
 }
 
 /**
- * 通过id执行实体逻辑
- * @author lxm
- * @date 2023-08-04 02:49:44
+ * @description 通过ID执行实体逻辑
  * @export
- * @param {string} deDELogicId
- * @param {string} dataEntityId
- * @param {IContext} context
- * @param {IData} data
- * @param {IParams} params
- * @return {*}  {Promise<unknown>}
+ * @param {string} deDELogicId 实体逻辑标识
+ * @param {string} dataEntityId 应用实体标识
+ * @param {IContext} context 上下文
+ * @param {IData} data 数据
+ * @param {IParams} params 视图参数
+ * @returns {*}  {Promise<unknown>}
  */
 export async function execDELogicById(
   deDELogicId: string,
@@ -86,11 +71,11 @@ export async function execDELogicById(
   data: IData,
   params: IParams,
 ): Promise<unknown> {
-  const deLogic = await findDeLogic(
-    deDELogicId,
+  const appDataEntity = await ibiz.hub.getAppDataEntity(
     dataEntityId,
     context.srfappid,
   );
+  const deLogic = findDELogic(deDELogicId, appDataEntity);
   if (!deLogic) {
     throw new RuntimeError(
       ibiz.i18n.t('runtime.deLogic.deLogicNode.noFoundEntityLogic', {
@@ -99,33 +84,37 @@ export async function execDELogicById(
       }),
     );
   }
-  return execDELogic(deLogic, context, data, params);
+  return execDELogic(deLogic, appDataEntity, context, data, params);
 }
 
 /**
- * 执行实体方法的实体逻辑并返回对应的response
- * @author lxm
- * @date 2023-03-16 12:44:43
+ * @description 执行实体逻辑行为并返回响应
  * @export
- * @param {IAppDELogic} deDELogic
- * @param {IContext} context
- * @param {(IData)} data
- * @param {IParams} params
- * @param {IParams} [opt]
- * @return {*}  {Promise<HttpResponse<IData>>}
+ * @param {IAppDELogic} deDELogic 实体逻辑
+ * @param {IAppDataEntity} appDataEntity 应用实体
+ * @param {IContext} context 上下文
+ * @param {(IData | IData[])} [data] 数据
+ * @param {IParams} [params] 视图参数
+ * @returns {*}  {Promise<HttpResponse<IData>>}
  */
 export async function execDELogicAction(
   deDELogic: IAppDELogic,
+  appDataEntity: IAppDataEntity,
   context: IContext,
   data?: IData | IData[],
   params?: IParams,
 ): Promise<HttpResponse<IData>> {
-  const _context = clone(context);
-  const _data = data ? clone(data) : data;
-  const _params = params ? clone(params) : params;
-
   try {
-    const result = await execDELogic(deDELogic, _context, _data, _params);
+    const _context = clone(context);
+    const _data = data ? clone(data) : data;
+    const _params = params ? clone(params) : params;
+    const result = await execDELogic(
+      deDELogic,
+      appDataEntity,
+      _context,
+      _data,
+      _params,
+    );
     return new HttpResponse(result);
   } catch (err) {
     if (err instanceof HttpError) {
@@ -136,16 +125,13 @@ export async function execDELogicAction(
 }
 
 /**
- * 执行属性实体逻辑（单条数据）
- * @author lxm
- * @date 2023-10-19 04:00:15
- * @export
- * @param {IAppDataEntity} entity
- * @param {('compute' | 'change' | 'default')} type
- * @param {IContext} context
- * @param {IData} data
- * @param {IParams} params
- * @return {*}  {Promise<void>}
+ * @description 执行属性实体逻辑（单条数据）
+ * @param {IAppDataEntity} entity 实体
+ * @param {('compute' | 'change' | 'default')} type 逻辑类型
+ * @param {IContext} context 上下文
+ * @param {IData} data 实体数据
+ * @param {IParams} params 视图参数
+ * @returns {*}  {Promise<void>}
  */
 async function execSingleFieldLogics(
   entity: IAppDataEntity,
@@ -158,7 +144,7 @@ async function execSingleFieldLogics(
   if (fieldLogics.length) {
     const promiseResult = await Promise.all(
       fieldLogics.map(logic => {
-        return execDELogic(logic, context, data, params);
+        return execDELogic(logic, entity, context, data, params);
       }),
     );
     promiseResult.forEach(value => {
@@ -168,16 +154,14 @@ async function execSingleFieldLogics(
 }
 
 /**
- * 执行属性实体逻辑(单条或者多条)
- * @author lxm
- * @date 2023-06-14 12:29:56
+ * @description 执行属性实体逻辑(单条或者多条)
  * @export
- * @param {IAppDataEntity} entity
- * @param {('compute' | 'change' | 'default')} type
- * @param {IContext} context
- * @param {IData | IData[]} data 单条或多条数据
- * @param {IParams} params
- * @return {*}  {Promise<void>}
+ * @param {IAppDataEntity} entity 实体
+ * @param {('compute' | 'change' | 'default')} type 逻辑类型
+ * @param {IContext} context 上下文
+ * @param {(IData | IData[])} data 实体数据
+ * @param {IParams} [params={}] 视图参数
+ * @returns {*}  {Promise<void>}
  */
 export async function execFieldLogics(
   entity: IAppDataEntity,
@@ -186,10 +170,7 @@ export async function execFieldLogics(
   data: IData | IData[],
   params: IParams = {},
 ): Promise<void> {
-  if (!data) {
-    return;
-  }
-
+  if (!data) return;
   if (isArray(data)) {
     await Promise.all(
       data.map(item =>

package/src/de-logic/provider.ts

@@ -0,0 +1,83 @@
+import { IAppDELogic, IDELogicNode, IAppDataEntity } from '@ibiz/model-core';
+import {
+  registerDELogicProvider,
+  registerDELogicNodeProvider,
+} from '../register';
+import { DELogic } from './de-logic';
+import {
+  EndNode,
+  StartNode,
+  DataSetNode,
+  DEActionNode,
+  SortParamNode,
+  BindParamNode,
+  CopyParamNode,
+  RenewParamNode,
+  ResetParamNode,
+  DebugParamNode,
+  AppendParamNode,
+  PrepareParamNode,
+  ThrowExceptionNode,
+} from './de-logic-node';
+
+/**
+ * @description 注册实体逻辑适配器
+ * @export
+ */
+export function presetDELogicProvider(): void {
+  // 注册默认界面逻辑
+  registerDELogicProvider(
+    'DEFAULT',
+    (logic: IAppDELogic, entity: IAppDataEntity) => new DELogic(logic, entity),
+  );
+  // 注册界面逻辑节点
+  registerDELogicNodeProvider(
+    'BEGIN',
+    (node: IDELogicNode) => new StartNode(node),
+  );
+  registerDELogicNodeProvider('END', (node: IDELogicNode) => new EndNode(node));
+  registerDELogicNodeProvider(
+    'DEACTION',
+    (node: IDELogicNode) => new DEActionNode(node),
+  );
+  registerDELogicNodeProvider(
+    'PREPAREPARAM',
+    (node: IDELogicNode) => new PrepareParamNode(node),
+  );
+  registerDELogicNodeProvider(
+    'RESETPARAM',
+    (node: IDELogicNode) => new ResetParamNode(node),
+  );
+  registerDELogicNodeProvider(
+    'COPYPARAM',
+    (node: IDELogicNode) => new CopyParamNode(node),
+  );
+  registerDELogicNodeProvider(
+    'BINDPARAM',
+    (node: IDELogicNode) => new BindParamNode(node),
+  );
+  registerDELogicNodeProvider(
+    'DEBUGPARAM',
+    (node: IDELogicNode) => new DebugParamNode(node),
+  );
+  registerDELogicNodeProvider(
+    'APPENDPARAM',
+    (node: IDELogicNode) => new AppendParamNode(node),
+  );
+  registerDELogicNodeProvider(
+    'SORTPARAM',
+    (node: IDELogicNode) => new SortParamNode(node),
+  );
+  registerDELogicNodeProvider(
+    'RENEWPARAM',
+    (node: IDELogicNode) => new RenewParamNode(node),
+  );
+  registerDELogicNodeProvider(
+    'DEDATASET',
+    (node: IDELogicNode) => new DataSetNode(node),
+  );
+  registerDELogicNodeProvider(
+    'THROWEXCEPTION',
+    (node: IDELogicNode) => new ThrowExceptionNode(node),
+  );
+}

package/src/install.ts

@@ -13,9 +13,11 @@ import { EngineFactory, installCtrlEngine } from './engine';
 import { GlobalUtil } from './global';
 import { presetUIActionProvider } from './ui-action';
 import { installLogicSchedule } from './logic-scheduler';
+import { presetUILogicProvider } from './ui-logic/provider';
 import { install as installPlatformProvider } from './platform/provider';
 import { getPlatformProvider } from './register';
 import { CollaborateManager, UIDomainManager } from './utils';
+import { presetDELogicProvider } from './de-logic/provider';
 
 /**
  * 安装运行时
@@ -50,6 +52,10 @@ export function install(): void {
   presetUIActionProvider();
   // 注册界面行为适配器
   presetDEMethodProvider();
+  // 注册界面逻辑适配器
+  presetUILogicProvider();
+  // 注册实体逻辑适配器
+  presetDELogicProvider();
   // 注册应用计数器适配器
   presetAppCounterProvider();
   // 安装逻辑调度器

package/src/interface/api/common/i-api-de-logic-params.ts

@@ -0,0 +1,8 @@
+import { IApiLogicParams } from './i-api-logic-params';
+
+/**
+ * @description 实体逻辑通用参数接口
+ * @export
+ * @interface IApiDELogicParams
+ */
+export interface IApiDeLogicParams extends IApiLogicParams {}

package/src/interface/api/common/i-api-logic-context.ts

@@ -0,0 +1,83 @@
+import { IApiContext, IApiData, IApiParams } from '@ibiz-template/core';
+
+/**
+ * @description 逻辑执行上下文接口
+ * @export
+ * @interface IApiLogicContext
+ */
+export interface IApiLogicContext {
+  /**
+   * @description 上下文
+   * @type {IApiContext}
+   * @memberof IApiLogicContext
+   */
+  readonly context: IApiContext;
+  /**
+   * @description 数据
+   * @type {IApiData[]}
+   * @memberof IApiLogicContext
+   */
+  readonly data: IApiData[];
+  /**
+   * @description 视图参数
+   * @type {IApiParams}
+   * @memberof IApiLogicContext
+   */
+  readonly viewParam: IApiParams;
+  /**
+   * @description 界面逻辑参数
+   * @type {Record<string, unknown>}
+   * @memberof IApiLogicContext
+   */
+  readonly params: Record<string, unknown>;
+  /**
+   * @description 上一次返回值
+   * @type {unknown}
+   * @memberof IApiLogicContext
+   */
+  lastReturn: unknown;
+  /**
+   * @description 逻辑执行返回值
+   * @type {unknown}
+   * @memberof IApiLogicContext
+   */
+  result: unknown;
+  /**
+   * @description 是否存在结束节点
+   * @type {boolean}
+   * @memberof IApiLogicContext
+   */
+  isEndNode: boolean;
+  /**
+   * @description 默认参数节点名称
+   * @default 'Default'
+   * @type {string}
+   * @memberof IApiLogicContext
+   */
+  defaultParamName: string;
+  /**
+   * @description 重置实体逻辑参数
+   * @param {string} name
+   * @memberof IApiLogicContext
+   */
+  resetParam(name: string): void;
+  /**
+   * @description 重新建立变量
+   * @param {string} name
+   * @memberof IApiLogicContext
+   */
+  renewParam(name: string): void;
+  /**
+   * @description 设置上一次返回值
+   * @param {unknown} value
+   * @memberof IApiLogicContext
+   */
+  setLastReturn(value: unknown): void;
+  /**
+   * @description 是否是实体参数变量（即后台数据对象）
+   * @param {string} paramId
+   * @returns {*}  {boolean}
+   * @memberof IApiLogicContext
+   */
+  isEntityParam(paramId: string): boolean;
+}