mini_read_space_front/utils/request.js

// 预发布地址
import { apple } from '../config/config';

let httpTrackLog = 'https://hyperion-track-app.mokamrp.com';
let httpServiceURL = '';
let version = __wxConfig.envVersion;
import { https } from '../config/config';
switch (version) {
  case 'develop':
    httpServiceURL = https.dev_apiHttps;
    break;
  case 'trial':
    httpServiceURL = https.test_apiHttps;
    break;
  case 'release': //正式版
    httpServiceURL = https.apiHttps;
    break;
  default: //未知,默认调用正式版
    httpServiceURL = https.apiHttps;
    break;
}

// 添加登录锁和请求队列
let isLoggingIn = false;
let loginPromise = null;
let pendingRequests = [];

// 执行等待队列中的请求
const executePendingRequests = () => {
  const requests = [...pendingRequests];
  pendingRequests = [];
  return Promise.all(requests.map(req => req()));
};

// 普通POST请求
export const post = (url, body = {}) => {
  return new Promise((resolve, reject) => {
    wx.request({
      url: url,
      data: body,
      method: 'POST',
      dataType: 'json',
      success: (res) => {
        if (res.statusCode == 200 && res.data.code == 200) {
          resolve(res.data.data);
        } else {
          reject(res);
        }
      },
      fail: (res) => {
        console.log(url, 'error--------', res);
        reject(res);
      },
    });
  });
};

// 普通Get请求
export const get = (url) => {
  return new Promise((resolve, reject) => {
    wx.request({
      url: url,
      method: 'GET',
      success: (res) => {
        if (res.statusCode == 200) {
          resolve(res.data);
        } else {
          reject(res);
        }
      },
      fail: (res) => {
        reject(res);
      },
    });
  });
};

/**
 * 打点请求
 */
export function uploadTrackLog(url, body) {
  if (!body) {
    body = {};
  }
  return post(httpTrackLog + url, body);
}

export const requestLogin = (data) => {
  console.log('开始登录请求，参数：', data);
  return new Promise((resolve, reject) => {
    // 检查是否已经有token
    const existingToken = wx.getStorageSync('accessToken');
    if (existingToken) {
      console.log('已存在token，跳过登录');
      return resolve({ accessToken: existingToken });
    }

    wx.request({
      url: httpServiceURL + '/user/loginWx',
      data: data,
      method: 'POST',
      dataType: 'json',
      header: {},
      success: function (res) {
        if (res.data.code == 200) {
          console.log('登录成功，保存token');
          wx.setStorageSync('accessToken', res.data.data.accessToken);
          resolve(res.data.data);
        } else {
          console.log('登录失败，错误信息：', res.data);
          wx.showToast({
            title: res.data.msg || res.data.error || '登录失败...',
            icon: 'none',
          });
          reject(res.data);
        }
      },
      fail: function (res) {
        console.log('登录请求失败：', res);
        wx.showToast({
          title: '登录失败...',
          icon: 'none',
        });
        reject(res);
      },
    });
  });
};

export const requestAll = (requestUrl, body, method = 'POST', customHeaders = {}) => {
  let url = httpServiceURL + requestUrl;
  if (method === 'GET') {
    if (body) {
      url += '?';
      for (const k in body) {
        url += `&${k}=${body[k]}`;
      }
    }
  }

  // 封装请求函数
  const doRequest = () => {
    return new Promise((resolve, reject) => {
      // 优先使用传入的token，其次使用storage中的token
      const token = customHeaders.token || wx.getStorageSync('accessToken') || '';

      wx.request({
        url: url,
        data: body,
        method: method,
        dataType: 'json',
        header: {
          ...customHeaders,
          token
        },
        success: function (res) {
          if (res.data.code == 200) {
            if (typeof res.data.data === 'number') {
              resolve(res.data.data);
            } else {
              resolve(res.data.data || []);
            }
          } 
          else if(res.data.code==20001){
            reject({code: 20001, msg: '令牌过期'});
          }
          else {
            reject(res.data);
          }
        },
        fail: function (res) {
          wx.showToast({
            title: '网络出错，请重试...',
            icon: 'none',
          });
          reject(res);
        },
      });
    });
  };

  // 执行请求，如果token过期则重新登录后重试
  return doRequest().catch(async error => {
    if (error.code == 20001) {
      // 如果已经在登录中，将请求添加到队列
      if (isLoggingIn) {
        return new Promise((resolve, reject) => {
          pendingRequests.push(() => doRequest().then(resolve).catch(reject));
        });
      }

      // 如果没有在登录，开始登录流程
      isLoggingIn = true;

      try {
        // 使用单例登录Promise
        if (!loginPromise) {
          wx.removeStorageSync('accessToken');
          loginPromise = getApp().login();
        }
        await loginPromise;
        
        // 重置登录状态和Promise
        isLoggingIn = false;
        loginPromise = null;

        // 执行所有请求
        if (pendingRequests.length > 0) {
          pendingRequests.push(() => doRequest());
          return executePendingRequests();
        }
        return doRequest();
      } catch (loginError) {
        // 登录失败，重置状态
        isLoggingIn = false;
        loginPromise = null;
        pendingRequests = [];
        console.error('重新登录失败:', loginError);
        throw loginError;
      }
    }
    throw error;
  });
};

/**
 * 添加公共参数
 */
export function postWithCommonParams(url, body, method = 'POST') {
  const app = getApp()
  if (!body) {
    body = {}
  }
  if (app.globalData.uuid) {
    body.uuid = app.globalData.uuid
  } else {
    body.uuid = 'fuck'
  }
  body.gh_id = apple.ghid
  
  // 判断是否为完整URL
  const isFullUrl = url.startsWith('http://') || url.startsWith('https://')
  const fullUrl = isFullUrl ? url : https.apiHttps + url
  
  if (method === 'POST') {
    return post(fullUrl, body)
  } else {
    return get(fullUrl)
  }
}