@bchr/bchr-front-lib 0.4.5 → 0.5.2

package/src/base/utils/LangTypes.js

@@ -0,0 +1,202 @@
+import moment from "moment";
+import Decimal from "decimal.js";
+import lodash from "lodash";
+
+const LangTypes = {
+
+    asStringValue(rawValue) {
+        if (rawValue === null || rawValue === void 0) {
+            return null;
+        }
+
+        if (lodash.isString(rawValue)) {
+            return rawValue.toString();
+        }
+        else if (lodash.isNumber(rawValue)) {
+            return rawValue.toString();
+        }
+        else if (lodash.isBoolean(rawValue)) {
+            return rawValue.toString();
+        }
+        else if (lodash.isDate(rawValue)) {
+            return moment(rawValue).format("YYYY-MM-DD HH:mm:ss");
+        }
+        else if (lodash.isFunction(rawValue.isValid) && lodash.isFunction(rawValue.toDate)) {
+            if (rawValue.isValid() === true) {
+                return moment(rawValue.toDate()).format("YYYY-MM-DD HH:mm:ss");
+            }
+        }
+        else if (lodash.isPlainObject(rawValue) && Object.prototype.hasOwnProperty.call(rawValue, "value")) {
+            return this.asStringValue(rawValue.value);
+        }
+
+        throw new Error("For type safe convert, " + rawValue + " cannot convert to String value.");
+    },
+
+    asBooleanValue(rawValue) {
+        if (rawValue === null || rawValue === void 0) {
+            return false;
+        }
+        else if (lodash.isBoolean(rawValue)) {
+            return rawValue;
+        }
+        else if (lodash.isString(rawValue)) {
+            let lowercaseValue = rawValue.toLowerCase();
+            return (lowercaseValue === "y"    || lowercaseValue === "yes"
+                 || lowercaseValue === "true" || lowercaseValue === "t"
+                 || lowercaseValue === "1"    || lowercaseValue === "是"
+                 || lowercaseValue === "ok"   || lowercaseValue === "on"
+                 );
+        }
+        else if (lodash.isNumber(rawValue)) {
+            return Boolean(rawValue)
+        }
+        else if (lodash.isPlainObject(rawValue) && Object.prototype.hasOwnProperty.call(rawValue, "value")) {
+            return this.asBooleanValue(rawValue.value);
+        }
+
+        throw new Error("For type safe convert, " + rawValue + " cannot convert to Boolean value.");
+
+    },
+
+    asNumberValue(rawValue) {
+        if (rawValue === null || rawValue === void 0) {
+            return 0;
+        }
+        else if (lodash.isNumber(rawValue)) {
+            return rawValue;
+        }
+        else if (lodash.isBoolean(rawValue)) {
+            return rawValue ? 1 : 0;
+        }
+        else if (lodash.isString(rawValue)) {
+            let _rawValue = rawValue.replaceAll(",", "").replaceAll(' ', '');
+            try {
+                let decimalValue = new Decimal(_rawValue);
+                return decimalValue.toNumber();
+            }
+            catch (e) {
+                // do nothing
+            }
+        }
+        else if (lodash.isDate(rawValue)) {
+            return rawValue.getTime();
+        }
+        else if (lodash.isFunction(rawValue.isValid) && lodash.isFunction(rawValue.toDate)) {
+            if (rawValue.isValid() === true) {
+                return rawValue.toDate().getTime();
+            }
+        }
+        else if (lodash.isPlainObject(rawValue) && Object.prototype.hasOwnProperty.call(rawValue, "value")) {
+            return this.asNumberValue(rawValue.value);
+        }
+
+        throw new Error("For type safe convert, " + rawValue + " cannot convert to Number value.");
+    },
+
+    asIntegerValue(rawValue) {
+        if (rawValue === null || rawValue === void 0) {
+            return 0;
+        }
+        else if (lodash.isInteger(rawValue)) {
+            return rawValue;
+        }
+        else if (lodash.isBoolean(rawValue)) {
+            return rawValue ? 1 : 0;
+        }
+        else if (lodash.isString(rawValue)) {
+            let _rawValue = rawValue.replaceAll(",", "").replaceAll(' ', '');
+            try {
+                let decimalValue = new Decimal(_rawValue);
+                if (decimalValue.isInteger()) {
+                    return decimalValue.toNumber();
+                }
+            }
+            catch (e) {
+                // do nothing
+            }
+        }
+        else if (lodash.isDate(rawValue)) {
+            return rawValue.getTime();
+        }
+        else if (lodash.isFunction(rawValue.isValid) && lodash.isFunction(rawValue.toDate)) {
+            if (rawValue.isValid() === true) {
+                return rawValue.toDate().getTime();
+            }
+        }
+        else if (lodash.isPlainObject(rawValue) && Object.prototype.hasOwnProperty.call(rawValue, "value")) {
+            return this.asIntegerValue(rawValue.value);
+        }
+
+        throw new Error("For type safe convert, " + rawValue + " cannot convert to Integer value.");
+    },
+
+    asDateValue(rawValue) {
+        if (rawValue === null || rawValue === void 0) {
+            return null;
+        }
+        else if (lodash.isInteger(rawValue)) {
+            return new Date(rawValue);
+        }
+        else if (lodash.isString(rawValue)) {
+            let day = moment(rawValue)
+            if (day.isValid()) {
+                return day.toDate();
+            }
+        }
+        else if (lodash.isDate(rawValue)) {
+            return rawValue;
+        }
+        else if (lodash.isFunction(rawValue.isValid) && lodash.isFunction(rawValue.toDate)) {
+            if (rawValue.isValid() === true) {
+                return rawValue.toDate();
+            }
+        }
+        else if (lodash.isPlainObject(rawValue) && Object.prototype.hasOwnProperty.call(rawValue, "value")) {
+            return this.asDateValue(rawValue.value);
+        }
+
+        throw new Error("For type safe convert, " + rawValue + " cannot convert to Date value.");
+    },
+
+    /**
+     * used for Framework model data type check
+     */
+    isBooleanType(typeExpression) {
+        return (typeExpression === Boolean || typeExpression?.toLowerCase() === "boolean" || typeExpression?.toLowerCase() === "bool");
+    },
+
+    /**
+     * used for Framework model data type check
+     */
+    isStringType(typeExpression) {
+        return (typeExpression === null || typeExpression === void 0
+            || typeExpression === String || typeExpression?.toLowerCase() === "string"
+            || typeExpression === ""
+        );
+    },
+
+    /**
+     * used for Framework model data type check
+     */
+    isDateType(typeExpression) {
+        return (typeExpression === Date || typeExpression?.toLowerCase() === "date");
+    },
+
+    /**
+     * used for Framework model data type check
+     */
+    isNumberType(typeExpression) {
+        return (typeExpression === Number || typeExpression?.toLowerCase() === "number");
+    },
+
+    /**
+     * used for Framework model data type check
+     */
+    isObjectType(typeExpression) {
+        return (typeExpression === Object || typeExpression?.toLowerCase() === "object");
+    }
+
+}
+
+export default LangTypes;

