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

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

@@ -0,0 +1,190 @@
+/* eslint-disable no-await-in-loop */
+import { DELogicModel, UnsupportedModelError } from '@ibiz-template/model';
+import { DELogicContext } from './de-logic-context';
+import {
+  DEActionNode,
+  EndNode,
+  PrepareParamNode,
+  StartNode,
+  DELogicNode,
+  DataSetNode,
+  BindParamNode,
+} 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';
+
+/**
+ * 界面逻辑
+ *
+ * @author lxm
+ * @date 2023-02-07 16:02:48
+ * @export
+ * @class DELogic
+ */
+export class DELogic {
+  /**
+   * 所有节点实例
+   *
+   * @author lxm
+   * @date 2023-02-08 21:02:38
+   * @protected
+   * @type {Map<string, DELogicNode>}
+   */
+  protected nodes: Map<string, DELogicNode> = new Map();
+
+  /**
+   * 所有参数实例
+   *
+   * @author lxm
+   * @date 2023-02-08 21:02:25
+   * @protected
+   * @type {Map<string, DELogicParam>}
+   */
+  protected params: Map<string, DELogicParam> = new Map();
+
+  /**
+   * Creates an instance of DELogic.
+   * @author lxm
+   * @date 2023-02-08 17:02:26
+   * @param {DELogicModel} model
+   */
+  constructor(protected model: DELogicModel) {
+    model.nodes.forEach(node => {
+      const { logicNodeType } = node.source;
+      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;
+        default:
+          throw new UnsupportedModelError(
+            node.source,
+            `未支持的逻辑节点类型: ${logicNodeType}`,
+          );
+      }
+      this.nodes.set(node.codeName, logicNode);
+    });
+    model.params.forEach(param => {
+      this.params.set(param.codeName, new DELogicParam(param));
+    });
+    // 将已经实例化的逻辑节点挂载到逻辑连接上
+    this.nodes.forEach(node => {
+      node.links.forEach(link => {
+        const { srcNode, dstNode } = link.model;
+        if (this.nodes.has(srcNode.codeName)) {
+          link.srcNode = this.nodes.get(srcNode.codeName)!;
+        }
+        if (this.nodes.has(dstNode.codeName)) {
+          link.dstNode = this.nodes.get(dstNode.codeName)!;
+        }
+      });
+    });
+  }
+
+  /**
+   * 初始化逻辑参数
+   *
+   * @author lxm
+   * @date 2023-02-08 21:02:58
+   * @protected
+   * @param {DELogicContext} ctx
+   * @param {IContext} context
+   * @param {IData} data
+   * @param {IParams} [opt]
+   */
+  protected initLogicParams(
+    ctx: DELogicContext,
+    context: IContext,
+    data: IData | null,
+    params: IParams,
+    opt?: IParams,
+  ): void {
+    this.params.forEach(param => {
+      param.calc(ctx, context, data, params, opt);
+    });
+  }
+
+  /**
+   * 执行逻辑
+   *
+   * @author lxm
+   * @date 2023-02-08 21:02:09
+   * @param {IContext} context
+   * @param {IData} data
+   * @param {IParams} [opt]
+   * @return {*}  {Promise<IData>}
+   */
+  async exec(
+    context: IContext,
+    data: IData | null,
+    params: IParams,
+    opt?: IParams,
+  ): Promise<unknown> {
+    const ctx = new DELogicContext();
+    this.initLogicParams(ctx, context, data, params, opt);
+    if (this.model.startNode && this.nodes.has(this.model.startNode.codeName)) {
+      const start = this.nodes.get(this.model.startNode.codeName)!;
+      await this.deepExec(start, ctx, context, data, params, opt);
+    } else {
+      throw new UnsupportedModelError(this.model.source, `未设置起始节点`);
+    }
+    return ctx.result || ctx.params.default || null;
+  }
+
+  /**
+   * 开始根据连线递归执行逻辑
+   *
+   * @author lxm
+   * @date 2023-02-09 15:02:32
+   * @protected
+   * @param {DELogicNode} node
+   * @param {DELogicContext} ctx
+   * @param {IContext} context
+   * @param {(IData | null)} data
+   * @param {IParams} params
+   * @param {IParams} [opt]
+   * @return {*}  {(Promise<IData | null>)}
+   */
+  protected async deepExec(
+    node: DELogicNode,
+    ctx: DELogicContext,
+    context: IContext,
+    data: IData | null,
+    params: IParams,
+    opt?: IParams,
+  ): Promise<void> {
+    // 执行逻辑节点
+    await node.exec(ctx, context, data, params, opt);
+    const { links } = node;
+    // 遍历所有节点连接，递归执行下级连接节点
+    for (let index = 0; index < links.length; index++) {
+      const link = links[index];
+      const bol = await link.exec(ctx, context, data, params, opt);
+      if (bol && link.dstNode) {
+        await this.deepExec(link.dstNode, ctx, context, data, params, opt);
+        // 平行输出: 在满足连接条件并逻辑执行完毕后若是非平行输出则执行完成
+        if (node.model.parallel === false) {
+          break;
+        }
+      }
+    }
+  }
+}

