@ibiz-template/runtime 0.0.1-alpha.9 → 0.0.1-beta.17

package/src/service/utils/de-dq-cond/ps-model-group-cond-base.ts

@@ -0,0 +1,106 @@
+import { CondType } from './cond-type';
+import { PSModelCondBase } from './ps-model-cond-base';
+import { PSModelSingleCondBase } from './ps-model-single-cond-base';
+
+/**
+ * 逻辑组
+ *
+ * @export
+ * @class PSModelGroupCondBase
+ * @extends {PSModelCondBase}
+ */
+export class PSModelGroupCondBase extends PSModelCondBase {
+  /**
+   * 子条件项
+   *
+   * @private
+   * @type {PSModelCondBase[]}
+   * @memberof PSModelGroupCondBase
+   */
+  private childCondList: PSModelCondBase[] = [];
+
+  /**
+   * 是否取反
+   *
+   * @private
+   * @memberof PSModelGroupCondBase
+   */
+  private bNotMode = false;
+
+  /**
+   * 解析分组条件
+   *
+   * @param {unknown[]} arr
+   * @memberof PSModelGroupCondBase
+   */
+  parse(arr: unknown[]): void {
+    const nCount: number = arr.length;
+    // 条件取反起始
+    let bNotStart = true;
+    // 条件参数起始
+    let bOpStart = true;
+    // 参数条件
+    let bCondStart = false;
+    for (let i = 0; i < nCount; i++) {
+      // 判断是否取反
+      if (bNotStart && bOpStart) {
+        const strText = arr[i];
+        if (strText === '!') {
+          this.setNotMode(true);
+          bNotStart = false;
+          continue;
+        }
+      }
+      // 设置判断条件是「AND」or「OR」
+      if (bOpStart) {
+        const strText = arr[i];
+        this.setCondOp(strText as string);
+        bOpStart = false;
+        bNotStart = false;
+        bCondStart = true;
+        continue;
+      }
+      // 设置子条件组
+      if (bCondStart) {
+        // 需要是数组
+        const list = arr[i];
+        if (list instanceof Array) {
+          // 判断操作符号
+          list.forEach(item => {
+            if (item.length > 0) {
+              const strText: string = item[0].toString();
+              if (
+                strText === '!' ||
+                CondType.GROUPOP_OR === strText ||
+                CondType.GROUPOP_AND === strText
+              ) {
+                const child: PSModelGroupCondBase = new PSModelGroupCondBase();
+                child.parse(item);
+                this.childCondList.push(child);
+              } else {
+                const child: PSModelSingleCondBase =
+                  new PSModelSingleCondBase();
+                child.parse(item);
+                this.childCondList.push(child);
+              }
+            }
+          });
+        } else {
+          throw new Error('值必须为数组');
+        }
+      }
+    }
+  }
+
+  setNotMode(bNotMode: boolean): void {
+    this.bNotMode = bNotMode;
+  }
+
+  isNotMode(): boolean {
+    return this.bNotMode;
+  }
+
+  getChildPSModelCondBases(): PSModelCondBase[] {
+    return this.childCondList;
+  }
+}

package/src/service/utils/de-dq-cond/ps-model-group-cond.ts

@@ -0,0 +1,12 @@
+import { PSModelGroupCondBase } from './ps-model-group-cond-base';
+
+/**
+ * 逻辑组
+ *
+ * @author chitanda
+ * @date 2022-08-17 23:08:27
+ * @export
+ * @class PSDEDQGroupCond
+ * @extends {PSModelGroupCondBase}
+ */
+export class PSDEDQGroupCond extends PSModelGroupCondBase {}

package/src/service/utils/de-dq-cond/ps-model-single-cond-base.ts