package/src/base/utils/Objects.js

@@ -0,0 +1,48 @@
+import lodash from "lodash";
+
+const genGetterAndReadonlySetter = function (plainObject) {
+
+    let retObject = {};
+
+    for (let attrName in plainObject) {
+        Object.defineProperty(retObject, attrName, {
+            get: function () {
+                return plainObject[attrName];
+            },
+            set: function (x) {
+                throw new Error("Cannot Set value for readonly attribute");
+            }
+        });
+    }
+
+    return retObject;
+}
+
+const isPromise = function(value){
+    return lodash.isObject(value) && lodash.isFunction(value.then) && lodash.isFunction(value.catch) && lodash.isFunction(value.finally);
+}
+
+const toStdPromise = function(thenableObject) {
+    if (lodash.isFunction(thenableObject.then)) {
+        return Promise.resolve(thenableObject);
+    }
+
+    throw new Error("Not thenable Object, cannot convert to Standard Promise.");
+}
+
+const clone = function(value) {
+    if (value === null || value === void 0) {
+        return null;
+    }
+
+    return lodash.cloneDeep(value);
+}
+
+const Objects = {
+    genGetterAndReadonlySetter,
+    clone,
+    isPromise,
+    toStdPromise
+}
+
+export default Objects

package/src/base/utils/Randoms.js

