fastchar-appjs/src/esm/FastServer.js

快速搭建VUE项目工具类的基本库，主要用于每个功能页面独立生成html，不使用vue单页面功能。

define(["require", "exports", "tslib", "axios", "./FastNative", "./FastBaseApp", "./FastHelper"], function (require, exports, tslib_1, axios_1, FastNative_1, FastBaseApp_1, FastHelper_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.FastServer = void 0;
    axios_1 = tslib_1.__importDefault(axios_1);
    /**
     * FastServer 创息公司请求服务器接口工具类
     * @author Janesen
     */
    var FastServer;
    (function (FastServer) {
        /**
         * 基本的网络请求接口
         */
        var Base = /** @class */ (function () {
            function Base() {
            }
            /**
             * 获取请求接口的默认头信息配置
             */
            Base.getHeaderConfig = function () {
                if (window["FastSecurity"]) {
                    return {
                        token: FastSecurity.token()
                    };
                }
                return {};
            };
            /**
             * 获取地址栏携带的参数
             * @param paramName 参数名
             */
            Base.getWindowUrlParam = function (paramName) {
                return this.getUrlParam(window.location.href, paramName);
            };
            /**
             * 获取地址栏携带的参数对象信息
             */
            Base.getWindowUrlInfo = function () {
                return this.getUrlParamInfo(window.location.href);
            };
            /**
             * 获取url的参数
             * @param url 地址
             * @param paramName 参数名
             */
            Base.getUrlParam = function (url, paramName) {
                var windowUrlInfo = FastServer.Base.getUrlParamInfo(url);
                for (var windowUrlInfoKey in windowUrlInfo) {
                    if (windowUrlInfoKey == paramName) {
                        return windowUrlInfo[windowUrlInfoKey];
                    }
                }
                return null;
            };
            /**
             * 获取url的参数实体对象
             * @param url 地址
             */
            Base.getUrlParamInfo = function (url) {
                var urlInfo = {};
                var splitArray = url.split("#")[0].split("?");
                var search = splitArray[splitArray.length - 1];
                var vars = search.split("&");
                for (var i = 0; i < vars.length; i++) {
                    var pair = vars[i].split("=");
                    urlInfo[pair[0]] = pair[1];
                }
                return urlInfo;
            };
            /**
             * 追加url参数
             * @param url
             * @param params
             */
            Base.appendUrlParams = function (url, params) {
                var newUrl = url;
                if (url.indexOf("?") > 0) {
                    newUrl = url + "&1=1";
                }
                else {
                    newUrl = url + "?1=1";
                }
                if (params) {
                    this.convertToFormData(params).forEach(function (value, key, parent) {
                        if (value instanceof File) {
                            return;
                        }
                        newUrl = newUrl + "&" + key + "=" + value;
                    });
                }
                return newUrl;
            };
            /**
             * 合并多个FormData参数
             * @param formData
             */
            Base.mergeFormData = function () {
                var formData = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    formData[_i] = arguments[_i];
                }
                var newParams = new FormData();
                formData.forEach(function (item) {
                    if (FastHelper_1.FastHelper.Strings.isEmpty(item)) {
                        return true;
                    }
                    item.forEach(function (value, key, parent) {
                        newParams.append(key, value);
                    });
                });
                return newParams;
            };
            /**
             * 如果是formData对象则转转换参数为object对象
             * @param param
             */
            Base.convertToObject = function (param) {
                if (param instanceof FormData) {
                    var newParams_1 = {};
                    param.forEach(function (value, key, parent) {
                        newParams_1[key] = value;
                    });
                    return newParams_1;
                }
                return param;
            };
            /**
             * 转换参数为FormData格式
             * @param param 任意格式的参数，FormData、Object、Function
             */
            Base.convertToFormData = function (param) {
                var newParams = new FormData();
                if (param instanceof FormData) {
                    return param;
                }
                else if (FastHelper_1.FastHelper.Functions.isFunction(param)) {
                    return this.convertToFormData(param());
                }
                else {
                    for (var paramKey in param) {
                        if (param.hasOwnProperty(paramKey)) {
                            newParams.append(paramKey, param[paramKey]);
                        }
                    }
                }
                return newParams;
            };
            /**
             * 合并参数并转换为FormData格式
             * @param params 任意多个参数，FormData、Object、Function
             */
            Base.mergeParams = function () {
                var params = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    params[_i] = arguments[_i];
                }
                var newParams = new FormData();
                params.forEach(function (param) {
                    if (FastHelper_1.FastHelper.Strings.isEmpty(param)) {
                        return true;
                    }
                    if (FastHelper_1.FastHelper.Arrays.isArray(param)) {
                        newParams = FastServer.Base.mergeFormData(newParams, FastServer.Base.mergeParamsByArray(param));
                    }
                    else {
                        newParams = FastServer.Base.mergeFormData(newParams, FastServer.Base.convertToFormData(param));
                    }
                });
                return newParams;
            };
            /**
             * 将数组格式的参数合并
             * @param params 数组
             */
            Base.mergeParamsByArray = function (params) {
                var newParams = new FormData();
                for (var i = 0; i < params.length; i++) {
                    var item = params[i];
                    if (FastHelper_1.FastHelper.Strings.isEmpty(item)) {
                        continue;
                    }
                    if (FastHelper_1.FastHelper.Arrays.isArray(item)) {
                        newParams = FastServer.Base.mergeFormData(newParams, FastServer.Base.mergeParamsByArray(item));
                    }
                    else {
                        newParams = FastServer.Base.mergeFormData(newParams, FastServer.Base.convertToFormData(item));
                    }
                }
                return newParams;
            };
            /**
             * 发起接口请求
             * @param method 请求方法，例如，post、get
             * @param url 请求地址
             * @param params 请求参数
             */
            Base.doRequest = function (method, url, params) {
                var axiosConfig = {
                    headers: FastServer.Base.getHeaderConfig(),
                    method: method,
                    url: url,
                    timeout: 3 * 60 * 1000
                };
                if (method === "post") {
                    if (FastHelper_1.FastHelper.Strings.isString(params)) {
                        axiosConfig.paramsSerializer = params;
                    }
                    else {
                        axiosConfig.data = this.convertToFormData(params);
                    }
                }
                else {
                    if (FastHelper_1.FastHelper.Strings.isString(params)) {
                        axiosConfig.paramsSerializer = params;
                    }
                    else {
                        axiosConfig.params = FastServer.Base.convertToObject(params);
                    }
                }
                return axios_1.default(axiosConfig);
            };
            /**
             * 执行post请求
             * @param url 请求地址
             * @param params 请求参数，可为object或formdata
             */
            Base.doPost = function (url, params) {
                return this.doRequest("post", url, params);
            };
            /**
             * 执行get请求
             * @param url 请求接口地址
             * @param params 请求接口参数
             */
            Base.doGet = function (url, params) {
                return this.doRequest("get", url, params);
            };
            return Base;
        }());
        FastServer.Base = Base;
        // noinspection DuplicatedCode
        /**
         * 创息公司系统的接口请求类
         */
        var Croshe = /** @class */ (function (_super) {
            tslib_1.__extends(Croshe, _super);
            function Croshe() {
                return _super !== null && _super.apply(this, arguments) || this;
            }
            /**
             * 获取接口的全局参数，同步获取了原生APP的全局参数
             */
            Croshe.getFinalParams = function () {
                return tslib_1.__awaiter(this, void 0, void 0, function () {
                    var result, justFinalParams, dataKey, finalParams, dataKey;
                    return tslib_1.__generator(this, function (_a) {
                        switch (_a.label) {
                            case 0: return [4 /*yield*/, FastNative_1.FastNative.CrosheApp.getFinalParams()];
                            case 1:
                                result = _a.sent();
                                justFinalParams = {};
                                if (result && result.success) {
                                    for (dataKey in result.data) {
                                        justFinalParams[dataKey] = result.data[dataKey];
                                    }
                                }
                                finalParams = FastBaseApp_1.FastBaseApp.Config.getGlobalConfig("FinalParams");
                                if (finalParams) {
                                    for (dataKey in finalParams) {
                                        if (finalParams[dataKey] === undefined) {
                                            continue;
                                        }
                                        justFinalParams[dataKey] = finalParams[dataKey];
                                    }
                                }
                                return [2 /*return*/, justFinalParams];
                        }
                    });
                });
            };
            /**
             * 发起请求接口
             * @param method 请求方法，例如：post、get
             * @param url 接口地址 完整的地址，例如：http://loalhost:8080/user/login
             * @param params 参数
             * @param config 请求配置
             * @param callBack 请求接口回调函数，在使用alwaysCache和alwaysBackRequest参数为true时，必须使用回调函数接收
             */
            Croshe.request = function (method, url, params, config, callBack) {
                return tslib_1.__awaiter(this, void 0, void 0, function () {
                    return tslib_1.__generator(this, function (_a) {
                        return [2 /*return*/, new Promise(function (resolved, rejected) {
                                return tslib_1.__awaiter(this, void 0, void 0, function () {
                                    var justFinalParams, dataKey, cacheKey, cachedData, result, fastResponseData, fastResponseData;
                                    return tslib_1.__generator(this, function (_a) {
                                        switch (_a.label) {
                                            case 0:
                                                if (!config) {
                                                    config = {
                                                        finalParams: true
                                                    };
                                                }
                                                params = FastServer.Base.convertToFormData(params);
                                                if (!config.finalParams) return [3 /*break*/, 2];
                                                return [4 /*yield*/, FastServer.Croshe.getFinalParams()];
                                            case 1:
                                                justFinalParams = _a.sent();
                                                for (dataKey in justFinalParams) {
                                                    if (params.has(dataKey)) {
                                                        delete justFinalParams[dataKey];
                                                    }
                                                }
                                                params = FastServer.Base.mergeParams(justFinalParams, params);
                                                _a.label = 2;
                                            case 2:
                                                cacheKey = FastServer.Croshe.buildCacheKey(url, params);
                                                cachedData = false;
                                                if (!config.cache) return [3 /*break*/, 4];
                                                return [4 /*yield*/, FastNative_1.FastNative.CrosheApp.getCache(cacheKey)];
                                            case 3:
                                                result = _a.sent();
                                                if (result.success) {
                                                    cachedData = true;
                                                    fastResponseData = new FastResponseData(JSON.parse(result.data), true);
                                                    fastResponseData.requestConfig = config;
                                                    resolved(fastResponseData);
                                                    if (callBack) {
                                                        callBack(fastResponseData);
                                                    }
                                                    if (!config.alwaysCache) {
                                                        return [2 /*return*/];
                                                    }
                                                }
                                                _a.label = 4;
                                            case 4:
                                                if (!url) {
                                                    fastResponseData = new FastResponseData({ success: false, message: "JS错误：请求地址不可为空！" });
                                                    resolved(fastResponseData);
                                                    if (callBack) {
                                                        callBack(fastResponseData);
                                                    }
                                                    return [2 /*return*/];
                                                }
                                                FastServer.Base.doRequest(method, url, params).then(function (response) {
                                                    if (!config) {
                                                        config = new FastServer.FastRequestConfig();
                                                    }
                                                    var fastResponseData = new FastResponseData(response.data);
                                                    fastResponseData.requestConfig = config;
                                                    if (config.cache) {
                                                        if (config.alwaysBackRequest || !cachedData) {
                                                            resolved(fastResponseData);
                                                            if (callBack) {
                                                                callBack(fastResponseData);
                                                            }
                                                        }
                                                        FastNative_1.FastNative.CrosheApp.setCache(cacheKey, JSON.stringify(response.data));
                                                    }
                                                    else {
                                                        resolved(fastResponseData);
                                                        if (callBack) {
                                                            callBack(fastResponseData);
                                                        }
                                                    }
                                                }).catch(function (error) {
                                                    console.error(error);
                                                    rejected(error);
                                                });
                                                return [2 /*return*/];
                                        }
                                    });
                                });
                            })];
                    });
                });
            };
            /**
             * post请求接口
             * @param url 接口地址 完整的地址，例如：http://loalhost:8080/user/login
             * @param params 参数
             * @param config 请求配置
             * @param callBack 请求接口回调函数，在使用alwaysCache和alwaysBackRequest参数为true时，必须使用回调函数接收
             */
            Croshe.post = function (url, params, config, callBack) {
                return tslib_1.__awaiter(this, void 0, void 0, function () {
                    return tslib_1.__generator(this, function (_a) {
                        return [2 /*return*/, this.request("post", url, params, config, callBack)];
                    });
                });
            };
            /**
             * get请求接口
             * @param url 接口地址 完整的地址，例如：http://loalhost:8080/user/login
             * @param params 参数
             * @param config 请求配置
             * @param callBack 请求接口回调函数，在使用alwaysCache和alwaysBackRequest参数为true时，必须使用回调函数接收
             */
            Croshe.get = function (url, params, config, callBack) {
                return tslib_1.__awaiter(this, void 0, void 0, function () {
                    return tslib_1.__generator(this, function (_a) {
                        return [2 /*return*/, this.request("get", url, params, config, callBack)];
                    });
                });
            };
            /**
             * 构建接口请求的缓存key
             * @param url 请求地址
             * @param params 请求参数
             */
            Croshe.buildCacheKey = function (url, params) {
                var md5 = require('md5');
                if (params instanceof FormData) {
                    var paramObj_1 = {};
                    params.forEach(function (value, key, parent) {
                        if (value instanceof File) {
                            paramObj_1[key] = value.name + "//" + value.size + "//" + value.type;
                        }
                        else {
                            paramObj_1[key] = value;
                        }
                    });
                    return md5(url + JSON.stringify(paramObj_1));
                }
                return md5(url + JSON.stringify(params));
            };
            return Croshe;
        }(Base));
        FastServer.Croshe = Croshe;
        /**
         * 创息公司接口返回数据的格式解析类
         */
        var FastResponseData = /** @class */ (function () {
            function FastResponseData(responseData, cacheData) {
                this.cacheData = false;
                this.requestConfig = new FastServer.FastRequestConfig();
                this.responseData = responseData;
                if (cacheData == undefined) {
                    cacheData = false;
                }
                this.cacheData = cacheData;
            }
            /**
             * 获取接口返回的原始数据
             */
            FastResponseData.prototype.getResponseData = function () {
                return this.responseData;
            };
            /**
             * 判断当前回调的数据是否是缓存的数据
             */
            FastResponseData.prototype.isCacheData = function () {
                return this.cacheData;
            };
            /**
             * 判断接口是否请求成功-success
             */
            FastResponseData.prototype.isSuccess = function () {
                return this.responseData.success;
            };
            /**
             * 获取接口请求返回的状态值-code
             */
            FastResponseData.prototype.getCode = function () {
                return this.responseData.code;
            };
            /**
             * 获取接口请求返回的消息提示-message
             */
            FastResponseData.prototype.getMessage = function () {
                return this.responseData.message;
            };
            /**
             * 获取接口请求返回的数据-data
             */
            FastResponseData.prototype.getData = function () {
                return this.responseData.data;
            };
            /**
             * 获取接口请求返回的其他数据，例如：data_1、data_2
             * @param suffixIndex 数据后缀，例如:data_1 后缀传 1
             */
            FastResponseData.prototype.getOtherData = function (suffixIndex) {
                return this.responseData["data_" + suffixIndex];
            };
            /**
             * 判断接口返回的数据data是否是分页的数据
             */
            FastResponseData.prototype.isPageData = function () {
                if (!this.responseData.data) {
                    return false;
                }
                return this.responseData.data.hasOwnProperty("page");
            };
            /**
             * 获取接口返回的数据列表，如果data是分页数据则返回分页的列表，否则返回data
             */
            FastResponseData.prototype.getList = function () {
                if (this.isPageData()) {
                    return this.responseData.data.list;
                }
                if (this.responseData.data) {
                    return this.responseData.data;
                }
                return [];
            };
            /**
             * 获取接口列表分页数据的页数
             */
            FastResponseData.prototype.getPage = function () {
                if (this.isPageData()) {
                    return this.responseData.data.page;
                }
                return -1;
            };
            /**
             * 获取接口列表分页数据的总页数
             */
            FastResponseData.prototype.getTotalPage = function () {
                if (this.isPageData()) {
                    return this.responseData.data.totalPage;
                }
                return -1;
            };
            /**
             * 获取接口列表分页数据的总行数
             */
            FastResponseData.prototype.getTotalRow = function () {
                if (this.isPageData()) {
                    return this.responseData.data.totalRow;
                }
                return -1;
            };
            /**
             * 获取接口列表分页数据的每页大小
             */
            FastResponseData.prototype.getPageSize = function () {
                if (this.isPageData()) {
                    return this.responseData.data.pageSize;
                }
                return -1;
            };
            /**
             * 是否已加载结束，当page>=totalPage 或 list 为空时，认为加载已结束
             */
            FastResponseData.prototype.isFinished = function () {
                return this.getPage() >= this.getTotalPage() || this.getList().length === 0;
            };
            return FastResponseData;
        }());
        FastServer.FastResponseData = FastResponseData;
        /**
         * 接口请求配置类
         */
        var FastRequestConfig = /** @class */ (function () {
            function FastRequestConfig() {
                /**
                 * 是否追加全局参数，默认true
                 */
                this.finalParams = true;
                /**
                 * 是否缓存数据，true：检测到有当前接口的缓存数据时，将回调缓存的数据
                 */
                this.cache = false;
                /**
                 * 是否总是缓存数据，true：无论是否已有缓存数据，都将请求接口并刷新当前缓存的数据，不支持then方法接收
                 */
                this.alwaysCache = false;
                /**
                 * 是否总是回调接口请求返回的数据，true：如果有缓存第一次回调缓存数据，第二次回调接口返回的数据，否则值回调一次接口返回的数据，不支持then方法接收
                 */
                this.alwaysBackRequest = false;
            }
            return FastRequestConfig;
        }());
        FastServer.FastRequestConfig = FastRequestConfig;
        for (var subClass in FastServer) {
            // @ts-ignore
            FastServer[subClass]();
        }
    })(FastServer = exports.FastServer || (exports.FastServer = {}));
});