@bchr/bchr-front-lib 0.4.5 → 0.5.2

package/src/base/utils/CNKits.js

@@ -0,0 +1,236 @@
+const CNKits = {
+
+    /**
+     * 是否有效的中国大陆身份证号码(含澳门)
+     */
+    isCNMainLandIDCardNo(strOfIDCardNo) {
+        const provincesAndCities = [
+            '11', // 北京
+            '12', // 天津
+            '13', // 河北
+            '14', // 山西
+            '15', // 内蒙古
+            '21', // 辽宁
+            '22', // 吉林
+            '23', // 黑龙江
+            '31', // 上海
+            '32', // 江苏
+            '33', // 浙江
+            '34', // 安徽
+            '35', // 福建
+            '36', // 江西
+            '37', // 山东
+            '41', // 河南
+            '42', // 湖北
+            '43', // 湖南
+            '44', // 广东
+            '45', // 广西
+            '46', // 海南
+            '50', // 重庆
+            '51', // 四川
+            '52', // 贵州
+            '53', // 云南
+            '54', // 西藏
+            '61', // 陕西
+            '62', // 甘肃
+            '63', // 青海
+            '64', // 宁夏
+            '65', // 新疆
+            '71', // 台湾
+            '81', // 香港
+            '82', // 澳门
+            '91', // 国外
+        ];
+
+        const powers = ['7', '9', '10', '5', '8', '4', '2', '1', '6', '3', '7', '9', '10', '5', '8', '4', '2'];
+
+        const parityBit = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];
+
+        const checkAddressCode = addressCode => provincesAndCities.includes(addressCode);
+
+        const checkBirthDayCode = (birDayCode) => {
+            const yyyy = parseInt(birDayCode.substring(0, 4), 10);
+            const mm = parseInt(birDayCode.substring(4, 6), 10);
+            const dd = parseInt(birDayCode.substring(6), 10);
+            const xdata = new Date(yyyy, mm - 1, dd);
+            if (xdata > new Date()) {
+                return false;
+                // eslint-disable-next-line max-len
+            } else if ((xdata.getFullYear() === yyyy) && (xdata.getMonth() === mm - 1) && (xdata.getDate() === dd)) {
+                return true;
+            }
+            return false;
+        };
+
+        const getParityBit = (idCardNo) => {
+            let id17 = idCardNo.substring(0, 17);
+
+            let power = 0;
+            for (let i = 0; i < 17; i++) {
+                power += parseInt(id17.charAt(i), 10) * parseInt(powers[i], 10);
+            }
+
+            let mod = power % 11;
+            return parityBit[mod];
+        };
+
+        const checkParityBit = idCardNo => getParityBit(idCardNo) === idCardNo.charAt(17).toUpperCase();
+
+
+        const check15IdCardNo = (idCardNo) => {
+            let check = /^[1-9]\d{7}((0[1-9])|(1[0-2]))((0[1-9])|([1-2][0-9])|(3[0-1]))\d{3}$/.test(idCardNo);
+            if (!check) return false;
+            let addressCode = idCardNo.substring(0, 2);
+            check = checkAddressCode(addressCode);
+            if (!check) return false;
+            let birDayCode = `19${idCardNo.substring(6, 12)}`;
+            check = checkBirthDayCode(birDayCode);
+            if (!check) return false;
+            return true;
+        };
+
+        const check18IdCardNo = (idCardNo) => {
+            let check = /^[1-9]\d{5}[1-9]\d{3}((0[1-9])|(1[0-2]))((0[1-9])|([1-2][0-9])|(3[0-1]))\d{3}(\d|x|X)$/.test(idCardNo);
+            if (!check) return false;
+            let addressCode = idCardNo.substring(0, 2);
+            check = checkAddressCode(addressCode);
+            if (!check) return false;
+            let birDayCode = idCardNo.substring(6, 14);
+            check = checkBirthDayCode(birDayCode);
+            if (!check) return false;
+            return checkParityBit(idCardNo);
+        };
+
+        const checkIdCardNo = (idCardNo) => {
+            if (idCardNo === null || idCardNo === void 0) {
+                return false;
+            }
+
+            idCardNo = idCardNo + "";
+
+            let check = /^\d{15}|(\d{17}(\d|x|X))$/.test(idCardNo);
+            if (!check) return false;
+
+            if (idCardNo.length === 15) {
+                return check15IdCardNo(idCardNo);
+            }
+
+            return check18IdCardNo(idCardNo);
+        };
+
+        return checkIdCardNo(strOfIDCardNo);
+    },
+
+    /**
+     * 是否有效的中国香港身份证号码
+     */
+    isHongKongIDCardNo(strOfIDCardNo) {
+        if (strOfIDCardNo === null || strOfIDCardNo === void 0) {
+            return false;
+        }
+
+        strOfIDCardNo = strOfIDCardNo + "";
+
+        // sanitize user input
+        strOfIDCardNo = strOfIDCardNo.trim();
+
+        // HKID number starts with 1 or 2 letters, followed by 6 digits,
+        // then a checksum contained in square / round brackets or nothing
+        const regexHKID = /^[A-Z]{1,2}[0-9]{6}((\([0-9A]\))|(\[[0-9A]\])|([0-9A]))$/;
+        const regexIsDigit = /^[0-9]$/;
+
+        // convert the user input to all uppercase and apply regex
+        strOfIDCardNo = strOfIDCardNo.toUpperCase();
+        if (!regexHKID.test(strOfIDCardNo)) return false;
+        strOfIDCardNo = strOfIDCardNo.replace(/\[|\]|\(|\)/g, '');
+
+        if (strOfIDCardNo.length === 8) strOfIDCardNo = `3${strOfIDCardNo}`;
+        let checkSumVal = 0;
+        for (let i = 0; i <= 7; i++) {
+            let convertedChar;
+            if (!regexIsDigit.test(strOfIDCardNo[i])) convertedChar = (strOfIDCardNo[i].charCodeAt(0) - 55) % 11;
+            else convertedChar = strOfIDCardNo[i];
+            checkSumVal += (convertedChar * (9 - i));
+        }
+        checkSumVal %= 11;
+
+        let checkSumConverted;
+        if (checkSumVal === 0) checkSumConverted = '0';
+        else if (checkSumVal === 1) checkSumConverted = 'A';
+        else checkSumConverted = String(11 - checkSumVal);
+        if (checkSumConverted === strOfIDCardNo[strOfIDCardNo.length - 1]) return true;
+        return false;
+    },
+
+    /**
+     * 是否有效的中国台湾身份证号码
+     */
+    isTaiWanIDCardNo(strOfIDCardNo) {
+        if (strOfIDCardNo === null || strOfIDCardNo === void 0) {
+            return false;
+        }
+
+        strOfIDCardNo = strOfIDCardNo + "";
+
+        const ALPHABET_CODES = {
+            A: 10,
+            B: 11,
+            C: 12,
+            D: 13,
+            E: 14,
+            F: 15,
+            G: 16,
+            H: 17,
+            I: 34,
+            J: 18,
+            K: 19,
+            L: 20,
+            M: 21,
+            N: 22,
+            O: 35,
+            P: 23,
+            Q: 24,
+            R: 25,
+            S: 26,
+            T: 27,
+            U: 28,
+            V: 29,
+            W: 32,
+            X: 30,
+            Y: 31,
+            Z: 33,
+        };
+
+        const sanitized = strOfIDCardNo.trim().toUpperCase();
+
+        if (!/^[A-Z][0-9]{9}$/.test(sanitized)) return false;
+
+        return Array.from(sanitized).reduce((sum, number, index) => {
+            if (index === 0) {
+                const code = ALPHABET_CODES[number];
+
+                return ((code % 10) * 9) + Math.floor(code / 10);
+            }
+
+            if (index === 9) {
+                return ((10 - (sum % 10)) - Number(number)) % 10 === 0;
+            }
+
+            return sum + (Number(number) * (9 - index));
+        }, 0);
+    },
+
+    isHasChineseWord(str) {
+        return /[\u4E00-\u9FFF]+/g.test(str)
+    },
+
+    isAllChineseWord(str) {
+        return /^[\u4E00-\u9FFF]+$/.test(str)
+    },
+
+    isCNMainLandMobilePhone(str) {
+        return /^((\+|00)86)?(1[3-9]|9[28])\d{9}$/.test(str)
+    }
+}
+
+export default CNKits;

