@zdb/utils/dist/request.js

工具包

import { getCookie } from './cookies';
import Axios from 'axios';
import Qs from 'qs';
/**
 * 请求钩子
 * @param HOST
 * @param axiosProps  AxiosProps
 * @returns Promise
 */
export const useAxios = (HOST, axiosProps = {
    ProxyStr: '',
    ACCESS_TOKEN: 'accessToken'
}) => {
    const { ProxyStr, ACCESS_TOKEN } = axiosProps;
    /**
     * 创建axios实例
     * @returns
     */
    const createInstance = () => {
        const baseURL = HOST;
        const instance = Axios.create({
            timeout: 100000,
            headers: {
                'Content-Type': 'application/json;charset=UTF-8'
            }
        });
        instance.defaults.baseURL = baseURL;
        initInterceptors(instance);
        return instance;
    };
    /**
     * 护理token
     * @returns
     */
    const handlerHeader = (config) => {
        if (config.url?.indexOf('api/system/auth/login') !== -1) {
            return {};
        }
        const Token = getCookie(ACCESS_TOKEN);
        const arr = {};
        if (Token) {
            arr.Authorization = `Bearer ${Token}`;
        }
        return arr;
    };
    /**
     * 初始化实例
     * @param instance
     */
    const initInterceptors = (instance) => {
        /**
         * 前置拦截器
         */
        instance.interceptors.request.use(async (config) => {
            delete config.headers?.Authentication;
            config.headers = {
                ...handlerHeader(config),
                ...config.headers
            };
            const contentType = config.headers['Content-Type'];
            const data = config.data;
            if (contentType?.includes('application/x-www-form-urlencoded') && data) {
                config.data = Qs.stringify(data); // 针对application/x-www-form-urlencoded; 转换data格式
            }
            return config;
        }, (error) => {
            return Promise.reject(error);
        });
        /**
         * 后置拦截器
         */
        instance.interceptors.response.use(async (response) => {
            const contentDisposition = response.headers['content-disposition'];
            if (contentDisposition) {
                const name = decodeURI(contentDisposition.split('=')[1]);
                // 下载文件
                return [name.replace(`UTF-8''`, ''), response.data];
            }
            if ([200, 1999002002, 1999002001].includes(response.data.code)) {
                return response.data;
            }
            if (response.data.code === 401) {
                axiosProps.handler401Response && axiosProps.handler401Response(response);
                return;
            }
            if (response.data.code === 403) {
                axiosProps.handler403Response && axiosProps.handler403Response(response);
                return;
            }
            if (response.config.responseType === 'blob') {
                const reader = new FileReader();
                return await new Promise((resolve, reject) => {
                    reader.onload = () => {
                        const result = JSON.parse(reader.result);
                        resolve(result);
                        axiosProps.errorNotification && axiosProps.errorNotification(result.msg);
                    };
                    reader.readAsText(response.data);
                });
            }
            else {
                axiosProps.errorNotification && axiosProps.errorNotification(response.data.msg);
            }
            return response.data;
        }, (error) => {
            axiosProps.handlerError && axiosProps.handlerError(error);
            return Promise.reject(error);
        });
    };
    /**
     * 请求资源
     * @param options 参照axios文档
     * @returns Promise<IResponse<T>> T 泛型
     */
    const service = async (options) => {
        return createInstance()(options);
    };
    /**
     * 获取资源
     * @param url 请求地址
     * @param params请求参数
     * @param options 参照axios文档
     * @returns Promise<IResponse<T>> T 泛型
     */
    function get(url, params, options) {
        let _params = Object.create({});
        let hasArray = false;
        Array.from(Object.entries(params || {})).forEach(([key, value], index) => {
            if (value && Array.isArray(value)) {
                hasArray = true;
                _params[key] = Qs.stringify({
                    [key]: value
                }, { arrayFormat: 'indices' });
            }
            else {
                _params[key] = value;
            }
        });
        const str = Qs.stringify(params, { arrayFormat: 'indices' });
        let _url = url;
        if (hasArray) {
            _params = undefined;
            _url = `${url}${url.indexOf('?') === -1 ? `?${str}` : `&${str}`}`;
        }
        return service({
            method: 'get',
            url: `${ProxyStr}${_url}`,
            params: _params,
            ...options
        });
    }
    /**
     * 添加资源
     * @param url 请求地址
     * @param data 请求参数
     * @param options 参照axios文档
     * @returns Promise<IResponse<T>> T 泛型
     */
    function post(url, data, options) {
        return service({
            url: `${ProxyStr}${url}`,
            method: 'post',
            data,
            ...options
        });
    }
    /**
     * 添加资源
     * @param url 请求地址
     * @param data 请求参数
     * @param options 参照axios文档
     * @returns Promise<IResponse<T>> T 泛型
     */
    function downloadFile(url, data, options) {
        return service({
            responseType: 'blob',
            url: `${ProxyStr}${url}`,
            method: 'get',
            data,
            ...options
        });
    }
    /**
     * 修改资源
     * @param url 请求地址
     * @param data 请求参数
     * @param options 参照axios文档
     * @returns Promise<IResponse<T>> T 泛型
     */
    function put(url, data, options) {
        return service({
            url: `${ProxyStr}${url}`,
            method: 'put',
            data,
            ...options
        });
    }
    /**
     * 删除资源
     * @param url 请求地址
     * @param data 请求参数
     * @param options 参照axios文档
     * @returns Promise<IResponse<T>> T 泛型
     */
    function _delete(url, params, options) {
        return service({
            url: `${ProxyStr}${url}`,
            method: 'delete',
            params,
            ...options
        });
    }
    return {
        service,
        get,
        post,
        put,
        _delete,
        downloadFile
    };
};