OumanMESUni/source/OumanMESUni/utils/request.js

import extend from './extend.js';
import token from './token.js';
import result from './result.js';
import ResultData from './resultData.js';

/**
 * 网络请求
 */
const request = {
    /**
     * 设置基础地址
     * @param {string} url - 基础地址
     */
    setBaseUrl(url) {
        if (!extend.isString(url)) {
            url = '';
        }
        extend.addStorage('base_url', url);
    },

    /**
     * 获取基础地址
     */
    getBaseUrl() {
        return extend.readStorage('base_url');
    },

    /**
     * 网络请求
     * @param {Object} opts - 请求参数
     * @param {string} opts.url - 请求地址
     * @param {string} opts.method - 请求方法，默认 get
     * @param {string} opts.dataType - 传输数据类型，默认 json
     * @param {string} opts.responseType - 接受数据类型，默认 json
     * @param {Object} opts.data - 请求参数
     * @param {Object} opts.header - 请求头
     * @returns {ResultData} 结果对象
     */
    send(opts) {
        return new Promise(async (resolve, reject) => {
            if (!extend.isObject(opts)) {
                resolve({
                    success: false,
                    message: '参数不能为空'
                });
                return;
            }
            let data = null;
            let url = '';
            let baseUrl = request.getBaseUrl();

            try {
                if (!extend.isUrl(opts.url)) {
                    if (extend.isEmptyString(baseUrl)) {
                        resolve({
                            success: false,
                            message: '未设置 BaseUrl'
                        });
                        return;
                    } else {
                        url = baseUrl + opts.url;
                    }
                }
                if (!extend.isObject(opts.header)) {
                    opts.header = {};
                }
                switch (opts.type) {
                    case 'json':
                        opts.header['content-type'] = 'application/json';
                        break;
                    case 'text':
                        opts.header['content-type'] = 'text/html; charset=utf-8';
                        break;
                    case 'form':
                        opts.header['content-type'] = 'multipart/form-data; boundary=something';
                        break;
                    case 'url':
                        opts.header['content-type'] = 'application/x-www-form-urlencoded';
                        break;
                }
                if (extend.isEmptyString(opts.method)) {
                    opts.method = 'get';
                }
                uni.request({
                    url: url,
                    method: opts.method || 'get',
                    dataType: opts.dataType || 'json',
                    responseType: opts.responseType || 'text',
                    header: opts.header || {},
                    data: opts.data,
                    timeout: 300000,
                    async success(res) {
                        if (res.statusCode === 401) {
                            let r = await tok.getByServer();
                            if (r.success) {
                                res = await Request.send(opts.data);
                            } else {
                                return resolve(new ResultData({
                                    success: false,
                                    message: r.message
                                }));
                            }
                        }
                        res = result.get(res);
                        resolve(new ResultData({
                            success: res.success,
                            message: res.message,
                            statusCode: res.statusCode,
                            data: res.data
                        }));
                    },
                    fail(ex) {
                        console.error(ex);
                        ex = extend.errorFormatter(ex);
                        resolve(new ResultData({
                            success: false,
                            message: ex.message
                        }));
                    }
                });
            } catch (ex) {
                let err = extend.errorFormatter(ex);
                console.error(ex);
                resolve(new ResultData({
                    success: false,
                    message: err.message,
                }));
            }
        });
    },

    /**
     * Token 网络请求
     * 在 header 中带 Authorization 参数。
     * @param {Object} opts - 请求参数
     * @param {string} opts.url - 请求地址
     * @param {string} opts.method - 请求方法，默认 get
     * @param {Object} opts.data - 请求参数
     * @param {Object} opts.header - 请求头
     * @returns {RequestResult} 网络请求结果对象
     */
    async sendToken(opts) {
        if (!extend.isObject(opts)) {
            return {
                success: false,
                message: '参数不能为空'
            };
        }
        let tokenStr = token.get();
        if (extend.isNonEmptyString(tokenStr)) {
            opts.header = {
                Authorization: tokenStr
            };
        }
        return await this.send(opts);
    }
};

/**
 * 网络请求
 */
export default request;