zhywpt-plug/wxminipro/plugin/network/request.js

const {
  configObj, isNeedEncry
} = require('../config.js');
const {
  encryption,
  sm4Decrypt
} = require('../new-utils/encryption.js');


/**
 * 网络请求工具类
 * 封装微信小程序的网络请求，支持加密和签名
 */
class NetworkRequest {
  constructor() {
    this.baseUrl = configObj.reqEtcSignUrl;
    this.timeout = 10000; // 默认超时时间10秒
  }

  /**
   * 发送POST请求
   * @param {string} ifCode - 接口编码
   * @param {Object} data - 请求数据
   * @param {Object} options - 请求选项
   * @returns {Promise} 返回Promise对象
   */
  post(ifCode, data = {}, options = {}) {
    return new Promise((resolve, reject) => {
      try {
        // 使用加密工具对数据进行加密和签名
        const encryptedData = encryption(ifCode, data);
        const requestOptions = {
          url: this.baseUrl,
          method: 'POST',
          data: encryptedData,
          header: {
            'Content-Type': 'application/json',
            ...options.header
          },
          timeout: options.timeout || this.timeout,
          success: (res) => {
            console.log(res)
            this.handleResponse(res, resolve, reject);
          },
          fail: (err) => {
            this.handleError(err, resolve, );
          }
        };
        wx.request(requestOptions);
      } catch (error) {
        console.log(error)
        reject({
          code: -1,
          message: '请求参数处理失败',
          error: error
        });
      }
    });
  }

  /**
   * 发送GET请求
   * @param {string} ifCode - 接口编码
   * @param {Object} data - 请求参数
   * @param {Object} options - 请求选项
   * @returns {Promise} 返回Promise对象
   */
  get(ifCode, data = {}, options = {}) {
    return new Promise((resolve, reject) => {
      try {
        // 将参数拼接到URL中
        const queryString = this.buildQueryString(data);
        const url = `${this.baseUrl}?ifCode=${ifCode}&${queryString}`;
        const requestOptions = {
          url: url,
          method: 'GET',
          header: {
            'Content-Type': 'application/json',
            ...options.header
          },
          timeout: options.timeout || this.timeout,
          success: (res) => {
            this.handleResponse(res, resolve, reject);
          },
          fail: (err) => {
            this.handleError(err, resolve);
          }
        };
        wx.request(requestOptions);
      } catch (error) {
        resolve({
          code: -1,
          message: '请求参数处理失败',
          error: error
        });
      }
    });
  }

  /**
   * 处理响应结果
   * @param {Object} res - 响应对象
   * @param {Function} resolve - 成功回调
   * @param {Function} reject - 失败回调
   */
  handleResponse(response, resolve, reject) {
    const res = response.data
    const msg = res.errorMsg;
    const code = res.statusCode
    let decrypting = res.bizContent || ""
    if (code !== 0) {
      resolve({
        code: code || -1,
        message: msg || '业务处理失败',
        data: decrypting
      });
    } else {
      if (res.bizContent) {
        if (isNeedEncry()) {
          decrypting = sm4Decrypt(res.bizContent);
        } else {
          decrypting = JSON.parse(res.bizContent);
        }
      }
      console.log("返回数据", decrypting)
      if (decrypting.errcode != 0 && decrypting.errcode) {
        resolve({
          code: -1,
          message: decrypting.errmsg,
          data: decrypting
        })
      } else {
        resolve({
          code: 0,
          message: decrypting.errmsg,
          data: decrypting
        })
      }
    }
  }

  /**
   * 处理请求错误
   * @param {Object} err - 错误对象
   * @param {Function} reject - 失败回调
   */
  handleError(err, resolve) {
    let errorMessage = '网络请求失败';
    if (err.errMsg) {
      if (err.errMsg.includes('timeout')) {
        errorMessage = '请求超时，请检查网络连接';
      } else if (err.errMsg.includes('fail')) {
        errorMessage = '网络连接失败，请检查网络设置';
      }
    }
    resolve({
      code: -1,
      message: errorMessage,
      data: err
    });
  }

  /**
   * 构建查询字符串
   * @param {Object} params - 参数对象
   * @returns {string} 查询字符串
   */
  buildQueryString(params) {
    const queryArray = [];
    for (const key in params) {
      if (params.hasOwnProperty(key) && params[key] !== undefined && params[key] !== null) {
        queryArray.push(`${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`);
      }
    }
    return queryArray.join('&');
  }

  /**
   * 设置请求超时时间
   * @param {number} timeout - 超时时间（毫秒）
   */
  setTimeout(timeout) {
    this.timeout = timeout;
  }

  /**
   * 设置基础URL
   * @param {string} url - 基础URL
   */
  setBaseUrl(url) {
    this.baseUrl = url;
  }
}

// 创建单例实例
const networkRequest = new NetworkRequest();

/**
 * 便捷的请求方法
 */
const request = {
  /**
   * POST请求
   * @param {string} ifCode - 接口编码
   * @param {Object} data - 请求数据
   * @param {Object} options - 请求选项
   * @returns {Promise} 返回Promise对象
   */
  post: (ifCode, data, options) => networkRequest.post(ifCode, data, options),

  /**
   * GET请求
   * @param {string} ifCode - 接口编码
   * @param {Object} data - 请求参数
   * @param {Object} options - 请求选项
   * @returns {Promise} 返回Promise对象
   */
  get: (ifCode, data, options) => networkRequest.get(ifCode, data, options),

  /**
   * 设置超时时间
   * @param {number} timeout - 超时时间（毫秒）
   */
  setTimeout: (timeout) => networkRequest.setTimeout(timeout),

  /**
   * 设置基础URL
   * @param {string} url - 基础URL
   */
  setBaseUrl: (url) => networkRequest.setBaseUrl(url)
};

// CommonJS 导出
module.exports = {
  NetworkRequest,
  request
};
module.exports.default = NetworkRequest;