package/src/base/utils/CharReplaceUtils.js

@@ -0,0 +1,99 @@
+const encryptionMap = {
+    'a': 'R',
+    'b': '5',
+    'c': 'g',
+    'd': 'N',
+    'e': '7',
+    'f': 'y',
+    'g': '1',
+    'h': 'W',
+    'i': 'b',
+    'j': '9',
+    'k': 'K',
+    'l': '2',
+    'm': 'E',
+    'n': '4',
+    'o': 'i',
+    'p': 'L',
+    'q': '8',
+    'r': 'x',
+    's': 'Q',
+    't': '3',
+    'u': 't',
+    'v': 'P',
+    'w': 'D',
+    'x': 'f',
+    'y': 'Z',
+    'z': 'e',
+    'A': '0',
+    'B': 'm',
+    'C': 'H',
+    'D': '6',
+    'E': 'u',
+    'F': 'J',
+    'G': 'a',
+    'H': 'C',
+    'I': 'v',
+    'J': 's',
+    'K': 'p',
+    'L': 'U',
+    'M': 'j',
+    'N': 'M',
+    'O': 'o',
+    'P': 'd',
+    'Q': 'T',
+    'R': 'k',
+    'S': 'V',
+    'T': 'z',
+    'U': 'I',
+    'V': 'h',
+    'W': 'L',
+    'X': 'W',
+    'Y': 'A',
+    'Z': 'q',
+    '0': 'S',
+    '1': 'B',
+    '2': 'n',
+    '3': 'F',
+    '4': 'X',
+    '5': 'r',
+    '6': 'c',
+    '7': 'G',
+    '8': 'O',
+    '9': 'Y'
+};
+
+// 解密字符映射表，与加密映射表相反
+const decryptionMap = {};
+for (let key in encryptionMap) {
+    decryptionMap[encryptionMap[key]] = key;
+}
+
+const CharReplaceUtils = {
+    encrypt(data){
+        let encrypted = '';
+        for (let i = 0; i < data.length; i++) {
+            let char = data[i];
+            if (encryptionMap.hasOwnProperty(char)) {
+                encrypted += encryptionMap[char];
+            } else {
+                encrypted += char;
+            }
+        }
+        return encrypted;
+    },
+    decrypt(data){
+        let decrypted = '';
+        for (let i = 0; i < data.length; i++) {
+            let char = data[i];
+            if (decryptionMap.hasOwnProperty(char)) {
+                decrypted += decryptionMap[char];
+            } else {
+                decrypted += char;
+            }
+        }
+        return decrypted;
+    }
+}
+
+export default CharReplaceUtils;

