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

package/out/service/utils/de-dq-cond/ps-de-dq-cond-engine.js

@@ -0,0 +1,120 @@
+import { isEmpty } from 'ramda';
+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 {
+    /**
+     * 测试
+     *
+     * @param {IData} data 检测的数据
+     * @param {SearchFilter} filter 过滤条件
+     * @return {*}  {boolean}
+     * @memberof PSDEDQCondEngine
+     */
+    test(data, filter) {
+        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}
+     */
+    testCond(cond, data, filter) {
+        // 分组条件
+        if (cond instanceof PSModelGroupCondBase) {
+            // 获取子条件
+            const list = cond.getChildPSModelCondBases();
+            if (list == null || isEmpty(list)) {
+                return !cond.isNotMode();
+            }
+            // 是否为「AND」
+            const bAnd = "AND" /* 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;
+    }
+    createPSModelSingleCond() {
+        return new PSDEDQSingleCond();
+    }
+    createPSModelGroupCond() {
+        return new PSDEDQGroupCond();
+    }
+}
+/**
+ * 数据上下文
+ *
+ * @static
+ * @memberof PSDEDQCondEngine
+ */
+PSDEDQCondEngine.PARAMTYPE_DATACONTEXT = 'DATACONTEXT';
+/**
+ * 网页请求上下文
+ *
+ * @static
+ * @memberof PSDEDQCondEngine
+ */
+PSDEDQCondEngine.PARAMTYPE_WEBCONTEXT = 'WEBCONTEXT';

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

@@ -0,0 +1,14 @@
+/**
+ * 查询条件基类
+ *
+ * @export
+ * @abstract
+ * @class PSModelCondBase
+ */
+export declare abstract class PSModelCondBase {
+    private strCondOp;
+    getCondOp(): string;
+    setCondOp(strCondOp: string): void;
+    abstract parse(array: unknown[]): void;
+}
+//# sourceMappingURL=ps-model-cond-base.d.ts.map

package/out/service/utils/de-dq-cond/ps-model-cond-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps-model-cond-base.d.ts","sourceRoot":"","sources":["../../../../src/service/utils/de-dq-cond/ps-model-cond-base.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,8BAAsB,eAAe;IACnC,OAAO,CAAC,SAAS,CAAuB;IAExC,SAAS,IAAI,MAAM;IAInB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIlC,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI;CACvC"}

package/out/service/utils/de-dq-cond/ps-model-cond-base.js

@@ -0,0 +1,18 @@
+/**
+ * 查询条件基类
+ *
+ * @export
+ * @abstract
+ * @class PSModelCondBase
+ */
+export class PSModelCondBase {
+    constructor() {
+        this.strCondOp = null;
+    }
+    getCondOp() {
+        return this.strCondOp;
+    }
+    setCondOp(strCondOp) {
+        this.strCondOp = strCondOp;
+    }
+}

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

@@ -0,0 +1,63 @@
+import { PSModelGroupCondBase } from './ps-model-group-cond-base';
+import { PSModelSingleCondBase } from './ps-model-single-cond-base';
+/**
+ * 模型条件引擎辅助对象
+ *
+ * @export
+ * @abstract
+ * @class PSModelCondEngineBase
+ */
+export declare abstract class PSModelCondEngineBase {
+    /**
+     * 根分组条件
+     *
+     * @private
+     * @type {(PSModelGroupCondBase | null)}
+     * @memberof PSModelCondEngineBase
+     */
+    private psModelGroupCondBase;
+    /**
+     * 解析条件
+     *
+     * @param {IData[]} obj
+     * @memberof PSModelCondEngineBase
+     */
+    parse(obj: unknown[]): void;
+    /**
+     * 测试项
+     *
+     * @protected
+     * @param {string} strCondOp
+     * @param {*} objValue
+     * @param {*} objCondValue
+     * @return {*}  {boolean}
+     * @memberof PSModelCondEngineBase
+     */
+    protected testSingleCond(strCondOp: string, objValue: string | number, objCondValue: string | number): boolean;
+    /**
+     * 创建分组
+     *
+     * @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;
+}
+//# sourceMappingURL=ps-model-cond-engine-base.d.ts.map

package/out/service/utils/de-dq-cond/ps-model-cond-engine-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps-model-cond-engine-base.d.ts","sourceRoot":"","sources":["../../../../src/service/utils/de-dq-cond/ps-model-cond-engine-base.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEpE;;;;;;GAMG;AACH,8BAAsB,qBAAqB;IACzC;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB,CAAqC;IAEjE;;;;;OAKG;IACH,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI;IAS3B;;;;;;;;;OASG;IACH,SAAS,CAAC,cAAc,CACtB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,YAAY,EAAE,MAAM,GAAG,MAAM,GAC5B,OAAO;IA+EV;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,CAAC,sBAAsB,IAAI,oBAAoB;IAEjE;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,CAAC,uBAAuB,IAAI,qBAAqB;IAEnE;;;;;OAKG;IACH,uBAAuB,IAAI,oBAAoB;CAGhD"}

package/out/service/utils/de-dq-cond/ps-model-cond-engine-base.js

@@ -0,0 +1,119 @@
+/**
+ * 模型条件引擎辅助对象
+ *
+ * @export
+ * @abstract
+ * @class PSModelCondEngineBase
+ */
+export class PSModelCondEngineBase {
+    constructor() {
+        /**
+         * 根分组条件
+         *
+         * @private
+         * @type {(PSModelGroupCondBase | null)}
+         * @memberof PSModelCondEngineBase
+         */
+        this.psModelGroupCondBase = null;
+    }
+    /**
+     * 解析条件
+     *
+     * @param {IData[]} obj
+     * @memberof PSModelCondEngineBase
+     */
+    parse(obj) {
+        if (obj instanceof Array) {
+            const psModelGroupCondBase = this.createPSModelGroupCond();
+            psModelGroupCondBase.parse(obj);
+            this.psModelGroupCondBase = psModelGroupCondBase;
+        }
+    }
+    /**
+     * 测试项
+     *
+     * @protected
+     * @param {string} strCondOp
+     * @param {*} objValue
+     * @param {*} objCondValue
+     * @return {*}  {boolean}
+     * @memberof PSModelCondEngineBase
+     */
+    testSingleCond(strCondOp, objValue, objCondValue) {
+        try {
+            if ("ISNULL" /* CondType.CONDOP_ISNULL */ === strCondOp) {
+                return objValue == null;
+            }
+            if ("ISNOTNULL" /* CondType.CONDOP_ISNOTNULL */ === strCondOp) {
+                return objValue != null;
+            }
+            if ("EQ" /* CondType.CONDOP_EQ */ === strCondOp ||
+                "ABSEQ" /* CondType.CONDOP_ABSEQ */ === strCondOp ||
+                "GT" /* CondType.CONDOP_GT */ === strCondOp ||
+                "GTANDEQ" /* CondType.CONDOP_GTANDEQ */ === strCondOp ||
+                "LT" /* CondType.CONDOP_LT */ === strCondOp ||
+                "LTANDEQ" /* CondType.CONDOP_LTANDEQ */ === strCondOp ||
+                "NOTEQ" /* CondType.CONDOP_NOTEQ */ === strCondOp) {
+                // 大小比较
+                let nRet = -1;
+                // eslint-disable-next-line eqeqeq
+                if (objValue == objCondValue) {
+                    nRet = 0;
+                }
+                else if (objValue > objCondValue) {
+                    nRet = 1;
+                }
+                if ("EQ" /* CondType.CONDOP_EQ */ === strCondOp ||
+                    "ABSEQ" /* CondType.CONDOP_ABSEQ */ === strCondOp) {
+                    return nRet === 0;
+                }
+                if ("GT" /* CondType.CONDOP_GT */ === strCondOp) {
+                    return nRet > 0;
+                }
+                if ("GTANDEQ" /* CondType.CONDOP_GTANDEQ */ === strCondOp) {
+                    return nRet >= 0;
+                }
+                if ("LT" /* CondType.CONDOP_LT */ === strCondOp) {
+                    return nRet < 0;
+                }
+                if ("LTANDEQ" /* CondType.CONDOP_LTANDEQ */ === strCondOp) {
+                    return nRet <= 0;
+                }
+                if ("NOTEQ" /* CondType.CONDOP_NOTEQ */ === strCondOp) {
+                    return nRet !== 0;
+                }
+            }
+            if ("LIKE" /* CondType.CONDOP_LIKE */ === strCondOp) {
+                if (objValue != null && objCondValue != null) {
+                    return (objValue
+                        .toString()
+                        .toUpperCase()
+                        .indexOf(objCondValue.toString().toUpperCase()) !== -1);
+                }
+                return false;
+            }
+            if ("LEFTLIKE" /* 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;
+    }
+    /**
+     * 获取根分组条件
+     *
+     * @return {*}  {PSModelGroupCondBase}
+     * @memberof PSModelCondEngineBase
+     */
+    getPSModelGroupCondBase() {
+        return this.psModelGroupCondBase;
+    }
+}

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

@@ -0,0 +1,36 @@
+import { PSModelCondBase } from './ps-model-cond-base';
+/**
+ * 逻辑组
+ *
+ * @export
+ * @class PSModelGroupCondBase
+ * @extends {PSModelCondBase}
+ */
+export declare class PSModelGroupCondBase extends PSModelCondBase {
+    /**
+     * 子条件项
+     *
+     * @private
+     * @type {PSModelCondBase[]}
+     * @memberof PSModelGroupCondBase
+     */
+    private childCondList;
+    /**
+     * 是否取反
+     *
+     * @private
+     * @memberof PSModelGroupCondBase
+     */
+    private bNotMode;
+    /**
+     * 解析分组条件
+     *
+     * @param {unknown[]} arr
+     * @memberof PSModelGroupCondBase
+     */
+    parse(arr: unknown[]): void;
+    setNotMode(bNotMode: boolean): void;
+    isNotMode(): boolean;
+    getChildPSModelCondBases(): PSModelCondBase[];
+}
+//# sourceMappingURL=ps-model-group-cond-base.d.ts.map

package/out/service/utils/de-dq-cond/ps-model-group-cond-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps-model-group-cond-base.d.ts","sourceRoot":"","sources":["../../../../src/service/utils/de-dq-cond/ps-model-group-cond-base.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD;;;;;;GAMG;AACH,qBAAa,oBAAqB,SAAQ,eAAe;IACvD;;;;;;OAMG;IACH,OAAO,CAAC,aAAa,CAAyB;IAE9C;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;;;OAKG;IACH,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI;IA2D3B,UAAU,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI;IAInC,SAAS,IAAI,OAAO;IAIpB,wBAAwB,IAAI,eAAe,EAAE;CAG9C"}

package/out/service/utils/de-dq-cond/ps-model-group-cond-base.js

@@ -0,0 +1,101 @@
+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 {
+    constructor() {
+        super(...arguments);
+        /**
+         * 子条件项
+         *
+         * @private
+         * @type {PSModelCondBase[]}
+         * @memberof PSModelGroupCondBase
+         */
+        this.childCondList = [];
+        /**
+         * 是否取反
+         *
+         * @private
+         * @memberof PSModelGroupCondBase
+         */
+        this.bNotMode = false;
+    }
+    /**
+     * 解析分组条件
+     *
+     * @param {unknown[]} arr
+     * @memberof PSModelGroupCondBase
+     */
+    parse(arr) {
+        const nCount = 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);
+                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 = item[0].toString();
+                            if (strText === '!' ||
+                                "OR" /* CondType.GROUPOP_OR */ === strText ||
+                                "AND" /* CondType.GROUPOP_AND */ === strText) {
+                                const child = new PSModelGroupCondBase();
+                                child.parse(item);
+                                this.childCondList.push(child);
+                            }
+                            else {
+                                const child = new PSModelSingleCondBase();
+                                child.parse(item);
+                                this.childCondList.push(child);
+                            }
+                        }
+                    });
+                }
+                else {
+                    throw new Error('值必须为数组');
+                }
+            }
+        }
+    }
+    setNotMode(bNotMode) {
+        this.bNotMode = bNotMode;
+    }
+    isNotMode() {
+        return this.bNotMode;
+    }
+    getChildPSModelCondBases() {
+        return this.childCondList;
+    }
+}

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

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

