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

package/src/service/app-data-entity/app-data-entity.ts

@@ -0,0 +1,158 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-constructor-return */
+/* eslint-disable max-classes-per-file */
+import { IAppDataEntity } from '@ibiz/model-core';
+import { clone } from 'ramda';
+import { Srfuf } from '../constant';
+import { findModelChild } from '../../model';
+
+/**
+ * 实体
+ *
+ * @author chitanda
+ * @date 2022-08-17 22:08:49
+ * @export
+ * @class AppDataEntity
+ */
+export class AppDataEntity {
+  [key: string | symbol]: any;
+
+  protected declare data: IData;
+
+  protected declare entity: IAppDataEntity;
+
+  /**
+   * 前端临时主键
+   *
+   * @author chitanda
+   * @date 2023-03-08 17:03:12
+   * @protected
+   * @type {string}
+   */
+  protected _srfkey: string = '';
+
+  declare srfdename: string;
+
+  declare srfkey: string;
+
+  declare srfmajortext: string;
+
+  get srfuf(): Srfuf {
+    return this.srfkey ? Srfuf.UPDATE : Srfuf.CREATE;
+  }
+
+  /**
+   * Creates an instance of AppDataEntity.
+   *
+   * @author chitanda
+   * @date 2022-10-11 21:10:21
+   * @param {IAppDataEntity} entity
+   * @param {(IData | AppDataEntity)} data
+   */
+  constructor(entity: IAppDataEntity, data: IData | AppDataEntity) {
+    Object.defineProperty(this, 'entity', {
+      enumerable: false,
+      configurable: true,
+      value: entity,
+    });
+    Object.defineProperty(this, 'data', {
+      enumerable: false,
+      configurable: true,
+      value: data instanceof AppDataEntity ? clone(data.data) : clone(data),
+    });
+    Object.defineProperty(this, 'srfdename', {
+      get() {
+        return entity.codeName;
+      },
+    });
+    const keyAppField = findModelChild(
+      entity.appDEFields || [],
+      entity.keyAppDEFieldId!,
+    );
+    if (keyAppField) {
+      const key = keyAppField.codeName!.toLowerCase();
+      Object.defineProperty(this, 'srfkey', {
+        set(val: unknown) {
+          this._srfkey = val;
+        },
+        get() {
+          return this.data[key] || this._srfkey;
+        },
+      });
+    } else {
+      ibiz.log.warn(`实体[${entity.codeName}]未配置主键字段`);
+    }
+    const majorAppField = findModelChild(
+      entity.appDEFields || [],
+      entity.majorAppDEFieldId!,
+    );
+    if (majorAppField) {
+      const major = majorAppField.codeName!.toLowerCase();
+      Object.defineProperty(this, 'srfmajortext', {
+        set(val: unknown) {
+          this.data[major] = val;
+        },
+        get() {
+          return this.data[major];
+        },
+      });
+    } else {
+      ibiz.log.warn(`实体[${entity.codeName}]未配置主文本字段`);
+    }
+    this.defineProperties();
+  }
+
+  /**
+   * 代理实际数据
+   *
+   * @author chitanda
+   * @date 2022-10-11 22:10:55
+   * @protected
+   */
+  protected defineProperties(): void {
+    const { data } = this;
+    const properties: { [key: string]: PropertyDescriptor } = {};
+    const fields = this.entity.appDEFields || [];
+    fields.forEach(field => {
+      const key = field.codeName!.toLowerCase();
+      properties[key] = {
+        enumerable: true,
+        set(val: unknown) {
+          data[key] = val;
+        },
+        get() {
+          return data[key];
+        },
+      };
+    });
+    Object.defineProperties(this, properties);
+  }
+
+  /**
+   * 克隆数据
+   *
+   * @author chitanda
+   * @date 2022-10-11 00:10:15
+   * @return {*}  {AppDataEntity}
+   */
+  clone(): AppDataEntity {
+    return new AppDataEntity(this.entity, this.data);
+  }
+
+  /**
+   * 合并参数
+   *
+   * @author chitanda
+   * @date 2022-10-19 11:10:25
+   * @param {(IData | AppDataEntity)} data
+   * @return {*}  {AppDataEntity}
+   */
+  assign(data: IData | AppDataEntity): AppDataEntity {
+    if (data instanceof AppDataEntity) {
+      Object.assign(this.data, data.data);
+    } else {
+      Object.assign(this.data, data);
+    }
+    return this;
+  }
+}