package/src/base/utils/DES24JS.js

@@ -0,0 +1,54 @@
+import lodash from "lodash";
+
+const DES24JS = {
+
+    supportDES24JS() {
+        return lodash.isFunction(window.strEnc) && lodash.isFunction(window.strDec);
+    },
+
+    decrypt(encodedString) {
+        if (!lodash.isFunction(window.strDec)) {
+            throw new Error("Current not support DES Decryption.");
+        }
+
+        if (encodedString === null || encodedString === void 0) {
+            return null;
+        }
+
+        if (!lodash.isString(encodedString)) {
+            throw new Error("Invalid input value for DES Decryption.");
+        }
+
+        try {
+            return window.strDec(encodedString);
+        }
+        catch (e) {
+            console.error(e);
+            return null;
+        }
+    },
+
+    encrypt(rawString) {
+        if (!lodash.isFunction(window.strEnc)) {
+            throw new Error("Current not support DES Encryption.");
+        }
+
+        if (rawString === null || rawString === void 0) {
+            return null;
+        }
+
+        if (!lodash.isString(rawString)) {
+            throw new Error("Invalid input value for DES Encryption.");
+        }
+
+        try {
+            return window.Error(rawString);
+        }
+        catch (e) {
+            console.error(e);
+            return null;
+        }
+    }
+}
+
+export default DES24JS;

