sirius-common-utils 1.0.0

package/src/packages/utils/AxiosUtils.js

@@ -0,0 +1,433 @@
+import _ from 'lodash';
+
+import CfgUtils from "./CfgUtils";
+import LoginUserUtils from "./LoginUserUtils";
+
+let axios = null;
+let urlContext = null; //URL路径前缀
+
+let RESULT = {
+    SUCCESS: 200,
+};
+
+
+let EXCEPTION_CODE = {
+    AUTHENTICATION_FAILED_COMMON: 901,
+    NETWORK_ISSUE_CLIENT: 911,
+    SYS_UNKNOWN_ISSUE: 999,
+}
+
+let globalDialogUtilsInstance;
+let globalSpinHandlerInstance;
+let loginServiceInstance;
+
+function init(pAxios, pSpinHandlerInstance, pDialogUtilsInstance, pLoginServiceInstance) {
+    axios = pAxios;
+
+    // axios.defaults.baseURL = getPath("/xms-test");
+    axios.defaults.baseURL = getPath(process.env.REACT_APP_AXIOS_CONTEXT);
+    axios.defaults.timeout = CfgUtils.ajax.timeout;
+
+    globalDialogUtilsInstance = pDialogUtilsInstance;
+    globalSpinHandlerInstance = pSpinHandlerInstance;
+    loginServiceInstance = pLoginServiceInstance;
+}
+
+/**
+ *
+ */
+function loadParamFromLocationSearch(paramKey) {
+    var paramsStr = window.location.search;
+    if (paramsStr.indexOf('?') === 0) {
+        paramsStr = paramsStr.substring(1);
+    }
+    var entryParams = paramsStr.split('&');
+    var entryParamStr = _.find(entryParams, function (param) {
+        return param.indexOf(paramKey) === 0;
+    });
+    if (!entryParamStr) {
+        return null;
+    }
+    var param = entryParamStr.split('=');
+    if (!param[1]) {
+        return null;
+    }
+    return param[1];
+}
+
+/**
+ * get the entire url path
+ * @param path start with '/'
+ * @returns {string|*}
+ */
+function getPath(path) {
+    if (_.startsWith(path, "http")) {
+        return path;
+    }
+
+    if (urlContext == null) {
+        urlContext = window.document.location.href;
+        let lastIdx = urlContext.indexOf('.htm');
+        if (lastIdx > -1) {
+            urlContext = urlContext.substring(0, urlContext.lastIndexOf('/', lastIdx));
+        } else {
+            lastIdx = urlContext.indexOf('/#');
+            if (lastIdx > -1) {
+                urlContext = urlContext.substring(0, lastIdx);
+            } else {
+                lastIdx = urlContext.indexOf('#');
+                if (lastIdx > -1) {
+                    urlContext = urlContext.substring(0, lastIdx);
+                } else {
+                    console.log(`Could not identify URL path ${urlContext}`);
+                }
+            }
+        }
+        //http://localhost:3000/index.html/#/index/highTriggerWiggleRoomValue -> http://localhost:3000
+    }
+
+    return urlContext + path;
+}
+
+/**
+ * Download excel from server
+ */
+function downloadExcelData(url, data, headers, options = {}) {
+    return new Promise(async function (resolve, reject) {
+        headers = headers || {};
+        if (headers['Content-Type'] == null) {
+            headers['Content-Type'] = 'application/json';
+        }
+
+        await buildUserAccessToken(headers);
+
+        try {
+            let response = await axios({
+                method: 'post',
+                url: url,
+                data: data,
+                headers: headers,
+                responseType: 'blob'
+            });
+            if (response.data) {
+                if (response.data.errorCode && response.data.errorCode !== RESULT.SUCCESS) {
+                    let errorResult = await handlerError(url, data, response);
+                    resolve(errorResult);
+                    return;
+                }
+            }
+
+            const link = document.createElement('a')
+            let blob = new Blob([response.data], {type: 'application/vnd.ms-excel'});
+            let contentDisposition = response.headers["content-disposition"];
+
+            if (contentDisposition == null) {
+                let errorResult = await handlerError(url, data, {
+                    data: {
+                        errorCode: EXCEPTION_CODE.SYS_UNKNOWN_ISSUE,
+                        error: "System Error",
+                    }
+                });
+                resolve(errorResult);
+                return;
+            }
+
+            let temp = contentDisposition.split(";")[1].split("ilename=")[1];
+            var fileName = decodeURIComponent(temp);
+            console.log(fileName)
+            link.style.display = 'none'
+            link.href = URL.createObjectURL(blob);
+            link.setAttribute('download', fileName);
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+
+            resolve(true);
+        } catch (e) {
+            let errorResult = await handlerError(url, {}, e);
+            resolve(errorResult);
+        }
+    });
+}
+
+/**
+ *
+ */
+function downloadServerData(url) {
+    return new Promise(function (resolve, reject) {
+
+        const hyperlink = document.createElement('a');
+        hyperlink.style.display = 'none';//隐藏,没必要展示出来
+        hyperlink.href = url;
+        hyperlink.target = "_blank";
+        document.body.appendChild(hyperlink);
+        hyperlink.click();
+        URL.revokeObjectURL(hyperlink.href); // 释放URL 对象
+        document.body.removeChild(hyperlink);//下载
+
+        resolve(true);
+    });
+}
+
+/**
+ * upload file to server
+ * TODO Joey need check with FormData scenario
+ */
+function uploadFile(url, file, headers, onUploadProgress, customizedOptions) {
+    headers = headers || {};
+
+    let formdata = new FormData();
+    if (_.isArray(file)) {
+        formdata.append("files", file);
+    } else {
+        formdata.append("file", file)
+    }
+
+    customizedOptions = customizedOptions || {};
+    return execute("POST", url, formdata, headers, onUploadProgress, customizedOptions)
+}
+
+/**
+ * getStaticTextFile
+ */
+function getStaticTextFile(url) {
+    return new Promise(async function (resolve, reject) {
+        axios.get(url).then((res) => {
+            resolve(res);
+        }, (error) => {
+            resolve(null);
+        });
+    });
+}
+
+/**
+ * build form-data from param object
+ */
+function getUrlParam(params) {
+    if (params) {
+        var param = '';
+        _.each(params, function (i, val) {
+            if (i != null) {
+                param += val + '=' + encodeURIComponent(i) + '&';
+            } else {
+                param += val + '=&';
+            }
+        });
+        param = param.substring(0, param.length - 1);
+        return param;
+    } else {
+        return '';
+    }
+}
+
+function getFormData(url, headers, customizedOptions) {
+    headers = headers || {};
+    if (headers['Content-Type'] == null) {
+        headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    }
+
+    customizedOptions = customizedOptions || {};
+
+    return execute("GET", url, null, headers, null, customizedOptions)
+}
+
+function postFormData(url, dataObject, headers, customizedOptions) {
+    let formdata = null;
+    if (dataObject) {
+        formdata = getUrlParam(dataObject);
+    }
+
+    headers = headers || {};
+    if (headers['Content-Type'] == null) {
+        headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    }
+
+    customizedOptions = customizedOptions || {};
+
+    return execute("POST", url, formdata, headers, null, customizedOptions)
+}
+
+function getJsonData(url, headers, customizedOptions) {
+    headers = headers || {};
+    if (headers['Content-Type'] == null) {
+        headers['Content-Type'] = 'application/json';
+    }
+
+    return execute("GET", url, null, headers, null, customizedOptions)
+}
+
+function postJsonData(url, dataObject, headers, customizedOptions) {
+    headers = headers || {};
+    if (headers['Content-Type'] == null) {
+        headers['Content-Type'] = 'application/json';
+    }
+
+    return execute("POST", url, dataObject, headers, null, customizedOptions)
+}
+
+/**
+ * General Axios Data request
+ *
+ * @param method
+ * @param url
+ * @param data
+ * @param headers
+ * @param customizedOptions: { }customizedErrorHandlerFlag: false }
+ */
+function execute(method, url, data, headers, onUploadProgress, customizedOptions = {}) {
+    return new Promise(function (resolve, reject) {
+        //check and set User AccessToken in the request header
+        buildUserAccessToken(headers).then(
+            function () {
+                //AccessToken is valid
+                axios({
+                    method: method,
+                    url: url,
+                    data: data,
+                    headers: headers,
+                    onUploadProgress: onUploadProgress,
+                })
+                    .then((response) => {
+                        if (response.data) {
+                            if (response.data.errorCode && response.data.errorCode !== RESULT.SUCCESS) {
+                                if (customizedOptions.customizedErrorHandlerFlag) {
+                                    resolve(response.data);
+                                } else {
+                                    handlerError(url, data, response).then((result) => {
+                                        resolve(result);
+                                    });
+                                }
+                            } else {
+                                resolve(response.data);
+                            }
+                        } else {
+                            resolve(response.data);
+                        }
+                    }, (error) => {
+                        if (customizedOptions.customizedErrorHandlerFlag) {
+                            resolve(error);
+                        } else {
+                            handlerError(url, data, error).then((result) => {
+                                resolve(result);
+                            });
+                        }
+                    });
+            },
+            (error) => {
+                //AccessToken is invalid
+                handlerError(url, data, error).then((result) => {
+                    resolve(result);
+                });
+            });
+
+    });
+}
+
+async function buildUserAccessToken(headers) {
+    let currUserInfo = await LoginUserUtils.getCurrUserInfo();
+    if (currUserInfo && currUserInfo.accessToken) {
+        if (headers['ENOS_ACCESS_TOKEN'] == null) {
+            headers['ENOS_ACCESS_TOKEN'] = currUserInfo.accessToken;
+        }
+    }
+}
+
+
+/**
+ * build error message base on errorCode
+ */
+function getErrorMsgByCode(errorCode, errorMsg) {
+    return errorMsg;
+}
+
+/**
+ * request error handler
+ * if multiple ajax error happened. just process the first one.
+ */
+var reqErrorInProcessing = false;
+
+async function handlerError(url, reqData, responseOrAxiosError) {
+    if (reqErrorInProcessing === true) {
+        return;
+    }
+
+    reqErrorInProcessing = true;
+    await handlerErrorLogic(url, reqData, responseOrAxiosError);
+    reqErrorInProcessing = false;
+}
+
+async function showErrorMessage(errorCode, heading = "System Error", message) {
+    globalSpinHandlerInstance.complete();
+    await globalDialogUtilsInstance.showAppErrorDialog(heading, message);
+}
+
+async function handlerErrorLogic(url, reqData, responseOrAxiosError) {
+    let errorCode = _.get(responseOrAxiosError, 'data.errorCode');
+    let error = _.get(responseOrAxiosError, 'data.error');
+
+    if (!errorCode && _.get(responseOrAxiosError, 'code')) {
+        let axiosErrorStatus = _.get(responseOrAxiosError, 'response.status');
+        let axiosErrorStatusText = _.get(responseOrAxiosError, 'response.statusText');
+
+        if (_.includes([502, 504], axiosErrorStatus)) {
+            errorCode = EXCEPTION_CODE.NETWORK_ISSUE_CLIENT;
+            error = axiosErrorStatusText;
+        } else if (_.includes([400], axiosErrorStatus)) {
+            errorCode = EXCEPTION_CODE.SYS_UNKNOWN_ISSUE;
+            error = axiosErrorStatusText;
+        } else if (_.includes([404], axiosErrorStatus)) {
+            errorCode = EXCEPTION_CODE.SYS_UNKNOWN_ISSUE;
+            error = axiosErrorStatusText;
+        }
+    }
+
+    //session timeout
+    var sessionTimeoutErrorCodes = [
+        EXCEPTION_CODE.AUTHENTICATION_FAILED_COMMON
+    ]
+
+    if (_.includes(sessionTimeoutErrorCodes, errorCode)) {
+        await appSessionExit(errorCode, true);
+        return;
+    }
+
+    if (EXCEPTION_CODE.NETWORK_ISSUE_CLIENT === errorCode) {
+        await showErrorMessage(errorCode, "Network issue", error);
+        return;
+    }
+
+    await showErrorMessage(errorCode, null, getErrorMsgByCode(errorCode, error));
+}
+
+/**
+ * application exit handler
+ */
+async function appSessionExit(resultCode, forceCloseFlag) {
+    if(loginServiceInstance && loginServiceInstance.logout){
+        await loginServiceInstance.logout();
+    }else {
+        await globalDialogUtilsInstance.showAppErrorDialog("Session Timeout", "Please login again");
+    }
+}
+
+const AxiosUtils = {
+    init: init,
+    loadParamFromLocationSearch: loadParamFromLocationSearch,
+    getPath: getPath,
+    getUrlParam: getUrlParam,
+    getFormData: getFormData,
+    postFormData: postFormData,
+    getJsonData: getJsonData,
+    postJsonData: postJsonData,
+    downloadExcelData: downloadExcelData,
+    downloadServerData: downloadServerData,
+    uploadFile: uploadFile,
+    getStaticTextFile: getStaticTextFile,
+    appSessionExit: appSessionExit,
+    handlerError: handlerError,
+    getErrorMsgByCode: getErrorMsgByCode,
+
+    RESULT: RESULT,
+};
+
+export default AxiosUtils;

