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

package/src/service/utils/app-counter/app-counter.ts

@@ -0,0 +1,217 @@
+import {
+  DefectModelError,
+  IPSAppCounter,
+  IPSAppDataEntity,
+} from '@ibiz-template/model';
+import { notNilEmpty, QXEvent } from 'qx-util';
+import { clone } from 'ramda';
+import { EntityService } from '../../service';
+
+/**
+ * 应用实体计数器
+ *
+ * @author chitanda
+ * @date 2022-10-26 18:10:51
+ * @export
+ * @class AppCounter
+ */
+export class AppCounter {
+  protected entity!: IPSAppDataEntity;
+
+  protected service!: EntityService;
+
+  protected action!: string;
+
+  protected intervalTimer: unknown;
+
+  protected destroyed: boolean = false;
+
+  /**
+   * 计数器是否已经销毁
+   *
+   * @author chitanda
+   * @date 2022-10-26 20:10:55
+   * @protected
+   * @type {boolean}
+   */
+  get isDestroyed(): boolean {
+    return this.destroyed;
+  }
+
+  protected context: IContext = {};
+
+  protected params: IParams = {};
+
+  protected evt: QXEvent<{ change: (data: IData) => void }> = new QXEvent();
+
+  /**
+   * 计数器数据
+   *
+   * @author chitanda
+   * @date 2022-10-26 19:10:08
+   * @protected
+   * @type {IData}
+   */
+  protected data: IData = {};
+
+  /**
+   * Creates an instance of AppCounter.
+   *
+   * @author chitanda
+   * @date 2022-10-26 20:10:55
+   * @param {IPSAppCounter} model 应用计数器模型
+   */
+  constructor(public model: IPSAppCounter) {}
+
+  /**
+   * 计数器初始化
+   *
+   * @author chitanda
+   * @date 2022-10-26 19:10:24
+   * @param {IContext} [context]
+   * @param {IParams} [params]
+   */
+  async init(context?: IContext, params?: IParams) {
+    this.setParams(context, params);
+    this.entity = this.model.getPSAppDataEntity()!;
+    await this.entity.fill(true);
+    this.service = await ibiz.entityService.getService(this.entity.codeName);
+    const action = this.model.getGetPSAppDEAction();
+    if (!action) {
+      throw new DefectModelError(this.model, `未找到获取计数器行为!`);
+    }
+    this.action = action.codeName;
+    this.interval();
+    await this.load();
+  }
+
+  /**
+   * 设置上下文以及查询参数
+   *
+   * @author chitanda
+   * @date 2022-10-26 19:10:58
+   * @protected
+   * @param {IContext} [context]
+   * @param {IParams} [params]
+   */
+  protected setParams(context?: IContext, params?: IParams): void {
+    if (context) {
+      this.context = clone(context);
+    }
+    if (params) {
+      this.params = clone(params);
+    }
+  }
+
+  /**
+   * 计数器定时刷新
+   *
+   * @author chitanda
+   * @date 2022-10-26 18:10:13
+   * @protected
+   */
+  protected interval(): void {
+    this.destroyInterval();
+    this.intervalTimer = setInterval(() => {
+      // 当无人订阅计数器时，跳过刷新
+      if (this.evt.getSize('change') > 0) {
+        this.load();
+      }
+    }, this.model.timer || 6000);
+  }
+
+  /**
+   * 销毁定时器自动刷新
+   *
+   * @author chitanda
+   * @date 2022-10-26 18:10:31
+   * @protected
+   */
+  protected destroyInterval(): void {
+    if (this.intervalTimer) {
+      clearInterval(this.intervalTimer as number);
+      this.intervalTimer = null;
+    }
+  }
+
+  /**
+   * 加载计数器
+   *
+   * @author chitanda
+   * @date 2022-10-26 19:10:38
+   * @protected
+   * @return {*}  {Promise<IData>}
+   */
+  protected async load(): Promise<IData> {
+    const res = await this.service.exec(this.action, this.context, this.params);
+    if (res.ok) {
+      this.data = res.data;
+      this.evt.emit('change', this.data);
+    }
+    return this.data;
+  }
+
+  /**
+   * 计数器刷新
+   *
+   * @author chitanda
+   * @date 2022-10-26 19:10:46
+   * @param {IContext} [context]
+   * @param {IParams} [params]
+   * @return {*}  {Promise<IData>}
+   */
+  refresh(context?: IContext, params?: IParams): Promise<IData> {
+    this.setParams(context, params);
+    return this.load();
+  }
+
+  /**
+   * 计数器数据变更事件监听
+   *
+   * @author chitanda
+   * @date 2022-10-26 20:10:13
+   * @param {(data: IData) => void} fn
+   * @param {boolean} [immediate=true] 当有计时器数据时，立即触发一次回调
+   */
+  onChange(fn: (data: IData) => void, immediate: boolean = true): void {
+    this.evt.on('change', fn);
+    if (immediate && notNilEmpty(this.data)) {
+      fn(this.data);
+    }
+  }
+
+  /**
+   * 取消计数器数据变更监听
+   *
+   * @author chitanda
+   * @date 2022-10-26 20:10:13
+   * @param {(data: IData) => void} fn
+   */
+  offChange(fn: (data: IData) => void): void {
+    this.evt.off('change', fn);
+  }
+
+  /**
+   * 根据计数器标识，获取计数器数值
+   *
+   * @author chitanda
+   * @date 2022-10-26 20:10:08
+   * @param {string} tag
+   * @return {*}  {number}
+   */
+  getCounter(tag: string): number {
+    return this.data[tag.toLowerCase()] || 0;
+  }
+
+  /**
+   * 销毁计数器
+   *
+   * @author chitanda
+   * @date 2022-10-26 18:10:31
+   */
+  destroy(): void {
+    this.destroyed = true;
+    this.destroyInterval();
+    this.evt.reset();
+  }
+}

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