@@ -0,0 +1,142 @@
+import lodash from "lodash";
+import uuid from 'react-uuid';
+
+const NUMBERS  = "0123456789";
+const ALPHABETS= "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const LOWER_CASE_ALPHABETS= "abcdefghijklmnopqrstuvwxyz";
+const UPPER_CASE_ALPHABETS= "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const CHARS    = ALPHABETS + NUMBERS
+
+
+const Randoms = {
+
+    /**
+     * Gen the value between the min integer Value and max integer Value.
+     * when only supply one parameter, the parameter as the max Integer Value.
+     * @param minValue
+     * @param maxValue
+     * @returns {number}
+     */
+    randomInt: function(minValue, maxValue) {
+        let minIntegerValue = 0;
+        let maxIntegerValue = Number.MAX_SAFE_INTEGER;
+
+        if (lodash.isInteger(minValue) && lodash.isInteger(maxValue) && maxValue > minValue) {
+            minIntegerValue = minValue;
+            maxIntegerValue = maxValue;
+        }
+
+        if (lodash.isInteger(minValue) && arguments.length == 1) {
+            if (minValue > 0) {
+                minIntegerValue = 0;
+                maxIntegerValue = minValue;
+            }
+            else if (minValue < 0) {
+                minIntegerValue = minValue;
+                maxIntegerValue = 0;
+            }
+        }
+
+        return Math.floor(Math.random() * (maxIntegerValue - minIntegerValue + 1)) + minIntegerValue;
+    },
+
+    /**
+     * @param genStrLength
+     * @returns {string}
+     */
+    randomString: function(genStrLength) {
+        if (!lodash.isInteger(genStrLength)) {
+            throw new Error("Invalid string length for generate random String.");
+        }
+
+        let genString = "";
+        let charsArrayLength = CHARS.length;
+        for (let i = 0; i < genStrLength; i++) {
+            let number = this.randomInt(charsArrayLength - 1);
+            genString = genString + CHARS.charAt(number);
+        }
+        return genString;
+    },
+
+    randomAlphabets: function(genStrLength) {
+        if (!lodash.isInteger(genStrLength)) {
+            throw new Error("Invalid string length for generate random Alphabets.");
+        }
+
+        let genString = "";
+        let charsArrayLength = ALPHABETS.length;
+        for (let i = 0; i < genStrLength; i++) {
+            let number = this.randomInt(charsArrayLength - 1);
+            genString = genString + ALPHABETS.charAt(number);
+        }
+
+        return genString;
+    },
+
+    randomLowercaseAlphabets: function(genStrLength) {
+        if (!lodash.isInteger(genStrLength)) {
+            throw new Error("Invalid string length for generate random uppercase Alphabets.");
+        }
+
+        let genString = "";
+        let charsArrayLength = LOWER_CASE_ALPHABETS.length;
+        for (let i = 0; i < genStrLength; i++) {
+            let number = this.randomInt(charsArrayLength - 1);
+            genString = genString + LOWER_CASE_ALPHABETS.charAt(number);
+        }
+
+        return genString;
+    },
+
+    randomUppercaseAlphabets: function(genStrLength) {
+        if (!lodash.isInteger(genStrLength)) {
+            throw new Error("Invalid string length for generate random lowercase Alphabets.");
+        }
+
+        let genString = "";
+        let charsArrayLength = UPPER_CASE_ALPHABETS.length;
+        for (let i = 0; i < genStrLength; i++) {
+            let number = this.randomInt(charsArrayLength - 1);
+            genString = genString + UPPER_CASE_ALPHABETS.charAt(number);
+        }
+
+        return genString;
+    },
+
+    randomStringsIn: function(scopedStrings, genStrLength) {
+        if (!lodash.isString(scopedStrings) ) {
+            throw new Error("Invalid scopedStrings for generate random strings.");
+        }
+
+        if (scopedStrings.length < 1) {
+            throw new Error("Invalid scopedStrings for generate random strings.");
+        }
+
+        if (!lodash.isInteger(genStrLength)) {
+            throw new Error("Invalid string length for generate random lowercase Alphabets.");
+        }
+
+        let genString = "";
+        let charsArrayLength = scopedStrings.length;
+        for (let i = 0; i < genStrLength; i++) {
+            let number = this.randomInt(charsArrayLength - 1);
+            genString = genString + scopedStrings.charAt(number);
+        }
+
+        return genString;
+    },
+
+    uuid: function() {
+        return uuid();
+    }
+}
+
+export {
+    NUMBERS,
+    ALPHABETS,
+    LOWER_CASE_ALPHABETS,
+    UPPER_CASE_ALPHABETS,
+    CHARS
+}
+
+export default Randoms;