package/src/de-logic/index.ts

@@ -0,0 +1,45 @@
+import { HttpError, HttpResponse } from '@ibiz-template/core';
+import { IPSDELogic, DELogicModel } from '@ibiz-template/model';
+import { DELogic } from './de-logic';
+
+/**
+ * 实体处理逻辑实例缓存
+ */
+const deLogicMap: WeakMap<IPSDELogic, DELogic> = new Map();
+
+/**
+ * 执行实体处理逻辑
+ *
+ * @author lxm
+ * @date 2023-02-09 11:02:23
+ * @export
+ * @param {IPSDELogic} deDELogic
+ * @param {IContext} context
+ * @param {(IData | null)} data
+ * @param {IParams} params
+ * @param {IParams} [opt]
+ * @return {*}  {Promise<HttpResponse<IData>>}
+ */
+export async function execDELogic(
+  deDELogic: IPSDELogic,
+  context: IContext,
+  data: IData | null,
+  params: IParams,
+  opt?: IParams,
+): Promise<HttpResponse<IData>> {
+  if (!deLogicMap.has(deDELogic)) {
+    const deLogicModel = new DELogicModel(deDELogic);
+    await deLogicModel.init();
+    deLogicMap.set(deDELogic, new DELogic(deLogicModel));
+  }
+  const deLogic = deLogicMap.get(deDELogic)!;
+  try {
+    const result = await deLogic.exec(context, data, params, opt);
+    return new HttpResponse(result);
+  } catch (err) {
+    if (err instanceof HttpError) {
+      return new HttpResponse(err, 500);
+    }
+    throw err;
+  }
+}

package/src/interface/i-global-config/i-global-config.ts

@@ -17,4 +17,38 @@ export interface IGlobalConfig {
    * @type {boolean}
    */
   enableDataInfoBar: boolean;
+
+  /**
+   * 默认代码表超时时间(单位：毫秒)
+   *
+   * @author lxm
+   * @date 2023-03-08 03:12:28
+   * @type {number}
+   * @memberof IGlobalConfig
+   */
+  defaultCodeListCacheTimeout: number;
+
+  /**
+   *  表格行编辑呈现模式
+   * - cell 每次只呈现悬浮点击之后的一个单元格的编辑态
+   * - row 每次呈现编辑中的那一行所有单元格的编辑态 TODO
+   * - all 呈现所有编辑项的编辑态
+   * @author lxm
+   * @date 2023-03-06 09:42:44
+   * @type {('cell' | 'row' | 'all')}
+   * @memberof IGlobalConfig
+   */
+  gridEditShowMode: 'cell' | 'row' | 'all';
+
+  /**
+   *  表格行编辑保存模式
+   * - cell-blur 单元格失焦时保存整行数据
+   * - auto 自动保存，值变更之后一段时间保存整行数据
+   * - manual 手动保存，由界面行为调用表格整体保存或行保存。
+   * @author lxm
+   * @date 2023-03-06 03:33:35
+   * @type {('cell-blur' | 'auto' | 'manual')}
+   * @memberof IGlobalConfig
+   */
+  gridEditSaveMode: 'cell-blur' | 'auto' | 'manual';
 }

package/src/interface/i-plugin-factory/i-plugin-factory.ts

