menduner-uniapp/utils/request.js

/**
 * Shopro-request
 * @description api模块管理，loading配置，请求拦截，错误处理
 */

import Request from 'luch-request';
import { refreshToken } from '@/api/common';
import { userStore } from '@/store/user'
import { baseUrl, tenantId } from './config'
import { showAuthModal } from '@/hooks/useModal'
import { rewardEventTrackClick } from '@/api/integral'
import { getSuffixAfterPrefix } from '@/utils/prefixUrl'
import { encryptionFun } from '@/utils/openEncryption'
import { useSystem } from '@/store/system'
import { sendError } from '@/api/system'

import qs from 'qs'

// 规则配置跟踪列表
const RETURNED_API = '/admin-api/menduner/reward/event-track/click'
let requestCompletionTrigger = []
let clickTrigger = []
const getEventList = () => {
	const eventRules = uni.getStorageSync('eventList')?.length ? JSON.parse(uni.getStorageSync('eventList')) : []
	requestCompletionTrigger = eventRules ? eventRules.filter(_e => _e.triggerType === '0') : []
	clickTrigger = eventRules ? eventRules.filter(_e => _e.triggerType === '1') : []
}
getEventList()

const errorData = []

const options = {
	// 显示操作成功消息 默认不显示
	showSuccess: false,
	// 成功提醒 默认使用后端返回值
	successMsg: '',
	// 显示失败消息 默认显示
	showError: true,
	// 失败提醒 默认使用后端返回信息
	errorMsg: '',
	// 显示请求时loading模态框 默认显示
	showLoading: true,
	// loading提醒文字
	loadingMsg: '加载中',
	// 需要授权才能请求 默认放开
	auth: false,
	// ...
};

// Loading全局实例
let LoadingInstance = {
	target: null,
	count: 0,
};

/**
 * 关闭loading
 */
function closeLoading() {
	if (LoadingInstance.count > 0) LoadingInstance.count--;
	if (LoadingInstance.count === 0) uni.hideLoading();
}

/**
 * @description 请求基础配置 可直接使用访问自定义请求
 */
const http = new Request({
	baseURL: baseUrl,
	timeout: 8000,
	method: 'GET',
	header: {
		Accept: 'text/json',
		'Content-Type': 'application/json;charset=UTF-8',
		platform: 'WechatMiniProgram',
		'Login-User-Type': 1
	},
	// #ifdef APP-PLUS
	sslVerify: false,
	// #endif
	// #ifdef H5
	// 跨域请求时是否携带凭证（cookies）仅H5支持（HBuilderX 2.6.15+）
	withCredentials: false,
	// #endif
	custom: options,
});

/**
 * @description 请求拦截器
 */
http.interceptors.request.use(
	async (config) => {
    const useUserStore = userStore()
    // 自定义处理【auth 授权】：必须登录的接口，则跳出 AuthModal 登录弹窗
		if (config.custom.auth && !useUserStore.isLogin) {
			uni.showToast({
				title:'请先登录',
				duration: 2000,
				icon: 'none'
			})
			showAuthModal()
			return Promise.reject();
		}

    // 自定义处理【loading 加载中】：如果需要显示 loading，则显示 loading
		if (config.custom.showLoading) {
			LoadingInstance.count++;
			LoadingInstance.count === 1 &&
				uni.showLoading({
					title: config.custom.loadingMsg,
					mask: true,
					fail: () => {
						uni.hideLoading();
					},
				});
		}

    // 增加 token 令牌、terminal 终端、tenant 租户的请求头
		const token = getAccessToken();
		if (token) {
			config.header['Authorization'] = 'Bearer ' + token;
		}
		config.header['terminal'] = 'mp-weixin'
		config.header['Accept-Language'] = 'zh_CN'

    config.header['Accept'] = '*/*';
    config.header['tenant-id'] = tenantId;

		// get参数编码
		const params = config.params || {}
    if (config.method === 'GET' && params) {
      config.params = {}
      const paramsStr = qs.stringify(params, { allowDots: true })
      if (paramsStr) {
        config.url = config.url + '?' + paramsStr
      }
    }
		
		// 开启参数加密
		if (config.custom?.openEncryption) {
      const { getTimeDifference, setTimeDifference, systemInfo } = useSystem()
			const raw = config.url.split('?')[1]
      const body = {
        ...typeof config.data === 'string' ? JSON.parse(config.data) : config.data,
        ...typeof config.params === 'string' ? JSON.parse(config.params) : config.params
      }
      if (!systemInfo?.timeDifference) {
        const _difference = await getTimeDifference()
        setTimeDifference(_difference)
      }

      const header = encryptionFun({
        raw,
        body,
        appId: 'web_client',
        AppSecret: 'fa0fc0b5098b974b',
        timestamp: new Date().getTime() + (Number(systemInfo?.timeDifference) || 0),
      })
      const content = {
        data: config.data,
        params: config.params,
        body,
        raw,
        config
      }
			// 记录请求备用-签名错误后重试

      errorData.push({
        time: header.timestamp,
        url: config.url,
        content
      })
			Object.assign(config.header, header)
		}

		if (uni.getStorageSync('token')) {
      // 截取request url
      const url = getSuffixAfterPrefix(config.url)
			if (url) getEventList()
      if (!url || !clickTrigger.length) return config
      const _obj = clickTrigger.find(e => e.url === url)
      if (_obj) {
        getIntegral(_obj.url)
      }
    }

		return config;
	},
	(error) => {
		return Promise.reject(error);
	},
);

