import config from '@/config/index.js'
|
import { clearJPushAliasBinding } from '@/utils/push.js'
|
import {
|
clearAuthSession,
|
getStoredToken,
|
hasBoundPhone,
|
hasPendingPhoneBindSession,
|
saveAuthSession,
|
willTokenExpireWithin,
|
} from '@/utils/auth-session.js'
|
|
const GET = 'GET'
|
const POST = 'POST'
|
const PUT = 'PUT'
|
const FORM = 'FORM'
|
const DELETE = 'DELETE'
|
const baseURL = config.BASE_URL
|
const TOKEN_REFRESH_BUFFER_MS = 30 * 60 * 1000
|
const SUCCESS_CODES = [0, 200]
|
const UNAUTHORIZED_CODES = [401, 504, 505, 510]
|
const SESSION_INVALID_MESSAGES = ['用户不存在', '用户已禁用']
|
const PENDING_BIND_ALLOWED_URLS = [
|
'/api/app/settings/phone/code',
|
'/api/app/settings/phone/bind',
|
]
|
const PUBLIC_APP_URL_PREFIXES = [
|
'/api/app/home/',
|
'/api/v1/app/home/',
|
]
|
|
const waitingList = []
|
const excutingList = []
|
let appAuthRedirecting = false
|
let refreshTokenPromise = null
|
|
/**
|
* 判断当前响应码是否属于成功态。
|
*/
|
function isSuccessCode(code) {
|
return SUCCESS_CODES.includes(code)
|
}
|
|
/**
|
* 从响应体中提取可展示的错误文案。
|
*/
|
function resolveMessage(payload) {
|
if (!payload) {
|
return '服务器错误'
|
}
|
if (typeof payload.data === 'string' && payload.data) {
|
return payload.data
|
}
|
return payload.msg || payload.message || '服务器错误'
|
}
|
|
/**
|
* 后端部分已登录接口会以业务错误返回“用户不存在/已禁用”，这里统一视为登录态失效。
|
*/
|
function isSessionInvalidPayload(payload) {
|
if (!getStoredToken()) {
|
return false
|
}
|
const message = resolveMessage(payload).trim()
|
return SESSION_INVALID_MESSAGES.includes(message)
|
}
|
|
/**
|
* 读取当前语言请求头值。
|
*/
|
function resolveLangHeader() {
|
return uni.getStorageSync('locale') === 'zh-Hans' ? 'zh_CN' : 'zh-tw'
|
}
|
|
/**
|
* 构造当前请求头。
|
*/
|
function buildHeaders(type, url) {
|
const authorization = resolveAuthorizationHeader(url)
|
const headers = {
|
'content-type': type ? 'application/x-www-form-urlencoded;charset=UTF-8' : 'application/json',
|
lang: resolveLangHeader(),
|
}
|
if (authorization) {
|
headers.Authorization = authorization
|
}
|
return headers
|
}
|
|
/**
|
* 解析请求鉴权头，待绑定手机号临时 token 仅允许访问绑定手机号接口。
|
*/
|
function resolveAuthorizationHeader(url) {
|
if (isPublicAppUrl(url)) {
|
return ''
|
}
|
if (!hasPendingPhoneBindSession()) {
|
return getStoredToken()
|
}
|
return isPendingBindAllowedUrl(url) ? getStoredToken() : ''
|
}
|
|
/**
|
* 首页公共接口允许游客访问，不能被本地旧登录态或 token 刷新失败影响。
|
*/
|
function isPublicAppUrl(url) {
|
return PUBLIC_APP_URL_PREFIXES.some((prefix) => url.startsWith(prefix))
|
}
|
|
/**
|
* 判断当前接口是否允许使用待绑定手机号临时 token。
|
*/
|
function isPendingBindAllowedUrl(url) {
|
return PENDING_BIND_ALLOWED_URLS.includes(url)
|
}
|
|
/**
|
* 统一展示普通业务错误提示。
|
*/
|
function showErrorToast(payload) {
|
uni.showToast({
|
title: resolveMessage(payload),
|
duration: 2000,
|
icon: 'none',
|
mask: true,
|
})
|
}
|
|
/**
|
* 统一发起请求，并兼容当前仓库 `code=0` 的后端成功协议。
|
*/
|
function request(method, url, data, type, lodingFlag = true) {
|
return new Promise((resolve, reject) => {
|
const executeRequest = () => {
|
if (lodingFlag) {
|
uni.showLoading({
|
mask: true,
|
})
|
}
|
const requestTask = uni.request({
|
url: `${baseURL}${url}`,
|
method,
|
data,
|
header: buildHeaders(type, url),
|
success: (res) => {
|
if (lodingFlag) {
|
uni.hideLoading()
|
}
|
const payload = res.data || {}
|
if (isSuccessCode(payload.code)) {
|
resolve(payload)
|
return
|
}
|
if (payload.code === 502 || payload.code === 501) {
|
showErrorToast(payload)
|
resolve(payload)
|
return
|
}
|
if (isSessionInvalidPayload(payload)) {
|
handleUnauthorized(payload)
|
resolve(payload)
|
return
|
}
|
if (payload.code === 1 || payload.code === 500) {
|
showErrorToast(payload)
|
resolve(payload)
|
return
|
}
|
if (UNAUTHORIZED_CODES.includes(payload.code)) {
|
handleUnauthorized(payload)
|
resolve(payload)
|
return
|
}
|
if (payload.code === 506) {
|
resolve(payload)
|
return
|
}
|
showErrorToast(payload)
|
resolve(payload)
|
},
|
fail: (error) => {
|
if (lodingFlag) {
|
uni.hideLoading()
|
}
|
reject(error)
|
},
|
complete: () => {
|
const excutingIndex = excutingList.findIndex((item) => item === requestTask)
|
if (excutingIndex >= 0) {
|
excutingList.splice(excutingIndex, 1)
|
}
|
const [apiFn] = waitingList
|
if (excutingList.length === 0 && typeof apiFn === 'function') {
|
apiFn()
|
waitingList.splice(0, 1)
|
}
|
},
|
})
|
excutingList.push(requestTask)
|
}
|
|
ensureSessionFresh(url)
|
.then(() => {
|
executeRequest()
|
})
|
.catch((error) => {
|
reject(error)
|
})
|
})
|
}
|
|
/**
|
* 收到未登录响应时清理 APP 登录态并跳转登录页。
|
*/
|
function handleUnauthorized(payload) {
|
const routeStr = getCurrentRoute()
|
clearLoginSession()
|
clearAllRequest()
|
if (routeStr === 'pages/login/login' || appAuthRedirecting) {
|
return
|
}
|
appAuthRedirecting = true
|
uni.showToast({
|
title: resolveMessage(payload) || '请先登录',
|
duration: 1500,
|
icon: 'none',
|
mask: true,
|
})
|
setTimeout(() => {
|
uni.reLaunch({
|
url: '/pages/login/login',
|
})
|
setTimeout(() => {
|
appAuthRedirecting = false
|
}, 300)
|
}, 150)
|
}
|
|
/**
|
* 清除 APP 登录态缓存。
|
*/
|
function clearLoginSession() {
|
clearAuthSession()
|
clearJPushAliasBinding()
|
}
|
|
/**
|
* 获取当前页面路由，便于避免在登录页重复跳转。
|
*/
|
function getCurrentRoute() {
|
const currentPages = getCurrentPages()
|
if (!currentPages || currentPages.length === 0) {
|
return ''
|
}
|
return currentPages[currentPages.length - 1].route || ''
|
}
|
|
/**
|
* 清除请求队列，避免登录失效后旧请求继续回写界面状态。
|
*/
|
function clearAllRequest() {
|
excutingList.forEach((item) => {
|
if (item && typeof item.abort === 'function') {
|
item.abort()
|
}
|
})
|
excutingList.length = 0
|
waitingList.length = 0
|
}
|
|
/**
|
* 在请求发送前按阈值串行刷新 APP token，避免多个接口同时触发续期。
|
*/
|
function ensureSessionFresh(url) {
|
if (!shouldAttemptTokenRefresh(url)) {
|
return Promise.resolve()
|
}
|
if (refreshTokenPromise) {
|
return refreshTokenPromise
|
}
|
refreshTokenPromise = refreshAppToken().finally(() => {
|
refreshTokenPromise = null
|
})
|
return refreshTokenPromise
|
}
|
|
/**
|
* 判断当前请求是否需要在发送前尝试刷新 token。
|
*/
|
function shouldAttemptTokenRefresh(url) {
|
if (isPublicAppUrl(url)) {
|
return false
|
}
|
const token = getStoredToken()
|
if (!token || !hasBoundPhone()) {
|
return false
|
}
|
if (url === '/api/app/auth/refresh-token' || url === '/api/v1/app/auth/refresh-token') {
|
return false
|
}
|
const routeStr = getCurrentRoute()
|
if (routeStr === 'pages/login/login' || routeStr === 'pages/register/register' || routeStr === 'pages/bindPhone/bindPhone') {
|
return false
|
}
|
return willTokenExpireWithin(TOKEN_REFRESH_BUFFER_MS)
|
}
|
|
/**
|
* 调用后端续期接口并回写本地 token 与用户信息。
|
*/
|
function refreshAppToken() {
|
return new Promise((resolve, reject) => {
|
uni.request({
|
url: `${baseURL}/api/app/auth/refresh-token`,
|
method: POST,
|
data: {},
|
header: {
|
'content-type': 'application/json',
|
Authorization: getStoredToken(),
|
lang: resolveLangHeader(),
|
},
|
success: (res) => {
|
const payload = res.data || {}
|
if (isSuccessCode(payload.code) && payload.data) {
|
saveAuthSession(payload.data)
|
resolve(payload)
|
return
|
}
|
if (UNAUTHORIZED_CODES.includes(payload.code) || isSessionInvalidPayload(payload)) {
|
handleUnauthorized(payload)
|
}
|
reject(payload)
|
},
|
fail: (error) => {
|
reject(error)
|
},
|
})
|
})
|
}
|
|
/**
|
* 发起 GET 请求。
|
*/
|
function get(url, data, type = false, lodingFlag = true) {
|
return request(GET, url, data, type, lodingFlag)
|
}
|
|
/**
|
* 发起 POST 请求。
|
*/
|
function post(url, data, type = false, lodingFlag = true) {
|
return request(POST, url, data, type, lodingFlag)
|
}
|
|
/**
|
* 发起 PUT 请求。
|
*/
|
function put(url, data, type = false, lodingFlag = true) {
|
return request(PUT, url, data, type, lodingFlag)
|
}
|
|
/**
|
* 发起表单编码请求。
|
*/
|
function form(url, data, type = false, lodingFlag = true) {
|
return request(FORM, url, data, type, lodingFlag)
|
}
|
|
/**
|
* 发起 DELETE 请求。
|
*/
|
function remove(url, data, type = false, lodingFlag = true) {
|
return request(DELETE, url, data, type, lodingFlag)
|
}
|
|
export default {
|
get,
|
post,
|
put,
|
FORM: form,
|
delete: remove,
|
}
|