@@ -39,7 +39,7 @@ export interface IPluginFactory {
    */
   loadPluginRef(rtObjectName: string, rtObjectRepo: string): Promise<boolean>;
   /**
-   * 注册插件
+   * 给入应用实例，将已经加载的过插件注入。主要用于多实例的情况
    *
    * @author chitanda
    * @date 2023-02-02 16:02:39
@@ -51,31 +51,16 @@ export interface IPluginFactory {
    *
    * @author chitanda
    * @date 2023-02-06 21:02:06
-   * @param {IPluginItem} plugin
+   * @param {IPluginItem} plugin 其中 Name 将作为插件标识
    */
-  registerViewPlugin(plugin: IPluginItem): void;
+  registerPredefinedPlugin(plugin: IPluginItem): void;
   /**
-   * 注册默认部件插件
+   * 加载指定标识视图插件
    *
    * @author chitanda
-   * @date 2023-02-06 21:02:24
-   * @param {IPluginItem} plugin
+   * @date 2023-03-09 18:03:44
+   * @param {string} name 插件标识
+   * @return {*}  {Promise<void>}
    */
-  registerControlPlugin(plugin: IPluginItem): void;
-  /**
-   * 注册默认编辑器插件
-   *
-   * @author chitanda
-   * @date 2023-02-06 21:02:30
-   * @param {IPluginItem} plugin
-   */
-  registerEditorPlugin(plugin: IPluginItem): void;
-  /**
-   * 获取所有的默认编辑器插件
-   *
-   * @author chitanda
-   * @date 2023-02-06 21:02:15
-   * @return {*}  {IPluginItem[]}
-   */
-  getAllDefaultPlugins(): IPluginItem[];
+  loadPredefinedPlugin(name: string): Promise<void>;
 }

package/src/interface/i-plugin-item/i-plugin-item.ts

