public-fuse/src/request/index.ts

import axios, { AxiosResponse } from "axios";
import qs from "qs";
import { openLoading, closeLoading } from "./loading";
import { openErrorMsg } from "./errorMsg";
import {
  fromUrls,
  fileUrls,
  GetUrls,
  PostUrls,
  notLoginUrls,
  baseURL,
  unAuthCode,
  successCode,
} from "./config";
import { router } from "@/router";
import { RouteName } from "@/router/config";
import { isOfflineMode } from "@/util/offline";

export * from "./urls";
export * from "./config";
export * from "./loading";
export * from "./errorMsg";

export type AuthHook = () => {
  token: string;
  userId: string;
  clear: () => void;
};
export const setAuthHook = (hook: AuthHook) => (getAuth = hook);
let getAuth: AuthHook = () => ({ token: "", userId: "0", clear: () => { } });

axios.defaults.baseURL = baseURL;

axios.interceptors.request.use(async (config) => {
  if (config.method === "get" && config.params) {
    for (const key in config.params) {
      const val = config.params[key];
      if (typeof val === "string") {
        config.params[key] = val.replaceAll(/[\[\]]/g, "").trim();
      }
    }
  }

  if (!config.url) {
    return config;
  }

  const { token, userId } = getAuth();
  config.headers.token = token;
  config.headers.userid = userId;

  // 当链接存在 share=1 时，为所有请求头注入 caseId 与 sharePassword
  // 同时记录是否处于分享模式，以便后续跳过登录校验
  let isShareMode = false;
  try {
    const currentRoute = router.currentRoute?.value;
    const shareParam: any = currentRoute?.query?.share;
    console.log('currentRoute', currentRoute, shareParam)
    const isShare = Array.isArray(shareParam)
      ? shareParam.includes("1")
      : shareParam === "1";

    isShareMode = !!isShare;

    if (isShare) {
      const caseIdParam: any = currentRoute?.params?.caseId;
      const sharePwdParam: any = currentRoute?.query?.p;
      const caseIdHeader = Array.isArray(caseIdParam)
        ? caseIdParam[0]
        : caseIdParam;
      const sharePasswordHeader = Array.isArray(sharePwdParam)
        ? sharePwdParam[0]
        : sharePwdParam;

      if (caseIdHeader != null) {
        (config.headers as any).caseId = caseIdHeader;
      }
      if (sharePasswordHeader != null) {
        (config.headers as any).sharePassword = sharePasswordHeader;
      }
    }
  } catch (e) {
    // 忽略注入错误，保证请求不中断
  }

  const hasIgnore = config.params ? "ingoreRes" in config.params : false;
  // 分享模式下（share=1 且已注入 sharePassword/caseId），跳过登录校验
  const shareBypassLogin = (() => {
    try {
      const sharePwd = (config.headers as any)?.sharePassword;
      const caseIdHeader = (config.headers as any)?.caseId;
      return isShareMode && sharePwd != null && caseIdHeader != null;
    } catch {
      return false;
    }
  })();

  if (!hasIgnore) {
    const offline = isOfflineMode();
    if (!offline) {
      if (!token && !~notLoginUrls.indexOf(config.url) && !shareBypassLogin) {
        const redirect = encodeURIComponent(window.location.href);
        router.replace({ name: RouteName.login, query: { redirect } });
        throw "用户未登录";
      }
    }
  }

  if (~GetUrls.indexOf(config.url)) {
    config.method = "GET";
  } else if (~PostUrls.indexOf(config.url)) {
    config.method = "POST";
    if (!config.data && config.params) {
      config.data = config.params;
    }
  }

  // 处理需要用表单上传的请求
  if (~fromUrls.indexOf(config.url)) {
    config.data = qs.stringify(config.data);
    config.headers["Content-Type"] =
      "application/x-www-form-urlencoded; charset=utf-8;";
  } else if (~fileUrls.indexOf(config.url)) {
    const fromData = new FormData();

    Object.keys(config.data).forEach((key) => {
      if (key === 'files') {
        Array.from(config.data[key]).forEach(file => {
          fromData.append('files', file as any as File);
        })
      } else {
        fromData.append(key, config.data[key]);
      }


    });
    config.data = fromData;
    config.headers["Content-Type"] = "multipart/form-data";
  }

  openLoading(config.url);
  return config;
});

const responseInterceptor = (res: AxiosResponse<any, any>) => {
  closeLoading();
  const hasIgnore = res.config.params
    ? "ingoreRes" in res.config.params
    : false;
  if (!successCode.includes(res.data.code) && !hasIgnore) {
    let errMsg = res.data.msg || res.data.message;
    openErrorMsg(errMsg);

    const offline = isOfflineMode();
    if (!offline) {
      if (
        ~unAuthCode.indexOf(res.data.code) ||
        errMsg === "token已经失效，请重新登录"
      ) {
        getAuth().clear();
        const redirect = encodeURIComponent(window.location.href);
        router.replace({ name: RouteName.login, query: { redirect } });
      }
    }
    throw res.data.msg;
  }

  return res.data;
};

axios.interceptors.response.use(responseInterceptor, (error) => {
  closeLoading();
  if (error.response && error.response.data) {
    return responseInterceptor(error.response);
  } else {
    openErrorMsg(
      typeof error === "string" ? error : "请求失败，服务端发生了点小故障！"
    );
    return Promise.reject(error);
  }
});

export { axios };

export type PaggingReq<T> = T & {
  pageNum: number;
  pageSize: number;
};

export type PaggingRes<T> = T & {
  total: number;
  list: T[];
};