package/out/service/utils/de-dq-cond/ps-model-group-cond.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps-model-group-cond.d.ts","sourceRoot":"","sources":["../../../../src/service/utils/de-dq-cond/ps-model-group-cond.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAElE;;;;;;;;GAQG;AACH,qBAAa,eAAgB,SAAQ,oBAAoB;CAAG"}

package/out/service/utils/de-dq-cond/ps-model-group-cond.js

@@ -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/out/service/utils/de-dq-cond/ps-model-single-cond-base.d.ts

@@ -0,0 +1,61 @@
+import { PSModelCondBase } from './ps-model-cond-base';
+/**
+ * 逻辑项
+ *
+ * @author chitanda
+ * @date 2022-08-17 23:08:20
+ * @export
+ * @class PSModelSingleCondBase
+ * @extends {PSModelCondBase}
+ */
+export declare class PSModelSingleCondBase extends PSModelCondBase {
+    /**
+     * 值
+     *
+     * @private
+     * @type {(string | null)}
+     * @memberof PSModelSingleCondBase
+     */
+    private strValue?;
+    /**
+     * 值类型
+     *
+     * @private
+     * @type {string}
+     * @memberof PSModelSingleCondBase
+     */
+    private strValueType?;
+    /**
+     * 参数
+     *
+     * @private
+     * @type {string}
+     * @memberof PSModelSingleCondBase
+     */
+    private strParam?;
+    /**
+     * 参数类型
+     *
+     * @private
+     * @type {string}
+     * @memberof PSModelSingleCondBase
+     */
+    private strParamType?;
+    /**
+     * 编译条件
+     *
+     * @author chitanda
+     * @date 2022-08-17 23:08:35
+     * @param {unknown[]} arr
+     */
+    parse(arr: unknown[]): void;
+    getValueType(): string;
+    setValueType(strValueType: string): void;
+    getValue(): string;
+    setValue(strValue: string): void;
+    getParamType(): string;
+    setParamType(strParamType: string): void;
+    getParam(): string;
+    setParam(strParam: string): void;
+}
+//# sourceMappingURL=ps-model-single-cond-base.d.ts.map