@@ -0,0 +1,132 @@
+import { PSModelCondBase } from './ps-model-cond-base';
+
+/**
+ * 逻辑项
+ *
+ * @author chitanda
+ * @date 2022-08-17 23:08:20
+ * @export
+ * @class PSModelSingleCondBase
+ * @extends {PSModelCondBase}
+ */
+export class PSModelSingleCondBase extends PSModelCondBase {
+  /**
+   * 值
+   *
+   * @private
+   * @type {(string | null)}
+   * @memberof PSModelSingleCondBase
+   */
+  private strValue?: string;
+
+  /**
+   * 值类型
+   *
+   * @private
+   * @type {string}
+   * @memberof PSModelSingleCondBase
+   */
+  private strValueType?: string;
+
+  /**
+   * 参数
+   *
+   * @private
+   * @type {string}
+   * @memberof PSModelSingleCondBase
+   */
+  private strParam?: string;
+
+  /**
+   * 参数类型
+   *
+   * @private
+   * @type {string}
+   * @memberof PSModelSingleCondBase
+   */
+  private strParamType?: string;
+
+  /**
+   * 编译条件
+   *
+   * @author chitanda
+   * @date 2022-08-17 23:08:35
+   * @param {unknown[]} arr
+   */
+  parse(arr: unknown[]): void {
+    const nCount = arr.length;
+    // 是否为条件起始
+    let bOpStart = true;
+    let bParamStart = false;
+    let bValueStart = false;
+    for (let i = 0; i < nCount; i++) {
+      // 设置判断条件
+      if (bOpStart) {
+        const strText = arr[i];
+        this.setCondOp(strText as string);
+        bOpStart = false;
+        bParamStart = true;
+        continue;
+      }
+      // 设置参数标识
+      if (bParamStart) {
+        const strText = arr[i];
+        this.setParam(strText as string);
+        bParamStart = false;
+        bValueStart = true;
+        continue;
+      }
+      // 设置值
+      if (bValueStart) {
+        // 需要是对象
+        const obj = arr[i];
+        if (obj instanceof Object && !(obj instanceof Array)) {
+          const data = obj as IData;
+          // 设置值类型
+          if (data.type != null) {
+            this.setValueType(data.type.toString());
+          }
+          // 设置条件值
+          if (data.value != null) {
+            this.setValue(data.value.toString());
+          }
+        } else {
+          this.setValue(obj as string);
+        }
+        break;
+      }
+    }
+  }
+
+  getValueType(): string {
+    return this.strValueType!;
+  }
+
+  setValueType(strValueType: string): void {
+    this.strValueType = strValueType;
+  }
+
+  getValue(): string {
+    return this.strValue!;
+  }
+
+  setValue(strValue: string): void {
+    this.strValue = strValue;
+  }
+
+  getParamType(): string {
+    return this.strParamType!;
+  }
+
+  setParamType(strParamType: string): void {
+    this.strParamType = strParamType;
+  }
+
+  getParam(): string {
+    return this.strParam!;
+  }
+
+  setParam(strParam: string): void {
+    this.strParam = strParam;
+  }
+}

package/src/service/utils/de-dq-cond/ps-model-single-cond.ts

@@ -0,0 +1,12 @@
+import { PSModelSingleCondBase } from './ps-model-single-cond-base';
+
+/**
+ * 逻辑项
+ *
+ * @author chitanda
+ * @date 2022-08-17 23:08:11
+ * @export
+ * @class PSDEDQSingleCond
+ * @extends {PSModelSingleCondBase}
+ */
+export class PSDEDQSingleCond extends PSModelSingleCondBase {}

package/src/service/utils/de-dq-cond-util/de-dq-cond-util.ts

@@ -0,0 +1,104 @@
+import {
+  IPSAppDEDataSet,
+  IPSDEDQCondition,
+  IPSDEDQFieldCondition,
+  IPSDEDQGroupCondition,
+} from '@ibiz-template/model';
+import { PSDEDQCondEngine } from '../de-dq-cond/ps-de-dq-cond-engine';
+
+/**
+ * 获取查询条件工具类
+ *
+ * @author chitanda
+ * @date 2022-08-25 17:08:44
+ * @export
+ * @class DEDQCondUtil
+ */
+export class DEDQCondUtil {
+  /**
+   * 查询条件缓存
+   *
+   * @author chitanda
+   * @date 2022-08-25 17:08:57
+   * @protected
+   * @static
+   * @type {WeakMap<IPSAppDEDataSet, PSDEDQCondEngine>}
+   */
+  protected static map: WeakMap<IPSAppDEDataSet, PSDEDQCondEngine> =
+    new WeakMap();
+
+  /**
+   * 根据数据查询获取查询
+   *
+   * @author chitanda
+   * @date 2022-08-25 17:08:04
+   * @static
+   * @param {IPSAppDEDataSet} dataSet
+   * @return {*}  {PSDEDQCondEngine}
+   */
+  static getCond(dataSet: IPSAppDEDataSet): PSDEDQCondEngine | null {
+    if (this.map.has(dataSet)) {
+      return this.map.get(dataSet)!;
+    }
+    const groups = dataSet.getPSDEDQGroupConditions();
+    if (groups) {
+      const cond = new PSDEDQCondEngine();
+      cond.parse(['OR', this.calcCond(groups)]);
+      this.map.set(dataSet, cond);
+      return cond;
+    }
+    return null;
+  }
+
+  /**
+   * 计算查询条件
+   *
+   * @author chitanda
+   * @date 2022-08-25 17:08:39
+   * @protected
+   * @static
+   * @param {IPSDEDQCondition[]} items
+   * @return {*}  {unknown[]}
+   */
+  protected static calcCond(items: IPSDEDQCondition[]): unknown[] {
+    const arr: unknown[] = [];
+    items.forEach(item => {
+      const condArr: unknown[] = [];
+      if (item.condType === 'GROUP') {
+        const cond = item as IPSDEDQGroupCondition;
+        // 是否取反
+        if (cond.notMode) {
+          condArr.push('!');
+        }
+        // 分组模式 AND、OR
+        condArr.push(item.condOp);
+        // 填充子条件
+        const children = cond.getPSDEDQConditions();
+        if (children) {
+          const child = this.calcCond(children);
+          condArr.push(child);
+        }
+      } else if (item.condType === 'SINGLE') {
+        const cond = item as IPSDEDQFieldCondition;
+        condArr.push(cond.fieldName);
+        if (cond.condValue) {
+          if (cond.getPSVARTypeId()) {
+            condArr.push({
+              type: cond.getPSVARTypeId(),
+              value: cond.getPSVARTypeId(),
+            });
+          } else {
+            condArr.push(cond.condValue);
+          }
+        } else {
+          // 无条件值为空字符串
+          condArr.push('');
+        }
+      } else {
+        throw new Error(`暂未支持的查询条件类型: ${item.condType}`);
+      }
+      arr.push(condArr);
+    });
+    return arr;
+  }
+}

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

