@bchr/bchr-front-lib 0.4.5 → 0.5.2

package/src/base/utils/Values.js

@@ -0,0 +1,196 @@
+import Decimal from "decimal.js";
+import lodash from "lodash";
+import moment from "moment";
+import Strings from "./Strings"
+
+const Values = {
+
+    ifNull(rawValue, defaultValue) {
+        if (rawValue === null || rawValue === void 0) {
+            return defaultValue;
+        }
+
+        return rawValue;
+    },
+
+    ifEmpty(rawValue, defaultValue){
+        if (this.isEmpty(rawValue)) {
+            return defaultValue;
+        }
+
+        return rawValue;
+    },
+
+    isUndefined(value) {
+        return value === void 0;
+    },
+
+    isNull(value) {
+        return value === null || value === void 0;
+    },
+
+    isNotNull(value) {
+        return !(this.isNull(value));
+    },
+
+    isEmptyArray(value) {
+        return value === void 0 || value === null || (Array.isArray(value) && value.length === 0);
+    },
+
+    isNotEmptyArray(value) {
+        return Array.isArray(value) && value.length > 0;
+    },
+
+    isEmpty(rawValue) {
+        if (rawValue === null || rawValue === void 0) {
+            return true;
+        }
+
+        if (lodash.isString(rawValue)) {
+            return this.isBlankString(rawValue);
+        }
+        else if (this.isEmptyArray(rawValue)) {
+            return true;
+        }
+        else if (lodash.isSet(rawValue)) {
+            return (rawValue.size === 0);
+        }
+        else if (lodash.isMap(rawValue)) {
+            return (rawValue.size === 0);
+        }
+        else if (lodash.isPlainObject(rawValue)) {
+            return (lodash.isEmpty(rawValue));
+        }
+        else if (lodash.isArrayLike(rawValue)) {
+            return rawValue.length === 0;
+        }
+        else if (lodash.isArrayBuffer(rawValue)) {
+            return rawValue.byteLength === 0;
+        }
+
+        return false;
+    },
+
+    isNotEmpty(rawValue) {
+        return !this.isEmpty(rawValue);
+    },
+
+    isBlankString(value) {
+        return Strings.isBlankString(value);
+    },
+
+    isNotBlankString(value) {
+        return Strings.isNotBlankString(value);
+    },
+
+    isPK(value) {
+        if (value === null || value === void 0) {
+            return false;
+        }
+
+        if (lodash.isString(value)) {
+            return this.isNotBlankString(value);
+        }
+        else if (lodash.isNumber(value)) {
+            return lodash.isInteger(value) && value > 0;
+        }
+
+        return false;
+    },
+
+    isDateValue(value) {
+        if (value === null || value === void 0) {
+            return false;
+        }
+
+        if (lodash.isString(value)) {
+            let day = moment(value)
+            return day.isValid();
+        }
+        else if (lodash.isDate(value)) {
+            return true;
+        }
+        else if (lodash.isFunction(value.toDate) && lodash.isFunction(value.isValid)) {
+            return value.isValid();
+        }
+        else if (lodash.isPlainObject(value) && Object.prototype.hasOwnProperty.call(value, "value")) {
+            return this.isDateValue(value.value);
+        }
+
+        return false;
+    },
+
+    isInteger(value) {
+        if (value === null || value === void 0) {
+            return false;
+        }
+
+        if (lodash.isInteger(value)) {
+            return true;
+        }
+
+        if (lodash.isString(value)) {
+            let _value = value.replaceAll(",", "").replaceAll(' ', '');
+            try {
+                let decimalValue = new Decimal(_value);
+                return decimalValue.isInteger();
+            }
+            catch (e) {
+                return false;
+            }
+        }
+
+        return false;
+    },
+
+    isInteger2(value) {
+        if (value === null || value === void 0) {
+            return false;
+        }
+
+        if (lodash.isInteger(value)) {
+            return true;
+        }
+
+        if (lodash.isString(value)) {
+            try {
+                let decimalValue = new Decimal(value);
+                return decimalValue.isInteger();
+            }
+            catch (e) {
+                return false;
+            }
+        }
+
+        return false;
+    },
+
+    isNumber(value) {
+        if (value === null || value === void 0) {
+            return false;
+        }
+
+        if (isNaN(value)) {
+            return false;
+        }
+
+        if (lodash.isNumber(value)) {
+            return true;
+        }
+
+        if (lodash.isString(value)) {
+            let _value = value.replaceAll(",", "").replaceAll(' ', '');
+            try {
+                new Decimal(_value);
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        }
+
+        return false;
+    }
+}
+
+export default Values;

package/src/base/utils/index.js

@@ -0,0 +1,15 @@
+import {
+    convertFormValues2VOUsingVOFormat,
+    convertVO2FormValuesUsingFormValueFormat
+}
+from './FormDatas';
+
+import Strings from "./Strings";
+import Values from "./Values";
+import DateTimes from "./DateTimes";
+
+export {
+    Strings, Values, DateTimes,
+    convertFormValues2VOUsingVOFormat,
+    convertVO2FormValuesUsingFormValueFormat,
+}

package/src/services/http.js

@@ -0,0 +1,460 @@
+import lodash from "lodash";
+import queryString from "query-string";
+import { Values } from '../base/utils';
+import { message } from 'antd';
+
+const http = {
+
+    isUseDefaultExceptionHandler: function() {
+        return false;
+    },
+
+    getRequestContextPath: function(options) {
+        if (lodash.isString(options)) {
+            let requestURL = options;
+            if (requestURL.toLowerCase().startsWith("http")) {
+                return requestURL;
+            }
+            else if (requestURL.startsWith(AppConfig.BackServiceRpcPrefix)) {
+                // like "/d/module_code/function_let_code/method1
+                let requestContextPathParts = requestURL.split("/")
+                if (requestContextPathParts.length >= 4) {
+                    return requestContextPathParts.slice(0, 4).join("/");
+                }
+                else {
+                    return requestURL;
+                }
+            }
+            else if (requestURL.startsWith("/")) {
+                return requestURL;
+            }
+        }
+
+        let SERVICE_HOST_NAME       = AppConfig.BackServiceHostAddress;
+        let SERVICE_CONTEXT_PATH    = AppConfig.BackServiceContextPath;
+        let BACK_SERVICE_RPC_PREFIX = AppConfig.BackServiceRpcPrefix;
+        let ajaxBasePath = null;
+        if (lodash.isPlainObject(options)) {
+            ajaxBasePath  = options.ajaxBasePath;
+        }
+
+        if (Values.isBlankString(ajaxBasePath)) {
+            ajaxBasePath = this.requestContextPath;
+        }
+
+        if (Values.isBlankString(ajaxBasePath)) {
+            let locationHash = window.location.hash;
+            if (!locationHash || locationHash === "#") {
+                return null;
+            }
+
+            locationHash = locationHash.substring(1);
+            if (!locationHash) {
+                return null;
+            }
+
+            let requestContextPathParts = locationHash.split('/')
+            if (requestContextPathParts.length >= 3) {
+                ajaxBasePath = requestContextPathParts.slice(0, 3).join("/");
+            }
+            else {
+                ajaxBasePath = locationHash;
+            }
+        }
+
+        let requestContextPath = SERVICE_HOST_NAME + SERVICE_CONTEXT_PATH + BACK_SERVICE_RPC_PREFIX + ajaxBasePath;
+
+        if (!requestContextPath.endsWith("/")) {
+            requestContextPath = requestContextPath + "/"
+        }
+
+        return requestContextPath;
+    },
+
+    getRequestPath: function(options) {
+        let rpcMethodName = null;
+        let ajaxOptions = {};
+        if (lodash.isPlainObject(options)) {
+            rpcMethodName = options.rpcMethodName;
+            ajaxOptions = {...options};
+        }
+        else if (lodash.isString(options)) {
+            let requestURL = options;
+            if (requestURL.toLowerCase().startsWith("http")) {
+                return requestURL;
+            }
+            else if (requestURL.toLowerCase().startsWith("/")) {
+                return requestURL;
+            }
+            else {
+                rpcMethodName = options;
+            }
+        }
+        else {
+            throw new Error("Invalid arguments value [" + options + "] for http#getRequestPath");
+        }
+
+        if (!rpcMethodName) {
+            rpcMethodName = "";
+        }
+
+        if (ajaxOptions.url) {
+            return ajaxOptions.url
+        } else {
+            let requestContextPath = this.getRequestContextPath(options);
+            return requestContextPath + rpcMethodName;
+        }
+    },
+
+    getFunctionLetUIPathFromLocationString: function(locationString) {
+        if (locationString == null || locationString === "") {
+            return null;
+        }
+
+        let index1 = locationString.indexOf("#");
+        if (index1 === -1) {
+            return null;
+        }
+
+        let locationHash = locationString.substring(index1);
+        let index2 = locationHash.indexOf("?");
+        if (index2 === -1) {
+            return locationHash;
+        }
+
+        return locationHash.substring(0, index2);
+    },
+
+    getFunctionLetUIContextPathFromLocationString: function(locationString) {
+        let functionLetUIPath = this.getFunctionLetUIPathFromLocationString(locationString);
+        if (functionLetUIPath == null) {
+            return null;
+        }
+
+        if (functionLetUIPath.endsWith("/")) {
+            return functionLetUIPath;
+        }
+
+        let index1 = functionLetUIPath.lastIndexOf("/");
+        if (index1 == -1) {
+            return functionLetUIPath;
+        }
+
+        return functionLetUIPath.substring(0, index1 + 1);
+    },
+
+    getViewNameFromLocationHash: function() {
+        let currentHash = window.location.hash;
+        if (!currentHash) {
+            return null;
+        }
+
+        let pureHashLocation = currentHash;
+        let p1 = pureHashLocation.indexOf("?");
+        if (p1 > 0) {
+            pureHashLocation = pureHashLocation.substring(0, p1);
+        }
+
+        if (pureHashLocation.endsWith("/")) {
+            return null;
+        }
+
+        let p2 = pureHashLocation.lastIndexOf("/");
+        if (p2 > 0) {
+            return pureHashLocation.substring(p2 + 1);
+        }
+        else {
+            return pureHashLocation.substring(1);
+        }
+    },
+
+    getParameterValue: function (paramName) {
+        if (!paramName) {
+            return null;
+        }
+
+        let hash = window.location.hash;
+        if (!hash) {
+            return null;
+        }
+
+        let index = hash.indexOf("?");
+        if (index < 0) {
+            return null;
+        }
+
+        let search = hash.substring(index + 1);
+
+        let paramObject = queryString.parse(search);
+
+        if (!paramObject) {
+            return null;
+        }
+
+        return paramObject[paramName];
+    },
+
+    getParameterObject: function (...paramNames) {
+        let hash = window.location.hash;
+        if (!hash) {
+            return null;
+        }
+
+        let index = hash.indexOf("?");
+        if (index < 0) {
+            return null;
+        }
+
+        let search = hash.substring(index + 1);
+
+        let paramObject = queryString.parse(search);
+
+        if (!Array.isArray(paramNames)){
+            return paramObject;
+        }
+
+        let _paramObject = {};
+        for (let i = 0, len = paramNames.length; i < len; i++) {
+            let param = paramNames[i];
+            _paramObject[param] = paramObject[param];
+        }
+
+        return _paramObject;
+    },
+
+    encodeObject2ParameterString2: function(object) {
+        if (!lodash.isPlainObject(object)) {
+            return "";
+        }
+
+        return "?" + queryString.stringify(object);
+    },
+
+    encodeObject2ParameterString: function (object) {
+        if (!lodash.isPlainObject(object)) {
+            return "";
+        }
+
+        return queryString.stringify(object);
+    },
+
+    redirectToFunctionLet(functionLetRouterPath, parameterObject) {
+        this.redirectTo("#" + functionLetRouterPath, parameterObject)
+    },
+
+    redirectTo: function(targetLocation, parameterObject) {
+        if (targetLocation === null || targetLocation === void 0) {
+            return;
+        }
+
+        if (Values.isBlankString(targetLocation)) {
+            return;
+        }
+
+        let location = targetLocation;
+        if (lodash.isPlainObject(parameterObject)) {
+            location = location + this.encodeObject2ParameterString2(parameterObject)
+        }
+
+        let lowerCaseLocation = location.toLowerCase();
+        if (lowerCaseLocation.startsWith("http://") || lowerCaseLocation.startsWith("https://") || lowerCaseLocation.startsWith("/")) {
+            window.location = location;
+        }
+
+        if (location.startsWith("#")) {
+            window.location.hash = location
+        }
+        else if (location.startsWith("./")) {
+            let currentHash = window.location.hash;
+            if (!currentHash) {
+                window.location = location;
+            }
+            else if (currentHash === "#/") {
+                window.location.hash = "#" + location.substring(1);
+            }
+            else {
+                let pureHashLocation = currentHash;
+                let p1 = pureHashLocation.indexOf("?");
+                if (p1 > 0) {
+                    pureHashLocation = pureHashLocation.substring(0, p1);
+                }
+
+                let p2 = pureHashLocation.lastIndexOf("/");
+                if (p2 > 0) {
+                    window.location.hash = pureHashLocation.substring(0, p2 + 1) + location.substring(2);
+                }
+                else {
+                    window.location.hash = "#" + location.substring(1);
+                }
+            }
+        }
+        else if (location.indexOf("../") >= 0) {
+            let currentHash = window.location.hash;
+            if (!currentHash) {
+                window.location = location;
+            }
+            else {
+                message.error("Not support the location pattern:" + location);
+            }
+        }
+        else {
+            let currentHash = window.location.hash;
+            if (!currentHash) {
+                window.location = location;
+            }
+            else {
+                let pureHashLocation = currentHash;
+                let p1 = pureHashLocation.indexOf("?");
+                if (p1 > 0) {
+                    pureHashLocation = pureHashLocation.substring(0, p1);
+                }
+
+                let p2 = pureHashLocation.lastIndexOf("/");
+                if (p2 > 0) {
+                    window.location.hash = pureHashLocation.substring(0, p2 + 1) + location;
+                }
+                else {
+                    window.location.hash = "#/" + location;
+                }
+            }
+        }
+    },
+
+    goBack: function() {
+        let currentHash = window.location.hash;
+        if (currentHash == null || currentHash.length == 0 || currentHash == "#/" || currentHash == "#") {
+            window.history.go(-1);
+            return;
+        }
+
+        let pureHashLocation = currentHash;
+        let p1 = pureHashLocation.indexOf("?");
+        if (p1 > 0) {
+            pureHashLocation = pureHashLocation.substring(0, p1);
+        }
+
+        let p2 = pureHashLocation.lastIndexOf("/");
+        let hash = "";
+        if (p2 > 0) {
+            window.location.hash = pureHashLocation.substring(0, p2 + 1);
+            return;
+        }
+        else {
+            window.history.go(-1);
+            return;
+        }
+    },
+
+    getFullURL: function(targetLocation, parameterObject) {
+        if (targetLocation === null || targetLocation === void 0) {
+            return null;
+        }
+
+        if (Values.isBlankString(targetLocation)) {
+            return null;
+        }
+
+        let location = targetLocation;
+        if (lodash.isPlainObject(parameterObject)) {
+            location = location + this.encodeObject2ParameterString2(parameterObject)
+        }
+
+        let lowerCaseLocation = location.toLowerCase();
+        if (lowerCaseLocation.startsWith("http://") || lowerCaseLocation.startsWith("https://") || lowerCaseLocation.startsWith("/")) {
+            return location;
+        }
+
+        if (location.startsWith("#")) {
+            return window.location.origin + window.location.pathname + location;
+        }
+        else if (location.startsWith("./")) {
+            let currentHash = window.location.hash;
+            if (Values.isBlankString(currentHash)) {
+                let currentPathname = window.location.pathname;
+                let idx = currentHash.lastIndexOf("/")
+                if (idx >= 0) {
+                    return window.location.origin + currentPathname.substring(0, idx + 1) + location.substring(2);
+                }
+                else {
+                    return window.location.origin + location.substring(1);
+                }
+            }
+            else if (currentHash === "#/") {
+                return window.location.origin + window.location.pathname + "#" + location.substring(1);
+            }
+            else {
+                let pureHashLocation = currentHash;
+                let p1 = pureHashLocation.indexOf("?");
+                if (p1 > 0) {
+                    pureHashLocation = pureHashLocation.substring(0, p1);
+                }
+
+                let p2 = pureHashLocation.lastIndexOf("/");
+                let hash = "";
+                if (p2 > 0) {
+                    hash = pureHashLocation.substring(0, p2 + 1) + location.substring(2);
+                }
+                else {
+                    hash = "#" + location.substring(1);
+                }
+
+                return window.location.origin + window.location.pathname + hash;
+            }
+        }
+        else {
+            let currentHash = window.location.hash;
+            if (Values.isBlankString(currentHash)) {
+                let currentPathname = window.location.pathname;
+                let idx = currentHash.lastIndexOf("/")
+                if (idx >= 0) {
+                    return window.location.origin + currentPathname.substring(0, idx + 1) + location;
+                }
+                else {
+                    return window.location.origin + "/" + location;
+                }
+            }
+            else {
+                let pureHashLocation = currentHash;
+                let p1 = pureHashLocation.indexOf("?");
+                if (p1 > 0) {
+                    pureHashLocation = pureHashLocation.substring(0, p1);
+                }
+
+                let p2 = pureHashLocation.lastIndexOf("/");
+                let hash = "";
+                if (p2 > 0) {
+                    hash = pureHashLocation.substring(0, p2 + 1) + location;
+                }
+                else {
+                    hash = "#/" + location;
+                }
+
+                return window.location.origin + window.location.pathname + hash;
+            }
+        }
+    },
+
+    isInView: function(viewName) {
+        if (!lodash.isString(viewName)) {
+            return false;
+        }
+
+        let currentView = this.getViewNameFromLocationHash();
+        if (!currentView) {
+            return false;
+        }
+
+        return viewName.toLowerCase() === currentView.toLowerCase();
+    },
+
+    switchMainView: (parameterObject) => {
+        if (this.isInView("main_view")) {
+            this.redirectTo("main_view2", parameterObject)
+        }
+        else if (this.isInView("main_view2")) {
+            this.redirectTo("main_view", parameterObject)
+        }
+    },
+}
+
+export default http;