package/out/service/utils/de-dq-cond/ps-model-single-cond-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps-model-single-cond-base.d.ts","sourceRoot":"","sources":["../../../../src/service/utils/de-dq-cond/ps-model-single-cond-base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,SAAQ,eAAe;IACxD;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,CAAS;IAE1B;;;;;;OAMG;IACH,OAAO,CAAC,YAAY,CAAC,CAAS;IAE9B;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,CAAS;IAE1B;;;;;;OAMG;IACH,OAAO,CAAC,YAAY,CAAC,CAAS;IAE9B;;;;;;OAMG;IACH,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI;IA6C3B,YAAY,IAAI,MAAM;IAItB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAIxC,QAAQ,IAAI,MAAM;IAIlB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIhC,YAAY,IAAI,MAAM;IAItB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAIxC,QAAQ,IAAI,MAAM;IAIlB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAGjC"}

package/out/service/utils/de-dq-cond/ps-model-single-cond-base.js

@@ -0,0 +1,88 @@
+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 {
+    /**
+     * 编译条件
+     *
+     * @author chitanda
+     * @date 2022-08-17 23:08:35
+     * @param {unknown[]} arr
+     */
+    parse(arr) {
+        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);
+                bOpStart = false;
+                bParamStart = true;
+                continue;
+            }
+            // 设置参数标识
+            if (bParamStart) {
+                const strText = arr[i];
+                this.setParam(strText);
+                bParamStart = false;
+                bValueStart = true;
+                continue;
+            }
+            // 设置值
+            if (bValueStart) {
+                // 需要是对象
+                const obj = arr[i];
+                if (obj instanceof Object && !(obj instanceof Array)) {
+                    const data = obj;
+                    // 设置值类型
+                    if (data.type != null) {
+                        this.setValueType(data.type.toString());
+                    }
+                    // 设置条件值
+                    if (data.value != null) {
+                        this.setValue(data.value.toString());
+                    }
+                }
+                else {
+                    this.setValue(obj);
+                }
+                break;
+            }
+        }
+    }
+    getValueType() {
+        return this.strValueType;
+    }
+    setValueType(strValueType) {
+        this.strValueType = strValueType;
+    }
+    getValue() {
+        return this.strValue;
+    }
+    setValue(strValue) {
+        this.strValue = strValue;
+    }
+    getParamType() {
+        return this.strParamType;
+    }
+    setParamType(strParamType) {
+        this.strParamType = strParamType;
+    }
+    getParam() {
+        return this.strParam;
+    }
+    setParam(strParam) {
+        this.strParam = strParam;
+    }
+}

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

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

package/out/service/utils/de-dq-cond/ps-model-single-cond.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps-model-single-cond.d.ts","sourceRoot":"","sources":["../../../../src/service/utils/de-dq-cond/ps-model-single-cond.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEpE;;;;;;;;GAQG;AACH,qBAAa,gBAAiB,SAAQ,qBAAqB;CAAG"}