更新政府端和银行端

This commit is contained in:
2025-09-17 18:04:28 +08:00
parent f35ceef31f
commit e4287b83fe
185 changed files with 78320 additions and 189 deletions

View File

@@ -0,0 +1,134 @@
import axios from 'axios'
import { message } from 'ant-design-vue'
import router from '@/router'
// 创建axios实例
const api = axios.create({
baseURL: import.meta.env.VITE_API_BASE_URL || '/api',
timeout: 10000,
headers: {
'Content-Type': 'application/json'
}
})
// 请求拦截器
api.interceptors.request.use(
(config) => {
// 添加认证token
const token = localStorage.getItem('token')
if (token) {
config.headers.Authorization = `Bearer ${token}`
}
// 添加时间戳防止缓存
if (config.method === 'get') {
config.params = {
...config.params,
_t: Date.now()
}
}
return config
},
(error) => {
return Promise.reject(error)
}
)
// 响应拦截器
api.interceptors.response.use(
(response) => {
const { code, message: msg } = response.data
// 处理业务错误码
if (code && code !== 200) {
message.error(msg || '请求失败')
return Promise.reject(new Error(msg || '请求失败'))
}
return response
},
(error) => {
const { response } = error
if (response) {
const { status, data } = response
switch (status) {
case 401:
// 未授权清除token并跳转到登录页
localStorage.removeItem('token')
localStorage.removeItem('userInfo')
localStorage.removeItem('permissions')
router.push('/login')
message.error('登录已过期,请重新登录')
break
case 403:
message.error('没有权限访问该资源')
break
case 404:
message.error('请求的资源不存在')
break
case 500:
message.error('服务器内部错误')
break
default:
message.error(data?.message || `请求失败 (${status})`)
}
} else if (error.code === 'ECONNABORTED') {
message.error('请求超时,请稍后重试')
} else {
message.error('网络错误,请检查网络连接')
}
return Promise.reject(error)
}
)
// 封装常用请求方法
export const request = {
get: (url, params = {}) => api.get(url, { params }),
post: (url, data = {}) => api.post(url, data),
put: (url, data = {}) => api.put(url, data),
delete: (url, params = {}) => api.delete(url, { params }),
patch: (url, data = {}) => api.patch(url, data)
}
// 文件上传
export const upload = (url, formData, onProgress) => {
return api.post(url, formData, {
headers: {
'Content-Type': 'multipart/form-data'
},
onUploadProgress: onProgress
})
}
// 文件下载
export const download = async (url, filename, params = {}) => {
try {
const response = await api.get(url, {
params,
responseType: 'blob'
})
const blob = new Blob([response.data])
const downloadUrl = window.URL.createObjectURL(blob)
const link = document.createElement('a')
link.href = downloadUrl
link.download = filename
document.body.appendChild(link)
link.click()
document.body.removeChild(link)
window.URL.revokeObjectURL(downloadUrl)
} catch (error) {
message.error('文件下载失败')
throw error
}
}
export default api

View File

