fastchar-appjs/src/cjs/FastServer.js

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

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