基于uniapp封装请求

const SUCCESS_CODE = 200;
const UNAUTHORIZED_CODES = [401, 403];
const HTTP_ERROR_TEXT_DEFAULT = "network anomaly";
const TIME_OUT = 200000;

// 标准请求头字段名
const HEADER_FIELDS = {
  AUTHORIZATION: "Authorization",
  LANGUAGE: "Language",
  DEVICE_ID: "Device-Id",
  VERSION: "Version",
};

function switchMethod(method) {
  let header = {
    "Content-Type": "application/json;charset=UTF-8",
  };
  switch (method) {
    case "POST":
      break;
    case "GET":
      break;
  }
  return header;
}

/**
 * 发起API HTTP请求
 *
 * @param {string} url - 请求的URL地址
 * @param {Object} params - 请求参数
 * @param {string} method - HTTP请求方法，支持GET, POST, PUT, DELETE
 * @param {boolean} [isToken=true] - 是否需要携带用户token
 * @param {boolean} [isOpenAI=false] - 是否是OpenAI的请求
 * @param {boolean} [enableChunked=false] - 是否开启分块传输编码
 * @param {string} [customUrl] - 自定义URL前缀
 * @param {number} [timeout=TIME_OUT] - 请求超时时间
 * @returns {Promise} 返回一个Promise对象，根据请求结果进行resolve或reject
 */
const ApiHttp = (
  url,
  params,
  method,
  isToken = true,
  isOpenAI = false,
  enableChunked = false,
  customUrl,
  timeout = TIME_OUT
) => {
  // 参数校验
  if (typeof url !== "string" || !url.trim()) {
    return Promise.reject(new Error("Invalid URL"));
  }

  if (!["GET", "POST", "PUT", "DELETE"].includes(method)) {
    return Promise.reject(new Error(`Unsupported HTTP method: ${method}`));
  }

  // 构建请求头
  const baseHeader = switchMethod(method);

  const token = store?.state?.login?.token || "";
  let finalHeader = { ...baseHeader };

  let request_url = customUrl ? `${customUrl}${url}` : `${serverUrl}${url}`;

  // 根据是否是OpenAI请求或是否需要token，设置请求头
  if (isOpenAI) {
    finalHeader[HEADER_FIELDS.AUTHORIZATION] = `Bearer ${
      store?.state?.user?.configInfo?.open_web_ai_key || ""
    }`;
  } else if (isToken) {
    finalHeader = {
      ...finalHeader,
      [HEADER_FIELDS.AUTHORIZATION]: token,
      [HEADER_FIELDS.LANGUAGE]: store?.state?.language?.appLanguage || "en",
      [HEADER_FIELDS.DEVICE_ID]: getApp().globalData.deviceId,
      [HEADER_FIELDS.VERSION]: getApp().globalData.appWgtVersion,
    };
  }

  return new Promise((resolve, reject) => {
    uni.request({
      url: request_url,
      method,
      data: params,
      header: finalHeader,
      enableChunked,
      timeout,
      success: (res) => {
        const {
          data: { code, msg, ...rest },
        } = res;
        // 根据请求结果处理响应
        if (isOpenAI) {
          resolve(res.data);
        } else if (code === SUCCESS_CODE) {
          resolve(res.data);
        } else if (UNAUTHORIZED_CODES.includes(code)) {
          uni.showToast({
            title: msg || rest.error,
            icon: "none",
          });
          store.commit("loginOut");
          reject({ code, msg });
        } else {
          uni.showToast({
            title: msg || rest.error,
            icon: "none",
          });
          reject({ code, msg, ...rest });
        }
      },
      fail: (err) => {
        console.error("http error", url, err);
        uni.showToast({
          title: err.errMsg || HTTP_ERROR_TEXT_DEFAULT,
          icon: "none",
        });
        reject({
          code: -1,
          msg: err.errMsg ? String(err.errMsg) : HTTP_ERROR_TEXT_DEFAULT,
          rawError: err,
        });
      },
      complete: () => {},
    });
  });
};