@ibiz-template/runtime 0.7.41-alpha.104 → 0.7.41-alpha.106

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

@@ -0,0 +1,59 @@
+import { ModelError } from '@ibiz-template/core';
+import { IDEEndLogic } from '@ibiz/model-core';
+import { DELogicContext } from '../../de-logic-context';
+import { DELogicNode } from '../de-logic-node';
+
+/**
+ * 结束节点
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:00
+ * @export
+ * @class EndNode
+ * @extends {DELogicNode}
+ */
+export class EndNode extends DELogicNode {
+  declare model: IDEEndLogic;
+
+  async exec(ctx: DELogicContext): Promise<void> {
+    ctx.isEndNode = true;
+    const { returnParamId, returnType, rawValue } = this.model;
+
+    // 没配置不做处理
+    if (!returnType) {
+      return;
+    }
+
+    switch (returnType) {
+      case 'NONEVALUE': // 无值（NONE）
+        ctx.result = undefined;
+        break;
+      case 'NULLVALUE': // 空值（NULL）
+        ctx.result = null;
+        break;
+      case 'SRCVALUE': // 直接值
+        ctx.result = ibiz.util.rawValue.format(rawValue);
+        break;
+      case 'LOGICPARAM': // 逻辑参数对象
+        ctx.result = ctx.params[returnParamId!];
+        break;
+      case 'LOGICPARAMFIELD': // 逻辑参数属性
+      case 'BREAK': // 跳出循环（BREAK）
+      default:
+        throw new ModelError(
+          this.model,
+          ibiz.i18n.t('runtime.deLogic.deLogicNode.unsupportedReturnType', {
+            returnType,
+          }),
+        );
+    }
+
+    ibiz.log.debug(
+      ibiz.i18n.t('runtime.deLogic.deLogicNode.endNode', {
+        id: this.model.id,
+        returnType,
+      }),
+      ctx.result,
+    );
+  }
+}

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

@@ -0,0 +1,13 @@
+export { DEActionNode } from './de-action-node/de-action-node';
+export { StartNode } from './start-node/start-node';
+export { EndNode } from './end-node/end-node';
+export { PrepareParamNode } from './prepare-param-node/prepare-param-node';
+export { DELogicNode } from './de-logic-node';
+export { DataSetNode } from './data-set-node/data-set-node';
+export { BindParamNode } from './bind-param-node/bind-param-node';
+export { ResetParamNode } from './reset-param-node/reset-param-node';
+export { RenewParamNode } from './renew-param-node/renew-param-node';
+export { CopyParamNode } from './copy-param-node/copy-param-node';
+export { SortParamNode } from './sort-param-node/sort-param-node';
+export { AppendParamNode } from './append-param-node/append-param-node';
+export { DebugParamNode } from './debug-param-node/debug-param-node';

package/src/de-logic/de-logic-node/prepare-param-node/prepare-param-node.ts