package/src/service/de-service-util.ts

@@ -0,0 +1,105 @@
+import { IApplication } from '@ibiz/model-core';
+import { IHttpResponse, RuntimeModelError } from '@ibiz-template/core';
+import { IAppDEService } from './interface';
+import { DEService } from './service';
+
+/**
+ * 应用服务工具类
+ *
+ * @author chitanda
+ * @date 2022-08-17 23:08:12
+ * @export
+ * @class DEServiceUtil
+ */
+export class DEServiceUtil {
+  /**
+   * 实体服务缓存
+   *
+   * @author chitanda
+   * @date 2022-08-17 23:08:36
+   * @protected
+   * @type {Map<string, IAppDEService>}
+   */
+  protected cache: Map<string, IAppDEService> = new Map();
+
+  /**
+   * Creates an instance of DEServiceUtil.
+   *
+   * @author chitanda
+   * @date 2023-04-18 14:04:01
+   * @param {IApplication} appModel
+   */
+  constructor(protected appModel: IApplication) {}
+
+  /**
+   * 注册实体服务实例
+   *
+   * @author chitanda
+   * @date 2023-04-23 17:04:03
+   * @param {string} id
+   * @param {IAppDEService} service
+   */
+  registerService(id: string, service: IAppDEService): void {
+    this.cache.set(id, service);
+  }
+
+  /**
+   * 根据实体标识获取实体服务
+   *
+   * @author chitanda
+   * @date 2022-12-23 10:12:24
+   * @param {string} id 实体标识
+   * @param {IParams} [context] 上下文,用于计算模型所属沙箱环境
+   * @return {*}  {Promise<IAppDEService>}
+   */
+  async getService(id: string): Promise<IAppDEService> {
+    if (!this.cache.has(id)) {
+      const entityModel = await ibiz.hub.getAppDataEntity(
+        id,
+        this.appModel.appId,
+      );
+      if (!entityModel) {
+        throw new RuntimeModelError(`未找到应用实体[${id}]`);
+      }
+      const service = await new DEService(entityModel);
+      this.cache.set(id, service);
+    }
+    return this.cache.get(id)!;
+  }
+
+  /**
+   * 清理所有服务, 当前临时域下的所有临时数据缓存
+   *
+   * @description 根据 srfsessionid 作为临时数据域
+   * @author chitanda
+   * @date 2022-08-18 14:08:48
+   * @param {IParams} context
+   */
+  clearTempCache(context: IParams): void {
+    this.cache.forEach(service => {
+      service.local.clear(context);
+    });
+  }
+
+  /**
+   * 执行服务方法
+   * @author lxm
+   * @date 2023-04-26 02:02:43
+   * @param {string} appDataEntityId 实体名称
+   * @param {string} methodName 方法名
+   * @param {IParams} context 上下文
+   * @param {(IData | undefined)} [params] 数据
+   * @param {(IParams | undefined)} [params2] 视图参数
+   * @return {*}  {Promise<IHttpResponse<IData>>}
+   */
+  async exec(
+    appDataEntityId: string,
+    methodName: string,
+    context: IParams,
+    params?: IData | IData[] | undefined,
+    params2?: IParams | undefined,
+  ): Promise<IHttpResponse<IData>> {
+    const service = await this.getService(appDataEntityId);
+    return service.exec(methodName, context, params, params2);
+  }
+}

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

@@ -1,12 +1,14 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable no-await-in-loop */
 import {
   IAppDataEntity,
   IAppDEMethodDTO,
   IAppDEMethodDTOField,
 } from '@ibiz/model-core';