@@ -0,0 +1,508 @@
import { usePermissionStore } from '@/stores/permission'
/**
* 权限检查工具函数
*/
// 检查单个权限
export function hasPermission(permission) {
const permissionStore = usePermissionStore()
return permissionStore.hasPermission(permission)
}
// 检查角色
export function hasRole(role) {
const permissionStore = usePermissionStore()
return permissionStore.hasRole(role)
}
// 检查任一权限
export function hasAnyPermission(permissions) {
const permissionStore = usePermissionStore()
return permissionStore.hasAnyPermission(permissions)
}
// 检查全部权限
export function hasAllPermissions(permissions) {
const permissionStore = usePermissionStore()
return permissionStore.hasAllPermissions(permissions)
}
// 检查路由权限
export function checkRoutePermission(route) {
const permissionStore = usePermissionStore()
return permissionStore.checkRoutePermission(route)
}
/**
* 权限装饰器
* 用于方法级别的权限控制
*/
export function requirePermission(permission) {
return function(target, propertyKey, descriptor) {
const originalMethod = descriptor.value
descriptor.value = function(...args) {
if (hasPermission(permission)) {
return originalMethod.apply(this, args)
} else {
console.warn(`权限不足: ${permission}`)
return Promise.reject(new Error('权限不足'))
}
}
return descriptor
}
}
/**
* 角色装饰器
* 用于方法级别的角色控制
*/
export function requireRole(role) {
return function(target, propertyKey, descriptor) {
const originalMethod = descriptor.value
descriptor.value = function(...args) {
if (hasRole(role)) {
return originalMethod.apply(this, args)
} else {
console.warn(`角色权限不足: ${role}`)
return Promise.reject(new Error('角色权限不足'))
}
}
return descriptor
}
}
/**
* 权限混入
* 为组件提供权限检查方法
*/
export const permissionMixin = {
methods: {
$hasPermission: hasPermission,
$hasRole: hasRole,
$hasAnyPermission: hasAnyPermission,
$hasAllPermissions: hasAllPermissions,
// 权限检查快捷方法
$canView(resource) {
return hasPermission(`${resource}:view`)
},
$canCreate(resource) {
return hasPermission(`${resource}:create`)
},
$canUpdate(resource) {
return hasPermission(`${resource}:update`)
},
$canDelete(resource) {
return hasPermission(`${resource}:delete`)
},
$canExport(resource) {
return hasPermission(`${resource}:export`)
}
}
}
/**
* 权限常量
*/
export const PERMISSIONS = {
// 养殖场管理
FARM_VIEW: 'farm:view',
FARM_CREATE: 'farm:create',
FARM_UPDATE: 'farm:update',
FARM_DELETE: 'farm:delete',
FARM_EXPORT: 'farm:export',
// 设备管理
DEVICE_VIEW: 'device:view',
DEVICE_CREATE: 'device:create',
DEVICE_UPDATE: 'device:update',
DEVICE_DELETE: 'device:delete',
DEVICE_CONTROL: 'device:control',
// 监控管理
MONITOR_VIEW: 'monitor:view',
MONITOR_ALERT: 'monitor:alert',
MONITOR_REPORT: 'monitor:report',
// 数据管理
DATA_VIEW: 'data:view',
DATA_EXPORT: 'data:export',
DATA_ANALYSIS: 'data:analysis',
// 用户管理
USER_VIEW: 'user:view',
USER_CREATE: 'user:create',
USER_UPDATE: 'user:update',
USER_DELETE: 'user:delete',
// 系统管理
SYSTEM_CONFIG: 'system:config',
SYSTEM_LOG: 'system:log',
SYSTEM_BACKUP: 'system:backup',
// 政府监管
SUPERVISION_VIEW: 'supervision:view',
SUPERVISION_CREATE: 'supervision:create',
SUPERVISION_UPDATE: 'supervision:update',
SUPERVISION_DELETE: 'supervision:delete',
SUPERVISION_APPROVE: 'supervision:approve',
SUPERVISION_EXPORT: 'supervision:export',
// 审批管理
APPROVAL_VIEW: 'approval:view',
APPROVAL_CREATE: 'approval:create',
APPROVAL_UPDATE: 'approval:update',
APPROVAL_DELETE: 'approval:delete',
APPROVAL_APPROVE: 'approval:approve',
APPROVAL_REJECT: 'approval:reject',
APPROVAL_EXPORT: 'approval:export',
// 人员管理
PERSONNEL_VIEW: 'personnel:view',
PERSONNEL_CREATE: 'personnel:create',
PERSONNEL_UPDATE: 'personnel:update',
PERSONNEL_DELETE: 'personnel:delete',
PERSONNEL_ASSIGN: 'personnel:assign',
PERSONNEL_EXPORT: 'personnel:export',
// 设备仓库
WAREHOUSE_VIEW: 'warehouse:view',
WAREHOUSE_CREATE: 'warehouse:create',
WAREHOUSE_UPDATE: 'warehouse:update',
WAREHOUSE_DELETE: 'warehouse:delete',
WAREHOUSE_IN: 'warehouse:in',
WAREHOUSE_OUT: 'warehouse:out',
WAREHOUSE_EXPORT: 'warehouse:export',
// 防疫管理
EPIDEMIC_VIEW: 'epidemic:view',
EPIDEMIC_CREATE: 'epidemic:create',
EPIDEMIC_UPDATE: 'epidemic:update',
EPIDEMIC_DELETE: 'epidemic:delete',
EPIDEMIC_PLAN: 'epidemic:plan',
EPIDEMIC_REPORT: 'epidemic:report',
// 服务管理
SERVICE_VIEW: 'service:view',
SERVICE_CREATE: 'service:create',
SERVICE_UPDATE: 'service:update',
SERVICE_DELETE: 'service:delete',
SERVICE_ASSIGN: 'service:assign',
// 可视化大屏
VISUALIZATION_VIEW: 'visualization:view',
VISUALIZATION_CONFIG: 'visualization:config',
VISUALIZATION_EXPORT: 'visualization:export'
}
/**
* 角色常量
*/
export const ROLES = {
SUPER_ADMIN: 'super_admin',
ADMIN: 'admin',
MANAGER: 'manager',
OPERATOR: 'operator',
VIEWER: 'viewer'
}
/**
* 权限组合
*/
export const PERMISSION_GROUPS = {
// 养殖场管理权限组
FARM_MANAGEMENT: [
PERMISSIONS.FARM_VIEW,
PERMISSIONS.FARM_CREATE,
PERMISSIONS.FARM_UPDATE,
PERMISSIONS.FARM_DELETE,
PERMISSIONS.FARM_EXPORT
],
// 设备管理权限组
DEVICE_MANAGEMENT: [
PERMISSIONS.DEVICE_VIEW,
PERMISSIONS.DEVICE_CREATE,
PERMISSIONS.DEVICE_UPDATE,
PERMISSIONS.DEVICE_DELETE,
PERMISSIONS.DEVICE_CONTROL
],
// 监控管理权限组
MONITOR_MANAGEMENT: [
PERMISSIONS.MONITOR_VIEW,
PERMISSIONS.MONITOR_ALERT,
PERMISSIONS.MONITOR_REPORT
],
// 数据管理权限组
DATA_MANAGEMENT: [
PERMISSIONS.DATA_VIEW,
PERMISSIONS.DATA_EXPORT,
PERMISSIONS.DATA_ANALYSIS
],
// 用户管理权限组
USER_MANAGEMENT: [
PERMISSIONS.USER_VIEW,
PERMISSIONS.USER_CREATE,
PERMISSIONS.USER_UPDATE,
PERMISSIONS.USER_DELETE
],
// 系统管理权限组
SYSTEM_MANAGEMENT: [
PERMISSIONS.SYSTEM_CONFIG,
PERMISSIONS.SYSTEM_LOG,
PERMISSIONS.SYSTEM_BACKUP
],
// 政府监管
SUPERVISION_MANAGEMENT: [
PERMISSIONS.SUPERVISION_VIEW,
PERMISSIONS.SUPERVISION_CREATE,
PERMISSIONS.SUPERVISION_UPDATE,
PERMISSIONS.SUPERVISION_DELETE,
PERMISSIONS.SUPERVISION_APPROVE,
PERMISSIONS.SUPERVISION_EXPORT
],
// 审批管理
APPROVAL_MANAGEMENT: [
PERMISSIONS.APPROVAL_VIEW,
PERMISSIONS.APPROVAL_CREATE,
PERMISSIONS.APPROVAL_UPDATE,
PERMISSIONS.APPROVAL_DELETE,
PERMISSIONS.APPROVAL_APPROVE,
PERMISSIONS.APPROVAL_REJECT,
PERMISSIONS.APPROVAL_EXPORT
],
// 人员管理
PERSONNEL_MANAGEMENT: [
PERMISSIONS.PERSONNEL_VIEW,
PERMISSIONS.PERSONNEL_CREATE,
PERMISSIONS.PERSONNEL_UPDATE,
PERMISSIONS.PERSONNEL_DELETE,
PERMISSIONS.PERSONNEL_ASSIGN,
PERMISSIONS.PERSONNEL_EXPORT
],
// 设备仓库
WAREHOUSE_MANAGEMENT: [
PERMISSIONS.WAREHOUSE_VIEW,
PERMISSIONS.WAREHOUSE_CREATE,
PERMISSIONS.WAREHOUSE_UPDATE,
PERMISSIONS.WAREHOUSE_DELETE,
PERMISSIONS.WAREHOUSE_IN,
PERMISSIONS.WAREHOUSE_OUT,
PERMISSIONS.WAREHOUSE_EXPORT
],
// 防疫管理
EPIDEMIC_MANAGEMENT: [
PERMISSIONS.EPIDEMIC_VIEW,
PERMISSIONS.EPIDEMIC_CREATE,
PERMISSIONS.EPIDEMIC_UPDATE,
PERMISSIONS.EPIDEMIC_DELETE,
PERMISSIONS.EPIDEMIC_PLAN,
PERMISSIONS.EPIDEMIC_REPORT
],
// 服务管理
SERVICE_MANAGEMENT: [
PERMISSIONS.SERVICE_VIEW,
PERMISSIONS.SERVICE_CREATE,
PERMISSIONS.SERVICE_UPDATE,
PERMISSIONS.SERVICE_DELETE,
PERMISSIONS.SERVICE_ASSIGN
],
// 可视化大屏
VISUALIZATION_MANAGEMENT: [
PERMISSIONS.VISUALIZATION_VIEW,
PERMISSIONS.VISUALIZATION_CONFIG,
PERMISSIONS.VISUALIZATION_EXPORT
]
}
/**
* 角色权限映射
*/
export const ROLE_PERMISSIONS = {
[ROLES.SUPER_ADMIN]: [
...PERMISSION_GROUPS.FARM_MANAGEMENT,
...PERMISSION_GROUPS.DEVICE_MANAGEMENT,
...PERMISSION_GROUPS.MONITOR_MANAGEMENT,
...PERMISSION_GROUPS.DATA_MANAGEMENT,
...PERMISSION_GROUPS.USER_MANAGEMENT,
...PERMISSION_GROUPS.SYSTEM_MANAGEMENT,
...PERMISSION_GROUPS.SUPERVISION_MANAGEMENT,
...PERMISSION_GROUPS.APPROVAL_MANAGEMENT,
...PERMISSION_GROUPS.PERSONNEL_MANAGEMENT,
...PERMISSION_GROUPS.WAREHOUSE_MANAGEMENT,
...PERMISSION_GROUPS.EPIDEMIC_MANAGEMENT,
...PERMISSION_GROUPS.SERVICE_MANAGEMENT,
...PERMISSION_GROUPS.VISUALIZATION_MANAGEMENT
],
[ROLES.ADMIN]: [
...PERMISSION_GROUPS.FARM_MANAGEMENT,
...PERMISSION_GROUPS.DEVICE_MANAGEMENT,
...PERMISSION_GROUPS.MONITOR_MANAGEMENT,
...PERMISSION_GROUPS.DATA_MANAGEMENT,
PERMISSIONS.USER_VIEW,
PERMISSIONS.USER_CREATE,
PERMISSIONS.USER_UPDATE,
...PERMISSION_GROUPS.SUPERVISION_MANAGEMENT,
...PERMISSION_GROUPS.APPROVAL_MANAGEMENT,
...PERMISSION_GROUPS.PERSONNEL_MANAGEMENT,
...PERMISSION_GROUPS.WAREHOUSE_MANAGEMENT,
...PERMISSION_GROUPS.EPIDEMIC_MANAGEMENT,
...PERMISSION_GROUPS.SERVICE_MANAGEMENT,
PERMISSIONS.VISUALIZATION_VIEW,
PERMISSIONS.VISUALIZATION_CONFIG
],
[ROLES.MANAGER]: [
...PERMISSION_GROUPS.FARM_MANAGEMENT,
...PERMISSION_GROUPS.DEVICE_MANAGEMENT,
...PERMISSION_GROUPS.MONITOR_MANAGEMENT,
PERMISSIONS.DATA_VIEW,
PERMISSIONS.DATA_EXPORT,
PERMISSIONS.SUPERVISION_VIEW,
PERMISSIONS.SUPERVISION_CREATE,
PERMISSIONS.SUPERVISION_UPDATE,
PERMISSIONS.SUPERVISION_EXPORT,
PERMISSIONS.APPROVAL_VIEW,
PERMISSIONS.APPROVAL_APPROVE,
PERMISSIONS.APPROVAL_REJECT,
PERMISSIONS.PERSONNEL_VIEW,
PERMISSIONS.PERSONNEL_ASSIGN,
PERMISSIONS.WAREHOUSE_VIEW,
PERMISSIONS.WAREHOUSE_IN,
PERMISSIONS.WAREHOUSE_OUT,
PERMISSIONS.EPIDEMIC_VIEW,
PERMISSIONS.EPIDEMIC_PLAN,
PERMISSIONS.SERVICE_VIEW,
PERMISSIONS.SERVICE_ASSIGN,
PERMISSIONS.VISUALIZATION_VIEW
],
[ROLES.OPERATOR]: [
PERMISSIONS.FARM_VIEW,
PERMISSIONS.FARM_UPDATE,
PERMISSIONS.DEVICE_VIEW,
PERMISSIONS.DEVICE_CONTROL,
PERMISSIONS.MONITOR_VIEW,
PERMISSIONS.MONITOR_ALERT,
PERMISSIONS.DATA_VIEW,
PERMISSIONS.SUPERVISION_VIEW,
PERMISSIONS.SUPERVISION_CREATE,
PERMISSIONS.APPROVAL_VIEW,
PERMISSIONS.PERSONNEL_VIEW,
PERMISSIONS.WAREHOUSE_VIEW,
PERMISSIONS.WAREHOUSE_IN,
PERMISSIONS.WAREHOUSE_OUT,
PERMISSIONS.EPIDEMIC_VIEW,
PERMISSIONS.EPIDEMIC_CREATE,
PERMISSIONS.SERVICE_VIEW,
PERMISSIONS.VISUALIZATION_VIEW
],
[ROLES.VIEWER]: [
PERMISSIONS.FARM_VIEW,
PERMISSIONS.DEVICE_VIEW,
PERMISSIONS.MONITOR_VIEW,
PERMISSIONS.DATA_VIEW,
PERMISSIONS.SUPERVISION_VIEW,
PERMISSIONS.APPROVAL_VIEW,
PERMISSIONS.PERSONNEL_VIEW,
PERMISSIONS.WAREHOUSE_VIEW,
PERMISSIONS.EPIDEMIC_VIEW,
PERMISSIONS.SERVICE_VIEW,
PERMISSIONS.VISUALIZATION_VIEW
]
}
/**
* 获取角色对应的权限列表
*/
export function getRolePermissions(role) {
return ROLE_PERMISSIONS[role] || []
}
/**
* 检查权限是否属于某个权限组
*/
export function isPermissionInGroup(permission, group) {
return PERMISSION_GROUPS[group]?.includes(permission) || false
}
/**
* 格式化权限显示名称
*/
export function formatPermissionName(permission) {
const permissionNames = {
// 养殖场管理
'farm:view': '查看养殖场',
'farm:create': '新增养殖场',
'farm:update': '编辑养殖场',
'farm:delete': '删除养殖场',
'farm:export': '导出养殖场数据',
// 设备管理
'device:view': '查看设备',
'device:create': '新增设备',
'device:update': '编辑设备',
'device:delete': '删除设备',
'device:control': '控制设备',
// 监控管理
'monitor:view': '查看监控',
'monitor:alert': '处理预警',
'monitor:report': '生成报表',
// 数据管理
'data:view': '查看数据',
'data:export': '导出数据',
'data:analysis': '数据分析',
// 用户管理
'user:view': '查看用户',
'user:create': '新增用户',
'user:update': '编辑用户',
'user:delete': '删除用户',
// 系统管理
'system:config': '系统配置',
'system:log': '系统日志',
'system:backup': '系统备份'
}
return permissionNames[permission] || permission
}
/**
* 格式化角色显示名称
*/
export function formatRoleName(role) {
const roleNames = {
'super_admin': '超级管理员',
'admin': '管理员',
'manager': '经理',
'operator': '操作员',
'viewer': '查看者'
}
return roleNames[role] || role
}

