@ibiz-template/runtime 0.6.1-dev.0 → 0.6.1-dev.1

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

@@ -1,131 +0,0 @@
-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.CONDOP_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

@@ -1,20 +0,0 @@
-/**
- * 查询条件基类
- *
- * @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

@@ -1,163 +0,0 @@
-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
-      ) {
-        // 特殊处理，如果值为空，直接返回false
-        if (objValue == null || objCondValue == null) {
-          return false;
-        }
-        // 大小比较
-        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!;
-  }
-}

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

@@ -1,107 +0,0 @@
-import { RuntimeError } from '@ibiz-template/core';
-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.CONDOP_OR === strText ||
-                CondType.CONDOP_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 RuntimeError('值必须为数组');
-        }
-      }
-    }
-  }
-
-  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

@@ -1,12 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,110 +0,0 @@
-import { ModelError } from '@ibiz-template/core';
-import {
-  IAppDEDataSet,
-  IDEDQCondition,
-  IDEDQFieldCondition,
-  IDEDQGroupCondition,
-} from '@ibiz/model-core';
-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<IAppDEDataSet, PSDEDQCondEngine>}
-   */
-  protected static map: WeakMap<IAppDEDataSet, PSDEDQCondEngine> =
-    new WeakMap();
-
-  /**
-   * 根据数据查询获取查询
-   *
-   * @author chitanda
-   * @date 2022-08-25 17:08:04
-   * @static
-   * @param {IAppDEDataSet} dataSet
-   * @return {*}  {PSDEDQCondEngine}
-   */
-  static getCond(dataSet: IAppDEDataSet): PSDEDQCondEngine | null {
-    if (this.map.has(dataSet)) {
-      return this.map.get(dataSet)!;
-    }
-    const groups = dataSet.dedqgroupConditions;
-    if (groups) {
-      const cond = new PSDEDQCondEngine();
-      if (groups.length === 1) {
-        cond.parse(this.calcCond(groups)[0] as unknown[]);
-      } else if (groups.length > 1) {
-        cond.parse(['AND', this.calcCond(groups)][0] as unknown[]);
-      }
-      this.map.set(dataSet, cond);
-      return cond;
-    }
-    return null;
-  }
-
-  /**
-   * 计算查询条件
-   *
-   * @author chitanda
-   * @date 2022-08-25 17:08:39
-   * @protected
-   * @static
-   * @param {IDEDQCondition[]} items
-   * @return {*}  {unknown[]}
-   */
-  protected static calcCond(items: IDEDQCondition[]): unknown[] {
-    const arr: unknown[] = [];
-    items.forEach(item => {
-      const condArr: unknown[] = [];
-      if (item.condType === 'GROUP') {
-        const cond = item as IDEDQGroupCondition;
-        // 是否取反
-        if (cond.notMode) {
-          condArr.push('!');
-        }
-        // 分组模式 AND、OR
-        condArr.push(item.condOp);
-        // 填充子条件
-        const children = cond.dedqconditions;
-        if (children) {
-          const child = this.calcCond(children);
-          condArr.push(child);
-        }
-      } else if (item.condType === 'SINGLE') {
-        const cond = item as IDEDQFieldCondition;
-        condArr.push(cond.condOp);
-        condArr.push(cond.fieldName);
-        if (cond.condValue) {
-          if (cond.vartypeId) {
-            condArr.push({
-              type: cond.vartypeId,
-              value: cond.condValue,
-            });
-          } else {
-            condArr.push(cond.condValue);
-          }
-        } else {
-          // 无条件值为空字符串
-          condArr.push('');
-        }
-      } else {
-        throw new ModelError(item, `暂未支持的查询条件类型: ${item.condType}`);
-      }
-      arr.push(condArr);
-    });
-    return arr;
-  }
-}