@ibiz-template/runtime 0.0.1-beta.1 → 0.0.1-beta.17

package/src/service/service/code-list/code-list.service.ts

@@ -0,0 +1,168 @@
+import {
+  getModelService,
+  IPSAppCodeList,
+  IPSCodeItem,
+} from '@ibiz-template/model';
+import { CodeListItem } from '../../interface';
+import { DynamicCodeListCache } from '../../utils';
+
+/**
+ * 全局代码表服务
+ *
+ * @author chitanda
+ * @date 2022-08-25 15:08:32
+ * @export
+ * @class CodeListService
+ */
+export class CodeListService {
+  /**
+   * 所有代码表缓存
+   *
+   * @author lxm
+   * @date 2022-08-25 20:08:16
+   */
+  allCodeLists = new Map<string, IPSAppCodeList>();
+
+  /**
+   * 代码表项数据缓存
+   *
+   * @author lxm
+   * @date 2022-08-25 21:08:12
+   * @protected
+   * @type {Map<string, CodeListItem[]>}
+   */
+  protected cache: Map<string, readonly CodeListItem[] | DynamicCodeListCache> =
+    new Map();
+
+  /**
+   * 初始化所有代码表缓存
+   *
+   * @author lxm
+   * @date 2022-08-25 21:08:32
+   * @protected
+   * @param {IContext} [context]
+   * @returns {*}
+   */
+  protected async initAllCodeList(context?: IContext) {
+    if (this.allCodeLists.size !== 0) {
+      return;
+    }
+    const modelService = await getModelService(context);
+    const items = modelService.app.getAllPSAppCodeLists() || [];
+    items.forEach(item => {
+      const codeName = item.isFill ? item.codeName : item.refM.codeName;
+      this.allCodeLists.set(codeName, item);
+    });
+  }
+
+  /**
+   * 获取静态代码表
+   *
+   * @author chitanda
+   * @date 2022-08-25 15:08:11
+   * @param {string} _tag
+   * @return {*}  {CodeListItem[]}
+   */
+  protected getStatic(codeList: IPSAppCodeList): CodeListItem[] {
+    if (this.cache.has(codeList.codeName)) {
+      return this.cache.get(codeList.codeName)! as CodeListItem[];
+    }
+    const items = codeList.getPSCodeItems();
+    let result: CodeListItem[] = [];
+    if (items?.length) {
+      result = this.formatStaticItems(items, codeList.codeItemValueNumber);
+    }
+    this.cache.set(codeList.codeName, Object.freeze(result));
+    return result;
+  }
+
+  /**
+   * 格式化代码表
+   *
+   * @author lxm
+   * @date 2022-08-25 21:08:03
+   * @protected
+   * @param {IPSCodeItem[]} codeItems
+   * @param {boolean} isValueNumber
+   * @returns {*}
+   */
+  protected formatStaticItems(
+    codeItems: IPSCodeItem[],
+    isValueNumber: boolean,
+  ) {
+    return codeItems.map(codeItem => {
+      // todo代码项其他属性，表单数据
+      const _codeItem: CodeListItem = {
+        text: codeItem.text,
+        value: isValueNumber ? Number(codeItem.value) : codeItem.value,
+        color: codeItem.color,
+        id: codeItem.codeName,
+      };
+      if (codeItem.getPSCodeItems()?.length) {
+        _codeItem.children = this.formatStaticItems(
+          codeItem.getPSCodeItems()!,
+          isValueNumber,
+        );
+      }
+      return Object.freeze(_codeItem);
+    });
+  }
+
+  /**
+   * 获取动态代码表
+   *
+   * @author lxm
+   * @date 2022-08-25 21:08:06
+   * @protected
+   * @param {IPSAppCodeList} codeList
+   * @returns {*}  {IData[]}
+   */
+  protected async getDynamicCodeList(
+    codeList: IPSAppCodeList,
+    context: IContext = {},
+    params: IParams = {},
+  ): Promise<CodeListItem[]> {
+    let dynamicCache: DynamicCodeListCache;
+    if (this.cache.has(codeList.codeName)) {
+      dynamicCache = this.cache.get(codeList.codeName)! as DynamicCodeListCache;
+    } else {
+      dynamicCache = new DynamicCodeListCache(codeList);
+      this.cache.set(codeList.codeName, dynamicCache);
+      await dynamicCache.init();
+    }
+    return dynamicCache.get(context, params);
+  }
+
+  /**
+   * 获取代码表
+   *
+   * @author chitanda
+   * @date 2022-08-25 15:08:45
+   * @param {string} tag
+   * @param {IContext} [context]
+   * @param {IParams} [params]
+   * @return {*}  {Promise<CodeListItem[]>}
+   */
+  async get(
+    tag: string,
+    context?: IContext,
+    params?: IParams,
+  ): Promise<readonly CodeListItem[]> {
+    if (this.allCodeLists.size === 0) {
+      await this.initAllCodeList(context);
+    }
+    const codeList = this.allCodeLists.get(tag);
+    if (!codeList) {
+      throw new Error(`找不到${tag}代码表`);
+    }
+    await codeList.fill(true);
+    if (codeList.codeListType === 'STATIC') {
+      return this.getStatic(codeList);
+    }
+    if (codeList.codeListType === 'DYNAMIC') {
+      return this.getDynamicCodeList(codeList, context, params);
+    }
+    // todo 预定义代码表
+    return [];
+  }
+}

package/src/service/service/counter/counter.service.ts

