pocket-jiuzhang-miniprogram/miniprogram/utils/request.ts

import Message from "tdesign-miniprogram/message/index";
import { setToken } from "./settings";

const authWhitelist = ["/mini-app/login"];

interface RequestOption {
  url: string;
  method?: "POST" | "PUT" | "DELETE" | "OPTIONS" | "HEAD" | "TRACE" | "CONNECT";
  data?: any;
  params?: object;
  header?: object;
}

interface RequestConfig {
  baseUrl: string;
  timeout?: number;
}

const buildQueryString = (params: object) => {
  const queryParams = [];

  for (const key in params) {
    if (params.hasOwnProperty(key)) {
      // @ts-ignore
      const value = encodeURIComponent(params[key]);
      queryParams.push(`${encodeURIComponent(key)}=${value}`);
    }
  }
  return `?${queryParams.join("&")}`;
};

class HttpClient {
  baseUrl: string;
  constructor(config: RequestConfig) {
    this.baseUrl = config.baseUrl;
  }
  request(req: RequestOption) {
    let url: string;
    let paramsString = "";
    if (req.params) {
      paramsString = buildQueryString(req.params);
    }
    if (req.url.startsWith("https://") || req.url.startsWith("http://")) {
      url = req.url;
    } else {
      url = `${this.baseUrl}${req.url}${paramsString}`;
    }
    const app = getApp();

    const header: any = req.header ?? {};

    if (!authWhitelist.includes(req.url) && !header.Authorization) {
      header.Authorization = `Bearer ${app?.globalData?.authToken}`;
    }
    return new Promise(function (resolve, reject) {
      wx.request({
        url,
        method: req.method,
        data: req.data,
        header,
        success(response) {
          let respData: any = response.data;
          let statusCode = respData.code;
          if (statusCode == 200) {
            resolve(respData);
          } else {
            Message.error({
              offset: [20, 32],
              duration: 5000,
              content: respData.msg,
            });
            if (statusCode == 401) {
              // TODO: remove token & redirect to login
              setToken(undefined);
              wx.switchTab({
                url: "/pages/login/login",
              });
            }
            reject(response.data);
          }
        },
        fail(error) {
          Message.error({
            offset: [20, 32],
            duration: 5000,
            content: error.errMsg,
          });
          reject(error);
        },
      });
    });
  }
  uploadFile(req: any) {
    let url: string;
    const app = getApp();
    if (req.url.startsWith("https://") || req.url.startsWith("http://")) {
      url = req.url;
    } else {
      url = `${this.baseUrl}${req.url}`;
    }

    return new Promise((resolve, reject) => {
      wx.uploadFile({
        url,
        filePath: req.file.url,
        name: "file",
        header: {
          Authorization: `Bearer ${app.globalData.authToken}`,
        },
        success(response) {
          let respData: any;
          if (typeof response.data === "string") {
            try {
              respData = JSON.parse(response.data);
            } catch {
              respData = {};
            }
          } else {
            respData = response.data;
          }
          let statusCode = respData.code;

          if (statusCode == 200) {
            resolve(respData);
          } else {
            Message.error({
              offset: [20, 32],
              duration: 5000,
              content: respData.msg,
            });
            reject(respData);
          }
        },
        fail: (error) => {
          Message.error({
            offset: [20, 32],
            duration: 5000,
            content: error.errMsg,
          });
          reject(error);
        },
      });
    });
  }
}

export const httpClient = new HttpClient({
  baseUrl: "https://nine.motse.com.cn/api",
  // baseUrl: "http://192.168.0.200:8080",
});

export default httpClient;