@@ -0,0 +1,212 @@
+import { ModelError } from '@ibiz-template/core';
+import { IDELogicNodeParam } from '@ibiz/model-core';
+import { clone } from 'ramda';
+import { DELogicContext } from '../../de-logic-context';
+import { handleSrcVal } from '../../utils';
+import { DELogicNode } from '../de-logic-node';
+
+/**
+ * 准备参数
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:20
+ * @export
+ * @class PrepareParamNode
+ * @extends {DELogicNode}
+ */
+export class PrepareParamNode extends DELogicNode {
+  async exec(ctx: DELogicContext): Promise<void> {
+    const nodeParams = this.model.delogicNodeParams;
+    if (nodeParams?.length) {
+      await Promise.all(
+        nodeParams.map(nodeParam => {
+          let result;
+          // 记录下原值(仅仅debug模式才会使用，优化拷贝数据耗时问题)
+          let originValue;
+          if (nodeParam.dstDELogicParamId && ibiz.env.logLevel === 'DEBUG') {
+            originValue = clone(ctx.params[nodeParam.dstDELogicParamId]);
+          }
+          switch (nodeParam.paramAction) {
+            // 设置变量
+            case 'SETPARAMVALUE':
+              result = this.setParamValue(nodeParam, ctx);
+              break;
+            // 重置变量
+            case 'RESETPARAM':
+              result = this.resetParam(nodeParam, ctx);
+              break;
+            // 拷贝变量
+            case 'COPYPARAM':
+              result = this.copyParam(nodeParam, ctx);
+              break;
+            // 绑定参数
+            case 'BINDPARAM':
+              result = this.bindParam(nodeParam, ctx);
+              break;
+            // 重新建立变量
+            case 'RENEWPARAM':
+              result = this.renewParam(nodeParam, ctx);
+              break;
+            // 附加到数组变量
+            case 'APPENDPARAM':
+              result = this.appendParam(nodeParam, ctx);
+              break;
+            // 排序数组变量
+            case 'SORTPARAM':
+              result = this.sortParam(nodeParam, ctx);
+              break;
+            default:
+              throw new ModelError(
+                nodeParam,
+                ibiz.i18n.t('runtime.deLogic.deLogicNode.noSupportedLogic', {
+                  paramAction: nodeParam.paramAction,
+                }),
+              );
+          }
+          ibiz.log.debug(
+            ibiz.i18n.t('runtime.deLogic.deLogicNode.preparationParameter', {
+              id: this.model.id,
+              paramAction: nodeParam.paramAction,
+              dstDELogicParamId: nodeParam.dstDELogicParamId,
+            }),
+            originValue,
+            ibiz.i18n.t('runtime.deLogic.deLogicNode.targetParameter'),
+            ctx.params[nodeParam.dstDELogicParamId!],
+          );
+          return result;
+        }),
+      );
+    }
+  }
+
+  /**
+   * 拷贝变量
+   * @author lxm
+   * @date 2023-03-24 09:50:02
+   * @protected
+   * @param {IDELogicNodeParam} nodeParam
+   * @param {DELogicContext} ctx
+   * @return {*}  {*}
+   */
+  protected copyParam(nodeParam: IDELogicNodeParam, ctx: DELogicContext): void {
+    const { dstDELogicParamId } = nodeParam;
+    const srcVal = handleSrcVal(ctx, nodeParam);
+    ctx.params[dstDELogicParamId!] = clone(srcVal);
+  }
+
+  /**
+   * 绑定参数
+   * @author lxm
+   * @date 2023-06-13 05:43:43
+   * @protected
+   * @param {IDELogicNodeParam} nodeParam
+   * @param {DELogicContext} ctx
+   */
+  protected bindParam(nodeParam: IDELogicNodeParam, ctx: DELogicContext): void {
+    const srcVal = handleSrcVal(ctx, nodeParam);
+    ctx.params[nodeParam.dstDELogicParamId!] = srcVal;
+  }
+
+  /**
+   * 设置变量
+   * @author lxm
+   * @date 2023-03-17 03:34:02
+   * @protected
+   * @param {IDELogicNodeParam} nodeParam
+   * @param {DELogicContext} ctx
+   */
+  protected setParamValue(
+    nodeParam: IDELogicNodeParam,
+    ctx: DELogicContext,
+  ): void {
+    const { dstFieldName, dstDELogicParamId } = nodeParam;
+    // 目标参数
+    let dstField = dstFieldName;
+
+    // 实体参数对象转小写
+    if (ctx.isEntityParam(dstDELogicParamId!)) {
+      dstField = dstField?.toLowerCase();
+    }
+
+    // 源参数
+    const srcVal = handleSrcVal(ctx, nodeParam);
+    if (dstField) {
+      ctx.params[dstDELogicParamId!][dstField] = srcVal;
+    } else {
+      ctx.params[dstDELogicParamId!] = srcVal;
+    }
+  }
+
+  /**
+   * 重置变量
+   * @author lxm
+   * @date 2023-03-24 09:46:57
+   * @protected
+   * @param {IDELogicNodeParam} nodeParam
+   * @param {DELogicContext} ctx
+   */
+  protected resetParam(
+    nodeParam: IDELogicNodeParam,
+    ctx: DELogicContext,
+  ): void {
+    const { dstDELogicParamId } = nodeParam;
+    ctx.resetParam(dstDELogicParamId!);
+  }
+
+  /**
+   * 重新建立变量
+   * @author lxm
+   * @date 2023-03-24 09:46:47
+   * @protected
+   * @param {IDELogicNodeParam} nodeParam
+   * @param {DELogicContext} ctx
+   */
+  protected renewParam(
+    nodeParam: IDELogicNodeParam,
+    ctx: DELogicContext,
+  ): void {
+    const { dstDELogicParamId } = nodeParam;
+    ctx.renewParam(dstDELogicParamId!);
+  }
+
+  /**
+   * 附加到数组变量
+   * @author lxm
+   * @date 2023-03-24 09:46:47
+   * @protected
+   * @param {IDELogicNodeParam} nodeParam
+   * @param {DELogicContext} ctx
+   */
+  protected appendParam(
+    nodeParam: IDELogicNodeParam,
+    ctx: DELogicContext,
+  ): void {
+    const { dstDELogicParamId, 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[dstDELogicParamId!].splice(
+      insertIndex,
+      0,
+      ...srcVal.slice(_srcIndex, _srcSize),
+    );
+  }
+
+  /**
+   * 排序数组变量
+   * @author lxm
+   * @date 2023-03-24 10:23:01
+   * @protected
+   * @param {IDELogicNodeParam} nodeParam
+   * @param {DELogicContext} ctx
+   */
+  protected sortParam(nodeParam: IDELogicNodeParam, ctx: DELogicContext): void {
+    const { dstDELogicParamId, dstFieldName, dstSortDir } = nodeParam;
+    const key = dstFieldName!.toLowerCase();
+    const arr = ctx.params[dstDELogicParamId!] as IData[];
+    arr.sort((a, b) => {
+      return dstSortDir === 'ASC' ? a[key] - b[key] : b[key] - a[key];
+    });
+  }
+}

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

@@ -0,0 +1,34 @@
+import { RuntimeModelError } from '@ibiz-template/core';
+import { IDERenewParamLogic } from '@ibiz/model-core';
+import { DELogicContext } from '../../de-logic-context';
+import { DELogicNode } from '../de-logic-node';
+
+/**
+ * 重新建立参数
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:20
+ * @export
+ * @class RenewParamNode
+ * @extends {DELogicNode}
+ */
+export class RenewParamNode extends DELogicNode {
+  declare model: IDERenewParamLogic;
+
+  async exec(ctx: DELogicContext): Promise<void> {
+    const { dstDELogicParamId } = this.model;
+    if (!dstDELogicParamId) {
+      throw new RuntimeModelError(
+        this.model,
+        ibiz.i18n.t('runtime.deLogic.deLogicNode.missingConfiguration'),
+      );
+    }
+    ctx.renewParam(dstDELogicParamId);
+    ibiz.log.debug(
+      ibiz.i18n.t('runtime.deLogic.deLogicNode.rebuildParameter', {
+        id: this.model.id,
+        dstDELogicParamId,
+      }),
+    );
+  }
+}

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

@@ -0,0 +1,34 @@
+import { RuntimeModelError } from '@ibiz-template/core';
+import { IDEResetParamLogic } from '@ibiz/model-core';
+import { DELogicContext } from '../../de-logic-context';
+import { DELogicNode } from '../de-logic-node';
+
+/**
+ * 重置参数
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:20
+ * @export
+ * @class ResetParamNode
+ * @extends {DELogicNode}
+ */
+export class ResetParamNode extends DELogicNode {
+  declare model: IDEResetParamLogic;
+
+  async exec(ctx: DELogicContext): Promise<void> {
+    const { dstDELogicParamId } = this.model;
+    if (!dstDELogicParamId) {
+      throw new RuntimeModelError(
+        this.model,
+        ibiz.i18n.t('runtime.deLogic.deLogicNode.missingConfiguration'),
+      );
+    }
+    ctx.resetParam(dstDELogicParamId);
+    ibiz.log.debug(
+      ibiz.i18n.t('runtime.deLogic.deLogicNode.resetParameter', {
+        id: this.model.id,
+        dstDELogicParamId,
+      }),
+    );
+  }
+}

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

@@ -0,0 +1,41 @@
+import { RuntimeModelError } from '@ibiz-template/core';
+import { IDESortParamLogic } from '@ibiz/model-core';
+import { DELogicContext } from '../../de-logic-context';
+import { DELogicNode } from '../de-logic-node';
+
+/**
+ * 排序数组参数
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:20
+ * @export
+ * @class SortParamNode
+ * @extends {DELogicNode}
+ */
+export class SortParamNode extends DELogicNode {
+  declare model: IDESortParamLogic;
+
+  async exec(ctx: DELogicContext): Promise<void> {
+    const { dstDELogicParamId, dstSortDir, dstFieldName } = this.model;
+    if (!dstDELogicParamId || !dstFieldName) {
+      throw new RuntimeModelError(
+        this.model,
+        ibiz.i18n.t('runtime.deLogic.deLogicNode.missingParameterProperty'),
+      );
+    }
+    const key = dstFieldName!.toLowerCase();
+    const arr = ctx.params[dstDELogicParamId!] as IData[];
+    arr.sort((a, b) => {
+      return dstSortDir === 'ASC' ? a[key] - b[key] : b[key] - a[key];
+    });
+    ibiz.log.debug(
+      ibiz.i18n.t('runtime.deLogic.deLogicNode.sortedArrayParameters', {
+        id: this.model.id,
+        dstFieldName,
+        dstSortDir,
+        dstDELogicParamId,
+      }),
+      arr,
+    );
+  }
+}

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

@@ -0,0 +1,22 @@
+import { DELogicContext } from '../../de-logic-context';
+import { DELogicNode } from '../de-logic-node';
+
+/**
+ * 启动节点
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:30
+ * @export
+ * @class StartNode
+ * @extends {DELogicNode}
+ */
+export class StartNode extends DELogicNode {
+  async exec(_ctx: DELogicContext): Promise<void> {
+    // 启动节点，无任何操作
+    ibiz.log.debug(
+      ibiz.i18n.t('runtime.deLogic.deLogicNode.startupNode', {
+        id: this.model.id,
+      }),
+    );
+  }
+}

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

@@ -0,0 +1,36 @@
+import { HttpError } from '@ibiz-template/core';
+import { IDEThrowExceptionLogic } from '@ibiz/model-core';
+import { DELogicContext } from '../../de-logic-context';
+import { DELogicNode } from '../de-logic-node';
+
+/**
+ * 抛出异常节点
+ *
+ * @author lxm
+ * @date 2023-02-09 21:02:00
+ * @export
+ * @class ThrowExceptionNode
+ * @extends {DELogicNode}
+ */
+export class ThrowExceptionNode extends DELogicNode {
+  declare model: IDEThrowExceptionLogic;
+
+  async exec(_ctx: DELogicContext): Promise<void> {
+    const { errorCode, errorInfo } = this.model;
+
+    ibiz.log.debug(
+      ibiz.i18n.t('runtime.deLogic.deLogicNode.throwsException', {
+        id: this.model.id,
+        errorCode,
+        errorInfo,
+      }),
+    );
+    throw new HttpError({
+      response: {
+        status: errorCode!,
+        statusText: errorInfo!,
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+  }
+}

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

@@ -0,0 +1,140 @@
+import { ModelError } from '@ibiz-template/core';
+import { IDELogicParam } from '@ibiz/model-core';
+import { clone } from 'ramda';
+import { DELogicContext } from '../de-logic-context';
+
+/**
+ * 界面逻辑参数
+ *
+ * @author lxm
+ * @date 2023-02-07 21:02:45
+ * @export
+ * @class DELogicParam
+ */
+export class DELogicParam {
+  /**
+   * Creates an instance of DELogicParam.
+   *
+   * @author lxm
+   * @date 2023-02-08 16:02:22
+   * @param {DELogicParamModel} model
+   */
+  constructor(public model: IDELogicParam) {}
+
+  /**
+   * 向界面逻辑中计算基础参数
+   *
+   * @author lxm
+   * @date 2023-02-08 20:02:33
+   * @param {DELogicContext} ctx
+   * @param {IContext} context
+   * @param {IData} data
+   * @param {IParams} [opt]
+   */
+  calc(ctx: DELogicContext): void {
+    const tag = this.model.id!;
+    const m = this.model;
+    if (m.default) {
+      // 配置了列表的拿数组数据
+      if (m.entityListParam) {
+        ctx.params[tag] = ctx.data || [];
+      } else {
+        ctx.params[tag] = ctx.data[0] || {};
+      }
+    } else if (m.appGlobalParam) {
+      // 应用全局变量
+      ctx.params[tag] = clone(ibiz.env);
+    } else if (m.entityListParam) {
+      // 数据对象列表
+      ctx.params[tag] = [];
+    } else if (m.entityPageParam) {
+      ctx.params[tag] = {};
+    } else if (m.entityParam) {
+      // 数据对象变量
+      ctx.params[tag] = {};
+    } else if (m.lastReturnParam) {
+      // 上一次调用返回
+      ctx.initLastReturnParam(tag);
+    } else if (m.appContextParam) {
+      // 应用上下文
+      ctx.params[tag] = ctx.parameters.context;
+    } else if (m.simpleListParam) {
+      // 简单数据列表
+      ctx.params[tag] = [];
+    } else if (m.simpleParam) {
+      // 简单数据
+      ctx.params[tag] = {};
+    } else if (m.cloneParam) {
+      // 克隆传入参数
+      ctx.params[tag] = clone(ctx.data || {});
+    } else if (m.envParam) {
+      throw new ModelError(
+        m,
+        ibiz.i18n.t('runtime.deLogic.deLogicNode.environmentVariables'),
+      );
+    } else if (m.fileListParam) {
+      throw new ModelError(
+        m,
+        ibiz.i18n.t('runtime.deLogic.deLogicNode.fileObjectListVariable'),
+      );
+    } else if (m.fileParam) {
+      throw new ModelError(
+        m,
+        ibiz.i18n.t('runtime.deLogic.deLogicNode.fileObjectVariables'),
+      );
+    } else if (m.filterParam) {
+      throw new ModelError(
+        m,
+        ibiz.i18n.t('runtime.deLogic.deLogicNode.filterObjectVariables'),
+      );
+    } else if (m.lastParam) {
+      throw new ModelError(
+        m,
+        ibiz.i18n.t('runtime.deLogic.deLogicNode.finalDataVariables'),
+      );
+    } else if (m.originEntity) {
+      throw new ModelError(
+        m,
+        ibiz.i18n.t('runtime.deLogic.deLogicNode.rawDataObjects'),
+      );
+    } else if (m.sessionParam) {
+      throw new ModelError(
+        m,
+        ibiz.i18n.t('runtime.deLogic.deLogicNode.operationSessionVariables'),
+      );
+    }
+
+    ibiz.log.debug(
+      ibiz.i18n.t('runtime.deLogic.deLogicNode.calculateEntity', { tag }),
+      ibiz.i18n.t('runtime.deLogic.deLogicNode.value'),
+      { ...ctx.params[tag] },
+    );
+  }
+
+  /**
+   * 重新建立变量
+   * @author lxm
+   * @date 2023-03-24 09:20:42
+   * @param {DELogicContext} ctx
+   */
+  renew(ctx: DELogicContext): void {
+    const tag = this.model.id!;
+    const m = this.model;
+    if (m.entityListParam || m.simpleListParam || m.entityPageParam) {
+      ctx.params[tag] = [];
+    } else if (m.simpleParam || m.entityParam) {
+      ctx.params[tag] = {};
+    } else {
+      throw new ModelError(
+        m,
+        ibiz.i18n.t('runtime.deLogic.deLogicNode.recreatingVariables'),
+      );
+    }
+
+    ibiz.log.debug(
+      ibiz.i18n.t('runtime.deLogic.deLogicNode.reEstablish', { tag }),
+      ibiz.i18n.t('runtime.deLogic.deLogicNode.value'),
+      { ...ctx.params[tag] },
+    );
+  }
+}