package/src/base/utils/Strings.js

@@ -0,0 +1,146 @@
+import lodash from "lodash";
+import LangTypes from "./LangTypes"
+
+const isWhitespace = function(c) {
+    if (c === null || c === void 0) {
+        return false;
+    }
+
+    let stringAfterTrim = c.trim();
+    return !(stringAfterTrim === c)
+}
+
+const Strings = {
+    isBlankString(value) {
+        if (value === null || value === void 0) {
+            return true;
+        }
+
+        if (lodash.isString(value)) {
+            for (let i = 0, len = value.length; i < len; i++) {
+                let str = value.charAt(i);
+                if (!isWhitespace(str)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        return false;
+    },
+
+    isNotBlankString(value) {
+        if (value === null || value === void 0) {
+            return false;
+        }
+
+        if (lodash.isString(value)) {
+            return !this.isBlankString(value);
+        }
+
+        return false;
+    },
+
+    removeBlankStrings(value) {
+        if (value === null || value === void 0) {
+            return null;
+        }
+
+        if (!lodash.isString(value)) {
+            throw new Error("Invalid value [" + value + "] for Strings#removeBlankStrings");
+        }
+
+        let lastString = "";
+        for (let i = 0, len = value.length; i < len; i++) {
+            let str = value.charAt(i);
+            if (!isWhitespace(str)) {
+                lastString = lastString + str;
+            }
+        }
+
+        return lastString;
+    },
+
+    isEmail(value) {
+        if (!lodash.isString(value)) {
+            return false;
+        }
+
+        return new RegExp(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|.(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/)
+            .test(value);
+    },
+
+    /**
+     * 检测密码强度
+     * @param password {string}
+     *      密码
+     * @param minLength
+     *      最小长度 默认8位，最小4位;
+     * @returns
+     *      强度等级: [0,1,2,3,4]
+     */
+    checkPasswordStrength(password, minLength = 8) {
+        let level = 0;
+
+        if (password === null || password === void 0) {
+            return level;
+        }
+
+        if (minLength < 4) {
+            minLength = 4;
+        }
+
+        let _password = LangTypes.asStringValue(password);
+
+        if (_password.length < minLength) {
+            return level
+        }
+
+        if (/[0-9]/.test(_password)) {
+            level++
+        }
+
+        if (/[a-z]/.test(_password)) {
+            level++
+        }
+
+        if (/[A-Z]/.test(_password)) {
+            level++
+        }
+
+        if (/\W/.test(_password)) {
+            level++
+        }
+
+        return level
+    },
+
+    isUppercase(str) {
+        if (str === null || str === void 0) {
+            return false;
+        }
+
+        if (lodash.isString(str)) {
+            return str === str.toUpperCase();
+        }
+
+        return false;
+    },
+
+    isLowercase(str) {
+        if (str === null || str === void 0) {
+            return false;
+        }
+
+        if (lodash.isString(str)) {
+            return str === str.toLowerCase();
+        }
+
+        return false;
+
+    },
+}
+
+
+
+export default Strings;

package/src/base/utils/TreeDataUtils.js

@@ -0,0 +1,128 @@
+import {Values} from "./index";
+
+const convertList2TreeNodeList = function (list, parent_pk) {
+    let nodes = [];
+    if (!list || list.length < 1) {
+        return nodes;
+    }
+
+    let trees = list.filter(item => item.parent_pk === parent_pk);
+    if (!trees || trees.length < 1) {
+        return nodes;
+    }
+
+    for (let i = 0; i < trees.length; i++) {
+        let tree = trees[i];
+        let children = convertList2TreeNodeList(list, tree.pk);
+        let node = {
+            ...tree,
+            children: [],
+            label: tree.name,
+            value: tree.pk,
+            key: "" + tree.pk,
+            option: tree
+        };
+
+        if (tree.renderLabel && typeof tree.renderLabel === 'function') {
+            node.label = tree.renderLabel(tree.name, tree);
+        }
+
+        if (!children || children.length < 1) {
+            nodes.push(node);
+        } else {
+            node.children = children;
+            nodes.push(node)
+        }
+    }
+
+    return nodes;
+}
+
+const convertTreeNode2List = function (list, treeItem, treeIndex, treeList) {
+    if (treeList[treeIndex] && Values.isNotEmptyArray(treeList[treeIndex].children)) {
+        convertTreeNode2List(list, treeList[treeIndex].children[0], 0, treeList[treeIndex].children);
+    }
+    let bHasChildItem = list.findIndex(item => treeItem && item.pk === treeItem.pk);
+    if (bHasChildItem === -1) {
+        list.push({...treeItem});
+    }
+    if (treeIndex === treeList.length - 1) {
+    } else {
+        treeIndex++;
+        convertTreeNode2List(list, treeList[treeIndex], treeIndex, treeList);
+    }
+}
+
+const setTreeNodeSelectedByPk = function(treeViewData, treeNodePKAttrName, pkValue) {
+    if (!treeViewData || treeViewData.length == 0) {
+        return;
+    }
+
+    for (let treeNodeItem of treeViewData) {
+        if (treeNodeItem[treeNodePKAttrName] == pkValue) {
+            treeNodeItem.selected = true;
+        }
+        else {
+            treeNodeItem.selected = false;
+        }
+
+        if (treeNodeItem.children && treeNodeItem.children.length > 0)
+        {
+            setTreeNodeSelectedByPk(treeNodeItem.children, treeNodePKAttrName, pkValue);
+        }
+    }
+}
+
+const convertList2GroupList = (list, iskey, isCodeKey) => {
+    let moth = [],
+        flag = 0;
+
+    let item = {
+        title: '',
+        children: ''
+    };
+
+    for (let i = 0; i < list.length; i++) {
+        let az = '';
+        for (let j = 0; j < moth.length; j++) {
+            if (moth[j].title_code === list[i][iskey]) {
+                flag = 1;
+                az = j;
+                break;
+            }
+        }
+        if (flag === 1) {
+            let ab = moth[az];
+            ab.children.push(list[i]);
+            flag = 0;
+
+        } else if (flag === 0 && list[i][iskey] !== null) {
+            item = {};
+            item.key = i + 1;
+            item.extra_code = list[i][isCodeKey];
+            item.title_code = list[i][iskey];
+            item.title = list[i][iskey];
+            item.children = [];
+            item.children.push(list[i]);
+            moth.push(item);
+        } else if (flag === 0 && (!list[i][iskey] || list[i][iskey] === null)) {
+            item = {};
+            item.key = i + 1;
+            item.extra_code = list[i][isCodeKey];
+            item.title_code = null;
+            item.title = "其他";
+            item.children = [];
+            item.children.push(list[i]);
+            moth.push(item);
+        }
+    }
+
+    return moth;
+};
+
+export {
+    convertList2TreeNodeList,
+    convertTreeNode2List,
+    convertList2GroupList,
+    setTreeNodeSelectedByPk
+}