/**
 * @description 响应拦截器
 */
http.interceptors.response.use(
	(response) => {
		// 约定：如果是 /auth/ 下的 URL 地址，并且返回了 accessToken 说明是登录相关的接口，则自动设置登陆令牌
		if (response.config.url.indexOf('/system/auth/') >= 0 && response.data?.data?.accessToken) {
			const useUserStore = userStore()
			useUserStore.setToken(response.data.data.accessToken, response.data.data.refreshToken);
		}
		if (response.config.url.includes(RETURNED_API)) {
			if (!response.data.data || !response.data.data.length) return

			// 目前先默认展示返回的第一个，后续需改为展示多个内容
			const item = response.data.data && response.data.data.length ? response.data.data[0] : {}
			if (item.match) {
				uni.showModal({
					title: '系统提示',
					content: `恭喜您 【${item.title}】获得${item.point}积分`,
					showCancel: false,
					confirmText: '关闭',
					confirmColor: '#00B760'
				})
			}
      return
    }

		const config = response.config

    // 自定处理【loading 加载中】：如果需要显示 loading，则关闭 loading
		response.config.custom.showLoading && closeLoading();

    // 自定义处理【error 错误提示】：如果需要显示错误提示，则显示错误提示
		if (response.data.code !== 0) {
      // 特殊：如果 401 错误码，则跳转到登录页 or 刷新令牌
      if (response.data.code === 401) {
        return handleRefreshToken(response.config);
      }

			// 签名错误
			if (response.data.code === 440) {
				// 更新服务器与用户时间差的值
      	const { setTimeDifference } = useSystem()
				if (Number(response?.data?.msg)) setTimeDifference(response.data.msg - new Date().getTime())
				// 请求重试
				signErrRetry(response.config)
				// 保存错误信息
				const _index = errorData.findIndex(e => e.url === config.url && e.time === +config.header.timestamp)
				if (_index > -1) {
					const _d = errorData.splice(_index, 1)
					const _item = _d[0]
					sendError({ content: JSON.stringify(_item.content), mark: _item.time + '' })
				}
				response.config.custom.showError = false // 不弹错误弹窗
			}

      // 错误提示
			if (response.config.custom.showError) {
				if (response.data?.msg === '重复请求，请稍后重试') console.error('前台打印: 重复请求，请稍后重试')
				else {
					uni.showToast({
						title: response.data.msg || '服务器开小差啦,请稍后再试~',
						icon: 'none',
						duration: 2000,
						mask: true,
					});
				}
      }
			return Promise.reject(response.data);
		}

		// 自定义处理【showSuccess 成功提示】：如果需要显示成功提示，则显示成功提示
		if (response.config.custom.showSuccess && response.config.custom.successMsg !== '' && response.data.code === 0) {
      uni.showToast({
				title: response.config.custom.successMsg,
				icon: 'none',
				duration: 2000,
			});
		}

		// 请求成功后触发获取积分
    if (uni.getStorageSync('token')) {
      const url = getSuffixAfterPrefix(response.config.url)
			if (url) getEventList()
      if (!url || !requestCompletionTrigger.length) return response.data
      const _obj = requestCompletionTrigger.find(e => e.url === url)
      if (_obj) {
        getIntegral(_obj.url)
      }
    }

    // 返回结果：包括 code + data + msg
		return Promise.resolve(response.data);
	},
	(error) => {
		const useUserStore = userStore()
		const isLogin = useUserStore.isLogin;
		let errorMessage = '网络请求出错';
		if (error !== undefined) {
			switch (error.statusCode) {
				case 400:
					errorMessage = '请求错误';
					break;
				case 401:
          errorMessage = isLogin ? '您的登陆已过期' : '请先登录';
          // 正常情况下，后端不会返回 401 错误，所以这里不处理 handleAuthorized
          break;
				case 403:
					errorMessage = '拒绝访问';
					break;
				case 404:
					errorMessage = '请求出错';
					break;
				case 408:
					errorMessage = '请求超时';
					break;
				case 429:
					errorMessage = '请求频繁, 请稍后再访问';
					break;
				case 440:
					errorMessage = '网络请求出错'; // 签名异常
					break;
				case 500:
					errorMessage = '服务器开小差啦,请稍后再试~';
					break;
				case 501:
					errorMessage = '服务未实现';
					break;
				case 502:
					errorMessage = '网络错误';
					break;
				case 503:
					errorMessage = '服务不可用';
					break;
				case 504:
					errorMessage = '网络超时';
					break;
				case 505:
					errorMessage = 'HTTP 版本不受支持';
					break;
			}
			if (error?.errMsg?.includes('timeout')) errorMessage = '请求超时';
			// #ifdef H5
			if (error?.errMsg?.includes('Network'))
				errorMessage = window.navigator.onLine ? '服务器异常' : '请检查您的网络连接';
			// #endif
		}

		if (error && error.config) {
			if (error.config.custom.showError === false) {
				uni.showToast({
					title: error.data?.msg || errorMessage,
					icon: 'none',
					duration: 2000,
					mask: true,
				});
			}
			error.config.custom.showLoading && closeLoading();
		}

		return false;
	},
);

