@dcp-designable/utils/lib/fetch.js

工具类

/**
 * @file ajax请求统一封装
 * @author lishuna
 * @createDate 2025-03-24 08:35:44
 * @LastModifiedBy lishuna
 * @LastModifiedTime 2025-03-24 08:35:44
 * @desc
 */
import React from 'react';
import axios from 'axios';
import qs from 'qs';
import { Designer_GlobalRegister } from './register';
import InfoTemplate, { FetchNotification } from './template';
import { getGlobalContext } from './tool';
const errorCode = {
    200: '任务已完成，一切顺利',
    201: '数据已创建，一切顺利',
    202: '服务器已经收到你的请求，但还在忙着处理呢，稍安勿躁哦',
    204: '数据已入虚空，删除成功啦',
    400: '你的请求好像有点问题呢，再检查一下吧',
    401: '抱歉，你需要先登录才能继续，记得带上你的通行证',
    403: '抱歉，你没有权限访问这里，赶紧溜走吧',
    404: '这里什么都没有，你可能迷路了',
    406: '这个格式的大饼，服务器消化不了',
    410: '这个资源已经消失不见了，好像去了外太空',
    412: '请求的前置条件弄错了，你得重新来过',
    422: '新对象，抱歉你不是我的菜',
    500: '服务器发生故障，程序猿正在抢修',
    502: '微服务网关故障，程序猿正在抢修',
    503: '服务不可用，先去喝杯茶等等吧',
    504: '网关超时，稍后再试试吧',
};
// 自定义扩展 header 请求头
function getConfigHeaders() {
    const { tenantId, token, systemId } = Designer_GlobalRegister.getSystemConfig();
    return {
        authorization: `Bearer ${token}`,
        QFCTid: tenantId,
        QFCSid: systemId,
        lang: localStorage.getItem('lang') || 'zh-cn',
        userAgent: 'pc',
        gray: '0', // 灰度
    };
}
const pendingRequest = new Map();
const lockingRequest = new Map();
function generateReqKey(config) {
    const { method, url } = config;
    return [method, url].join('&');
}
function addPendingRequest(config) {
    if (!config.cancelable)
        return;
    const requestKey = generateReqKey(config);
    config.cancelToken = new axios.CancelToken((cancel) => {
        if (!pendingRequest.has(requestKey)) {
            pendingRequest.set(requestKey, cancel);
        }
    });
}
function removePendingRequest(config) {
    const requestKey = generateReqKey(config);
    if (pendingRequest.has(requestKey)) {
        const cancelToken = pendingRequest.get(requestKey);
        cancelToken('取消请求');
        pendingRequest.delete(requestKey);
    }
}
function addLockingRequest(config) {
    if (!config.lockable)
        return;
    const requestKey = generateReqKey(config);
    if (!lockingRequest.has(requestKey)) {
        lockingRequest.set(requestKey, true);
    }
}
function removeLockingRequest(config) {
    const requestKey = generateReqKey(config);
    if (lockingRequest.has(requestKey)) {
        lockingRequest.delete(requestKey);
    }
}
function getErrorText(code) {
    const statusCode = [
        200,
        201,
        202,
        204,
        400,
        401,
        403,
        404,
        406,
        410,
        412,
        422,
        500,
        502,
        503,
        504,
    ];
    if (!statusCode.includes(code)) {
        return '';
    }
    return errorCode[code];
}
function createMessage(data) {
    const typeConf = { I: 'info', W: 'warning', E: 'error' };
    const errTypeConf = { S: 'system', B: 'business' };
    // const { siteInfo } = store.getState().app
    const tempProps = {
        type: typeConf[data.msgType] || 'error',
        message: data.message,
        detailMsg: data.errMsg,
        errCode: data.errCode,
        errType: errTypeConf[data.errType] || 'system',
        // extraInfo: siteInfo,
    };
    FetchNotification(React.createElement(InfoTemplate, tempProps), tempProps);
}
function createRequestContext(headers) {
    let _value = null;
    try {
        _value = JSON.parse(headers[`qfc-user-para`] || '{}');
    }
    catch (err) {
        // ...
    }
    const _result = {};
    const _context = getGlobalContext();
    for (const k in _context) {
        _result[k] = encodeURIComponent(_context[k]);
    }
    return Object.assign({}, _value, _result);
}
function getBaseURL() {
    const { fetch } = Designer_GlobalRegister.getSystemConfig();
    return fetch.baseURL;
}
// 创建 axios 实例
const instance = axios.create({
    baseURL: getBaseURL(),
    timeout: 1000 * 60 * 30,
    withCredentials: false,
    paramsSerializer: (params) => {
        // 序列化 GET 请求参数 -> a: [1, 2] => a[0]=1&a[1]=2
        return qs.stringify(params, { arrayFormat: 'indices' });
    },
});
// 异常处理程序
function errorHandler(error) {
    const { isAxiosError, code, config = {}, response = {} } = error;
    const { status, statusText = '' } = response;
    const errortext = getErrorText(status) || statusText || '请求超时';
    removePendingRequest(config);
    removeLockingRequest(config);
    if (code !== 'ERR_CANCELED') {
        isAxiosError && createMessage({ message: errortext });
    }
    return Promise.reject(error);
}
// 请求拦截
instance.interceptors.request.use((config) => {
    // 锁定当次请求
    if (lockingRequest.has(generateReqKey(config))) {
        return null; // Promise.reject({ message: '锁定请求' })
    }
    // 取消已发请求
    removePendingRequest(config);
    // 请求头信息，token 验证
    if (config) {
        config.headers = {
            ...getConfigHeaders(),
            ...config.headers,
        };
    }
    // 上下文参数
    if (Object.keys(getGlobalContext()).length) {
        config.headers[`qfc-user-para`] = JSON.stringify(createRequestContext(config.headers));
    }
    // 处理 GET 请求缓存
    if (config.method === 'get') {
        config.params = {
            ...config.params,
            _t: +new Date().getTime(),
        };
    }
    addPendingRequest(config);
    addLockingRequest(config);
    return config;
}, errorHandler);
// 响应拦截
instance.interceptors.response.use((response) => {
    const { config, data } = response;
    removePendingRequest(config);
    removeLockingRequest(config);
    // 文件流，直接过
    if (config.responseType === 'blob') {
        return response;
    }
    // 请求异常提示信息
    if (data.code !== 200) {
        // token 过期 或 无效，需要重新登录
        if (data.code === 55001 || data.code === 55002) {
            createMessage({
                type: 'error',
                message: '登录失效',
            });
        }
        data.message && createMessage(data);
    }
    return data;
}, errorHandler);
export { getConfigHeaders };
export default instance;
//# sourceMappingURL=fetch.js.map