@@ -0,0 +1,278 @@
+import {
+  AppEntityModel,
+  DefectModelError,
+  IPSAppCodeList,
+  UnsupportedModelError,
+} from '@ibiz-template/model';
+import { CodeListItem } from '../../interface';
+
+/**
+ * 实际缓存对象
+ *
+ * @author lxm
+ * @date 2022-08-26 14:08:10
+ * @interface CacheData
+ */
+type CacheData = {
+  /**
+   * 过期时间
+   *
+   * @author lxm
+   * @date 2022-08-26 14:08:56
+   * @type {number}
+   */
+  expirationTime: number;
+
+  /**
+   * 代码项数据
+   *
+   * @author lxm
+   * @date 2022-08-26 14:08:01
+   * @type {CodeListItem[]}
+   */
+  items?: CodeListItem[];
+
+  /**
+   * 正在加载的promise
+   *
+   * @author lxm
+   * @date 2022-08-26 14:08:47
+   * @type {Promise<CodeListItem[]>}
+   */
+  promise?: Promise<CodeListItem[]>;
+};
+
+/**
+ * 动态代码表缓存对象
+ *
+ * @author lxm
+ * @date 2022-08-26 13:08:08
+ * @export
+ * @class DynamicCodeListCache
+ */
+export class DynamicCodeListCache {
+  /**
+   * 代码表对象
+   *
+   * @author lxm
+   * @date 2022-08-26 14:08:11
+   * @protected
+   * @type {IPSAppCodeList}
+   */
+  protected codeList: IPSAppCodeList;
+
+  /**
+   * 动态代码表对应实体模型
+   *
+   * @author lxm
+   * @date 2022-08-26 14:08:16
+   * @type {AppEntityModel}
+   */
+  protected entity?: AppEntityModel;
+
+  /**
+   * 代码表请求实体服务的方法名称
+   *
+   * @author lxm
+   * @date 2022-08-26 14:08:46
+   * @type {string}
+   */
+  protected methodName?: string;
+
+  /**
+   * 缓存的map,key是context和params合成的字符串
+   *
+   * @author lxm
+   * @date 2022-08-26 14:08:19
+   * @protected
+   */
+  protected cache = new Map<string, CacheData>();
+
+  /**
+   * 是否是预定义类型
+   *
+   * @author lxm
+   * @date 2022-10-20 10:10:48
+   * @protected
+   * @type {boolean}
+   */
+  protected isPredefined: boolean = false;
+
+  /**
+   * 初始化promise
+   *
+   * @author lxm
+   * @date 2022-08-26 15:08:06
+   * @type {Promise<void>}
+   */
+  protected initPromise?: Promise<void>;
+
+  constructor(codeList: IPSAppCodeList) {
+    this.codeList = codeList;
+  }
+
+  /**
+   * 初始化
+   *
+   * @author lxm
+   * @date 2022-08-26 14:08:28
+   * @returns {*}  {Promise<void>}
+   */
+  async init(): Promise<void> {
+    const fn = async () => {
+      // 预定义类型处理
+      const { predefinedType } = this.codeList;
+      if (predefinedType) {
+        this.isPredefined = true;
+        if (!['OPERATOR', 'RUNTIME'].includes(predefinedType)) {
+          throw new UnsupportedModelError(
+            this.codeList,
+            `预定义类型${predefinedType}暂不支持`,
+          );
+        }
+        return;
+      }
+      // *非预定的需要准备实体模型和方法
+      const appDataEntity = this.codeList.getPSAppDataEntity();
+      if (!appDataEntity) {
+        throw new DefectModelError(this.codeList, '未配置应用实体');
+      }
+      await appDataEntity.fill(true);
+      const methodName = this.codeList.getPSAppDEDataSet()?.codeName;
+      if (!methodName) {
+        throw new DefectModelError(this.codeList, '未配置数据集');
+      }
+      const entityModel = new AppEntityModel(appDataEntity);
+      await entityModel.init();
+      this.entity = entityModel;
+      this.methodName = methodName;
+      this.initPromise = undefined;
+    };
+
+    this.initPromise = fn();
+    return this.initPromise;
+  }
+
+  /**
+   * 把数据转换成代码项
+   *
+   * @author lxm
+   * @date 2022-08-26 15:08:24
+   * @param {IData} data
+   * @returns {*}
+   */
+  protected convertData(data: IData) {
+    // todo 根据模型转换
+    const result: IData = {};
+    // 值属性
+    if (this.codeList.getValuePSAppDEField()) {
+      const valueKey = this.codeList
+        .getValuePSAppDEField()!
+        .codeName.toLowerCase();
+      result.id = data[valueKey];
+      result.value = data[valueKey];
+    } else {
+      result.id = data[this.entity!.keyName];
+      result.value = data[this.entity!.keyName];
+    }
+    // 文本属性
+    if (this.codeList.getTextPSAppDEField()) {
+      result.text =
+        data[this.codeList.getTextPSAppDEField()!.codeName.toLowerCase()];
+    } else {
+      result.text = data[this.entity!.textName];
+    }
+    return Object.freeze(result);
+  }
+
+  /**
+   * 加载服务获取数据，返回代码项
+   *
+   * @author lxm
+   * @date 2022-08-26 14:08:08
+   * @protected
+   * @param {IContext} [context={}]
+   * @param {IParams} [params={}]
+   * @returns {*}  {Promise<CodeListItem[]>}
+   */
+  protected async load(
+    context: IContext = {},
+    params: IParams = {},
+  ): Promise<CodeListItem[]> {
+    // *预定义加载
+    if (this.isPredefined) {
+      const res = await ibiz.net.get(
+        `/dictionaries/codelist/${this.codeList.codeName}`,
+        params,
+      );
+      return Object.freeze(res.data.items);
+    }
+
+    // *加载实体服务数据
+    if (!this.entity || !this.methodName) {
+      new Error('动态代码表找不到实体或数据集');
+    }
+
+    const deService = await ibiz.entityService.getService(
+      this.entity!.source.codeName,
+    );
+    const res = await deService.exec(this.methodName!, context, params);
+    let resultItems: CodeListItem[] = [];
+    if (res.data.length) {
+      resultItems = res.data.map((item: IData) => {
+        return this.convertData(item);
+      });
+      // todo 动态树形代码表
+    }
+    return resultItems;
+  }
+
+  /**
+   * 获取动态的代码项
+   *
+   * @author lxm
+   * @date 2022-08-26 14:08:44
+   * @param {IContext} [context={}]
+   * @param {IParams} [params={}]
+   * @returns {*}  {Promise<IData[]>}
+   */
+  async get(
+    context: IContext = {},
+    params: IParams = {},
+  ): Promise<CodeListItem[]> {
+    // 初始化还未完成时被调用
+    if (this.initPromise) {
+      await this.initPromise;
+    }
+    // 不需要缓存的直接请求;
+    if (!this.codeList.enableCache || this.codeList.cacheTimeout === -1) {
+      return this.load(context, params);
+    }
+
+    // 需要缓存的先找，在判断是否过期，是否正在加载等情况
+    const key = JSON.stringify(context) + JSON.stringify(params);
+    if (this.cache.has(key)) {
+      const cacheData: CacheData = this.cache.get(key)!;
+      // 没过期的返回cacheData的promise或items
+      if (cacheData.expirationTime > new Date().getTime()) {
+        return cacheData.promise ? cacheData.promise! : cacheData.items!;
+      }
+      // 过期的删除缓存
+      this.cache.delete(key);
+    }
+
+    // 创建新的cacheData,存入cache,并添加load的promise
+    const promise = this.load(context, params);
+    const cacheData: CacheData = {
+      expirationTime: new Date().getTime() + this.codeList.cacheTimeout,
+      promise,
+    };
+    this.cache.set(key, cacheData);
+
+    // 加载完后删除promise,添加items
+    const result = await promise;
+    cacheData.items = result;
+    delete cacheData.promise;
+    return result;
+  }
+}