@bchr/bchr-front-lib 0.4.4 → 0.5.1-alpha-20241221

package/src/services/http.js

@@ -0,0 +1,1075 @@
+import lodash from "lodash";
+import queryString from "query-string";
+import {Strings, Values} from '../base/utils';
+import {saveAs} from "file-saver";
+import {forceRedirectToForError, isNeedForceRedirect} from "../base/utils/AppKits";
+import { message } from 'antd';
+import React from "react";
+
+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)
+        }
+    },
+
+    post: function (options, jsonObject, mockData) {
+        let ajaxOptions = {};
+        let failedDealFunction = this.dealAjaxException;
+        if (lodash.isPlainObject(options)) {
+            if (lodash.isFunction(options.fail)) {
+                failedDealFunction = options.fail
+                delete options.fail;
+            }
+            ajaxOptions = {...options};
+        }
+
+        try {
+            this.__checkJSONObjectSecurity(jsonObject)
+        }
+        catch (e) {
+            let promise = new Promise(function (resolve, reject) {
+                return reject(e);
+            });
+
+            if (this.isUseDefaultExceptionHandler()) {
+                return promise.catch(failedDealFunction);
+            }
+
+            return promise;
+        }
+
+        if (jsonObject) {
+            ajaxOptions.data = jsonObject;
+        }
+
+        if (ajaxOptions.rpcMethodName) {
+            delete ajaxOptions.rpcMethodName;
+        }
+
+        ajaxOptions.type = "post";
+        ajaxOptions.dataType = "json";
+
+        if (!ajaxOptions.url) {
+            ajaxOptions.url = this.getRequestPath(options);
+        }
+
+        if (this.isValidMockData(mockData)) {
+            let promise = this.__postForMock(mockData);
+            if (this.isUseDefaultExceptionHandler()) {
+                return promise.catch(failedDealFunction);
+            }
+            return promise;
+        }
+        else {
+            let deferred = window.$.ajax(ajaxOptions);
+
+            if (this.isUseDefaultExceptionHandler()) {
+                return this.__toStdPromise(deferred, failedDealFunction);
+            }
+            else {
+                return this.__toStdPromise(deferred);
+            }
+        }
+    },
+
+    __postForMock: function (mockData) {
+
+        let waitTime = mockData.waitTime ? mockData.waitTime : 600;
+        return new Promise(function (resolve, reject) {
+
+            setTimeout(function () {
+                if (mockData.success === false) {
+                    return reject(new Error(mockData.message ? mockData.message : "请求数据发生异常"));
+                }
+                else {
+                    let resultData = mockData.data ? mockData.data : mockData;
+                    return resolve(resultData);
+                }
+            }, waitTime)
+        });
+    },
+
+    postJSONWithNotCareSecurity: function(options, jsonObject, mockData) {
+        let ajaxOptions = {};
+        let failedDealFunction = this.dealAjaxException;
+        if (lodash.isPlainObject(options)) {
+            if (lodash.isFunction(options.fail)) {
+                failedDealFunction = options.fail
+                delete options.fail;
+            }
+            ajaxOptions = {...options};
+        }
+
+        if (ajaxOptions.rpcMethodName) {
+            delete ajaxOptions.rpcMethodName;
+        }
+
+        if (lodash.isPlainObject(ajaxOptions.data)) {
+            jsonObject = ajaxOptions.data;
+        }
+
+        if (jsonObject) {
+            ajaxOptions.data = jsonObject;
+        }
+
+        if (ajaxOptions.data) {
+            ajaxOptions.data = JSON.stringify(ajaxOptions.data);
+        }
+
+        ajaxOptions.type = "post";
+        ajaxOptions.dataType = "json";
+        ajaxOptions.contentType = "application/json; charset=utf-8";
+        if (!ajaxOptions.url) {
+            ajaxOptions.url = this.getRequestPath(options);
+        }
+
+        if (this.isValidMockData(mockData)) {
+            let promise =  this.__postJSONForMock(mockData);
+            if (this.isUseDefaultExceptionHandler()) {
+                return promise.catch(failedDealFunction);
+            }
+            return promise;
+        }
+        else {
+            let deferred = window.$.ajax(ajaxOptions);
+            if (this.isUseDefaultExceptionHandler()) {
+                return this.__toStdPromise(deferred, failedDealFunction);
+            }
+            else {
+                return this.__toStdPromise(deferred);
+            }
+        }
+    },
+
+    postJSON: function(options, jsonObject, mockData) {
+        let ajaxOptions = {};
+        let failedDealFunction = this.dealAjaxException;
+        if (lodash.isPlainObject(options)) {
+            if (lodash.isFunction(options.fail)) {
+                failedDealFunction = options.fail
+                delete options.fail;
+            }
+            ajaxOptions = {...options};
+        }
+
+        if (lodash.isPlainObject(ajaxOptions.data)) {
+            jsonObject = ajaxOptions.data;
+        }
+
+        try {
+            this.__checkJSONObjectSecurity(jsonObject)
+        }
+        catch (e) {
+            let promise = new Promise(function (resolve, reject) {
+                return reject(e);
+            });
+
+            if (this.isUseDefaultExceptionHandler()) {
+                return promise.catch(failedDealFunction);
+            }
+
+            return promise;
+        }
+
+        return this.postJSONWithNotCareSecurity(options, jsonObject, mockData);
+    },
+
+    postJSONAllowHTML: function(options, jsonObject, mockData) {
+        let ajaxOptions = {};
+        let failedDealFunction = this.dealAjaxException;
+        if (lodash.isPlainObject(options)) {
+            if (lodash.isFunction(options.fail)) {
+                failedDealFunction = options.fail
+                delete options.fail;
+            }
+            ajaxOptions = {...options};
+        }
+
+        if (lodash.isPlainObject(ajaxOptions.data)) {
+            jsonObject = ajaxOptions.data;
+        }
+
+        try {
+            this.__checkJSONObjectContainsScriptTag(jsonObject)
+        }
+        catch (e) {
+            let promise = new Promise(function (resolve, reject) {
+                return reject(e);
+            });
+
+            if (this.isUseDefaultExceptionHandler()) {
+                return promise.catch(failedDealFunction);
+            }
+
+            return promise;
+        }
+
+        return this.postJSONWithNotCareSecurity(options, jsonObject, mockData);
+    },
+
+    __checkJSONObjectContainsScriptTag: function(jsonObject) {
+        if (!jsonObject) {
+            return;
+        }
+
+        if (lodash.isString(jsonObject)) {
+            this.__checkStringContainsScriptTag(jsonObject);
+        }
+        else if (Array.isArray(jsonObject)) {
+            let len = jsonObject.length;
+            if (len === 0) {
+                return;
+            }
+
+            for (let i = 0; i < len; i++) {
+                this.__checkJSONObjectContainsScriptTag(jsonObject[i]);
+            }
+        }
+        else if (lodash.isPlainObject(jsonObject)) {
+            for (let p in jsonObject) {
+                this.__checkJSONObjectContainsScriptTag(jsonObject[p]);
+            }
+        }
+
+        return;
+    },
+
+    __checkStringContainsScriptTag: function(str) {
+        if (!str || str.length < 3) {
+            return;
+        }
+
+        let containsHTML = /<(noframes|noscript|object|script|video).*?<\/\2>/i.test(str);
+        if (containsHTML) {
+            throw new Error("不安全的输入,请检查!");
+        }
+    },
+
+    __checkJSONObjectSecurity: function(jsonObject) {
+        if (!jsonObject) {
+            return;
+        }
+
+        if (lodash.isString(jsonObject)) {
+            this.__checkStringIfSecurity(jsonObject);
+        }
+        else if (Array.isArray(jsonObject)) {
+            let len = jsonObject.length;
+            if (len === 0) {
+                return;
+            }
+
+            for (let i = 0; i < len; i++) {
+                this.__checkJSONObjectSecurity(jsonObject[i]);
+            }
+        }
+        else if (lodash.isPlainObject(jsonObject)) {
+            for (let p in jsonObject) {
+                this.__checkJSONObjectSecurity(jsonObject[p]);
+            }
+        }
+
+        return;
+    },
+
+    __checkStringIfSecurity: function(str) {
+        if (!str || str.length < 3) {
+            return;
+        }
+
+        let containsHTML = /<(br|basefont|hr|input|source|frame|param|area|meta|!--|col|link|option|base|img|wbr|!DOCTYPE).*?>|<(a|abbr|acronym|address|applet|article|aside|audio|b|bdi|bdo|big|blockquote|body|button|canvas|caption|center|cite|code|colgroup|command|datalist|dd|del|details|dfn|dialog|dir|div|dl|dt|em|embed|fieldset|figcaption|figure|font|footer|form|frameset|head|header|hgroup|h1|h2|h3|h4|h5|h6|html|i|iframe|ins|kbd|keygen|label|legend|li|map|mark|menu|meter|nav|noframes|noscript|object|ol|optgroup|output|p|pre|progress|q|rp|rt|ruby|s|samp|script|section|select|small|span|strike|strong|style|sub|summary|sup|table|tbody|td|textarea|tfoot|th|thead|time|title|tr|track|tt|u|ul|var|video).*?<\/\2>/i.test(str);
+        if (containsHTML) {
+            throw new Error("不安全的输入,请检查!");
+        }
+    },
+
+    __postJSONForMock: function(mockData) {
+        let waitTime = mockData.waitTime ? mockData.waitTime : 300;
+        return new Promise(function (resolve, reject) {
+            setTimeout(function () {
+                if (mockData.success === false) {
+                    return reject(new Error(mockData.message ? mockData.message : "请求数据发生异常"));
+                }
+                else {
+                    let resultData = mockData.data ? mockData.data : mockData;
+                    return resolve(resultData);
+                }
+            }, waitTime)
+        });
+    },
+
+    getJSON: function(options, paramObject, mockData) {
+        let ajaxOptions = {};
+        let failedDealFunction = this.dealAjaxException;
+        if (lodash.isPlainObject(options)) {
+            if (lodash.isFunction(options.fail)) {
+                failedDealFunction = options.fail
+                delete options.fail;
+            }
+            ajaxOptions = {...options};
+        }
+
+        ajaxOptions.type = "get";
+        ajaxOptions.dataType = "json";
+        if (lodash.isPlainObject(paramObject)) {
+            ajaxOptions.data = paramObject;
+        }
+
+        if (!ajaxOptions.data){
+            ajaxOptions.data = {};
+        }
+
+        if (!ajaxOptions.data.euts) {
+            ajaxOptions.data.euts = (new Date()).getTime();
+        }
+
+        if (!ajaxOptions.url) {
+            ajaxOptions.url = this.getRequestPath(options);
+        }
+
+        if (this.isValidMockData(mockData)) {
+            let promise = this.__getJSONForMock(mockData);
+            if (this.isUseDefaultExceptionHandler()) {
+                return promise.catch(failedDealFunction);
+            }
+            return promise;
+        }
+        else {
+            let deferred = window.$.ajax(ajaxOptions);
+            if (this.isUseDefaultExceptionHandler()) {
+                return this.__toStdPromise(deferred, failedDealFunction);
+            }
+            else {
+                return this.__toStdPromise(deferred);
+            }
+        }
+    },
+
+    isValidMockData : function (mockData) {
+        if (mockData === null || mockData === void 0) {
+            return false;
+        }
+
+        return lodash.isPlainObject(mockData);
+    },
+
+    __getJSONForMock: function(mockData) {
+
+        let waitTime = mockData.waitTime ? mockData.waitTime : 600;
+        return new Promise(function (resolve, reject) {
+
+            setTimeout(function () {
+                if (mockData.success === false) {
+                    return reject(new Error(mockData.message ? mockData.message : "请求数据发生异常"));
+                }
+                else {
+                    let resultData = mockData.data ? mockData.data : mockData;
+                    return resolve(resultData);
+                }
+            }, waitTime)
+        });
+    },
+
+    requestStaticHTMLTemplate: function(staticTemplateFilePath) {
+        let deferred = window.$.ajax({
+            url : staticTemplateFilePath,
+            dataType: "html"
+        });
+
+        let failedDealFunction = this.dealAjaxException;
+        return this.__toStdPromise(deferred, failedDealFunction);
+    },
+
+    downloadFileByPostJSON: function (options, jsonObject, saveFileName) {
+        let ajaxOptions = {};
+        let failedDealFunction = this.dealAjaxException;
+        if (lodash.isPlainObject(options)) {
+            if (lodash.isFunction(options.fail)) {
+                failedDealFunction = options.fail
+                delete options.fail;
+            }
+            ajaxOptions = {...options};
+        }
+
+        if (lodash.isPlainObject(ajaxOptions.data)) {
+            jsonObject = ajaxOptions.data;
+        }
+
+        try {
+            this.__checkJSONObjectSecurity(jsonObject)
+        }
+        catch (e) {
+            let promise = new Promise(function (resolve, reject) {
+                return reject(e);
+            });
+
+            if (this.isUseDefaultExceptionHandler()) {
+                return promise.catch(failedDealFunction);
+            }
+
+            return promise;
+        }
+
+        if (jsonObject) {
+            ajaxOptions.data = jsonObject;
+        }
+
+        if (ajaxOptions.rpcMethodName) {
+            delete ajaxOptions.rpcMethodName;
+        }
+
+        ajaxOptions.type = "post";
+        ajaxOptions.dataType = "*";
+
+        if (!ajaxOptions.data){
+            ajaxOptions.data = {};
+        }
+
+        if (!ajaxOptions.data.euts) {
+            ajaxOptions.data.euts = (new Date()).getTime();
+        }
+
+        if (!ajaxOptions.url) {
+            ajaxOptions.url = this.getRequestPath(options);
+        }
+
+        ajaxOptions.xhrFields = {
+            responseType: "blob"
+        }
+
+        ajaxOptions.success = function (result, request, xhr) {
+            let fileName = "下载文件-" + new Date().getTime();
+            if (lodash.isString(saveFileName) && saveFileName.length > 0) {
+                fileName = saveFileName
+            }
+            else {
+                let contentDisposition = xhr.getResponseHeader('Content-Disposition');
+                if (contentDisposition && contentDisposition.split) {
+                    let parts = contentDisposition.split(';');
+                    if (parts.length >= 1) {
+                        let fileInfo = parts[1]
+                        let fileInfoArray = fileInfo.split('=');
+                        if (fileInfoArray.length >= 1) {
+                            fileName = fileInfoArray[1];
+                            fileName = decodeURIComponent(fileName)
+                            fileName = fileName.replaceAll("\"", "")
+                        }
+                    }
+                }
+            }
+
+            let type = xhr.getResponseHeader("content-type")
+            if (!type) {
+                type = "application/octet-stream";
+            }
+            let blob = new Blob([result], { type: type })
+            saveAs(blob, fileName)
+        }
+
+        ajaxOptions.error = function (error) {
+            console.log('ajaxOptions :', error)
+        }
+
+        let deferred = window.$.ajax(ajaxOptions);
+
+        if (this.isUseDefaultExceptionHandler()) {
+            return this.__toStdPromise(deferred, failedDealFunction);
+        }
+        else {
+            return this.__toStdPromise(deferred);
+        }
+    },
+
+    createRequestURL: function (requestURL, params) {
+        let lastRequestURL = this.getRequestPath(requestURL);
+        if (!params) {
+            return lastRequestURL;
+        }
+        else if (lodash.isString(params)) {
+            if (requestURL.includes('?')) {
+                let requestURLData = queryString.parseUrl(requestURL);
+                if (JSON.stringify(requestURLData.query) === '{}') {
+                    return `${requestURL}${params}`;
+                }
+                return `${requestURL}&${params}`;
+            }
+            return `${requestURL}?${params}`;
+        }
+        else if (lodash.isPlainObject(params)) {
+            if (requestURL.includes('?')) {
+                let requestURLData = queryString.parseUrl(requestURL);
+                if (JSON.stringify(requestURLData.query) === '{}') {
+                    return `${requestURL}${this.encodeObject2ParameterString(params)}`;
+                }
+                return `${requestURL}&${this.encodeObject2ParameterString(params)}`;
+            }
+            return `${requestURL}?${this.encodeObject2ParameterString(params)}`;
+        }
+    },
+
+    /**
+     * !important! <br/>
+     * DoNot use this pointer in this function body.
+     */
+    dealAjaxException: function (httpExceptionResponse) {
+        let errorID = "[ClientTraceID=" + new Date().getTime() + "] ";
+        let errorMsg = null;
+        if (lodash.isString(httpExceptionResponse)) {
+            errorMsg = httpExceptionResponse;
+            message.error(errorMsg)
+        }
+        else if (httpExceptionResponse && (httpExceptionResponse.responseJSON || httpExceptionResponse.response)) {
+            let responseJSON = httpExceptionResponse.responseJSON || (Strings.isNotBlankString(httpExceptionResponse.response) ? JSON.parse(httpExceptionResponse.response) : httpExceptionResponse.response);
+            let responseJSONData = responseJSON.resultData || responseJSON.data;
+            let statusCode = responseJSON.statusCode;
+            if (statusCode && statusCode > 40000 && statusCode < 50000) {
+                errorMsg = responseJSON.msg || responseJSON.message;
+                message.error(errorMsg)
+                console.error(errorID + "Http request error:" + errorMsg, httpExceptionResponse)
+                if (isNeedForceRedirect()) {
+                    setTimeout(() => {
+                        forceRedirectToForError();
+                    }, 300)
+                }
+
+                return httpExceptionResponse;
+            }
+
+            if (Values.isNotEmptyArray(responseJSONData)) {
+                let msgItemList = responseJSONData.map(msgItem => <li>{msgItem}</li>)
+                let durationSeconds = responseJSONData.length * 1;
+                durationSeconds = durationSeconds < 3 ? 3 : durationSeconds;
+                let multiLineOpts = {
+                    content: (
+                        <>
+                            <div>{responseJSON.msg}</div>
+                            <ol style={{ marginTop: 8, paddingLeft: 0 }}>
+                                {msgItemList}
+                            </ol>
+                        </>
+                    ),
+                    duration: durationSeconds,
+                };
+                message.error(multiLineOpts);
+            } else {
+                if (responseJSON.error) {
+                    if (Values.isNotBlankString(responseJSON.error.msg)) {
+                        errorMsg = responseJSON.error.msg;
+                    }
+                    else if (Values.isNotBlankString(responseJSON.error.message)) {
+                        errorMsg = responseJSON.error.message;
+                    }
+                    else if (Values.isNotBlankString(responseJSON.error))  {
+                        errorMsg = responseJSON.error;
+                    }
+
+                    if (Values.isNotBlankString(errorMsg)) {
+                        message.error(errorMsg)
+                    }
+                } else {
+                    errorMsg = responseJSON.msg || responseJSON.message || responseJSON.err;
+
+                    if (Values.isNotBlankString(errorMsg)) {
+                        message.error(errorMsg)
+                    }
+                }
+            }
+            console.error(errorID + "Http request error:" + errorMsg, httpExceptionResponse)
+            return httpExceptionResponse;
+        }
+        else if (Values.isNotBlankString(httpExceptionResponse.message)) {
+            message.error(httpExceptionResponse.message)
+        }
+        else if (httpExceptionResponse.status === 502) {
+            message.error("[502]服务正在重启,请稍后重试")
+        }
+        else if (httpExceptionResponse.status === 200) {
+            message.error("[200]Http状态码为200,但是出错,可能的原因是数据格式转换异常,请排查。")
+        }
+        else if (httpExceptionResponse.status === 404) {
+            let contentType = httpExceptionResponse.getResponseHeader("Content-Type");
+            if (Values.isNotBlankString(contentType) && !contentType.toLowerCase().startsWith("application/json")) {
+                // because the request is always to for backend service
+                // but when failed, we always return json;
+                // when not json, that is always the backend service not available (not start);
+                message.error("[404] Not Found, 可能是后端服务尚未启动.")
+                if (isNeedForceRedirect()) {
+                    setTimeout(() => {
+                        forceRedirectToForError();
+                    }, 300)
+                }
+            }
+            else {
+                message.error("[404] Not Found（所请求的资源不存在）")
+            }
+        }
+        else if (httpExceptionResponse.status === 0 || httpExceptionResponse.readyState === 0) {
+            message.error("应用服务链路不通：请联系管理员检查应用服务是否已启动.")
+        }
+        else if (httpExceptionResponse.status && httpExceptionResponse.statusText) {
+            let errorTip = "[" + httpExceptionResponse.status + "] " + httpExceptionResponse.statusText;
+            message.error(errorTip)
+        }
+
+        console.error(errorID + "Maybe Http request error or Unresolved promise message:", httpExceptionResponse)
+        return httpExceptionResponse;
+    },
+
+    __toStdPromise: function (deferred, failedDealFunction) {
+        if (failedDealFunction === null || failedDealFunction === void 0) {
+            return Promise.resolve(deferred);
+        }
+
+        return Promise.resolve(deferred).catch(failedDealFunction)
+    }
+}
+
+export default http;