@@ -7,17 +7,10 @@
  * @interface IPluginItem
  */
 export interface IPluginItem {
-  /**
-   * 用于标识类型，具体的类型解释归具体的插件识别对象解释。例如此插件用于视图，那么由视图的注册机制做解释。其他类似
-   *
-   * @author chitanda
-   * @date 2023-02-06 21:02:54
-   * @type {string}
-   */
-  type: string;
   /**
    * 插件名称，对应模型 rtObjectName
    *
+   * @description 预置插件类型名称规则: 视图(VIEW_${视图类型}_DEFAULT)、部件(CONTROL_${部件类型}_DEFAULT)、编辑器(EDITOR_${编辑器类型}_DEFAULT)
    * @author chitanda
    * @date 2023-02-06 21:02:21
    * @type {string}

package/src/service/dto/method.dto.ts

@@ -108,32 +108,34 @@ export class MethodDto {
    * @author chitanda
    * @date 2022-10-10 23:10:50
    * @param {IContext} context
-   * @param {IData} data
-   * @return {*}  {Promise<IData>}
+   * @param {IData[]} data
+   * @return {*}  {Promise<Entity[]>}
    */
-  async set(context: IContext, data: IData): Promise<Entity> {
+  async sets(context: IContext, data: IData[]): Promise<Entity[]> {
     const service = await this.app!.es.getService(this.entity.codeName);
-    const all = await this.fields
-      .filter(field => field.type === 'DTOS')
-      .map(async field => {
-        const key = field.codeName.toLowerCase();
-        const dto = await this.getFieldDto(field);
-        const items: IData[] = data[key];
-        if (items) {
-          for (let i = 0; i < items.length; i++) {
-            const item = items[i];
-            await dto.set(context, item);
-          }
+    service.local.clear(context);
+    return Promise.all(
+      data.map(async datum => {
+        const all = this.fields
+          .filter(field => field.type === 'DTOS')
+          .map(async field => {
+            const key = field.codeName.toLowerCase();
+            const dto = await this.getFieldDto(field);
+            const items: IData[] = datum[key];
+            if (items) {
+              await dto.sets(context, items);
+            }
+          });
+        for (let i = 0; i < all.length; i++) {
+          await all[i];
         }
-      });
-    for (let i = 0; i < all.length; i++) {
-      await all[i];
-    }
-    const entityData = new Entity(this.entity.source, data);
-    if (this.entity.isLocalMode) {
-      await service.local.add(context, entityData);
-    }
-    return entityData;
+        const entityData = new Entity(this.entity.source, datum);
+        if (this.entity.isLocalMode) {
+          await service.local.add(context, entityData);
+        }
+        return entityData;
+      }),
+    );
   }
 
   /**

package/src/service/entity/entity.ts

@@ -20,6 +20,16 @@ export class Entity {
 
   protected declare entity: IPSAppDataEntity;
 
+  /**
+   * 前端临时主键
+   *
+   * @author chitanda
+   * @date 2023-03-08 17:03:12
+   * @protected
+   * @type {string}
+   */
+  protected _srfkey: string = '';
+
   declare srfdename: string;
 
   declare srfkey: string;
@@ -58,10 +68,10 @@ export class Entity {
     });
     Object.defineProperty(this, 'srfkey', {
       set(val: unknown) {
-        this.data[key] = val;
+        this._srfkey = val;
       },
       get() {
-        return this.data[key];
+        return this.data[key] || this._srfkey;
       },
     });
     Object.defineProperty(this, 'srfmajortext', {

package/src/service/service/entity/method/de-action.ts

@@ -1,4 +1,5 @@
 import { HttpResponse, IHttpResponse } from '@ibiz-template/core';
+import { execDELogic } from '../../../../de-logic';
 import { Entity } from '../../../entity/entity';
 import { Method } from './method';
 
@@ -17,6 +18,14 @@ export class DEActionMethod extends Method {
     data: IData,
     params: IParams,
   ): Promise<HttpResponse<IData>> {
+    // 实体逻辑处理
+    if (this.method.actionType === 'DELOGIC') {
+      const deLogic = this.method.getPSAppDELogic();
+      if (deLogic?.enableFront) {
+        return execDELogic(deLogic, context, data, params);
+      }
+    }
+
     if (!this.entity.isLocalMode) {
       data = await this.input.handle(context, data);
     }
@@ -30,11 +39,11 @@ export class DEActionMethod extends Method {
       case 'Create':
         return this.create(context, data, params);
       case 'Get':
-        return this.get(context, data);
+        return this.get(context, params);
       case 'GetDraft':
-        return this.getDraft(context, data);
+        return this.getDraft(context, params);
       case 'Remove':
-        return this.remove(context, data);
+        return this.remove(context, params);
       case 'Update':
         return this.update(context, data, params);
       case 'CreateTemp':
@@ -42,7 +51,7 @@ export class DEActionMethod extends Method {
       case 'GetTemp':
         return this.getTemp(context, data);
       case 'GetDraftTemp':
-        return this.getDraftTemp(context, data);
+        return this.getDraftTemp(context, params);
       case 'RemoveTemp':
         return this.removeTemp(context, data);
       case 'UpdateTemp':

package/src/service/service/entity/method/method-renturn.ts

@@ -46,8 +46,8 @@ export class MethodReturn {
    */
   async handle(context: IContext, data: IData): Promise<Entity> {
     if (this.dto) {
-      this.app.es.clearTempCache(context);
-      return this.dto.set(context, data);
+      const items = await this.dto.sets(context, [data]);
+      return items[0];
     }
     return new Entity(this.entity.source, data);
   }

package/src/service/service/entity/method/method.ts

@@ -101,38 +101,45 @@ export abstract class Method {
    */
   protected async request(
     path: string,
-    _context: IContext,
+    context: IContext,
     data: IData,
     params: IParams,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ): Promise<HttpResponse<any>> {
-    const requestType = this.method.requestMethod;
-    const methodName = this.method.codeName.toLowerCase();
-    let res: HttpResponse | null = null;
-    switch (requestType) {
-      case 'POST':
-        res = await this.app.net.post(`${path}/${methodName}`, data, params);
-        break;
-      case 'GET':
-        res = await this.app.net.get(`${path}/${methodName}`, data, params);
-        break;
-      case 'PUT':
-        res = await this.app.net.put(`${path}/${methodName}`, data, params);
-        break;
-      case 'DELETE':
-        res = await this.app.net.delete(`${path}/${methodName}`, data, params);
-        break;
-      default:
-        if (requestType) {
-          throw new DefectModelError(
-            this.method,
-            `未支持的请求方式: ${requestType}`,
+    const { actionType, requestMethod } = this.method;
+    if (actionType === 'REMOTE') {
+      const methodName = this.method.codeName.toLowerCase();
+      let res: HttpResponse | null = null;
+      switch (requestMethod) {
+        case 'POST':
+          res = await this.app.net.post(`${path}/${methodName}`, data, params);
+          break;
+        case 'GET':
+          res = await this.app.net.get(`${path}/${methodName}`, data, params);
+          break;
+        case 'PUT':
+          res = await this.app.net.put(`${path}/${methodName}`, data, params);
+          break;
+        case 'DELETE':
+          res = await this.app.net.delete(
+            `${path}/${methodName}`,
+            data,
+            params,
           );
-        } else {
-          throw new DefectModelError(this.method, '未配置请求方式');
-        }
+          break;
+        default:
+          if (requestMethod) {
+            throw new DefectModelError(
+              this.method,
+              `未支持的请求方式: ${requestMethod}`,
+            );
+          } else {
+            throw new DefectModelError(this.method, '未配置请求方式');
+          }
+      }
+      return res;
     }
-    return res;
+    throw new DefectModelError(this.method, `未支持的行为类型[${actionType}]`);
   }
 
   /**

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

@@ -108,9 +108,15 @@ export class ControlService<T extends ControlModel = ControlModel> {
   async exec(
     methodName: string,
     context: IContext,
+    data: IData = {},
     params: IParams = {},
   ): Promise<IHttpResponse> {
-    const res = await this.entityService.exec(methodName, context, params);
+    const res = await this.entityService.exec(
+      methodName,
+      context,
+      data,
+      params,
+    );
     return res;
   }
 

package/src/service/service/widget/edit-form-service.ts

@@ -20,7 +20,7 @@ export class EditFormService<
     context: IContext,
     params: IParams = {},
   ): Promise<IHttpResponse<ControlVO>> {
-    let res = await this.exec(this.model.getAction, context, params);
+    let res = await this.exec(this.model.getAction, context, undefined, params);
     res = this.handleResponse(res);
     return res as IHttpResponse<ControlVO>;
   }
@@ -38,7 +38,12 @@ export class EditFormService<
     context: IContext,
     params: IParams = {},
   ): Promise<IHttpResponse<ControlVO>> {
-    let res = await this.exec(this.model.getDraftAction, context, params);
+    let res = await this.exec(
+      this.model.getDraftAction,
+      context,
+      undefined,
+      params,
+    );
     res = this.handleResponse(res);
     return res as IHttpResponse<ControlVO>;
   }
@@ -56,7 +61,12 @@ export class EditFormService<
     context: IContext,
     params: IParams = {},
   ): Promise<IHttpResponse> {
-    const res = await this.exec(this.model.removeAction, context, params);
+    const res = await this.exec(
+      this.model.removeAction,
+      context,
+      undefined,
+      params,
+    );
     return res;
   }
 

package/src/service/service/widget/md-control-service.ts

@@ -38,7 +38,7 @@ export class MDControlService<
     context: IContext,
     params: IParams = {},
   ): Promise<IHttpResponse<ControlVO>> {
-    let res = await this.exec(this.model.getAction, context, params);
+    let res = await this.exec(this.model.getAction, context, undefined, params);
     res = this.handleResponse(res);
     return res as IHttpResponse<ControlVO>;
   }
@@ -56,7 +56,12 @@ export class MDControlService<
     context: IContext,
     params: IParams = {},
   ): Promise<IHttpResponse<ControlVO>> {
-    let res = await this.exec(this.model.getDraftAction, context, params);
+    let res = await this.exec(
+      this.model.getDraftAction,
+      context,
+      undefined,
+      params,
+    );
     res = this.handleResponse(res);
     return res as IHttpResponse<ControlVO>;
   }
@@ -74,7 +79,12 @@ export class MDControlService<
     context: IContext,
     params: IParams = {},
   ): Promise<IHttpResponse> {
-    const res = await this.exec(this.model.removeAction, context, params);
+    const res = await this.exec(
+      this.model.removeAction,
+      context,
+      undefined,
+      params,
+    );
     return res;
   }
 

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

@@ -27,9 +27,10 @@ export class WizardPanelService<
    */
   async initialize(
     context: IContext,
+    data: IData = {},
     params: IParams = {},
   ): Promise<IHttpResponse<IData>> {
-    let res = await this.exec(this.model.initAction!, context, params);
+    let res = await this.exec(this.model.initAction!, context, data, params);
     res = this.handleResponse(res);
     return res as IHttpResponse<IData>;
   }
@@ -45,9 +46,10 @@ export class WizardPanelService<
    */
   async finish(
     context: IContext,
+    data: IData = {},
     params: IParams = {},
   ): Promise<IHttpResponse<IData>> {
-    let res = await this.exec(this.model.finishAction, context, params);
+    let res = await this.exec(this.model.finishAction, context, data, params);
     res = this.handleResponse(res);
     return res as IHttpResponse<IData>;
   }