// Axios 无感知刷新令牌，参考 https://www.dashingdog.cn/article/11 与 https://segmentfault.com/a/1190000020210980 实现
let requestList = [] // 请求队列
let isRefreshToken = false // 是否正在刷新中
const handleRefreshToken = async (config) => {
  // 如果当前已经是 refresh-token 的 URL 地址，并且还是 401 错误，说明是刷新令牌失败了，直接返回 Promise.reject(error)
  if (config.url.indexOf('/menduner/system/auth/refresh-token') >= 0) {
    return Promise.reject('error')
  }

  // 如果未认证，并且未进行刷新令牌，说明可能是访问令牌过期了
  if (!isRefreshToken) {
    isRefreshToken = true
    // 1. 如果获取不到刷新令牌，则只能执行登出操作
    const refresh_token = getRefreshToken()
    if (!refresh_token) {
      return handleAuthorized()
    }
    // 2. 进行刷新访问令牌
    try {
      const refreshTokenResult = await refreshToken(refresh_token);
      if (refreshTokenResult.code !== 0) {
        // 如果刷新不成功，直接抛出 e 触发 2.2 的逻辑
        // noinspection ExceptionCaughtLocallyJS
        throw new Error('刷新令牌失败');
      }
      // 2.1 刷新成功，则回放队列的请求 + 当前请求
      config.header.Authorization = 'Bearer ' + getAccessToken()
      requestList.forEach((cb) => {
        cb()
      })
      requestList = []
      return request(config)
    } catch (e) {
      // 为什么需要 catch 异常呢？刷新失败时，请求因为 Promise.reject 触发异常。
      // 2.2 刷新失败，只回放队列的请求
      requestList.forEach((cb) => {
        cb()
      })
      // 提示是否要登出。即不回放当前请求！不然会形成递归
      return handleAuthorized()
    } finally {
      requestList = []
      isRefreshToken = false
    }
  } else {
    // 添加到队列，等待刷新获取到新的令牌
    return new Promise((resolve) => {
      requestList.push(() => {
        config.header.Authorization = 'Bearer ' + getAccessToken() // 让每个请求携带自定义token 请根据实际情况自行修改
        resolve(request(config))
      })
    })
  }
}

/**
 * 处理 401 未登录的错误
 */
const handleAuthorized = () => {
  const useUserStore = userStore()
  useUserStore.handleLogout(true);
  uni.showToast({
		title:'请先登录',
		duration: 2000,
		icon: 'none'
	})
	const msg = useUserStore.isLogin ? '您的登陆已过期' : '请先登录'
	useUserStore.setLogin(false)
	showAuthModal()
  // 登录超时
  return Promise.reject({
    code: 401,
    msg
  })
}

/**
 * 处理440签名错误
*/
const maxRetries = 2 // 设置签名错误重试请求次数，超出次数弹出错误
const retryDelay = 1000 // 请求延迟
const signErrRetry = (config) => {
	if (config) {
		if (!config?.custom?.retryCount) {
			config.custom.retryCount = 0
		}
	
		// 超过重试次数
		if (config.custom.retryCount >= maxRetries) {
			uni.showToast({
				title: '网络请求错误！',
				icon: 'none',
				mask: false,
			});
			return Promise.reject({ statusCode: 440 })
		}
		// 重试
		config.custom.retryCount++
		setTimeout(() => {
			return request(config)
		}, retryDelay)
	}
}

// 触发获取积分
const getIntegral = (url) => {
  rewardEventTrackClick(url).then(() => {})
}

/** 获得必填人才信息情况 */
export const showNecessaryInfoPopup = () => {
  return uni.getStorageSync('necessaryInfoReady') === 'student';
}

/** 获得访问令牌 */
export const getAccessToken = () => {
  return uni.getStorageSync('token');
}

/** 获得刷新令牌 */
const getRefreshToken = () => {
  return uni.getStorageSync('refresh-token');
}

const request = (config) => {
	return http.middleware(config);
};

export default request;