@ibiz-template/runtime 0.1.21 → 0.1.22

package/src/ui-logic/ui-logic-node/execute-de-logic-node/execute-de-logic-node.ts

@@ -0,0 +1,57 @@
+import { RuntimeError, RuntimeModelError } from '@ibiz-template/core';
+import { IDEUIDELogicLogic } from '@ibiz/model-core';
+import { execDELogicById } from '../../../de-logic';
+import { UILogicContext } from '../../ui-logic-context';
+import { UILogicNode } from '../ui-logic-node';
+
+/**
+ * 执行实体逻辑节点
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:00
+ * @export
+ * @class ThrowExceptionNode
+ * @extends {UILogicNode}
+ */
+export class ExecuteDELogicNode extends UILogicNode {
+  declare model: IDEUIDELogicLogic;
+
+  async exec(ctx: UILogicContext): Promise<void> {
+    const {
+      dstAppDELogicId,
+      dstAppDataEntityId,
+      dstDEUILogicParamId,
+      retDEUILogicParamId,
+    } = this.model;
+
+    // 配置报错
+    if (!dstAppDataEntityId) {
+      throw new RuntimeModelError(this.model, '没有配置实体');
+    }
+    if (!dstAppDELogicId) {
+      throw new RuntimeModelError(this.model, '没有配置实体逻辑');
+    }
+    if (!dstDEUILogicParamId) {
+      throw new RuntimeModelError(this.model, '没有配置传入逻辑参数');
+    }
+
+    const dstParam = ctx.params[dstDEUILogicParamId];
+    if (!dstParam) {
+      throw new RuntimeError(`没有找到传入参数${dstDEUILogicParamId}`);
+    }
+
+    // todo 需要传入参数格式约束
+    const result = await execDELogicById(
+      dstAppDELogicId,
+      dstAppDataEntityId,
+      dstParam.context,
+      dstParam.data,
+      dstParam.params,
+    );
+
+    // 如果有返回值参数返回值填入。
+    if (retDEUILogicParamId) {
+      ctx.params[retDEUILogicParamId] = result;
+    }
+  }
+}

package/src/ui-logic/ui-logic-node/index.ts

@@ -8,3 +8,12 @@ export { ViewCtrlInvokeNode } from './view-ctrl-invoke-node/view-ctrl-invoke-nod
 export { BindParamNode } from './bind-param-node/bind-param-node';
 export { MsgBoxNode } from './msg-box-node/msg-box-node';
 export { DebugParamNode } from './debug-param-node/debug-param-node';
+export { ResetParamNode } from './reset-param-node/reset-param-node';
+export { CopyParamNode } from './copy-param-node/copy-param-node';
+export { AppendParamNode } from './append-param-node/append-param-node';
+export { SortParamNode } from './sort-param-node/sort-param-node';
+export { RenewParamNode } from './renew-param-node/renew-param-node';
+export { DataSetNode } from './data-set-node/data-set-node';
+export { ThrowExceptionNode } from './throw-exception-node/throw-exception-node';
+export { ViewCtrlFireEventNode } from './view-ctrl-fire-event-node/view-ctrl-fire-event-node';
+export { ExecuteDELogicNode } from './execute-de-logic-node/execute-de-logic-node';

package/src/ui-logic/ui-logic-node/prepare-js-param-node/prepare-js-param-node.ts

@@ -1,5 +1,7 @@
+/* eslint-disable no-await-in-loop */
 import { ModelError } from '@ibiz-template/core';
 import { IDEUILogicNodeParam } from '@ibiz/model-core';
+import { clone } from 'ramda';
 import { UILogicContext } from '../../ui-logic-context';
 import { handleSrcVal } from '../../utils';
 import { UILogicNode } from '../ui-logic-node';