package/src/base/utils/DateTimes.js

@@ -0,0 +1,136 @@
+import moment from "moment";
+import lodash from "lodash";
+import LangTypes from "./LangTypes"
+
+
+const DateTimes = {
+
+    strDateOfLen10(date) {
+        if (date === null || date === void 0) {
+            return "";
+        }
+
+        let dateTime = null;
+        if (lodash.isInteger(date)) {
+            dateTime = moment(new Date(date));
+        } else {
+            dateTime = moment(date);
+        }
+
+        if (dateTime.isValid()) {
+            return dateTime.format("YYYY-MM-DD")
+        }
+
+        return "";
+    },
+
+    strDateOfLen8(date) {
+        if (date === null || date === void 0) {
+            return "";
+        }
+
+        let dateTime = null;
+        if (lodash.isInteger(date)) {
+            dateTime = moment(new Date(date));
+        } else {
+            dateTime = moment(date);
+        }
+
+        if (dateTime.isValid()) {
+            return dateTime.format("YYYYMMDD")
+        }
+
+        return "";
+    },
+
+    strDateTimeOfLen19(date) {
+        if (date === null || date === void 0) {
+            return "";
+        }
+
+        let dateTime = null;
+        if (lodash.isInteger(date)) {
+            dateTime = moment(new Date(date));
+        } else {
+            dateTime = moment(date);
+        }
+
+        if (dateTime.isValid()) {
+            return dateTime.format("YYYY-MM-DD HH:mm:ss")
+        }
+
+        return "";
+    },
+
+    strDateTimeOfLen14(date) {
+        if (date === null || date === void 0) {
+            return "";
+        }
+
+        let dateTime = null;
+        if (lodash.isInteger(date)) {
+            dateTime = moment(new Date(date));
+        } else {
+            dateTime = moment(date);
+        }
+
+        if (dateTime.isValid()) {
+            return dateTime.format("YYYYMMDDHHmmss")
+        }
+
+        return "";
+    },
+
+    asHumanReadablePastTime(dateValue, format = 'YYYY-MM-DD HH:mm:ss') {
+        let pastDate = LangTypes.asDateValue(dateValue);
+        if (!pastDate) {
+            return "";
+        }
+
+        let currTS = new Date().getTime()
+        let pastTS = pastDate.getTime();
+        let time = currTS - pastTS;
+        if (time < 10 * 1000) {
+            return '刚刚'
+        } else if (time < 60 * 1000 && time >= 10 * 1000) {
+            let s = Math.floor(time / 1000)
+            return `${s}秒前`
+        } else if (time < 60 * 60 * 1000 && time >= 60 * 1000) {
+            let s = Math.floor(time / (60 * 1000))
+            return `${s}分钟前`
+        } else if (time < 24 * 60 * 60 * 1000 && time >= 60 * 60 * 1000) {
+            let s = Math.floor(time / (60 * 60 * 1000))
+            return `${s}小时前`
+        } else if (time < 7 * 24 * 60 * 60 * 1000 && time >= 24 * 60 * 60 * 1000) {
+            let s = Math.floor(time / (24 * 60 * 60 * 1000))
+            return `${s}天前`
+        } else {
+            return moment(pastDate).format(format);
+        }
+    },
+
+    timeDiff(startDate, endDate) {
+        let startTime = new Date(startDate).getTime();
+        let endTime = new Date(endDate).getTime();
+        let usedTime = endTime - startTime;
+
+        let day = Math.floor(usedTime / (24 * 3600 * 1000));
+        let leave1 = usedTime % (24 * 3600 * 1000);
+        let hours = Math.floor(leave1 / (3600 * 1000));
+        //计算相差分钟数
+        let leave2 = leave1 % (3600 * 1000);
+        let minutes = Math.floor(leave2 / (60 * 1000));
+        //计算相差秒数
+        let leave3 = leave2 % (60 * 1000);
+        let second = Math.round(leave3 / 1000);
+
+        if (day) {
+            return {day, hours, minutes, second};
+        } else if (!day && hours) {
+            return {hours, minutes, second};
+        }
+        return {minutes, second};
+    }
+}
+
+export default DateTimes;