@@ -0,0 +1,76 @@
+import {
+  DefectModelError,
+  IPSAppCounter,
+  IPSAppCounterRef,
+} from '@ibiz-template/model';
+import { AppCounter } from '../../utils';
+
+/**
+ * 计数器服务，用来获取计数器实例
+ *
+ * @author chitanda
+ * @date 2022-10-26 17:10:48
+ * @export
+ * @class CounterService
+ */
+export class CounterService {
+  /**
+   * 计数器组，应用级计数器缓存，不存在重复
+   *
+   * @author chitanda
+   * @date 2022-10-26 19:10:54
+   * @protected
+   * @static
+   * @type {Map<string, AppCounter>}
+   */
+  protected static counterMap: Map<string, AppCounter> = new Map();
+
+  /**
+   * 获取计数器
+   *
+   * @author chitanda
+   * @date 2022-10-26 19:10:18
+   * @param {IPSAppCounter} model
+   * @return {*}  {Promise<AppCounter>}
+   */
+  static async getCounter(
+    model: IPSAppCounter,
+    context?: IContext,
+    params?: IParams,
+  ): Promise<AppCounter> {
+    if (this.counterMap.has(model.id)) {
+      const counter = this.counterMap.get(model.id)!;
+      if (counter.isDestroyed === false) {
+        return counter;
+      }
+      this.counterMap.delete(model.id);
+    }
+    const counter = new AppCounter(model);
+    await counter.init(context, params);
+    this.counterMap.set(model.id, counter);
+    return counter;
+  }
+
+  /**
+   * 根据计数器引用获取计数器实例
+   *
+   * @author chitanda
+   * @date 2022-10-26 20:10:20
+   * @static
+   * @param {IPSAppCounterRef} model
+   * @param {IContext} context
+   * @param {IParams} params
+   * @return {*}  {Promise<AppCounter>}
+   */
+  static async getCounterByRef(
+    model: IPSAppCounterRef,
+    context?: IContext,
+    params?: IParams,
+  ): Promise<AppCounter> {
+    const appCounter = model.getPSAppCounter();
+    if (!appCounter) {
+      throw new DefectModelError(model, `未配置应用计数器!`);
+    }
+    return this.getCounter(appCounter, context, params);
+  }
+}

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

@@ -0,0 +1,145 @@
+import {
+  AppEntityModel,
+  IAppDEMethod,
+  UnsupportedModelError,
+} from '@ibiz-template/model';
+import { IHttpResponse, RuntimeError } from '@ibiz-template/core';
+import { EntityCache, ServicePathItem } from '../../utils';
+import { WorkFlowService } from '../work-flow/work-flow.service';
+import { Method } from './method/method';
+import { DEActionMethod } from './method/de-action';
+import { FetchMethod } from './method/fetch';
+import { FileService } from '../file/file.service';
+
+/**
+ * 实体服务
+ *
+ * @author chitanda
+ * @date 2022-08-17 22:08:21
+ * @export
+ * @class EntityService
+ */
+export class EntityService {
+  /**
+   * 工作流相关服务
+   *
+   * @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 {EntityCache}
+   */
+  readonly local: EntityCache = new EntityCache();
+
+  /**
+   * Creates an instance of EntityService.
+   *
+   * @author chitanda
+   * @date 2022-08-24 18:08:44
+   * @param {AppEntityModel} model 应用实体模型
+   * @param {ServicePathItem[][]} paths 计算出的资源关系路径
+   */
+  constructor(
+    protected model: AppEntityModel,
+    protected paths: ServicePathItem[][],
+  ) {
+    this.wf = new WorkFlowService(model);
+    this.file = new FileService(model, paths);
+  }
+
+  /**
+   * 获取实体服务方法实例
+   *
+   * @author chitanda
+   * @date 2022-10-10 14:10:53
+   * @protected
+   * @param {string} methodName
+   * @return {*}  {Method}
+   */
+  protected getMethod(methodName: string): Method {
+    if (this.methodMap.has(methodName)) {
+      return this.methodMap.get(methodName)!;
+    }
+    const model = this.model.findPSAppDeMethod(methodName) as IAppDEMethod;
+    let method: Method | null = null;
+    switch (model.methodType) {
+      case 'DEACTION':
+        method = new DEActionMethod(this.model, model, this.paths);
+        break;
+      case 'FETCH':
+      case 'FETCHTEMP':
+        method = new FetchMethod(this.model, model, this.paths);
+        break;
+      default:
+        throw new UnsupportedModelError(
+          model,
+          `未支持的服务方法类型: ${model.methodType}`,
+        );
+    }
+    this.methodMap.set(methodName, method);
+    return method;
+  }
+
+  /**
+   * 执行服务方法
+   *
+   * @author chitanda
+   * @date 2022-09-13 19:09:55
+   * @param {string} methodName
+   * @param {IContext} context
+   * @param {IData} [params={}] 请求参数
+   * @param {IParams} [params2={}] 查询参数
+   * @return {*}  {Promise<IHttpResponse>}
+   */
+  exec(
+    methodName: string,
+    context: IContext,
+    params: IData = {},
+    params2: IParams = {},
+  ): Promise<IHttpResponse> {
+    const method = this.getMethod(methodName);
+    if (method) {
+      return method.exec(context, params, params2);
+    }
+    throw new RuntimeError(`${this.model.deName}未支持「${methodName}」方法`);
+  }
+
+  getPath(
+    methodName: string,
+    context: IContext,
+    params: IData = {},
+    params2: IParams = {},
+  ) {
+    const method = this.getMethod(methodName);
+    if (method) {
+      return method.exec(context, params, params2);
+    }
+    throw new RuntimeError(`${this.model.deName}未支持「${methodName}」方法`);
+  }
+}