@@ -16,21 +18,45 @@ import { UILogicNode } from '../ui-logic-node';
 export class PrepareJSParamNode extends UILogicNode {
   async exec(ctx: UILogicContext): Promise<void> {
     const nodeParams = this.model.deuilogicNodeParams;
-    if (nodeParams?.length) {
-      await Promise.all(
-        nodeParams.map(nodeParam => {
-          switch (nodeParam.paramAction) {
-            // 设置变量
-            case 'SETPARAMVALUE':
-              return this.setParamValue(nodeParam, ctx);
-            default:
-              throw new ModelError(
-                nodeParam,
-                `暂未支持逻辑处理参数操作${nodeParam.paramAction}`,
-              );
-          }
-        }),
-      );
+    if (!nodeParams?.length) {
+      return;
+    }
+    for (const nodeParam of nodeParams) {
+      switch (nodeParam.paramAction) {
+        // 设置变量
+        case 'SETPARAMVALUE':
+          await this.setParamValue(nodeParam, ctx);
+          break;
+        // 重置变量
+        case 'RESETPARAM':
+          await this.resetParam(nodeParam, ctx);
+          break;
+        // 拷贝变量
+        case 'COPYPARAM':
+          await this.copyParam(nodeParam, ctx);
+          break;
+        // 绑定参数
+        case 'BINDPARAM':
+          await this.bindParam(nodeParam, ctx);
+          break;
+        // 重新建立变量
+        case 'RENEWPARAM':
+          await this.renewParam(nodeParam, ctx);
+          break;
+        // 附加到数组变量
+        case 'APPENDPARAM':
+          await this.appendParam(nodeParam, ctx);
+          break;
+        // 排序数组变量
+        case 'SORTPARAM':
+          await this.sortParam(nodeParam, ctx);
+          break;
+        default:
+          throw new ModelError(
+            nodeParam,
+            `暂未支持逻辑处理参数操作${nodeParam.paramAction}`,
+          );
+      }
     }
   }
 
@@ -40,7 +66,7 @@ export class PrepareJSParamNode extends UILogicNode {
    * @date 2023-03-17 03:34:02
    * @protected
    * @param {IPSDELogicNodeParam} nodeParam
-   * @param {DELogicContext} ctx
+   * @param {UILogicContext} ctx
    */
   protected setParamValue(
     nodeParam: IDEUILogicNodeParam,
@@ -48,7 +74,7 @@ export class PrepareJSParamNode extends UILogicNode {
   ): void {
     const { dstFieldName, dstDEUILogicParamId } = nodeParam;
     // 目标参数
-    const dstField = dstFieldName?.toLowerCase();
+    const dstField = dstFieldName;
     // 源参数
     const srcVal = handleSrcVal(ctx, nodeParam);
     if (dstField) {
@@ -57,4 +83,114 @@ export class PrepareJSParamNode extends UILogicNode {
       ctx.params[dstDEUILogicParamId!] = srcVal;
     }
   }
+
+  /**
+   * 拷贝变量
+   * @author lxm
+   * @date 2023-03-24 09:50:02
+   * @protected
+   * @param {IDEUILogicNodeParam} nodeParam
+   * @param {UILogicContext} ctx
+   * @return {*}  {*}
+   */
+  protected copyParam(
+    nodeParam: IDEUILogicNodeParam,
+    ctx: UILogicContext,
+  ): void {
+    const { dstDEUILogicParamId } = nodeParam;
+    const srcVal = handleSrcVal(ctx, nodeParam);
+    ctx.params[dstDEUILogicParamId!] = clone(srcVal);
+  }
+
+  /**
+   * 绑定参数
+   * @author lxm
+   * @date 2023-06-13 05:43:43
+   * @protected
+   * @param {IDEUILogicNodeParam} nodeParam
+   * @param {UILogicContext} ctx
+   */
+  protected bindParam(
+    nodeParam: IDEUILogicNodeParam,
+    ctx: UILogicContext,
+  ): void {
+    const srcVal = handleSrcVal(ctx, nodeParam);
+    ctx.params[nodeParam.dstDEUILogicParamId!] = srcVal;
+  }
+
+  /**
+   * 重置变量
+   * @author lxm
+   * @date 2023-03-24 09:46:57
+   * @protected
+   * @param {IDEUILogicNodeParam} nodeParam
+   * @param {UILogicContext} ctx
+   */
+  protected resetParam(
+    nodeParam: IDEUILogicNodeParam,
+    ctx: UILogicContext,
+  ): void {
+    const { dstDEUILogicParamId } = nodeParam;
+    ctx.resetParam(dstDEUILogicParamId!);
+  }
+
+  /**
+   * 重新建立变量
+   * @author lxm
+   * @date 2023-03-24 09:46:47
+   * @protected
+   * @param {IDEUILogicNodeParam} nodeParam
+   * @param {UILogicContext} ctx
+   */
+  protected renewParam(
+    nodeParam: IDEUILogicNodeParam,
+    ctx: UILogicContext,
+  ): void {
+    const { dstDEUILogicParamId } = nodeParam;
+    ctx.renewParam(dstDEUILogicParamId!);
+  }
+
+  /**
+   * 附加到数组变量
+   * @author lxm
+   * @date 2023-03-24 09:46:47
+   * @protected
+   * @param {IDEUILogicNodeParam} nodeParam
+   * @param {UILogicContext} ctx
+   */
+  protected appendParam(
+    nodeParam: IDEUILogicNodeParam,
+    ctx: UILogicContext,
+  ): void {
+    const { dstDEUILogicParamId, dstIndex, srcIndex, srcSize } = nodeParam;
+    const srcVal = handleSrcVal(ctx, nodeParam) as IData[];
+    const insertIndex = dstIndex || 0;
+    const _srcIndex = srcIndex || 0;
+    const _srcSize = srcSize || srcVal.length;
+    ctx.params[dstDEUILogicParamId!].splice(
+      insertIndex,
+      0,
+      ...srcVal.slice(_srcIndex, _srcSize),
+    );
+  }
+
+  /**
+   * 排序数组变量
+   * @author lxm
+   * @date 2023-03-24 10:23:01
+   * @protected
+   * @param {IDEUILogicNodeParam} nodeParam
+   * @param {UILogicContext} ctx
+   */
+  protected sortParam(
+    nodeParam: IDEUILogicNodeParam,
+    ctx: UILogicContext,
+  ): void {
+    const { dstDEUILogicParamId, dstFieldName, dstSortDir } = nodeParam;
+    const key = dstFieldName!;
+    const arr = ctx.params[dstDEUILogicParamId!] as IData[];
+    arr.sort((a, b) => {
+      return dstSortDir === 'ASC' ? a[key] - b[key] : b[key] - a[key];
+    });
+  }
 }

package/src/ui-logic/ui-logic-node/renew-param-node/renew-param-node.ts

@@ -0,0 +1,25 @@
+import { RuntimeModelError } from '@ibiz-template/core';
+import { IDEUIRenewParamLogic } from '@ibiz/model-core';
+import { UILogicContext } from '../../ui-logic-context';
+import { UILogicNode } from '../ui-logic-node';
+
+/**
+ * 重新建立参数
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:20
+ * @export
+ * @class RenewParamNode
+ * @extends {UILogicNode}
+ */
+export class RenewParamNode extends UILogicNode {
+  declare model: IDEUIRenewParamLogic;
+
+  async exec(ctx: UILogicContext): Promise<void> {
+    const { dstDEUILogicParamId } = this.model;
+    if (!dstDEUILogicParamId) {
+      throw new RuntimeModelError(this.model, '缺少目标参数对象配置');
+    }
+    ctx.renewParam(dstDEUILogicParamId);
+  }
+}

package/src/ui-logic/ui-logic-node/reset-param-node/reset-param-node.ts

@@ -0,0 +1,25 @@
+import { RuntimeModelError } from '@ibiz-template/core';
+import { IDEUIResetParamLogic } from '@ibiz/model-core';
+import { UILogicContext } from '../../ui-logic-context';
+import { UILogicNode } from '../ui-logic-node';
+
+/**
+ * 重置参数
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:20
+ * @export
+ * @class ResetParamNode
+ * @extends {UILogicNode}
+ */
+export class ResetParamNode extends UILogicNode {
+  declare model: IDEUIResetParamLogic;
+
+  async exec(ctx: UILogicContext): Promise<void> {
+    const { dstDEUILogicParamId } = this.model;
+    if (!dstDEUILogicParamId) {
+      throw new RuntimeModelError(this.model, '缺少目标参数对象配置');
+    }
+    ctx.resetParam(dstDEUILogicParamId);
+  }
+}

package/src/ui-logic/ui-logic-node/sort-param-node/sort-param-node.ts

@@ -0,0 +1,29 @@
+import { RuntimeModelError } from '@ibiz-template/core';
+import { IDEUISortParamLogic } from '@ibiz/model-core';
+import { UILogicContext } from '../../ui-logic-context';
+import { UILogicNode } from '../ui-logic-node';
+
+/**
+ * 排序数组参数
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:20
+ * @export
+ * @class SortParamNode
+ * @extends {UILogicNode}
+ */
+export class SortParamNode extends UILogicNode {
+  declare model: IDEUISortParamLogic;
+
+  async exec(ctx: UILogicContext): Promise<void> {
+    const { dstDEUILogicParamId, dstSortDir, dstFieldName } = this.model;
+    if (!dstDEUILogicParamId || !dstFieldName) {
+      throw new RuntimeModelError(this.model, '缺少目标参数对象或目标属性配置');
+    }
+    const key = dstFieldName;
+    const arr = ctx.params[dstDEUILogicParamId!] as IData[];
+    arr.sort((a, b) => {
+      return dstSortDir === 'ASC' ? a[key] - b[key] : b[key] - a[key];
+    });
+  }
+}

package/src/ui-logic/ui-logic-node/throw-exception-node/throw-exception-node.ts

@@ -0,0 +1,23 @@
+import { RuntimeError } from '@ibiz-template/core';
+import { IDEUIThrowExceptionLogic } from '@ibiz/model-core';
+import { UILogicContext } from '../../ui-logic-context';
+import { UILogicNode } from '../ui-logic-node';
+
+/**
+ * 抛出异常节点
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:00
+ * @export
+ * @class ThrowExceptionNode
+ * @extends {UILogicNode}
+ */
+export class ThrowExceptionNode extends UILogicNode {
+  declare model: IDEUIThrowExceptionLogic;
+
+  async exec(_ctx: UILogicContext): Promise<void> {
+    const { errorInfo } = this.model;
+
+    throw new RuntimeError(errorInfo!);
+  }
+}

package/src/ui-logic/ui-logic-node/view-ctrl-fire-event-node/view-ctrl-fire-event-node.ts

@@ -0,0 +1,47 @@
+import { RuntimeError, RuntimeModelError } from '@ibiz-template/core';
+import { IDEUICtrlFireEventLogic } from '@ibiz/model-core';
+import { IControlController } from '../../../interface';
+import { UILogicContext } from '../../ui-logic-context';
+import { UILogicNode } from '../ui-logic-node';
+
+/**
+ * 视图部件事件触发逻辑节点
+ * @author lxm
+ * @date 2023-03-28 01:45:08
+ * @export
+ * @class ViewCtrlInvokeNode
+ * @extends {UILogicNode}
+ */
+export class ViewCtrlFireEventNode extends UILogicNode {
+  declare model: IDEUICtrlFireEventLogic;
+
+  async exec(ctx: UILogicContext): Promise<void> {
+    ctx.isEndNode = true;
+    const { eventName, eventParamId, fireCtrlId } = this.model;
+
+    // 配置报错
+    if (!fireCtrlId) {
+      throw new RuntimeModelError(this.model, '没有配置触发对象');
+    }
+    if (!eventName) {
+      throw new RuntimeModelError(this.model, '没有配置事件名称参数');
+    }
+    if (!eventParamId) {
+      throw new RuntimeModelError(this.model, '没有配置事件参数');
+    }
+
+    const invokeCtrl = ctx.params[fireCtrlId] as IControlController;
+    if (!invokeCtrl) {
+      throw new RuntimeError(`没有找到触发对象${fireCtrlId}`);
+    }
+
+    const eventParam = ctx.params[eventParamId];
+    if (!eventParam) {
+      throw new RuntimeError(`没有找到事件参数对象${eventParamId}`);
+    }
+
+    // 触发部件事件
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    await invokeCtrl.evt.emit(eventName as any, eventParam);
+  }
+}

package/src/ui-logic/ui-logic-param/ui-logic-param.ts

@@ -1,4 +1,4 @@
-import { ModelError, RuntimeModelError } from '@ibiz-template/core';
+import { ModelError } from '@ibiz-template/core';
 import { IDEUILogicParam } from '@ibiz/model-core';
 import { UILogicContext } from '../ui-logic-context';
 
@@ -46,10 +46,7 @@ export class UILogicParam {
       if (control) {
         ctx.params[tag] = control;
       } else {
-        throw new RuntimeModelError(
-          this.model,
-          `视图逻辑初始化参数，未找到${m.codeName!}指定部件对象`,
-        );
+        ibiz.log.error(`视图逻辑初始化参数，未找到${m.codeName!}指定部件对象`);
       }
     } else if (m.activeViewParam) {
       // 当前视图

package/src/ui-logic/ui-logic.ts

@@ -4,15 +4,24 @@ import { IDEUILogic } from '@ibiz/model-core';
 import { IUILogicParams } from '../interface';
 import { UILogicContext } from './ui-logic-context';
 import {
+  AppendParamNode,
   BindParamNode,
+  CopyParamNode,
+  DataSetNode,
   DEActionNode,
   DebugParamNode,
   DEUIActionNode,
   EndNode,
+  ExecuteDELogicNode,
   MsgBoxNode,
   PrepareJSParamNode,
+  RenewParamNode,
+  ResetParamNode,
+  SortParamNode,
   StartNode,
+  ThrowExceptionNode,
   UILogicNode,
+  ViewCtrlFireEventNode,
   ViewCtrlInvokeNode,
 } from './ui-logic-node';
 import { UILogicParam } from './ui-logic-param/ui-logic-param';
@@ -75,6 +84,12 @@ export class UILogic {
         case 'PREPAREJSPARAM': // 准备参数
           logicNode = new PrepareJSParamNode(node);
           break;
+        case 'RESETPARAM': // 重置参数
+          logicNode = new ResetParamNode(node);
+          break;
+        case 'COPYPARAM': // 拷贝参数
+          logicNode = new CopyParamNode(node);
+          break;
         case 'BINDPARAM': // 绑定参数
           logicNode = new BindParamNode(node);
           break;
@@ -87,16 +102,28 @@ export class UILogic {
         case 'DEBUGPARAM': // 调试逻辑参数
           logicNode = new DebugParamNode(node);
           break;
-        case 'RESETPARAM': // 重置参数
-        case 'COPYPARAM': // 拷贝参数
-        case 'VIEWCTRLFIREEVENT': // 视图部件事件触发
         case 'APPENDPARAM': // 附加到数组参数
+          logicNode = new AppendParamNode(node);
+          break;
         case 'SORTPARAM': // 排序数组参数
+          logicNode = new SortParamNode(node);
+          break;
         case 'RENEWPARAM': // 重新建立参数
-        case 'PFPLUGIN': // 前端插件调用
+          logicNode = new RenewParamNode(node);
+          break;
         case 'DEDATASET': // 实体数据集
-        case 'DELOGIC': // 实体逻辑
+          logicNode = new DataSetNode(node);
+          break;
         case 'THROWEXCEPTION': // 抛出异常
+          logicNode = new ThrowExceptionNode(node);
+          break;
+        case 'VIEWCTRLFIREEVENT': // 视图部件事件触发
+          logicNode = new ViewCtrlFireEventNode(node);
+          break;
+        case 'DELOGIC': // 实体逻辑
+          logicNode = new ExecuteDELogicNode(node);
+          break;
+        case 'PFPLUGIN': // 前端插件调用
         default:
           throw new ModelError(node, `未支持的逻辑节点类型: ${logicNodeType}`);
       }

package/src/ui-logic/utils/handle-src-val.ts

@@ -53,12 +53,14 @@ export function handleSrcVal(
     // 直接值
     case 'SRCVALUE':
       return srcValue;
-    // 视图参数
-    case 'VIEWPARAM':
+    case 'WEBCONTEXT': // 网页请求上下文
+    case 'VIEWPARAM': // 视图参数
       value = ctx.viewParams;
       break;
-    // 应用上下文
-    case 'APPDATA':
+    case 'APPLICATION': // 系统全局对象
+    case 'SESSION': // 用户全局对象
+    case 'APPDATA': // 应用上下文
+    case 'DATACONTEXT': // 数据上下文
       value = ctx.context;
       break;
     // 当前环境参数
@@ -70,7 +72,7 @@ export function handleSrcVal(
   }
 
   // 取属性值
-  const srcField = srcFieldName?.toLowerCase();
+  const srcField = srcFieldName;
   if (value && srcField) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     value = (value as any)[srcField];

package/src/utils/verify/de-rule-verify.ts

@@ -90,7 +90,7 @@ export function verifyDeRules(
       }
     }
   } else {
-    name = (condition as IDEFVRSingleCondition)?.defname!.toLowerCase();
+    name = (condition as IDEFVRSingleCondition)?.defname!.toLowerCase() || name;
     try {
       // 常规规则
       if (isSimpleCondition(condition)) {