@@ -0,0 +1,123 @@
+/* eslint-disable no-shadow */
+/**
+ * 逻辑类型
+ *
+ * @export
+ * @enum {number}
+ */
+export const enum CondType {
+  /**
+   * 等于操作
+   */
+  CONDOP_EQ = 'EQ',
+
+  /**
+   * 绝对等于（保留）
+   */
+  CONDOP_ABSEQ = 'ABSEQ',
+
+  /**
+   * 大于操作
+   */
+  CONDOP_GT = 'GT',
+
+  /**
+   * 大于等于操作
+   */
+  CONDOP_GTANDEQ = 'GTANDEQ',
+
+  /**
+   * 小于操作
+   */
+  CONDOP_LT = 'LT',
+
+  /**
+   * 小于等于操作
+   */
+  CONDOP_LTANDEQ = 'LTANDEQ',
+
+  /**
+   * 不等于操作
+   */
+  CONDOP_NOTEQ = 'NOTEQ',
+
+  /**
+   * 为空判断操作
+   */
+  CONDOP_ISNULL = 'ISNULL',
+
+  /**
+   * 不为空判断操作
+   */
+  CONDOP_ISNOTNULL = 'ISNOTNULL',
+
+  /**
+   * 文本包含
+   */
+  CONDOP_USERLIKE = 'USERLIKE',
+
+  /**
+   * 文本包含
+   */
+  CONDOP_LIKE = 'LIKE',
+
+  /**
+   * 文本左包含
+   */
+  CONDOP_LEFTLIKE = 'LEFTLIKE',
+
+  /**
+   * 文本右包含
+   */
+  CONDOP_RIGHTLIKE = 'RIGHTLIKE',
+
+  /**
+   * 空判断
+   */
+  CONDOP_TESTNULL = 'TESTNULL',
+
+  /**
+   * 值包含在给定的范围中
+   */
+  CONDOP_IN = 'IN',
+
+  /**
+   * 值不包含在给定的范围中
+   */
+  CONDOP_NOTIN = 'NOTIN',
+
+  /**
+   * 指定数据的子数据
+   */
+  CONDOP_CHILDOF = 'CHILDOF',
+
+  /**
+   * 指定数据的父数据
+   */
+  CONDOP_PARENTOF = 'PARENTOF',
+
+  /**
+   * 组逻辑操作，或处理
+   */
+  CONDOP_OR = 'OR',
+
+  /**
+   * 组逻辑操作，与处理
+   */
+  CONDOP_AND = 'AND',
+
+  /**
+   * 组逻辑操作，位与处理
+   */
+  CONDOP_BITAND = 'BITAND',
+
+  /**
+   * 组逻辑操作，或处理
+   */
+  GROUPOP_OR = 'OR',
+
+  /**
+   * 组逻辑操作，与处理
+   */
+  GROUPOP_AND = 'AND',
+}

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

@@ -0,0 +1 @@
+export { PSDEDQCondEngine } from './ps-de-dq-cond-engine';

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