package/src/base/utils/FormDatas.js

@@ -0,0 +1,103 @@
+import lodash, {isPlainObject} from "lodash";
+import LangTypes from "./LangTypes";
+
+const convertFormValues2VOUsingVOFormat = function (values) {
+    if (!values) {
+        return null;
+    }
+
+    let vo = {};
+    let attrs = Object.keys(values);
+    for (let i = 0, length = attrs.length; i < length; i++) {
+        let attr = attrs[i];
+        let attrValue = values[attr];
+        if (attrValue === null || attrValue === void 0) {
+            continue;
+        }
+
+        if (lodash.isString(attrValue)) {
+            vo[attr] = attrValue;
+        }
+        else if (lodash.isNumber(attrValue)) {
+            if (!Number.isNaN(attrValue)) {
+                vo[attr] = attrValue;
+            }
+        }
+        else if (lodash.isBoolean(attrValue)) {
+            vo[attr] = attrValue;
+        }
+        else if (lodash.isDate(attrValue)) {
+            vo[attr] = attrValue;
+        }
+        else if (lodash.isArray(attrValue)) {
+            vo[attr] = attrValue.join(",");
+        }
+        else if (lodash.isObject(attrValue)
+            && attr.endsWith("_pk")
+            && (attrValue.label !== null)
+            && (attrValue.value !== null)
+            && Object.keys(attrValue)) {
+            if (attrValue._inputCreateOnly === true) {
+                vo[attr] = -1;
+                vo[attr.substring(0, attr.length - 3) + "_ext_name"] = attrValue.label;
+            }
+            else {
+                vo[attr] = attrValue.value;
+                vo[attr.substring(0, attr.length - 3) + "_ext_name"] = attrValue.label;
+            }
+
+        }
+    }
+    return vo;
+}
+
+const convertVO2FormValuesUsingFormValueFormat = function (voValue, attrNameArrayForMultiSelect) {
+    if (!voValue) {
+        return null;
+    }
+
+    let formValues = {};
+    let attrs = Object.keys(voValue);
+    for (let i = 0, length = attrs.length; i < length; i++) {
+        let attr = attrs[i];
+        let attrValue = voValue[attr];
+        if (attrValue === null) {
+            continue;
+        }
+
+        if (isPlainObject(attrValue)) {
+            formValues[attr] = convertVO2FormValuesUsingFormValueFormat(attrValue, attrNameArrayForMultiSelect);
+        }
+        else if (attr.endsWith("_pk")) {
+            formValues[attr] = {
+                value: attrValue,
+                label: voValue[attr.substring(0, attr.length - 3) + "_ext_name"]
+            };
+        }
+        else if (attr.endsWith("status")) {
+            formValues[attr] = LangTypes.asBooleanValue(attrValue);
+        }
+        else {
+            formValues[attr] = attrValue;
+        }
+    }
+
+    if (attrNameArrayForMultiSelect && attrNameArrayForMultiSelect.length > 0) {
+        for (let i = 0, length = attrNameArrayForMultiSelect.length; i < length; i++) {
+            let attrName = attrNameArrayForMultiSelect[i];
+            if (attrName) {
+                if (formValues[attrName] && formValues[attrName].split) {
+                    formValues[attrName] = formValues[attrName].split(",");
+                }
+            }
+        }
+    }
+
+    return formValues;
+}
+
+
+export {
+    convertFormValues2VOUsingVOFormat,
+    convertVO2FormValuesUsingFormValueFormat
+}