+import { isNilOrEmpty } from 'qx-util';
+import { ModelError } from '@ibiz-template/core';
 import { Application } from '../../application';
-import { Entity } from '../entity/entity';
+import { AppDataEntity } from '../app-data-entity/app-data-entity';
+import { findModelChild } from '../../model';
 
 /**
  * 应用实体服务方法转换 DTO
@@ -23,38 +25,20 @@ export class MethodDto {
 
   protected dtoMap: Map<string, MethodDto> = new Map();
 
-  protected _entity?: IAppDataEntity;
-
-  protected get entity(): IAppDataEntity {
-    // if (!this._entity) {
-    //   this._entity = new IAppDataEntity(
-    //     this.dto?.getParentPSModelObject(
-    //       'app.dataentity.IAppDataEntity',
-    //     ) as IAppDataEntity,
-    //   );
-    // }
-    return this._entity!;
-  }
-
   get isLocalMode(): boolean {
-    // return this.entity.isLocalMode;
-    return false;
+    return this.entity.storageMode === 1 || this.entity.storageMode === 4;
   }
 
-  /**
-   * Creates an instance of MethodDto.
-   *
-   * @author chitanda
-   * @date 2022-10-10 23:10:06
-   * @param {IAppDEMethodDTO} dto
-   */
-  constructor(protected dto?: IAppDEMethodDTO) {
-    // if (dto) {
-    //   this.app = ibiz.hub.getApp(dto.getPSModelService().app);
-    //   this.fields = dto.getPSAppDEMethodDTOFields() || [];
-    // } else {
-    //   this.fields = [];
-    // }
+  constructor(
+    protected entity: IAppDataEntity,
+    protected dto?: IAppDEMethodDTO,
+  ) {
+    if (dto) {
+      this.app = ibiz.hub.getApp(entity.appId);
+      this.fields = dto.appDEMethodDTOFields || [];
+    } else {
+      this.fields = [];
+    }
   }
 
   /**
@@ -68,40 +52,41 @@ export class MethodDto {
    */
   async get(context: IParams, data: IData): Promise<IData> {
     const params: IData = {};
-    // for (let i = 0; i < this.fields.length; i++) {
-    //   const field = this.fields[i];
-    //   const key = field.codeName.toLowerCase();
-    //   switch (field.type) {
-    //     case 'SIMPLE': {
-    //       const val = data[key];
-    //       if (isNilOrEmpty(val)) {
-    //         params[key] = null;
-    //       } else {
-    //         params[key] = val;
-    //       }
-    //       break;
-    //     }
-    //     case 'DTOS': {
-    //       const dto = await this.getFieldDto(field);
-    //       const refEntity = field.getRefPSAppDataEntity()!;
-    //       const service = await this.app!.es.getService(refEntity.codeName);
-    //       const items: IDatum[] = service.local.getList(context);
-    //       if (items) {
-    //         const arr = [];
-    //         for (let j = 0; j < items.length; j++) {
-    //           arr.push(await dto.get(context, items[j]));
-    //         }
-    //         params[key] = arr;
-    //       }
-    //       break;
-    //     }
-    //     default:
-    //       throw new ModelError(
-    //         field,
-    //         `未支持的应用实体方法输入属性类型: ${field.type}`,
-    //       );
-    //   }
-    // }
+    for (let i = 0; i < this.fields.length; i++) {
+      const field = this.fields[i];
+      const key = field.codeName!.toLowerCase();
+      switch (field.type) {
+        case 'SIMPLE': {
+          const val = data[key];
+          if (isNilOrEmpty(val)) {
+            params[key] = null;
+          } else {
+            params[key] = val;
+          }
+          break;
+        }
+        case 'DTOS': {
+          const dto = await this.getFieldDto(field);
+          const service = await this.app!.deService.getService(
+            field.refAppDataEntityId!,
+          );
+          const items: IDatum[] = service.local.getList(context);
+          if (items) {
+            const arr = [];
+            for (let j = 0; j < items.length; j++) {
+              arr.push(await dto.get(context, items[j]));
+            }
+            params[key] = arr;
+          }
+          break;
+        }
+        default:
+          throw new ModelError(
+            field,
+            `未支持的应用实体方法输入属性类型: ${field.type}`,
+          );
+      }
+    }
     return params;
   }
 
@@ -112,10 +97,10 @@ export class MethodDto {
    * @date 2022-10-10 23:10:50
    * @param {IParams} context
    * @param {IDatum[]} data
-   * @return {*}  {Promise<Entity[]>}
+   * @return {*}  {Promise<AppDataEntity[]>}
    */
-  async sets(context: IParams, data: IDatum[]): Promise<Entity[]> {
-    const service = await this.app!.es.getService(this.entity.codeName!);
+  async sets(context: IParams, data: IDatum[]): Promise<AppDataEntity[]> {
+    const service = await this.app!.deService.getService(this.entity.codeName!);
     service.local.clear(context);
     return Promise.all(
       data.map(async datum => {
@@ -132,7 +117,7 @@ export class MethodDto {
         for (let i = 0; i < all.length; i++) {
           await all[i];
         }
-        const entityData = new Entity(this.entity, datum);
+        const entityData = new AppDataEntity(this.entity, datum);
         if (this.isLocalMode) {
           await service.local.add(context, entityData);
         }
@@ -151,14 +136,19 @@ export class MethodDto {
    * @return {*}  {Promise<MethodDto>}
    */
   protected async getFieldDto(field: IAppDEMethodDTOField): Promise<MethodDto> {
-    // todo
-    // if (this.dtoMap.has(field.codeName)) {
-    //   return this.dtoMap.get(field.codeName)!;
-    // }
-    // await field.getRefPSAppDataEntity()?.fill(true);
-    // const dto = new MethodDto(field.getRefPSAppDEMethodDTO()!);
-    // this.dtoMap.set(field.codeName, dto);
-    // return dto;
-    throw new Error();
+    if (this.dtoMap.has(field.codeName!)) {
+      return this.dtoMap.get(field.codeName!)!;
+    }
+    const entity = await ibiz.hub.getAppDataEntity(
+      field.refAppDataEntityId!,
+      this.entity.appId,
+    );
+    const methodDto = findModelChild(
+      entity.appDEMethodDTOs || [],
+      field.refAppDEMethodDTOId!,
+    )!;
+    const dto = new MethodDto(entity, methodDto);
+    this.dtoMap.set(field.codeName!, dto);
+    return dto;
   }
 }

package/src/service/index.ts

@@ -6,4 +6,4 @@ export * from './vo';
 
 export { AuthService } from './auth/auth.service';
 export { AuthorityService } from './authority/authority.service';
-export { ServiceUtil } from './service-util';
+export { DEServiceUtil } from './de-service-util';

package/src/service/interface/i-app-de-service/i-app-de-service.ts

@@ -0,0 +1,39 @@
+import { IHttpResponse } from '@ibiz-template/core';
+import { DECache } from '../../utils';
+
+/**
+ * 实体服务
+ *
+ * @author chitanda
+ * @date 2023-04-23 09:04:10
+ * @export
+ * @interface IAppDEService
+ */
+export interface IAppDEService {
+  /**
+   * 实体本地缓存工具
+   *
+   * @author chitanda
+   * @date 2023-04-23 10:04:23
+   * @type {DECache}
+   */
+  readonly local: DECache;
+
+  /**
+   * 执行实体服务方法
+   *
+   * @author chitanda
+   * @date 2023-04-23 09:04:16
+   * @param {string} id 执行标识
+   * @param {IParams} context 上下文
+   * @param {IData} [params] 参数
+   * @param {IParams} [params2] 参数2
+   * @return {*}  {Promise<IHttpResponse>}
+   */
+  exec(
+    id: string,
+    context: IParams,
+    params?: IData | IData[],
+    params2?: IParams,
+  ): Promise<IHttpResponse>;
+}

package/src/service/interface/index.ts

@@ -1,2 +1,3 @@
 export { CodeListItem } from './code-list-item/code-list-item';
+export { IAppDEService } from './i-app-de-service/i-app-de-service';
 export { ITreeNodeData } from './i-tree-node-data/i-tree-node-data';

package/src/service/service/entity/de.service.ts

@@ -0,0 +1,126 @@
+import { IAppDEMethod, IAppDataEntity } from '@ibiz/model-core';
+import { IHttpResponse, ModelError, RuntimeError } from '@ibiz-template/core';
+import { DECache } from '../../utils';
+import { WorkFlowService } from '../work-flow/work-flow.service';
+import { Method } from './method/method';
+import { FileService } from '../file/file.service';
+import { findModelChild } from '../../../model';
+import { DEActionMethod } from './method/de-action';
+import { FetchMethod } from './method/fetch';
+import { IAppDEService } from '../../interface';
+
+/**
+ * 实体服务
+ *
+ * @author chitanda
+ * @date 2022-08-17 22:08:21
+ * @export
+ * @class DEService
+ */
+export class DEService implements IAppDEService {
+  /**
+   * 工作流相关服务
+   *
+   * @author lxm
+   * @date 2022-09-29 11:09:28
+   * @type {WorkFlowService}
+   */
+  readonly wf: WorkFlowService;
+
+  /**
+   * 文件相关服务
+   *
+   * @author lxm
+   * @date 2022-11-25 13:11:11
+   * @type {FileService}
+   */
+  readonly file: FileService;
+
+  /**
+   * 请求方法实例
+   *
+   * @author chitanda
+   * @date 2022-10-10 12:10:13
+   * @protected
+   * @type {Map<string, Method>}
+   */
+  protected readonly methodMap: Map<string, Method> = new Map();
+
+  /**
+   * 数据缓存
+   *
+   * @author chitanda
+   * @date 2022-08-18 19:08:40
+   * @type {DECache}
+   */
+  readonly local: DECache = new DECache();
+
+  /**
+   * Creates an instance of EntityService.
+   *
+   * @author chitanda
+   * @date 2022-08-24 18:08:44
+   * @param {IAppDataEntity} model 应用实体模型
+   */
+  constructor(protected model: IAppDataEntity) {
+    this.wf = new WorkFlowService(model);
+    this.file = new FileService(model);
+  }
+
+  /**
+   * 获取实体服务方法实例
+   *
+   * @author chitanda
+   * @date 2022-10-10 14:10:53
+   * @protected
+   * @param {string} id
+   * @return {*}  {Method}
+   */
+  protected getMethod(id: string): Method {
+    if (this.methodMap.has(id)) {
+      return this.methodMap.get(id)!;
+    }
+    const model = findModelChild(this.model.appDEMethods!, id) as IAppDEMethod;
+    let method: Method | null = null;
+    switch (model.methodType) {
+      case 'DEACTION':
+        method = new DEActionMethod(this.model, model);
+        break;
+      case 'FETCH':
+      case 'FETCHTEMP':
+        method = new FetchMethod(this.model, model);
+        break;
+      default:
+        throw new ModelError(
+          model,
+          `未支持的服务方法类型: ${model.methodType}`,
+        );
+    }
+    this.methodMap.set(id, method);
+    return method;
+  }
+
+  /**
+   * 执行服务方法
+   *
+   * @author chitanda
+   * @date 2022-09-13 19:09:55
+   * @param {string} id 执行服务方法标识
+   * @param {IParams} context
+   * @param {IData} [params={}] 请求参数
+   * @param {IParams} [params2={}] 查询参数
+   * @return {*}  {Promise<IHttpResponse>}
+   */
+  exec(
+    id: string,
+    context: IParams,
+    params: IData = {},
+    params2: IParams = {},
+  ): Promise<IHttpResponse> {
+    const method = this.getMethod(id);
+    if (method) {
+      return method.exec(context, params, params2);
+    }
+    throw new RuntimeError(`${this.model.codeName}未支持「${id}」方法`);
+  }
+}