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

package/out/service/utils/ibiz-verify/ibiz-verify.js

@@ -0,0 +1,653 @@
+import { isNilOrEmpty, notNilEmpty } from 'qx-util';
+import { isEmpty, isNil } from 'ramda';
+/**
+ * 校验对象
+ *
+ * @author chitanda
+ * @date 2022-09-08 10:09:16
+ * @export
+ * @class IBizVerify
+ */
+export class IBizVerify {
+    /**
+     * 校验属性值规则
+     *
+     * @param {string} name 校验属性值所在字段的名称
+     * @param {*} data 数据对象
+     * @param {*} condition 规则条件
+     * @returns {{ isPast: boolean, infoMessage: string }}
+     * @memberof Verify
+     */
+    static verifyDeRules(name, data, condition) {
+        var _a;
+        const flag = { isPast: true, infoMessage: condition.ruleInfo };
+        if (condition.condType === 'GROUP') {
+            const childRules = condition.getPSDEFVRConditions();
+            if ((childRules === null || childRules === void 0 ? void 0 : childRules.length) > 0) {
+                flag.isPast = this.logicForEach(childRules, (item) => {
+                    const { isPast, infoMessage } = this.verifyDeRules(name, data, item);
+                    // 每次都把分组的结果信息改为该条件的信息，短路后是最后一个条件的信息
+                    flag.infoMessage = infoMessage;
+                    return isPast;
+                }, condition.condOp, !!condition.notMode);
+                // 分组结果为false时，如果是AND分组且取反，或是OR分组未取反，提示分组信息
+                if (!flag.isPast &&
+                    ((condition.condOp === 'AND' && condition.notMode) ||
+                        (condition.condOp === 'OR' && !condition.notMode))) {
+                    flag.infoMessage = condition.ruleInfo;
+                }
+            }
+        }
+        else {
+            name = condition === null || condition === void 0 ? void 0 : condition.dEFName.toLowerCase();
+            try {
+                // 常规规则
+                if (condition.condType === 'SIMPLE') {
+                    flag.isPast = !this.checkFieldSimpleRule(data[name], condition.condOp, condition.paramValue, condition.ruleInfo, condition.paramType, data, condition.isKeyCond);
+                    // 数值范围
+                }
+                else if (condition.condType === 'VALUERANGE2') {
+                    flag.isPast = !this.checkFieldValueRangeRule(data[name], condition.minValue, condition.includeMinValue, condition.maxValue, condition.includeMaxValue, condition.ruleInfo, condition.isKeyCond);
+                    // 正则式
+                }
+                else if (condition.condType === 'REGEX') {
+                    flag.isPast = !this.checkFieldRegExRule(data[name], condition.regExCode, condition.ruleInfo, condition.isKeyCond);
+                    // 长度
+                }
+                else if (condition.condType === 'STRINGLENGTH') {
+                    flag.isPast = !this.checkFieldStringLengthRule(data[name], condition.minValue, condition.includeMinValue, condition.maxValue, condition.includeMaxValue, condition.ruleInfo, condition.isKeyCond);
+                    // 系统值规则
+                }
+                else if (condition.condType === 'SYSVALUERULE' &&
+                    ((_a = condition === null || condition === void 0 ? void 0 : condition.getPSSysValueRule) === null || _a === void 0 ? void 0 : _a.call(condition))) {
+                    const { ruleType, regExCode, scriptCode, ruleInfo } = condition.getPSSysValueRule();
+                    flag.infoMessage = condition.ruleInfo || ruleInfo;
+                    if (ruleType === 'REG') {
+                        flag.isPast = !this.checkFieldRegExRule(data[name], regExCode, flag.infoMessage, condition.isKeyCond);
+                    }
+                    else if (ruleType === 'SCRIPT') {
+                        const { isPast, infoMessage } = this.checkFieldScriptRule(data[name], data, scriptCode, flag.infoMessage, condition.isKeyCond);
+                        flag.isPast = isPast;
+                        flag.infoMessage = infoMessage || flag.infoMessage;
+                    }
+                }
+            }
+            catch (error) {
+                flag.isPast = false;
+            }
+            // 取反
+            flag.isPast = condition.notMode ? !flag.isPast : flag.isPast;
+        }
+        return flag;
+    }
+    /**
+     * 遍历数据并进行逻辑判断，支持&&和||，支持短路
+     *
+     * @param {any[]} array 数组
+     * @param {Function} callback 回调函数
+     * @param {string} [operateTag='AND'] 与或操作标识,支持AND、OR
+     * @param {boolean} [isReverse=false] 是否取反
+     * @returns {boolean}
+     * @memberof Verify
+     */
+    static logicForEach(array, callback, operateTag = 'AND', isReverse = false) {
+        if (!((array === null || array === void 0 ? void 0 : array.length) > 0)) {
+            return false;
+        }
+        let result = operateTag === 'AND';
+        for (let i = 0, len = array.length; i < len; i++) {
+            const temp = callback(array[i], i);
+            if (operateTag === 'AND') {
+                if (!temp) {
+                    result = false;
+                    break;
+                }
+            }
+            else if (operateTag === 'OR') {
+                if (temp) {
+                    result = true;
+                    break;
+                }
+            }
+        }
+        return isReverse ? !result : result;
+    }
+    /**
+     * 校验逻辑分组结果
+     *
+     * @param {*} data 数据对象
+     * @param {*} logic 逻辑分组对象
+     * @returns
+     */
+    static verifyGroupLogic(data, logic) {
+        var _a;
+        if (logic.logicType === 'GROUP' && ((_a = logic.getPSDEFDLogics()) === null || _a === void 0 ? void 0 : _a.length)) {
+            let result = true;
+            if (logic.groupOP === 'AND') {
+                const falseItem = logic
+                    .getPSDEFDLogics()
+                    .find((childLogic) => {
+                    return !this.verifyGroupLogic(data, childLogic);
+                });
+                result = falseItem === undefined;
+            }
+            else if (logic.groupOP === 'OR') {
+                const trueItem = logic
+                    .getPSDEFDLogics()
+                    .find((childLogic) => {
+                    return this.verifyGroupLogic(data, childLogic);
+                });
+                result = trueItem !== undefined;
+            }
+            // 是否取反
+            return logic.notMode ? !result : result;
+        }
+        if (logic.logicType === 'SINGLE') {
+            const singleLogic = logic;
+            return this.testCond(data[singleLogic.dEFDName.toLowerCase()], singleLogic.condOP, singleLogic.value);
+        }
+        return false;
+    }
+    /**
+     * 值比较
+     *
+     * @static
+     * @param {*} value
+     * @param {*} value2
+     * @returns {number}
+     * @memberof Verify
+     */
+    static compare(value, value2) {
+        let result;
+        if (!Object.is(value, '') &&
+            !Object.is(value2, '') &&
+            !isNaN(value) &&
+            !isNaN(value2)) {
+            result = this.compareNumber(parseFloat(value), parseFloat(value2));
+        }
+        else if (this.isParseDate(value) && this.isParseDate(value2)) {
+            result = this.compareDate(new Date(value).getTime(), new Date(value2).getTime());
+        }
+        else if (value &&
+            (typeof value === 'boolean' || value instanceof Boolean)) {
+            result = this.compareBoolean(value, value2);
+        }
+        else if (value &&
+            (typeof value === 'string' || value instanceof String)) {
+            result = this.compareString(value, value2);
+        }
+        return result;
+    }
+    /**
+     * 字符串比较
+     *
+     * @static
+     * @param {*} value
+     * @param {*} value2
+     * @returns {number}
+     * @memberof Verify
+     */
+    static compareString(value, value2) {
+        return value.localeCompare(value2);
+    }
+    /**
+     * boolean 值比较
+     *
+     * @static
+     * @param {*} value
+     * @param {*} value2
+     * @returns {number}
+     * @memberof Verify
+     */
+    static compareBoolean(value, value2) {
+        if (value === value2) {
+            return 0;
+        }
+        return -1;
+    }
+    /**
+     * 时间值比较（毫秒数）
+     *
+     * @static
+     * @param {number} value
+     * @param {number} value2
+     * @returns {number}
+     * @memberof Verify
+     */
+    static compareDate(value, value2) {
+        if (value > value2) {
+            return 1;
+        }
+        if (value < value2) {
+            return -1;
+        }
+        return 0;
+    }
+    /**
+     * 是否是时间
+     *
+     * @static
+     * @param {string} value
+     * @returns {boolean}
+     * @memberof Verify
+     */
+    static isParseDate(value) {
+        const time = new Date(value);
+        if (isNaN(time.getTime())) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * 数值比较
+     *
+     * @static
+     * @param {number} value
+     * @param {number} value2
+     * @returns {number}
+     * @memberof Verify
+     */
+    static compareNumber(value, value2) {
+        if (isNaN(value)) {
+            value = 0;
+        }
+        if (isNaN(value2)) {
+            value2 = 0;
+        }
+        if (value > value2) {
+            return 1;
+        }
+        if (value < value2) {
+            return -1;
+        }
+        return 0;
+    }
+    /**
+     * 文本包含
+     *
+     * @static
+     * @param {*} value
+     * @param {*} value2
+     * @returns {boolean}
+     * @memberof Verify
+     */
+    static contains(value, value2) {
+        if (value && value2) {
+            // 定义一数组
+            const arr = value2.split(',');
+            // 定义正则表达式的连接符
+            const S = String.fromCharCode(2);
+            const reg = new RegExp(S + value + S);
+            return reg.test(S + arr.join(S) + S);
+        }
+        return false;
+    }
+    /**
+     * 比较值
+     *
+     * @static
+     * @param {*} value
+     * @param {*} op
+     * @param {*} value2
+     * @returns {boolean}
+     * @memberof Verify
+     */
+    static testCond(value, op, value2) {
+        // 等于操作
+        if (Object.is(op, 'EQ')) {
+            const _value = `${value}`;
+            return _value === value2;
+        }
+        // 大于操作
+        if (Object.is(op, 'GT')) {
+            const result = this.compare(value, value2);
+            if (result != null && result > 0) {
+                return true;
+            }
+            return false;
+        }
+        // 大于等于操作
+        if (Object.is(op, 'GTANDEQ')) {
+            const result = this.compare(value, value2);
+            if (result != null && result >= 0) {
+                return true;
+            }
+            return false;
+        }
+        // 值包含在给定的范围中
+        if (Object.is(op, 'IN')) {
+            return this.contains(value, value2);
+        }
+        // 不为空判断操作
+        if (Object.is(op, 'ISNOTNULL')) {
+            return notNilEmpty(value);
+        }
+        // 为空判断操作
+        if (Object.is(op, 'ISNULL')) {
+            return isNilOrEmpty(value);
+        }
+        // 文本左包含
+        if (Object.is(op, 'LEFTLIKE')) {
+            return (value &&
+                value2 &&
+                value.toUpperCase().indexOf(value2.toUpperCase()) === 0);
+        }
+        // 文本包含
+        if (Object.is(op, 'LIKE')) {
+            return (value &&
+                value2 &&
+                value.toUpperCase().indexOf(value2.toUpperCase()) !== -1);
+        }
+        // 小于操作
+        if (Object.is(op, 'LT')) {
+            const result = this.compare(value, value2);
+            if (result != null && result < 0) {
+                return true;
+            }
+            return false;
+        }
+        // 小于等于操作
+        if (Object.is(op, 'LTANDEQ')) {
+            const result = this.compare(value, value2);
+            if (result != null && result <= 0) {
+                return true;
+            }
+            return false;
+        }
+        // 不等于操作
+        if (Object.is(op, 'NOTEQ')) {
+            const _value = `${value}`;
+            return _value !== value2;
+        }
+        // 值不包含在给定的范围中
+        if (Object.is(op, 'NOTIN')) {
+            return !this.contains(value, value2);
+        }
+        // 文本右包含
+        if (Object.is(op, 'RIGHTLIKE')) {
+            if (!(value && value2)) {
+                return false;
+            }
+            const nPos = value.toUpperCase().indexOf(value2.toUpperCase());
+            if (nPos === -1) {
+                return false;
+            }
+            return nPos + value2.length === value.length;
+        }
+        // 空判断
+        if (Object.is(op, 'TESTNULL')) {
+            // 未实现
+        }
+        // 自定义包含
+        if (Object.is(op, 'USERLIKE')) {
+            // 未实现
+        }
+        return false;
+    }
+    /**
+     * 检查属性常规条件
+     *
+     * @static
+     * @param {*} value 属性值
+     * @param {string} op 检测条件
+     * @param {*} value2 预定义值
+     * @param {string} errorInfo 错误信息
+     * @param {string} paramType 参数类型
+     * @param {*} form 表单对象
+     * @param {boolean} primaryModel 是否必须条件
+     * @returns {boolean}
+     * @memberof Verify
+     */
+    static checkFieldSimpleRule(value, op, value2, errorInfo, paramType, form, primaryModel) {
+        if (Object.is(paramType, 'CURTIME')) {
+            value2 = `${new Date()}`;
+        }
+        if (Object.is(paramType, 'ENTITYFIELD')) {
+            value2 = value2 ? value2.toLowerCase() : '';
+            const _value2Field = form[value2] ? form[value2] : value2;
+            value2 = _value2Field;
+        }
+        if (isNil(errorInfo) || isEmpty(errorInfo)) {
+            errorInfo = '内容必须符合值规则';
+        }
+        const result = this.testCond(value, op, value2);
+        if (!result) {
+            if (primaryModel) {
+                throw new Error(errorInfo);
+            }
+        }
+        return !result;
+    }
+    /**
+     * 检查属性字符长度规则
+     *
+     * @static
+     * @param {*} viewValue
+     * @param {number} minLength
+     * @param {boolean} indexOfMin
+     * @param {number} maxLength
+     * @param {boolean} indexOfMax
+     * @param {string} errorInfo
+     * @param {boolean} primaryModel
+     * @returns {boolean}
+     * @memberof Verify
+     */
+    static checkFieldStringLengthRule(viewValue, minLength, indexOfMin, maxLength, indexOfMax, errorInfo, primaryModel) {
+        if (isNilOrEmpty(errorInfo)) {
+            errorInfo = '内容长度必须符合范围规则';
+        }
+        const judge = isNilOrEmpty(viewValue);
+        if (judge) {
+            if (primaryModel) {
+                throw new Error('值为空');
+            }
+            errorInfo = '值为空';
+            return true;
+        }
+        const viewValueLength = viewValue.length;
+        // 小于等于
+        if (minLength !== null) {
+            if (indexOfMin) {
+                if (viewValueLength < minLength) {
+                    if (primaryModel) {
+                        throw new Error(errorInfo);
+                    }
+                    return true;
+                }
+            }
+            else if (viewValueLength <= minLength) {
+                if (primaryModel) {
+                    throw new Error(errorInfo);
+                }
+                return true;
+            }
+        }
+        //  大于等于
+        if (maxLength !== null) {
+            if (indexOfMax) {
+                if (viewValueLength > maxLength) {
+                    if (primaryModel) {
+                        throw new Error(errorInfo);
+                    }
+                    return true;
+                }
+            }
+            else if (viewValueLength >= maxLength) {
+                if (primaryModel) {
+                    throw new Error(errorInfo);
+                }
+                return true;
+            }
+        }
+        errorInfo = '';
+        return false;
+    }
+    /**
+     * 检查属性值正则式规则
+     *
+     * @static
+     * @param {string} viewValue 属性值
+     * @param {*} strReg 验证正则
+     * @param {string} errorInfo 错误信息
+     * @param {boolean} primaryModel 是否关键条件
+     * @returns {boolean}
+     * @memberof Verify
+     */
+    static checkFieldRegExRule(viewValue, strReg, errorInfo, primaryModel) {
+        if (isNilOrEmpty(errorInfo)) {
+            errorInfo = '值必须符合正则规则';
+        }
+        const judge = isNilOrEmpty(viewValue);
+        if (judge) {
+            if (primaryModel) {
+                throw new Error('值为空');
+            }
+            errorInfo = '值为空';
+            return true;
+        }
+        const regExp = new RegExp(strReg);
+        if (!regExp.test(viewValue)) {
+            if (primaryModel) {
+                throw new Error(errorInfo);
+            }
+            return true;
+        }
+        errorInfo = '';
+        return false;
+    }
+    /**
+     * 检查属性值范围规则
+     *
+     * @static
+     * @param {string} viewValue 属性值
+     * @param {*} minNumber 最小数值
+     * @param {boolean} indexOfMin 是否包含最小数值
+     * @param {*} maxNumber 最大数值
+     * @param {boolean} indexOfMax 是否包含最大数值
+     * @param {string} errorInfo 错误信息
+     * @param {boolean} primaryModel 是否关键条件
+     * @returns {boolean}
+     * @memberof Verify
+     */
+    static checkFieldValueRangeRule(viewValue, minNumber, indexOfMin, maxNumber, indexOfMax, errorInfo, primaryModel) {
+        if (isNilOrEmpty(errorInfo)) {
+            errorInfo = '值必须符合值范围规则';
+        }
+        const isEmptyVal = isNilOrEmpty(viewValue);
+        if (isEmptyVal) {
+            if (primaryModel) {
+                throw new Error('值为空');
+            }
+            errorInfo = '值为空';
+            return true;
+        }
+        const valueFormat = this.checkFieldRegExRule(viewValue, /^-?\d*\.?\d+$/, '', primaryModel);
+        if (valueFormat) {
+            return true;
+        }
+        const data = Number.parseFloat(viewValue);
+        // 小于等于
+        if (minNumber !== null) {
+            if (indexOfMin) {
+                if (data < minNumber) {
+                    if (primaryModel) {
+                        throw new Error(errorInfo);
+                    }
+                    return true;
+                }
+            }
+            else if (data <= minNumber) {
+                if (primaryModel) {
+                    throw new Error(errorInfo);
+                }
+                return true;
+            }
+        }
+        // //大于等于
+        if (maxNumber != null) {
+            if (indexOfMax) {
+                if (data > maxNumber) {
+                    if (primaryModel) {
+                        throw new Error(errorInfo);
+                    }
+                    return true;
+                }
+            }
+            else if (data >= maxNumber) {
+                if (primaryModel) {
+                    throw new Error(errorInfo);
+                }
+                return true;
+            }
+        }
+        errorInfo = '';
+        return false;
+    }
+    /**
+     * 检查属性值系统值范围规则  暂时支持正则表达式
+     *
+     * @static
+     * @param {string} viewValue 属性值
+     * @param {*} strReg 正则
+     * @param {string} errorInfo  错误信息
+     * @param {boolean} primaryModel 是否关键条件
+     * @returns {boolean}
+     * @memberof Verify
+     */
+    static checkFieldSysValueRule(viewValue, strReg, errorInfo, primaryModel) {
+        return this.checkFieldRegExRule(viewValue, strReg, errorInfo, primaryModel);
+    }
+    /**
+     * 检查脚本值规则
+     *
+     * @static
+     * @param {string} value 属性值
+     * @param {*} data 数据对象
+     * @param {*} scriptCode 脚本内容
+     * @param {string} errorInfo 错误信息
+     * @param {boolean} primaryModel 是否关键条件
+     * @returns {boolean}
+     * @memberof Verify
+     */
+    static checkFieldScriptRule(value, data, scriptCode, errorInfo, primaryModel) {
+        if (isNilOrEmpty(errorInfo)) {
+            errorInfo = '值必须符合脚本规则';
+        }
+        // 脚本准备参数
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const source = data;
+        let selfError = '';
+        let resultBoolean = true;
+        // 脚本回调
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const callback = (error) => {
+            resultBoolean = false;
+            // 脚本回调多个错误信息
+            if ((error === null || error === void 0 ? void 0 : error.length) > 0) {
+                error.forEach((item) => {
+                    if (item === null || item === void 0 ? void 0 : item.message) {
+                        selfError += item.message;
+                    }
+                });
+                // 脚本回调单个错误信息
+            }
+            else if (error === null || error === void 0 ? void 0 : error.message) {
+                selfError = error.message;
+            }
+        };
+        try {
+            // 避免脚本内变量冲突
+            // eslint-disable-next-line no-eval
+            const runScript = () => eval(scriptCode);
+            runScript();
+        }
+        catch (error) {
+            console.error(error);
+        }
+        errorInfo = '';
+        if (!resultBoolean && primaryModel) {
+            throw new Error(errorInfo);
+        }
+        return { isPast: resultBoolean, infoMessage: selfError || errorInfo };
+    }
+}

package/out/service/utils/index.d.ts

@@ -0,0 +1,10 @@
+export { AppCounter } from './app-counter/app-counter';
+export * from './de-dq-cond';
+export { DEDQCondUtil } from './de-dq-cond-util/de-dq-cond-util';
+export { DynamicCodeListCache } from './dynamic-code-list/dynamic-code-list';
+export { EntityCache } from './entity-cache/entity-cache';
+export { SearchFilter } from './search-filter/search-filter';
+export { ServicePathDeep, ServicePathItem, ServicePathUtil, } from './service-path-util/service-path-util';
+export { IBizVerify } from './ibiz-verify/ibiz-verify';
+export * from './res-path/res-path';
+//# sourceMappingURL=index.d.ts.map

package/out/service/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/service/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EACL,eAAe,EACf,eAAe,EACf,eAAe,GAChB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,cAAc,qBAAqB,CAAC"}

package/out/service/utils/index.js

@@ -0,0 +1,9 @@
+export { AppCounter } from './app-counter/app-counter';
+export * from './de-dq-cond';
+export { DEDQCondUtil } from './de-dq-cond-util/de-dq-cond-util';
+export { DynamicCodeListCache } from './dynamic-code-list/dynamic-code-list';
+export { EntityCache } from './entity-cache/entity-cache';
+export { SearchFilter } from './search-filter/search-filter';
+export { ServicePathUtil, } from './service-path-util/service-path-util';
+export { IBizVerify } from './ibiz-verify/ibiz-verify';
+export * from './res-path/res-path';

package/out/service/utils/res-path/res-path.d.ts

@@ -0,0 +1,13 @@
+import { ServicePathItem } from '../service-path-util/service-path-util';
+/**
+ * 计算资源路径url
+ *
+ * @author lxm
+ * @date 2022-11-25 13:11:53
+ * @export
+ * @param {IContext} context 上下文对象
+ * @param {ServicePathItem[][]} pathItems 计算出的资源关系路径
+ * @returns {*}  {string}
+ */
+export declare function calcResPath(context: IContext, pathItems: ServicePathItem[][]): string;
+//# sourceMappingURL=res-path.d.ts.map

package/out/service/utils/res-path/res-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"res-path.d.ts","sourceRoot":"","sources":["../../../../src/service/utils/res-path/res-path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAEzE;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,eAAe,EAAE,EAAE,GAC7B,MAAM,CAuBR"}