View File

@@ -0,0 +1,307 @@
/**
* HTTP请求工具
*/
import axios from 'axios'
import { message, Modal } from 'ant-design-vue'
import { useUserStore } from '@/stores/user'
import { useNotificationStore } from '@/stores/notification'
import router from '@/router'
// 创建axios实例
const request = axios.create({
baseURL: import.meta.env.VITE_API_BASE_URL || '/api',
timeout: 30000,
headers: {
'Content-Type': 'application/json'
}
})
// 请求拦截器
request.interceptors.request.use(
(config) => {
const userStore = useUserStore()
// 添加认证token
if (userStore.token) {
config.headers.Authorization = `Bearer ${userStore.token}`
}
// 添加请求ID用于追踪
config.headers['X-Request-ID'] = generateRequestId()
// 添加时间戳防止缓存
if (config.method === 'get') {
config.params = {
...config.params,
_t: Date.now()
}
}
// 开发环境下打印请求信息
if (import.meta.env.DEV) {
console.log('🚀 Request:', {
url: config.url,
method: config.method,
params: config.params,
data: config.data
})
}
return config
},
(error) => {
console.error('❌ Request Error:', error)
return Promise.reject(error)
}
)
// 响应拦截器
request.interceptors.response.use(
(response) => {
const { data, config } = response
// 开发环境下打印响应信息
if (import.meta.env.DEV) {
console.log('✅ Response:', {
url: config.url,
status: response.status,
data: data
})
}
// 统一处理响应格式
if (data && typeof data === 'object') {
// 标准响应格式: { code, data, message }
if (data.hasOwnProperty('code')) {
if (data.code === 200 || data.code === 0) {
return {
data: data.data,
message: data.message,
success: true
}
} else {
// 业务错误
const errorMessage = data.message || '请求失败'
message.error(errorMessage)
return Promise.reject(new Error(errorMessage))
}
}
// 直接返回数据
return {
data: data,
success: true
}
}
return {
data: data,
success: true
}
},
(error) => {
const { response, config } = error
const notificationStore = useNotificationStore()
console.error('❌ Response Error:', error)
// 网络错误
if (!response) {
const errorMessage = '网络连接失败,请检查网络设置'
message.error(errorMessage)
// 添加系统通知
notificationStore.addNotification({
type: 'error',
title: '网络错误',
content: errorMessage,
category: 'system'
})
return Promise.reject(new Error(errorMessage))
}
const { status, data } = response
let errorMessage = '请求失败'
// 根据状态码处理不同错误
switch (status) {
case 400:
errorMessage = data?.message || '请求参数错误'
break
case 401:
errorMessage = '登录已过期,请重新登录'
handleUnauthorized()
break
case 403:
errorMessage = '没有权限访问该资源'
break
case 404:
errorMessage = '请求的资源不存在'
break
case 422:
errorMessage = data?.message || '数据验证失败'
break
case 429:
errorMessage = '请求过于频繁,请稍后再试'
break
case 500:
errorMessage = '服务器内部错误'
break
case 502:
errorMessage = '网关错误'
break
case 503:
errorMessage = '服务暂时不可用'
break
case 504:
errorMessage = '请求超时'
break
default:
errorMessage = data?.message || `请求失败 (${status})`
}
// 显示错误消息
if (status !== 401) { // 401错误由handleUnauthorized处理
message.error(errorMessage)
}
// 添加错误通知
notificationStore.addNotification({
type: 'error',
title: '请求错误',
content: `${config.url}: ${errorMessage}`,
category: 'system'
})
return Promise.reject(new Error(errorMessage))
}
)
/**
* 处理未授权错误
*/
function handleUnauthorized() {
const userStore = useUserStore()
Modal.confirm({
title: '登录已过期',
content: '您的登录状态已过期,请重新登录',
okText: '重新登录',
cancelText: '取消',
onOk() {
userStore.logout()
router.push('/login')
}
})
}
/**
* 生成请求ID
*/
function generateRequestId() {
return Date.now().toString(36) + Math.random().toString(36).substr(2)
}
/**
* 请求方法封装
*/
export const http = {
get: (url, config = {}) => request.get(url, config),
post: (url, data = {}, config = {}) => request.post(url, data, config),
put: (url, data = {}, config = {}) => request.put(url, data, config),
patch: (url, data = {}, config = {}) => request.patch(url, data, config),
delete: (url, config = {}) => request.delete(url, config),
upload: (url, formData, config = {}) => {
return request.post(url, formData, {
...config,
headers: {
'Content-Type': 'multipart/form-data',
...config.headers
}
})
},
download: (url, config = {}) => {
return request.get(url, {
...config,
responseType: 'blob'
})
}
}
/**
* 批量请求
*/
export const batchRequest = (requests) => {
return Promise.allSettled(requests.map(req => {
const { method = 'get', url, data, config } = req
return http[method](url, data, config)
}))
}
/**
* 重试请求
*/
export const retryRequest = async (requestFn, maxRetries = 3, delay = 1000) => {
let lastError
for (let i = 0; i <= maxRetries; i++) {
try {
return await requestFn()
} catch (error) {
lastError = error
if (i < maxRetries) {
await new Promise(resolve => setTimeout(resolve, delay * Math.pow(2, i)))
}
}
}
throw lastError
}
/**
* 取消请求的控制器
*/
export const createCancelToken = () => {
return axios.CancelToken.source()
}
/**
* 检查请求是否被取消
*/
export const isCancel = axios.isCancel
/**
* 请求缓存
*/
const requestCache = new Map()
export const cachedRequest = (key, requestFn, ttl = 5 * 60 * 1000) => {
const cached = requestCache.get(key)
if (cached && Date.now() - cached.timestamp < ttl) {
return Promise.resolve(cached.data)
}
return requestFn().then(data => {
requestCache.set(key, {
data,
timestamp: Date.now()
})
return data
})
}
/**
* 清除请求缓存
*/
export const clearRequestCache = (key) => {
if (key) {
requestCache.delete(key)
} else {
requestCache.clear()
}
}
export default request