@@ -0,0 +1,131 @@
+import { isEmpty } from 'ramda';
+import { SearchFilter } from '../search-filter/search-filter';
+import { CondType } from './cond-type';
+import { PSModelCondBase } from './ps-model-cond-base';
+import { PSModelCondEngineBase } from './ps-model-cond-engine-base';
+import { PSDEDQGroupCond } from './ps-model-group-cond';
+import { PSModelGroupCondBase } from './ps-model-group-cond-base';
+import { PSDEDQSingleCond } from './ps-model-single-cond';
+import { PSModelSingleCondBase } from './ps-model-single-cond-base';
+
+/**
+ * 实体查询条件引擎
+ *
+ * @author chitanda
+ * @date 2022-08-17 23:08:58
+ * @export
+ * @class PSDEDQCondEngine
+ * @extends {PSModelCondEngineBase}
+ */
+export class PSDEDQCondEngine extends PSModelCondEngineBase {
+  /**
+   * 数据上下文
+   *
+   * @static
+   * @memberof PSDEDQCondEngine
+   */
+  static readonly PARAMTYPE_DATACONTEXT = 'DATACONTEXT';
+
+  /**
+   * 网页请求上下文
+   *
+   * @static
+   * @memberof PSDEDQCondEngine
+   */
+  static readonly PARAMTYPE_WEBCONTEXT = 'WEBCONTEXT';
+
+  /**
+   * 测试
+   *
+   * @param {IData} data 检测的数据
+   * @param {SearchFilter} filter 过滤条件
+   * @return {*}  {boolean}
+   * @memberof PSDEDQCondEngine
+   */
+  public test(data: IData, filter: SearchFilter): boolean {
+    return this.testCond(this.getPSModelGroupCondBase(), data, filter);
+  }
+
+  /**
+   * 查询条件判断
+   *
+   * @author chitanda
+   * @date 2022-08-17 23:08:11
+   * @protected
+   * @param {PSModelCondBase} cond
+   * @param {IData} data
+   * @param {SearchFilter} filter
+   * @return {*}  {boolean}
+   */
+  protected testCond(
+    cond: PSModelCondBase,
+    data: IData,
+    filter: SearchFilter,
+  ): boolean {
+    // 分组条件
+    if (cond instanceof PSModelGroupCondBase) {
+      // 获取子条件
+      const list = cond.getChildPSModelCondBases();
+      if (list == null || isEmpty(list)) {
+        return !cond.isNotMode();
+      }
+      // 是否为「AND」
+      const bAnd = CondType.GROUPOP_AND === cond.getCondOp();
+      let bRet = bAnd;
+      for (let i = 0; i < list.length; i++) {
+        const childCond = list[i];
+        if (this.testCond(childCond, data, filter)) {
+          if (!bAnd) {
+            bRet = true;
+            break;
+          }
+        } else if (bAnd) {
+          bRet = false;
+          break;
+        }
+      }
+      if (cond.isNotMode()) {
+        return !bRet;
+      }
+      return bRet;
+    }
+    // 逻辑项
+    if (cond instanceof PSModelSingleCondBase) {
+      if (isEmpty(cond.getParam())) {
+        ibiz.log.warn('没有指定属性名称', cond);
+      }
+      const objValue = data[cond.getParam().toLowerCase()];
+      let objCondValue = null;
+      const valType = cond.getValueType();
+      const val = cond.getValue();
+      if (valType != null && !isEmpty(valType)) {
+        if (isEmpty(val)) {
+          ibiz.log.warn('没有指定上下文参数名称');
+        }
+        // 网页请求上下文
+        if (PSDEDQCondEngine.PARAMTYPE_WEBCONTEXT === valType) {
+          objCondValue = filter.data[val.toLowerCase()];
+        }
+        // 值类型为数据上下文
+        else if (PSDEDQCondEngine.PARAMTYPE_DATACONTEXT === valType) {
+          // 从过滤条件中获取条件值
+          objCondValue = filter.getValue(val.toLowerCase());
+        }
+      } else {
+        objCondValue = cond.getValue();
+      }
+      // 进行值判断
+      return this.testSingleCond(cond.getCondOp(), objValue, objCondValue);
+    }
+    ibiz.log.warn(`无法识别的条件对象`, cond);
+    return false;
+  }
+
+  protected createPSModelSingleCond(): PSModelSingleCondBase {
+    return new PSDEDQSingleCond();
+  }
+
+  protected createPSModelGroupCond(): PSModelGroupCondBase {
+    return new PSDEDQGroupCond();
+  }
+}

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

@@ -0,0 +1,20 @@
+/**
+ * 查询条件基类
+ *
+ * @export
+ * @abstract
+ * @class PSModelCondBase
+ */
+export abstract class PSModelCondBase {
+  private strCondOp: string | null = null;
+
+  getCondOp(): string {
+    return this.strCondOp!;
+  }
+
+  setCondOp(strCondOp: string): void {
+    this.strCondOp = strCondOp;
+  }
+
+  abstract parse(array: unknown[]): void;
+}

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