package/src/packages/utils/CfgUtils.js

@@ -0,0 +1,15 @@
+export default {
+    //Application Configuration
+    appInfo: {
+        appName: 'XMS',  //application name
+
+        needFrontEndExceptionStatisticsFlag: true, //need trace front-end logs
+    },
+    //Ajax Configuration
+    ajax:{
+        timeOut: 60000, //Timeout
+    },
+    sysCfg: {
+        ibmsEnabled: true,
+    }
+};

package/src/packages/utils/DateUtils.js

@@ -0,0 +1,223 @@
+import dayjs from "dayjs";
+
+const FORMAT_DATE = "DD-MM-YYYY";
+const FORMAT_DATETIME = "DD-MM-YYYY HH:mm:ss";
+const FORMAT_YEARMONTH = "YYYY-MMMM";
+const FORMAT_YEARWEEK = "YYYY-WW";
+const FORMAT_DAYOFMONTH = "DD";
+const FORMAT_YEAR = "YYYY";
+const FORMAT_TIME = "HH:mm:ss";
+
+function getCurrentMoment(){
+    return dayjs();
+}
+
+function getCurrentDateText(){
+    return convertMomentToDateText(getCurrentMoment());
+}
+
+function getCurrentDateTimeText(){
+    return convertMomentToDateTimeText(getCurrentMoment());
+}
+
+function getCurrentDate(){
+    return getCurrentMoment().toDate();
+}
+
+function convertMomentToTimestamp(moment) {
+    if (moment) {
+        return moment.toDate().getTime();
+    } else {
+        return null;
+    }
+}
+
+function convertMomentToDateText(moment) {
+    if (moment) {
+        return moment.format(FORMAT_DATE);
+    } else {
+        return '';
+    }
+}
+
+function convertTimestampToMoment(timestamp) {
+    if (timestamp && timestamp > 0) {
+        return dayjs(timestamp);
+    } else {
+        return null;
+    }
+}
+
+function convertMomentToDateTimeText(moment) {
+    if (moment) {
+        return moment.format(FORMAT_DATETIME);
+    } else {
+        return "";
+    }
+}
+
+function convertMomentToYearText(moment) {
+    if (moment) {
+        return moment.format(FORMAT_YEAR);
+    } else {
+        return "";
+    }
+}
+
+function convertMomentToYearMonthText(moment) {
+    if (moment) {
+        return moment.format(FORMAT_YEARMONTH);
+    } else {
+        return "";
+    }
+}
+
+function convertMomentToDayOfMonthText(moment) {
+    if (moment) {
+        return moment.format(FORMAT_DAYOFMONTH);
+    } else {
+        return "";
+    }
+}
+
+
+
+function convertMomentToTimeText(moment) {
+    if (moment) {
+        return moment.format(FORMAT_TIME);
+    } else {
+        return "";
+    }
+}
+
+function convertDateTimeTextToMoment(dateTimeText) {
+    if (dateTimeText) {
+        return dayjs(dateTimeText, FORMAT_DATETIME);
+    } else {
+        return null;
+    }
+}
+
+function convertYearMonthTextToMoment(yearMonthText) {
+    if (yearMonthText) {
+        return dayjs(yearMonthText, FORMAT_YEARMONTH);
+    } else {
+        return null;
+    }
+}
+
+function convertDateTextToMoment(dateText) {
+    if (dateText) {
+        return dayjs(dateText, FORMAT_DATE);
+    } else {
+        return null;
+    }
+}
+
+function convertTimeTextToMoment(dateTimeText) {
+    if (dateTimeText) {
+        return dayjs(dateTimeText, FORMAT_TIME);
+    } else {
+        return null;
+    }
+}
+
+function convertDateTextToDate(dateText) {
+    if (dateText) {
+        return dayjs(dateText, FORMAT_DATE).toDate();
+    } else {
+        return null;
+    }
+}
+
+function convertDateTimeTextToDate(dateTimeText) {
+    if (dateTimeText) {
+        let moment = dayjs(dateTimeText, FORMAT_DATETIME);
+        return dayjs(dateTimeText, FORMAT_DATETIME).toDate();
+    } else {
+        return null;
+    }
+}
+
+function convertTimestampToDateText(timestamp) {
+    let moments = convertTimestampToMoment(timestamp);
+    let text = convertMomentToDateText(moments);
+    return text;
+}
+
+function convertTimestampToDateTimeText(timestamp) {
+    let moments = convertTimestampToMoment(timestamp);
+    let text = convertMomentToDateTimeText(moments);
+    return text;
+}
+
+function convertDateToMoment(date) {
+    if(!date){
+        return null;
+    }
+    return dayjs(date);
+}
+
+function convertDateToDateText(date) {
+    let moments = convertDateToMoment(date);
+    let text = convertMomentToDateText(moments);
+    return text;
+}
+
+function convertDateToDateTimeText(date) {
+    let moments = convertDateToMoment(date);
+    let text = convertMomentToDateTimeText(moments);
+    return text;
+}
+
+
+function buildDateRange(from, to){
+    return from+" ~ "+to;
+}
+
+function getFormatTextOfMMM(mthNumber){
+    let moment = getCurrentMoment();
+    moment = moment.month(mthNumber-1);
+    return moment.format('MMM');
+}
+
+export default {
+    FORMAT_DATE: FORMAT_DATE,
+    FORMAT_DATETIME: FORMAT_DATETIME,
+    FORMAT_YEARMONTH: FORMAT_YEARMONTH,
+    FORMAT_YEARWEEK: FORMAT_YEARWEEK,
+    FORMAT_TIME: FORMAT_TIME,
+
+    getCurrentMoment: getCurrentMoment,
+    getCurrentDateTimeText: getCurrentDateTimeText,
+    getCurrentDateText: getCurrentDateText,
+    getCurrentDate: getCurrentDate,
+
+    convertMomentToTimestamp: convertMomentToTimestamp,
+    convertMomentToDateText: convertMomentToDateText,
+    convertMomentToDateTimeText: convertMomentToDateTimeText,
+    convertMomentToYearText: convertMomentToYearText,
+    convertMomentToYearMonthText: convertMomentToYearMonthText,
+    convertMomentToDayOfMonthText: convertMomentToDayOfMonthText,
+    convertMomentToTimeText: convertMomentToTimeText,
+
+    convertTimestampToMoment: convertTimestampToMoment,
+    convertTimestampToDateText: convertTimestampToDateText,
+    convertTimestampToDateTimeText: convertTimestampToDateTimeText,
+
+    convertDateToMoment: convertDateToMoment,
+    convertDateToDateText: convertDateToDateText,
+    convertDateToDateTimeText: convertDateToDateTimeText,
+
+    convertYearMonthTextToMoment: convertYearMonthTextToMoment,
+    convertDateTextToMoment: convertDateTextToMoment,
+    convertDateTimeTextToMoment: convertDateTimeTextToMoment,
+    convertTimeTextToMoment: convertTimeTextToMoment,
+
+    convertDateTextToDate: convertDateTextToDate,
+    convertDateTimeTextToDate: convertDateTimeTextToDate,
+
+    buildDateRange:buildDateRange,
+
+    getFormatTextOfMMM: getFormatTextOfMMM,
+};

package/src/packages/utils/DomUtils.js

@@ -0,0 +1,48 @@
+import _ from "lodash";
+
+function resetBodyScroll(){
+    document.querySelector("body").style.position="initial";
+}
+
+function forbidBodyScroll(){
+    document.querySelector("body").style.position="fixed";
+}
+
+function syncDomAnimation() {
+    setTimeout(() => {
+        //sync all animation be the same
+        _.each(document.getAnimations(), (item) => {
+            item.startTime = 0;
+        });
+    }, 200);
+}
+
+/**
+ * find the closet parent element by className
+ *
+ * @param elem
+ * @param className
+ */
+function closetByClassName(elem, classNameList) {
+    let classList = elem.classList;
+    if (classList) {
+        if (_.intersection(classList, classNameList).length > 0) {
+            return elem;
+        }
+    }
+
+    let parentElement = elem.parentElement;
+    if (parentElement) {
+        return closetByClassName(parentElement, classNameList);
+    } else {
+        return null;
+    }
+}
+
+export default {
+    resetBodyScroll: resetBodyScroll,
+    forbidBodyScroll: forbidBodyScroll,
+
+    syncDomAnimation: syncDomAnimation,
+    closetByClassName: closetByClassName,
+};