修改保险后端代码，政府前端代码

government-admin/src/utils/api.js

@@ -1,10 +1,10 @@
 import axios from 'axios'
-import { message } from 'ant-design-vue'
-import router from '@/router'
+import { message } from 'antd'
+import { useUserStore } from '@/stores/user'
 
 // 创建axios实例
-const api = axios.create({
-  baseURL: import.meta.env.VITE_API_BASE_URL || '/api',
+const instance = axios.create({
+  baseURL: '/api',
   timeout: 10000,
   headers: {
     'Content-Type': 'application/json'
@@ -12,122 +12,203 @@ const api = axios.create({
 })
 
 // 请求拦截器
-api.interceptors.request.use(
-  (config) => {
-    // 添加认证token
-    const token = localStorage.getItem('token')
-    if (token) {
-      config.headers.Authorization = `Bearer ${token}`
+instance.interceptors.request.use(
+  config => {
+    // 获取用户store
+    const userStore = useUserStore()
+    // 如果有token，添加到请求头
+    if (userStore.token) {
+      config.headers['Authorization'] = `Bearer ${userStore.token}`
     }
-    
-    // 添加时间戳防止缓存
-    if (config.method === 'get') {
-      config.params = {
-        ...config.params,
-        _t: Date.now()
-      }
-    }
-    
     return config
   },
-  (error) => {
+  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
+instance.interceptors.response.use(
+  response => {
+    // 处理响应数据
+    return response.data
   },
-  (error) => {
-    const { response } = error
-    
-    if (response) {
-      const { status, data } = response
-      
-      switch (status) {
+  error => {
+    // 处理响应错误
+    if (error.response) {
+      // 根据不同的状态码处理错误
+      switch (error.response.status) {
         case 401:
-          // 未授权，清除token并跳转到登录页
-          localStorage.removeItem('token')
-          localStorage.removeItem('userInfo')
-          localStorage.removeItem('permissions')
-          router.push('/login')
+          // 未授权，跳转到登录页面
+          const userStore = useUserStore()
+          userStore.logout()
+          window.location.href = '/login'
           message.error('登录已过期，请重新登录')
           break
-          
         case 403:
-          message.error('没有权限访问该资源')
+          message.error('没有权限执行此操作')
           break
-          
         case 404:
           message.error('请求的资源不存在')
           break
-          
         case 500:
           message.error('服务器内部错误')
           break
-          
         default:
-          message.error(data?.message || `请求失败 (${status})`)
+          message.error(error.response.data.message || '请求失败')
       }
-    } else if (error.code === 'ECONNABORTED') {
-      message.error('请求超时，请稍后重试')
-    } else {
+    } else if (error.request) {
+      // 请求发出但没有收到响应
       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'
+// API接口定义
+const api = {
+  // 认证相关API
+  auth: {
+    // 登录
+    login: (data) => instance.post('/auth/login', data),
+    // 获取用户信息
+    getUserInfo: () => instance.get('/auth/userinfo'),
+    // 退出登录
+    logout: () => instance.post('/auth/logout'),
+    // 重置密码
+    resetPassword: (data) => instance.post('/auth/reset-password', data)
+  },
+  
+  // 用户管理相关API
+  user: {
+    // 获取用户列表
+    getList: (params) => instance.get('/users', { params }),
+    // 获取单个用户信息
+    getDetail: (id) => instance.get(`/users/${id}`),
+    // 创建用户
+    create: (data) => instance.post('/users', data),
+    // 更新用户
+    update: (id, data) => instance.put(`/users/${id}`, data),
+    // 删除用户
+    delete: (id) => instance.delete(`/users/${id}`),
+    // 批量删除用户
+    batchDelete: (ids) => instance.post('/users/batch-delete', { ids }),
+    // 更新用户状态
+    updateStatus: (id, status) => instance.put(`/users/${id}/status`, { status })
+  },
+  
+  // 监管相关API
+  supervision: {
+    // 获取监管统计数据
+    getStats: () => instance.get('/supervision/stats'),
+    // 获取监管任务列表
+    getTasks: (params) => instance.get('/supervision/tasks', { params }),
+    // 获取监管任务详情
+    getTaskDetail: (id) => instance.get(`/supervision/tasks/${id}`),
+    // 创建监管任务
+    createTask: (data) => instance.post('/supervision/tasks', data),
+    // 更新监管任务
+    updateTask: (id, data) => instance.put(`/supervision/tasks/${id}`, data),
+    // 删除监管任务
+    deleteTask: (id) => instance.delete(`/supervision/tasks/${id}`)
+  },
+  
+  // 审批相关API
+  approval: {
+    // 获取审批流程列表
+    getList: (params) => instance.get('/approval', { params }),
+    // 创建审批流程
+    create: (data) => instance.post('/approval', data),
+    // 获取审批详情
+    getDetail: (id) => instance.get(`/approval/${id}`),
+    // 更新审批状态
+    updateStatus: (id, status) => instance.put(`/approval/${id}/status`, { status })
+  },
+  
+  // 疫情监控相关API
+  epidemic: {
+    // 获取疫情统计数据
+    getStats: () => instance.get('/epidemic/stats'),
+    // 获取疫苗接种数据
+    getVaccinationData: (params) => instance.get('/epidemic/vaccination', { params }),
+    // 获取检测数据
+    getTestData: (params) => instance.get('/epidemic/test', { params })
+  },
+  
+  // 数据可视化相关API
+  visualization: {
+    // 获取可视化数据
+    getData: (params) => instance.get('/visualization/data', { params })
+  },
+  
+  // 文件管理相关API
+  file: {
+    // 获取文件列表
+    getList: (params) => instance.get('/files', { params }),
+    // 上传文件
+    upload: (file, onUploadProgress) => {
+      const formData = new FormData()
+      formData.append('file', file)
+      return instance.post('/files/upload', formData, {
+        headers: {
+          'Content-Type': 'multipart/form-data'
+        },
+        onUploadProgress
+      })
     },
-    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
+    // 下载文件
+    download: (id) => instance.get(`/files/${id}/download`, { responseType: 'blob' }),
+    // 删除文件
+    delete: (id) => instance.delete(`/files/${id}`)
+  },
+  
+  // 人员管理相关API
+  personnel: {
+    // 获取人员列表
+    getList: (params) => instance.get('/personnel', { params }),
+    // 创建人员
+    create: (data) => instance.post('/personnel', data),
+    // 更新人员
+    update: (id, data) => instance.put(`/personnel/${id}`, data),
+    // 删除人员
+    delete: (id) => instance.delete(`/personnel/${id}`)
+  },
+  
+  // 服务管理相关API
+  service: {
+    // 获取服务列表
+    getList: (params) => instance.get('/service', { params }),
+    // 创建服务
+    create: (data) => instance.post('/service', data),
+    // 更新服务
+    update: (id, data) => instance.put(`/service/${id}`, data),
+    // 删除服务
+    delete: (id) => instance.delete(`/service/${id}`)
+  },
+  
+  // 仓库管理相关API
+  warehouse: {
+    // 获取仓库列表
+    getList: (params) => instance.get('/warehouse', { params }),
+    // 创建仓库
+    create: (data) => instance.post('/warehouse', data),
+    // 更新仓库
+    update: (id, data) => instance.put(`/warehouse/${id}`, data),
+    // 删除仓库
+    delete: (id) => instance.delete(`/warehouse/${id}`)
+  },
+  
+  // 系统设置相关API
+  system: {
+    // 获取系统设置
+    getSettings: () => instance.get('/system/settings'),
+    // 更新系统设置
+    updateSettings: (data) => instance.put('/system/settings', data),
+    // 获取日志列表
+    getLogs: (params) => instance.get('/system/logs', { params })
   }
 }
 

government-admin/src/utils/format.js

@@ -1,176 +0,0 @@
-/**
- * 格式化工具函数
- */
-
-/**
- * 格式化日期时间
- * @param {Date|string|number} date - 日期
- * @param {string} format - 格式字符串
- * @returns {string} 格式化后的日期字符串
- */
-export function formatDateTime(date, format = 'YYYY-MM-DD HH:mm:ss') {
-  if (!date) return ''
-  
-  const d = new Date(date)
-  if (isNaN(d.getTime())) return ''
-  
-  const year = d.getFullYear()
-  const month = String(d.getMonth() + 1).padStart(2, '0')
-  const day = String(d.getDate()).padStart(2, '0')
-  const hours = String(d.getHours()).padStart(2, '0')
-  const minutes = String(d.getMinutes()).padStart(2, '0')
-  const seconds = String(d.getSeconds()).padStart(2, '0')
-  
-  return format
-    .replace('YYYY', year)
-    .replace('MM', month)
-    .replace('DD', day)
-    .replace('HH', hours)
-    .replace('mm', minutes)
-    .replace('ss', seconds)
-}
-
-/**
- * 格式化日期
- * @param {Date|string|number} date - 日期
- * @returns {string} 格式化后的日期字符串
- */
-export function formatDate(date) {
-  return formatDateTime(date, 'YYYY-MM-DD')
-}
-
-/**
- * 格式化时间
- * @param {Date|string|number} date - 日期
- * @returns {string} 格式化后的时间字符串
- */
-export function formatTime(date) {
-  return formatDateTime(date, 'HH:mm:ss')
-}
-
-/**
- * 格式化数字
- * @param {number} num - 数字
- * @param {number} decimals - 小数位数
- * @returns {string} 格式化后的数字字符串
- */
-export function formatNumber(num, decimals = 0) {
-  if (typeof num !== 'number' || isNaN(num)) return '0'
-  
-  return num.toLocaleString('zh-CN', {
-    minimumFractionDigits: decimals,
-    maximumFractionDigits: decimals
-  })
-}
-
-/**
- * 格式化文件大小
- * @param {number} bytes - 字节数
- * @returns {string} 格式化后的文件大小字符串
- */
-export function formatFileSize(bytes) {
-  if (bytes === 0) return '0 B'
-  
-  const k = 1024
-  const sizes = ['B', 'KB', 'MB', 'GB', 'TB']
-  const i = Math.floor(Math.log(bytes) / Math.log(k))
-  
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
-}
-
-/**
- * 格式化百分比
- * @param {number} value - 数值
- * @param {number} total - 总数
- * @param {number} decimals - 小数位数
- * @returns {string} 格式化后的百分比字符串
- */
-export function formatPercentage(value, total, decimals = 1) {
-  if (!total || total === 0) return '0%'
-  
-  const percentage = (value / total) * 100
-  return percentage.toFixed(decimals) + '%'
-}
-
-/**
- * 格式化货币
- * @param {number} amount - 金额
- * @param {string} currency - 货币符号
- * @returns {string} 格式化后的货币字符串
- */
-export function formatCurrency(amount, currency = '¥') {
-  if (typeof amount !== 'number' || isNaN(amount)) return currency + '0.00'
-  
-  return currency + amount.toLocaleString('zh-CN', {
-    minimumFractionDigits: 2,
-    maximumFractionDigits: 2
-  })
-}
-
-/**
- * 格式化相对时间
- * @param {Date|string|number} date - 日期
- * @returns {string} 相对时间字符串
- */
-export function formatRelativeTime(date) {
-  if (!date) return ''
-  
-  const now = new Date()
-  const target = new Date(date)
-  const diff = now - target
-  
-  const minute = 60 * 1000
-  const hour = 60 * minute
-  const day = 24 * hour
-  const week = 7 * day
-  const month = 30 * day
-  const year = 365 * day
-  
-  if (diff < minute) {
-    return '刚刚'
-  } else if (diff < hour) {
-    return Math.floor(diff / minute) + '分钟前'
-  } else if (diff < day) {
-    return Math.floor(diff / hour) + '小时前'
-  } else if (diff < week) {
-    return Math.floor(diff / day) + '天前'
-  } else if (diff < month) {
-    return Math.floor(diff / week) + '周前'
-  } else if (diff < year) {
-    return Math.floor(diff / month) + '个月前'
-  } else {
-    return Math.floor(diff / year) + '年前'
-  }
-}
-
-/**
- * 格式化手机号
- * @param {string} phone - 手机号
- * @returns {string} 格式化后的手机号
- */
-export function formatPhone(phone) {
-  if (!phone) return ''
-  
-  const cleaned = phone.replace(/\D/g, '')
-  if (cleaned.length === 11) {
-    return cleaned.replace(/(\d{3})(\d{4})(\d{4})/, '$1-$2-$3')
-  }
-  
-  return phone
-}
-
-/**
- * 格式化身份证号
- * @param {string} idCard - 身份证号
- * @returns {string} 格式化后的身份证号
- */
-export function formatIdCard(idCard) {
-  if (!idCard) return ''
-  
-  const cleaned = idCard.replace(/\D/g, '')
-  if (cleaned.length === 18) {
-    return cleaned.replace(/(\d{6})(\d{8})(\d{4})/, '$1-$2-$3')
-  }
-  
-  return idCard
-}

government-admin/src/utils/permission.js

@@ -1,527 +0,0 @@
-import { usePermissionStore } from '@/stores/permission'
-
-/**
- * 权限检查工具函数
- */
-
-// 检查单个权限
-export function hasPermission(permission) {
-  const permissionStore = usePermissionStore()
-  
-  // 超级管理员和管理员拥有所有权限
-  if (permissionStore.hasRole('super_admin') || permissionStore.hasRole('admin')) {
-    return true
-  }
-  
-  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 = {
-  // 工作台
-  DASHBOARD_VIEW: 'dashboard:view',
-  
-  // 养殖场管理
-  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 = {
-  // 工作台权限组
-  DASHBOARD_MANAGEMENT: [
-    PERMISSIONS.DASHBOARD_VIEW
-  ],
-  
-  // 养殖场管理权限组
-  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.DASHBOARD_MANAGEMENT,
-    ...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.DASHBOARD_MANAGEMENT,
-    ...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 = {
-    // 工作台
-    'dashboard:view': '查看工作台',
-    
-    // 养殖场管理
-    '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
-}

government-admin/src/utils/request.js

@@ -1,307 +0,0 @@
-/**
- * HTTP请求工具
- */
-import axios from 'axios'
-import { message, Modal } from 'ant-design-vue'
-import { useAuthStore } from '@/stores/auth'
-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 authStore = useAuthStore()
-    
-    // 添加认证token
-    if (authStore.token) {
-      config.headers.Authorization = `Bearer ${authStore.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 authStore = useAuthStore()
-  
-  Modal.confirm({
-    title: '登录已过期',
-    content: '您的登录状态已过期，请重新登录',
-    okText: '重新登录',
-    cancelText: '取消',
-    onOk() {
-      authStore.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