@@ -0,0 +1,159 @@
+import { CondType } from './cond-type';
+import { PSModelGroupCondBase } from './ps-model-group-cond-base';
+import { PSModelSingleCondBase } from './ps-model-single-cond-base';
+
+/**
+ * 模型条件引擎辅助对象
+ *
+ * @export
+ * @abstract
+ * @class PSModelCondEngineBase
+ */
+export abstract class PSModelCondEngineBase {
+  /**
+   * 根分组条件
+   *
+   * @private
+   * @type {(PSModelGroupCondBase | null)}
+   * @memberof PSModelCondEngineBase
+   */
+  private psModelGroupCondBase: PSModelGroupCondBase | null = null;
+
+  /**
+   * 解析条件
+   *
+   * @param {IData[]} obj
+   * @memberof PSModelCondEngineBase
+   */
+  parse(obj: unknown[]): void {
+    if (obj instanceof Array) {
+      const psModelGroupCondBase: PSModelGroupCondBase =
+        this.createPSModelGroupCond();
+      psModelGroupCondBase.parse(obj);
+      this.psModelGroupCondBase = psModelGroupCondBase;
+    }
+  }
+
+  /**
+   * 测试项
+   *
+   * @protected
+   * @param {string} strCondOp
+   * @param {*} objValue
+   * @param {*} objCondValue
+   * @return {*}  {boolean}
+   * @memberof PSModelCondEngineBase
+   */
+  protected testSingleCond(
+    strCondOp: string,
+    objValue: string | number,
+    objCondValue: string | number,
+  ): boolean {
+    try {
+      if (CondType.CONDOP_ISNULL === strCondOp) {
+        return objValue == null;
+      }
+
+      if (CondType.CONDOP_ISNOTNULL === strCondOp) {
+        return objValue != null;
+      }
+
+      if (
+        CondType.CONDOP_EQ === strCondOp ||
+        CondType.CONDOP_ABSEQ === strCondOp ||
+        CondType.CONDOP_GT === strCondOp ||
+        CondType.CONDOP_GTANDEQ === strCondOp ||
+        CondType.CONDOP_LT === strCondOp ||
+        CondType.CONDOP_LTANDEQ === strCondOp ||
+        CondType.CONDOP_NOTEQ === strCondOp
+      ) {
+        // 大小比较
+        let nRet = -1;
+        // eslint-disable-next-line eqeqeq
+        if (objValue == objCondValue) {
+          nRet = 0;
+        } else if (objValue > objCondValue) {
+          nRet = 1;
+        }
+        if (
+          CondType.CONDOP_EQ === strCondOp ||
+          CondType.CONDOP_ABSEQ === strCondOp
+        ) {
+          return nRet === 0;
+        }
+        if (CondType.CONDOP_GT === strCondOp) {
+          return nRet > 0;
+        }
+        if (CondType.CONDOP_GTANDEQ === strCondOp) {
+          return nRet >= 0;
+        }
+        if (CondType.CONDOP_LT === strCondOp) {
+          return nRet < 0;
+        }
+        if (CondType.CONDOP_LTANDEQ === strCondOp) {
+          return nRet <= 0;
+        }
+        if (CondType.CONDOP_NOTEQ === strCondOp) {
+          return nRet !== 0;
+        }
+      }
+
+      if (CondType.CONDOP_LIKE === strCondOp) {
+        if (objValue != null && objCondValue != null) {
+          return (
+            objValue
+              .toString()
+              .toUpperCase()
+              .indexOf(objCondValue.toString().toUpperCase()) !== -1
+          );
+        }
+        return false;
+      }
+
+      if (CondType.CONDOP_LEFTLIKE === strCondOp) {
+        if (objValue != null && objCondValue != null) {
+          return (
+            objValue
+              .toString()
+              .toUpperCase()
+              .indexOf(objCondValue.toString().toUpperCase()) === 0
+          );
+        }
+        return false;
+      }
+    } catch (err) {
+      ibiz.log.error(err);
+    }
+    return false;
+  }
+
+  /**
+   * 创建分组
+   *
+   * @protected
+   * @abstract
+   * @return {*}  {PSModelGroupCondBase}
+   * @memberof PSModelCondEngineBase
+   */
+  protected abstract createPSModelGroupCond(): PSModelGroupCondBase;
+
+  /**
+   * 创建逻辑项
+   *
+   * @protected
+   * @abstract
+   * @return {*}  {PSModelSingleCondBase}
+   * @memberof PSModelCondEngineBase
+   */
+  protected abstract createPSModelSingleCond(): PSModelSingleCondBase;
+
+  /**
+   * 获取根分组条件
+   *
+   * @return {*}  {PSModelGroupCondBase}
+   * @memberof PSModelCondEngineBase
+   */
+  getPSModelGroupCondBase(): PSModelGroupCondBase {
+    return this.psModelGroupCondBase!;
+  }
+}