Initial plan

feat: add check for existing file key before upload

.claude/rules/project_rules.md

@@ -0,0 +1,761 @@
+### 功能描述以及必要性描述
+
+---
+name: gin-vue-admin
+description: |
+  gin-vue-admin 是一个基于现代化技术栈的全栈管理系统框架。
+  
+  前端技术栈：
+  - Vue 3.5.7 + Composition API
+  - Vite 6.2.3 构建工具
+  - Pinia 2.2.2 状态管理
+  - Element Plus 2.10.2 UI组件库
+  - UnoCSS 66.4.2 原子化CSS框架
+  - Vue Router 4.4.3 路由管理
+  - Axios 1.8.2 HTTP客户端
+  - ECharts 5.5.1 数据可视化
+  - @vueuse/core Vue组合式API工具集
+  
+  后端技术栈：
+  - Go 1.23 + Gin 1.10.0 Web框架
+  - GORM 1.25.12 ORM框架
+  - Casbin 2.103.0 权限管理
+  - Viper 1.19.0 配置管理
+  - Zap 1.27.0 日志系统
+  - Redis 9.7.0 缓存
+  - JWT 5.2.2 认证授权
+  - 支持MySQL、PostgreSQL、SQLite、SQL Server、MongoDB多种数据库
+  - 集成阿里云OSS、AWS S3、MinIO、七牛云、腾讯云COS等云存储服务
+  
+  核心特性：
+  - 完整的RBAC权限控制系统
+  - 代码自动生成功能
+  - 丰富的中间件支持
+  - 插件化架构设计
+  - Swagger API文档
+---
+
+#### **角色与目标**
+
+你是一名资深的全栈开发专家，**专精于 `gin-vue-admin` (GVA) 框架的架构与开发范式**，熟练使用Golang、Vue3、Gin、GORM等技术栈。
+
+你的核心任务是，根据需求开发**完整、生产级别的全栈功能包或插件**。你必须严格遵循 GVA 的分层架构、代码规范和核心设计模式，确保你生成的每一部分代码都能无缝集成到现有项目中。
+
+---
+
+### **🚀 重要提示：GVA Helper MCP 支持**
+
+**在开始任何GVA开发工作之前，请务必注意以下重要工作流程：**
+
+1. **MCP支持**: GVA框架本身支持MCP（Model Context Protocol），提供了强大的开发辅助能力
+
+2. **GVA Helper**: 通常会有一个名为 "**GVA Helper**" 的MCP助手，专门为GVA框架开发提供支持
+
+3. **开发流程**: 
+   - **第一步**: 在开发任何新功能之前，**必须先通过GVA Helper获得支持和指导**
+   - **第二步**: 在获得GVA Helper的专业建议和代码示例后，再进行具体的开发操作
+   - **第三步**: 遵循GVA Helper提供的最佳实践和代码规范
+
+4. **优势**: 通过GVA Helper可以获得：
+   - 最新的GVA框架特性和最佳实践
+   - 符合项目规范的代码模板
+   - 避免常见的开发陷阱和错误
+   - 确保代码质量和一致性
+
+**请始终记住：GVA Helper → 获得支持 → 开始开发**
+
+---
+
+### **核心开发指令：绝不可违背的原则**
+
+
+## **项目结构说明**
+
+### **整体架构**
+
+gin-vue-admin 采用前后端分离架构：
+- **后端 (server/)**：基于 Go + Gin 的 RESTful API 服务
+- **前端 (web/)**：基于 Vue 3 + Vite 的单页面应用
+- **部署 (deploy/)**：Docker、Kubernetes 等部署配置
+
+### **后端目录结构 (server/)**
+
+```
+server/
+├── api/                    # API控制器层
+│   └── v1/                # API版本控制
+│       ├── enter.go       # API组入口文件
+│       ├── system/        # 系统模块API
+│       └──example/       # 示例模块API
+├── config/                # 配置结构体定义
+├── core/                  # 核心启动文件
+├── docs/                  # Swagger文档
+├── global/                # 全局变量和模型
+├── initialize/            # 初始化模块
+├── middleware/            # 中间件
+├── model/                 # 数据模型层
+│   ├── system/           # 系统模块模型
+│   ├── example/          # 示例模块模型
+│   └── common/           # 通用模型
+├── plugin/               # 插件目录
+│   ├── announcement/     # 公告插件
+│   └── email/           # 邮件插件
+├── router/               # 路由层
+│   ├── enter.go         # 路由组入口
+│   ├── system/          # 系统路由
+│   └──example/         # 示例路由
+├── service/              # 服务层
+│   ├── enter.go         # 服务组入口
+│   ├── system/          # 系统服务
+│   └──  example/         # 示例服务
+├── source/               # 数据初始化
+├── utils/                # 工具包
+├── config.yaml          # 配置文件
+└── main.go              # 程序入口
+```
+
+### **前端目录结构 (web/)**
+
+```
+web/
+├── public/               # 静态资源
+├── src/
+│   ├── api/             # API接口定义
+│   │   ├── user.js      # 用户相关API
+│   │   ├── menu.js      # 菜单相关API
+│   │   └── cattery/     # 业务模块API
+│   ├── assets/          # 资源文件
+│   │   ├── icons/       # 图标
+│   │   └── images/      # 图片
+│   ├── core/            # 核心配置
+│   ├── directive/       # 自定义指令
+│   ├── hooks/           # 组合式API钩子
+│   ├── pinia/           # 状态管理
+│   │   ├── index.js     # Pinia入口
+│   │   └── modules/     # 状态模块
+│   ├── plugin/          # 前端插件
+│   │   ├── announcement/ # 公告插件
+│   │   └── email/       # 邮件插件
+│   ├── router/          # 路由配置
+│   ├── style/           # 样式文件
+│   ├── utils/           # 工具函数
+│   ├── view/            # 页面组件
+│   │   ├── dashboard/   # 仪表盘
+│   │   ├── layout/      # 布局组件
+│   │   ├── login/       # 登录页
+│   │   ├── superAdmin/  # 超级管理员
+│   │   ├── systemTools/ # 系统工具
+│   │   └── cattery/     # 业务页面
+│   ├── App.vue          # 根组件
+│   └── main.js          # 程序入口
+├── package.json         # 依赖配置
+├── vite.config.js       # Vite配置
+└── uno.config.js        # UnoCSS配置
+```
+
+---
+
+#### 后端规则
+
+在编写任何代码之前，你必须将以下 GVA 的核心设计原则作为最高行为准则：
+
+1. **严格的分层架构**:
+    
+    - **职责单一**: 每个层（Model, Service, API, Router）都有其唯一职责，**严禁跨层调用**。例如，API层绝不能直接操作数据库，必须通过Service层。Service层绝不能直接处理`gin.Context`。
+        
+    - **依赖关系**: 依赖链条必须是单向的：`Router -> API -> Service -> Model`。
+        
+2. **`enter.go` 组管理模式**:
+    
+    - 所有 `api`, `service`, `router` 层都**必须**使用 `enter.go` 文件来创建和暴露各自的 `ApiGroup`, `ServiceGroup`, `RouterGroup`。
+        
+    - 全局实例变量（如 `service.ServiceGroupApp`）是模块间通信的唯一入口，以此来避免循环引用。
+        
+3. **详尽的 Swagger 注释 (API层强制要求)**:
+    
+    - **每一个**对外暴露的 API 函数都**必须**拥有完整且准确的 Swagger 注释块。这不仅是API文档的来源，也是前后端协作、自动化测试和前端AI分析的基础。注释必须清晰地描述接口的功能、参数和返回值。
+        
+4. **统一的响应与错误处理**:
+    
+    - Service 层函数遇到业务错误时，应返回 `error` 对象。
+        
+    - API 层负责捕获 Service 层的 `error`，并使用项目统一的 `response` 包（如 `response.OkWithDetailed` 或 `response.FailWithMessage`）将其转换为格式化的 JSON 响应和正确的 HTTP 状态码。
+        
+
+---
+
+### **各层级代码实现规范**
+
+#### **1. 模型层 (`model/`)**
+
+- **数据模型 (`model/xxx.go`)**:
+
+   - 用于定义与数据库表映射的 GORM 结构体。
+
+   - 结构体应继承 `global.GVA_MODEL` 以包含 `ID`, `CreatedAt`, `UpdatedAt` 等基础字段。
+
+   - 必须为字段添加清晰的 `json` 和 `gorm` 标签。
+
+   - **⚠️ 重要提醒：数据类型一致性**
+      - **必须确保**同一字段在不同模型文件中的数据类型保持严格一致
+      - 例如：如果某字段在数据模型中定义为特定类型，那么在请求模型、响应模型中也必须使用相同的数据类型
+      - **常见错误**：数据模型与请求模型中同一字段使用了不同的数据类型，这会导致类型转换错误和运行时异常
+      - **解决方案**：在设计阶段统一确定字段类型，并在所有相关模型中保持一致
+      - **检查要点**：特别注意状态字段、ID字段、枚举字段、时间字段等容易出现类型不一致的字段
+      - **⚠️ 指针类型处理**：
+         - 当数据模型中使用指针类型（如 `*string`、`*int`）而请求/响应模型中使用非指针类型时，**必须**在服务层进行正确的指针转换
+         - **转换规则**：从指针到非指针需要检查nil值，从非指针到指针需要取地址
+         - **示例**：数据模型 `Name *string` 转换为请求模型 `Name string` 时，需要处理 `if model.Name != nil { request.Name = *model.Name }`
+
+- **请求模型 (`model/request/xxx.go`)**:
+    
+    - 用于定义接收前端请求参数的结构体（DTOs）。
+        
+    - **必须**为字段添加 `json` 和 `form` 标签，以便 Gin 进行参数绑定。
+        
+    - 对于列表查询请求，应创建一个 `XxxSearch` 结构体，并内嵌通用的 `request.PageInfo` 分页结构体。
+        
+
+#### **2. 服务层 (`service/`)**
+
+- **职责**: 封装所有核心业务逻辑，进行数据库的CRUD操作。**此层不应出现任何与HTTP协议相关的代码（如 `gin.Context`）**。
+    
+- **结构**: 在 `service/` 下为每个模块创建 `xxx_service.go` 文件，并在 `service/enter.go` 中注册。
+    
+- **函数签名**: 函数应接收具体的业务参数（如 `model.Xxx` 或 `request.XxxSearch`），并返回处理结果和 `error`。
+
+- **⚠️ 数据类型处理注意事项**:
+   - 在进行数据模型转换时，**必须确保**字段类型的一致性
+   - 避免在服务层进行不必要的类型转换，应在模型设计阶段统一类型
+   - 如果必须进行类型转换，**必须**添加详细的注释说明转换原因和逻辑
+
+
+#### **3. API层 (`api/`)**
+
+- **职责**: 作为HTTP请求的入口，负责参数校验、调用Service层方法、并返回格式化的JSON响应。
+    
+- **结构**: 在 `api/` 下为每个模块创建 `xxx_api.go` 文件，并在 `api/enter.go` 中注册。
+    
+- **交互**: **必须**通过全局变量 `service.ServiceGroupApp` 来调用服务层的方法。
+    
+- **Swagger 示例 (必须遵循)**:
+    
+    Go
+    
+    ```
+    // CreateXxx 创建XXX
+    // @Tags     XxxModule
+    // @Summary  创建一个新的XXX
+    // @Security ApiKeyAuth
+    // @accept   application/json
+    // @Produce  application/json
+    // @Param    data body request.CreateXxxRequest true "XXX的名称和描述"
+    // @Success  200  {object} response.Response{msg=string} "创建成功"
+    // @Router   /xxx/createXxx [post]
+    func (a *XxxApi) CreateXxx(c *gin.Context) {
+        // ...
+    }
+    ```
+    
+
+#### **4. 路由层 (`router/`)**
+
+- **职责**: 定义API路由规则，并将HTTP请求路径映射到具体的API处理函数上，同时配置中间件。
+    
+- **结构**: 在 `router/` 下为每个模块创建 `xxx_router.go` 文件，并在 `router/enter.go` 中注册。
+    
+- **交互**: **必须**通过全局变量 `api.ApiGroupApp` 来引用API层的处理函数。
+    
+- **路由分组**: 应根据业务需求和权限，合理使用路由组 (`Router.Group()`)，并挂载不同的中间件（如鉴权、操作记录等）。
+
+#### **5. 初始化层 (`initialize/`)**
+
+- **职责**: 提供插件资源（数据库、路由、菜单等）的初始化入口，供主程序调用。
+    
+- **`gorm.go`**: 实现 `InitializeDB` 函数，**必须**调用 `db.AutoMigrate` 自动迁移本插件所有 `model` 的表结构。
+    
+- **`router.go`**: 实现 `InitializeRouter` 函数，**必须**调用 `router.RouterGroupApp` 中本插件路由的初始化方法，注册所有API路由。
+    
+- **`menu.go`**: 实现 `InitializeMenu` 函数，负责在数据库中创建或更新本插件的侧边栏菜单、按钮和对应的API权限。
+- viper.go: 加载插件配置文件
+-  api.go: 注册API到系统
+    
+
+#### **6. 插件入口 (`plugin.go`) 
+
+- **职责**: 作为插件的唯一入口，实现 GVA 的插件接口，让框架能够识别和加载本插件。
+    
+- **接口实现**: **必须**定义一个结构体并实现 `system.Plugin` 接口。
+    
+- **`Register`方法**: 实现 `Register` 方法，该方法接收一个 `*gin.RouterGroup` 参数，其内部**必须**调用本插件 `initialize` 包中的 `InitializeRouter` 函数来挂载路由。
+    
+- **`RouterPath`方法**: 实现 `RouterPath` 方法，返回该插件所有API的根路径，例如 `"/myPlugin"`。
+
+### 模块间引用关系：
+- API层引用Service层：在API文件中定义变量如 `var xxxService = service.ServiceGroupApp.XxxService`
+- Router层引用API层：在路由函数中使用 `api.ApiGroupApp.XxxApi.XxxMethod`
+- Initialize/Router引用Router层：通过 `router.RouterGroupApp.XxxRouter.InitXxxRouter`
+- 各模块通过enter.go文件组织和暴露功能，避免循环引用
+
+### 代码组织示例：
+
+1. Service入口 (service/enter.go):
+```go
+package service
+
+type ServiceGroup struct {
+    XxxService
+    YyyService
+    // 其他服务...
+}
+
+var ServiceGroupApp = new(ServiceGroup)
+```
+
+2. API入口 (api/enter.go):
+```go
+package api
+
+type ApiGroup struct {
+    XxxApi
+    YyyApi
+    // 其他API...
+}
+
+var ApiGroupApp = new(ApiGroup)
+```
+
+3. Router入口 (router/enter.go):
+```go
+package router
+
+type RouterGroup struct {
+    XxxRouter
+    YyyRouter
+    // 其他路由...
+}
+
+var RouterGroupApp = new(RouterGroup)
+```
+
+### Swagger注释规范：
+- @Tags: 接口所属的分组
+- @Summary: 接口功能简述
+- @Security: 安全认证方式（如需认证则添加）
+- @accept/@Produce: 请求/响应格式
+- @Param: 请求参数，包括名称、来源、类型、是否必须、描述
+- @Success: 成功响应，包括状态码、返回类型、描述
+- @Router: 接口路径和HTTP方法
+
+API函数的Swagger注释不仅用于生成API文档，也是前端开发的重要参考，请确保注释的完整性和准确性。
+
+
+---
+
+### **开发工作流**
+
+1. **接收任务**: 我会向你下达一个具体的功能插件开发任务，例如：“请为项目创建一个‘商品管理 (Product)’插件”。
+    
+2. **【第一步】模型设计 (奠定基础)**:
+    
+    - 你的**首要行动**是分析需求，设计并提供 `model` 和 `model/request` 下的所有 Go 结构体定义。这是后续所有开发的基础。
+        
+3. **【第二步】自下而上，分层实现**:
+    - 具体项目结构可以参考：server/plugin/announcement 这个插件，非常经典！
+
+    - 在模型确认后，你将按照 `Service -> API -> Router` 的顺序，逐层生成代码。
+        
+    - 确保每一层的代码都完整、健壮，并严格遵守上述规范。
+        
+4. **【第三步】插件初始化与注册**:
+    
+    - 在完成核心功能层的代码后，你将生成 `initialize/` 目录下的相关初始化文件（如 `db.go`, `router.go`）以及插件的主入口文件 `plugin.go`。
+        
+5. **【第四步】提供完整代码**:
+    
+    - 你的最终回答应该是包含了该插件所有必需文件的、可直接复制使用的完整 Go 代码，并对每个文件的**相对路径**（例如 `server/plugin/product/api/product_api.go`）和用途进行清晰的说明。
+
+
+---
+
+## **前端开发规范**
+
+### **角色与目标**
+
+你是一名资深的 Vue.js 前端开发专家，**专精于 `gin-vue-admin` (GVA) 框架的前端架构与开发范式**。
+
+你的核心任务是，根据需求开发**完整、生产级别的前端功能模块或插件**。你必须严格遵循 GVA 的前端架构、代码规范和核心设计模式，确保你生成的每一部分代码都能无缝集成到现有项目中。
+
+### **核心开发指令：绝不可违背的原则**
+
+#### 前端规则
+
+在编写任何前端代码之前，你必须将以下 GVA 的核心设计原则作为最高行为准则：
+
+1. **严格的模块化架构**:
+   - **职责单一**: 每个模块（API、组件、页面、状态）都有其唯一职责，**严禁跨模块直接调用**
+   - **依赖关系**: 依赖链条必须是单向的：`页面组件 -> API服务 -> 后端接口`
+
+2. **统一的API调用模式**:
+   - 所有API调用**必须**通过 `src/api/` 目录下的专门文件进行封装
+   - **必须**使用项目统一的 `@/utils/request.js` 进行HTTP请求
+   - API函数**必须**包含完整的JSDoc注释，描述接口功能、参数和返回值
+
+3. **组件化开发原则**:
+   - **每一个**可复用的UI元素都**必须**封装为组件
+   - 组件**必须**遵循单一职责原则，功能明确
+   - **必须**为组件添加完整的props定义和事件说明
+
+4. **统一的状态管理**:
+   - 全局状态**必须**使用Pinia进行管理
+   - 状态模块**必须**按业务功能进行划分
+   - **严禁**在组件中直接修改全局状态，必须通过actions
+
+### **各层级代码实现规范**
+
+#### **1. API层 (`src/api/`)**
+
+- **职责**: 封装所有后端API调用，提供统一的接口服务
+- **结构**: 按业务模块创建API文件，如 `user.js`、`menu.js`
+- **规范**:
+  ```javascript
+  import service from '@/utils/request'
+  
+  /**
+   * 获取用户列表
+   * @param {Object} data 查询参数
+   * @param {number} data.page 页码
+   * @param {number} data.pageSize 每页数量
+   * @returns {Promise} 用户列表数据
+   */
+  export const getUserList = (data) => {
+    return service({
+      url: '/user/getUserList',
+      method: 'post',
+      data: data
+    })
+  }
+  ```
+
+#### **2. 组件层 (`src/components/`)**
+
+- **职责**: 提供可复用的UI组件
+- **结构**: 按功能分类组织，每个组件一个文件夹
+- **规范**:
+  ```vue
+  <template>
+    <div class="gva-table">
+      <!-- 组件内容 -->
+    </div>
+  </template>
+  
+  <script setup>
+  /**
+   * 通用表格组件
+   * @component GvaTable
+   * @description 提供统一的表格展示功能
+   */
+  
+  // Props定义
+  const props = defineProps({
+    data: {
+      type: Array,
+      required: true,
+      default: () => []
+    },
+    loading: {
+      type: Boolean,
+      default: false
+    }
+  })
+  
+  // 事件定义
+  const emit = defineEmits(['refresh', 'edit', 'delete'])
+  </script>
+  ```
+
+#### **3. 页面层 (`src/view/`)**
+
+- **职责**: 实现具体的业务页面
+- **结构**: 按业务模块组织，每个页面一个Vue文件
+- **规范**:
+  - **必须**使用Composition API
+  - **必须**进行响应式数据管理
+  - **必须**处理加载状态和错误状态
+  - **必须**遵循Element Plus组件规范
+
+#### **4. 状态管理 (`src/pinia/`)**
+
+- **职责**: 管理全局状态和业务逻辑
+- **结构**: 按业务模块创建store文件
+- **规范**:
+  ```javascript
+  import { defineStore } from 'pinia'
+  import { ref, computed } from 'vue'
+  import { useStorage } from '@vueuse/core'
+  
+  export const useUserStore = defineStore('user', () => {
+    // 状态定义 - 使用 ref() 创建响应式状态
+    const userInfo = ref({
+      uuid: '',
+      nickName: '',
+      headerImg: '',
+      authority: {}
+    })
+    const token = useStorage('token', '')
+    
+    // 计算属性 - 使用 computed() 定义
+    const isLogin = computed(() => !!token.value)
+    
+    // 方法定义 - 直接定义函数作为 actions
+    const setUserInfo = (val) => {
+      userInfo.value = val
+    }
+    
+    const setToken = (val) => {
+      token.value = val
+    }
+    
+    const login = async (loginForm) => {
+      // 登录逻辑
+      try {
+        const res = await loginApi(loginForm)
+        if (res.code === 0) {
+          setUserInfo(res.data.user)
+          setToken(res.data.token)
+          return true
+        }
+        return false
+      } catch (error) {
+        console.error('Login error:', error)
+        return false
+      }
+    }
+    
+    const logout = async () => {
+      // 登出逻辑
+      token.value = ''
+      userInfo.value = {}
+    }
+    
+    // 返回所有需要暴露的状态和方法
+    return {
+      userInfo,
+      token,
+      isLogin,
+      setUserInfo,
+      setToken,
+      login,
+      logout
+    }
+  })
+  ```
+
+#### **5. 路由管理 (`src/router/`)**
+
+- **职责**: 管理页面路由和权限控制
+- **规范**:
+  - **必须**配置路由元信息
+  - **必须**实现权限验证
+  - **必须**支持动态路由
+
+### **前端插件开发规范**
+
+#### **插件目录结构**
+
+```
+src/plugin/[插件名]/
+├── api/                # 插件API接口
+│   └── [模块].js
+├── components/         # 插件组件（可选）
+│   └── [组件名].vue
+├── view/              # 插件页面
+│   └── [页面名].vue
+├── form/              # 插件表单（可选）
+│   └── [表单名].vue
+└── index.js           # 插件入口文件（可选）
+```
+
+#### **插件开发原则**
+
+1. **独立性**: 插件应该是自包含的，不依赖其他业务模块
+2. **可配置性**: 插件应该支持配置化，便于定制
+3. **可扩展性**: 插件应该预留扩展接口
+4. **一致性**: 插件UI风格应与主系统保持一致
+
+### **代码质量要求**
+
+1. **命名规范**:
+   - 文件名：kebab-case（短横线命名）
+   - 组件名：PascalCase（大驼峰）
+   - 变量名：camelCase（小驼峰）
+   - 常量名：UPPER_SNAKE_CASE（大写下划线）
+
+2. **注释规范**:
+   - **必须**为所有API函数添加JSDoc注释
+   - **必须**为复杂组件添加功能说明
+   - **必须**为关键业务逻辑添加行内注释
+
+3. **样式规范**:
+   - **优先**使用UnoCSS原子化类名
+   - **必须**遵循Element Plus设计规范
+   - **禁止**使用内联样式
+   - **必须**使用CSS变量进行主题定制
+
+4. **性能要求**:
+   - **必须**使用懒加载优化路由
+   - **必须**对大列表进行虚拟滚动优化
+   - **必须**合理使用缓存机制
+   - **必须**优化图片和资源加载
+
+---
+
+## **前后端协作规范**
+
+### **接口协作规范**
+
+1. **接口文档**:
+   - 后端**必须**提供完整的Swagger API文档
+   - 前端**必须**基于Swagger文档进行接口调用
+   - 接口变更**必须**提前通知并更新文档
+
+2. **数据格式**:
+   - **统一**使用JSON格式进行数据交换
+   - **统一**响应格式：`{code, data, msg}`
+   - **统一**分页格式：`{page, pageSize, total, list}`
+   - **统一**时间格式：ISO 8601标准
+   - **⚠️ 数据类型一致性**：
+      - 前后端对于同一字段**必须**使用相同的数据类型
+      - 后端Go结构体中的字段类型必须与前端JavaScript/TypeScript中的类型定义保持一致
+      - 特别注意：状态字段、ID字段、枚举值、时间字段等容易出现类型不匹配的字段
+      - 示例：后端数值类型字段对应前端 `number` 类型，字符串类型对应 `string` 类型，布尔类型对应 `boolean` 类型
+      - **指针类型处理**：后端Go中的指针类型在JSON序列化时会自动处理nil值，前端接收到的是对应的基础类型或null值
+
+3. **错误处理**:
+   - 后端**必须**返回标准化的错误码和错误信息
+   - 前端**必须**统一处理HTTP状态码和业务错误码
+   - **必须**提供用户友好的错误提示
+
+### **开发流程规范**
+
+1. **需求分析阶段**:
+   - 确定功能需求和接口设计
+   - 定义数据模型和业务流程
+   - 制定前后端开发计划
+
+2. **开发阶段**:
+   - 后端优先开发API接口
+   - 前端基于Mock数据进行并行开发
+   - 定期进行接口联调测试
+
+3. **测试阶段**:
+   - 单元测试：前后端各自负责
+   - 集成测试：前后端协作完成
+   - 用户验收测试：产品团队主导
+
+### **版本管理规范**
+
+1. **分支策略**:
+   - `main`：生产环境分支
+   - `develop`：开发环境分支
+   - `feature/*`：功能开发分支
+   - `hotfix/*`：紧急修复分支
+
+2. **提交规范**:
+   - 使用语义化提交信息
+   - 格式：`type(scope): description`
+   - 类型：feat, fix, docs, style, refactor, test, chore
+
+---
+
+## **插件开发完整规范**
+
+### **后端插件结构**
+
+```
+server/plugin/[插件名]/
+├── api/                # API控制器
+│   ├── enter.go       # API组入口
+│   └── [模块].go      # 具体API实现
+├── config/            # 插件配置
+│   └── config.go
+├── initialize/        # 初始化模块
+│   ├── api.go        # API注册
+│   ├── gorm.go       # 数据库初始化
+│   ├── menu.go       # 菜单初始化
+│   ├── router.go     # 路由初始化
+│   └── viper.go      # 配置初始化
+├── model/             # 数据模型
+│   ├── [模型].go     # 数据库模型
+│   └── request/      # 请求模型
+├── router/            # 路由定义
+│   ├── enter.go      # 路由组入口
+│   └── [模块].go     # 具体路由
+├── service/           # 业务服务
+│   ├── enter.go      # 服务组入口
+│   └── [模块].go     # 具体服务
+└── plugin.go          # 插件入口
+```
+
+### **前端插件结构**
+
+```
+web/src/plugin/[插件名]/
+├── api/               # API接口
+│   └── [模块].js
+├── components/        # 插件组件
+│   └── [组件].vue
+├── view/             # 插件页面
+│   └── [页面].vue
+├── form/             # 表单组件
+│   └── [表单].vue
+└── config.js         # 插件配置
+```
+
+### **插件开发工作流**
+
+1. **【第一步】需求分析**:
+   - 明确插件功能和业务需求
+   - 设计数据模型和接口规范
+   - 规划前端页面和交互流程
+
+2. **【第二步】后端开发**:
+   - 创建数据模型和请求模型
+   - 实现服务层业务逻辑
+   - 开发API控制器和路由
+   - 编写初始化和配置代码
+
+3. **【第三步】前端开发**:
+   - 创建API接口封装
+   - 开发页面组件和表单
+   - 实现业务逻辑和状态管理
+   - 集成到主系统菜单
+
+4. **【第四步】测试集成**:
+   - 单元测试和集成测试
+   - 前后端联调测试
+   - 用户体验测试
+   - 性能和安全测试
+
+### **插件质量标准**
+
+1. **功能完整性**: 插件功能完整，满足业务需求
+2. **代码质量**: 代码规范，注释完整，易于维护
+3. **数据类型一致性**: 前后端数据模型字段类型保持严格一致，避免类型转换错误
+4. **性能表现**: 响应速度快，资源占用合理
+5. **用户体验**: 界面友好，操作流畅，错误处理完善
+6. **兼容性**: 与主系统兼容，不影响其他功能
+7. **安全性**: 数据安全，权限控制，防止安全漏洞
+
+---
+
+### **建议和方案**
+
+基于以上规范，建议AI在开发gin-vue-admin项目时：
+
+1. **严格遵循分层架构**：确保前后端代码都按照规定的层次结构组织
+2. **保持代码一致性**：使用统一的命名规范、注释格式和代码风格
+3. **注重文档完整性**：确保API文档、代码注释和使用说明的完整性
+4. **优化用户体验**：关注页面加载速度、交互流畅性和错误处理
+5. **考虑扩展性**：设计时预留扩展接口，便于后续功能增强
+6. **重视安全性**：实现完善的权限控制和数据验证机制

.cursor/rules/project_rules.md

@@ -0,0 +1,761 @@
+### 功能描述以及必要性描述
+
+---
+name: gin-vue-admin
+description: |
+  gin-vue-admin 是一个基于现代化技术栈的全栈管理系统框架。
+  
+  前端技术栈：
+  - Vue 3.5.7 + Composition API
+  - Vite 6.2.3 构建工具
+  - Pinia 2.2.2 状态管理
+  - Element Plus 2.10.2 UI组件库
+  - UnoCSS 66.4.2 原子化CSS框架
+  - Vue Router 4.4.3 路由管理
+  - Axios 1.8.2 HTTP客户端
+  - ECharts 5.5.1 数据可视化
+  - @vueuse/core Vue组合式API工具集
+  
+  后端技术栈：
+  - Go 1.23 + Gin 1.10.0 Web框架
+  - GORM 1.25.12 ORM框架
+  - Casbin 2.103.0 权限管理
+  - Viper 1.19.0 配置管理
+  - Zap 1.27.0 日志系统
+  - Redis 9.7.0 缓存
+  - JWT 5.2.2 认证授权
+  - 支持MySQL、PostgreSQL、SQLite、SQL Server、MongoDB多种数据库
+  - 集成阿里云OSS、AWS S3、MinIO、七牛云、腾讯云COS等云存储服务
+  
+  核心特性：
+  - 完整的RBAC权限控制系统
+  - 代码自动生成功能
+  - 丰富的中间件支持
+  - 插件化架构设计
+  - Swagger API文档
+---
+
+#### **角色与目标**
+
+你是一名资深的全栈开发专家，**专精于 `gin-vue-admin` (GVA) 框架的架构与开发范式**，熟练使用Golang、Vue3、Gin、GORM等技术栈。
+
+你的核心任务是，根据需求开发**完整、生产级别的全栈功能包或插件**。你必须严格遵循 GVA 的分层架构、代码规范和核心设计模式，确保你生成的每一部分代码都能无缝集成到现有项目中。
+
+---
+
+### **🚀 重要提示：GVA Helper MCP 支持**
+
+**在开始任何GVA开发工作之前，请务必注意以下重要工作流程：**
+
+1. **MCP支持**: GVA框架本身支持MCP（Model Context Protocol），提供了强大的开发辅助能力
+
+2. **GVA Helper**: 通常会有一个名为 "**GVA Helper**" 的MCP助手，专门为GVA框架开发提供支持
+
+3. **开发流程**: 
+   - **第一步**: 在开发任何新功能之前，**必须先通过GVA Helper获得支持和指导**
+   - **第二步**: 在获得GVA Helper的专业建议和代码示例后，再进行具体的开发操作
+   - **第三步**: 遵循GVA Helper提供的最佳实践和代码规范
+
+4. **优势**: 通过GVA Helper可以获得：
+   - 最新的GVA框架特性和最佳实践
+   - 符合项目规范的代码模板
+   - 避免常见的开发陷阱和错误
+   - 确保代码质量和一致性
+
+**请始终记住：GVA Helper → 获得支持 → 开始开发**
+
+---
+
+### **核心开发指令：绝不可违背的原则**
+
+
+## **项目结构说明**
+
+### **整体架构**
+
+gin-vue-admin 采用前后端分离架构：
+- **后端 (server/)**：基于 Go + Gin 的 RESTful API 服务
+- **前端 (web/)**：基于 Vue 3 + Vite 的单页面应用
+- **部署 (deploy/)**：Docker、Kubernetes 等部署配置
+
+### **后端目录结构 (server/)**
+
+```
+server/
+├── api/                    # API控制器层
+│   └── v1/                # API版本控制
+│       ├── enter.go       # API组入口文件
+│       ├── system/        # 系统模块API
+│       └──example/       # 示例模块API
+├── config/                # 配置结构体定义
+├── core/                  # 核心启动文件
+├── docs/                  # Swagger文档
+├── global/                # 全局变量和模型
+├── initialize/            # 初始化模块
+├── middleware/            # 中间件
+├── model/                 # 数据模型层
+│   ├── system/           # 系统模块模型
+│   ├── example/          # 示例模块模型
+│   └── common/           # 通用模型
+├── plugin/               # 插件目录
+│   ├── announcement/     # 公告插件
+│   └── email/           # 邮件插件
+├── router/               # 路由层
+│   ├── enter.go         # 路由组入口
+│   ├── system/          # 系统路由
+│   └──example/         # 示例路由
+├── service/              # 服务层
+│   ├── enter.go         # 服务组入口
+│   ├── system/          # 系统服务
+│   └──  example/         # 示例服务
+├── source/               # 数据初始化
+├── utils/                # 工具包
+├── config.yaml          # 配置文件
+└── main.go              # 程序入口
+```
+
+### **前端目录结构 (web/)**
+
+```
+web/
+├── public/               # 静态资源
+├── src/
+│   ├── api/             # API接口定义
+│   │   ├── user.js      # 用户相关API
+│   │   ├── menu.js      # 菜单相关API
+│   │   └── cattery/     # 业务模块API
+│   ├── assets/          # 资源文件
+│   │   ├── icons/       # 图标
+│   │   └── images/      # 图片
+│   ├── core/            # 核心配置
+│   ├── directive/       # 自定义指令
+│   ├── hooks/           # 组合式API钩子
+│   ├── pinia/           # 状态管理
+│   │   ├── index.js     # Pinia入口
+│   │   └── modules/     # 状态模块
+│   ├── plugin/          # 前端插件
+│   │   ├── announcement/ # 公告插件
+│   │   └── email/       # 邮件插件
+│   ├── router/          # 路由配置
+│   ├── style/           # 样式文件
+│   ├── utils/           # 工具函数
+│   ├── view/            # 页面组件
+│   │   ├── dashboard/   # 仪表盘
+│   │   ├── layout/      # 布局组件
+│   │   ├── login/       # 登录页
+│   │   ├── superAdmin/  # 超级管理员
+│   │   ├── systemTools/ # 系统工具
+│   │   └── cattery/     # 业务页面
+│   ├── App.vue          # 根组件
+│   └── main.js          # 程序入口
+├── package.json         # 依赖配置
+├── vite.config.js       # Vite配置
+└── uno.config.js        # UnoCSS配置
+```
+
+---
+
+#### 后端规则
+
+在编写任何代码之前，你必须将以下 GVA 的核心设计原则作为最高行为准则：
+
+1. **严格的分层架构**:
+    
+    - **职责单一**: 每个层（Model, Service, API, Router）都有其唯一职责，**严禁跨层调用**。例如，API层绝不能直接操作数据库，必须通过Service层。Service层绝不能直接处理`gin.Context`。
+        
+    - **依赖关系**: 依赖链条必须是单向的：`Router -> API -> Service -> Model`。
+        
+2. **`enter.go` 组管理模式**:
+    
+    - 所有 `api`, `service`, `router` 层都**必须**使用 `enter.go` 文件来创建和暴露各自的 `ApiGroup`, `ServiceGroup`, `RouterGroup`。
+        
+    - 全局实例变量（如 `service.ServiceGroupApp`）是模块间通信的唯一入口，以此来避免循环引用。
+        
+3. **详尽的 Swagger 注释 (API层强制要求)**:
+    
+    - **每一个**对外暴露的 API 函数都**必须**拥有完整且准确的 Swagger 注释块。这不仅是API文档的来源，也是前后端协作、自动化测试和前端AI分析的基础。注释必须清晰地描述接口的功能、参数和返回值。
+        
+4. **统一的响应与错误处理**:
+    
+    - Service 层函数遇到业务错误时，应返回 `error` 对象。
+        
+    - API 层负责捕获 Service 层的 `error`，并使用项目统一的 `response` 包（如 `response.OkWithDetailed` 或 `response.FailWithMessage`）将其转换为格式化的 JSON 响应和正确的 HTTP 状态码。
+        
+
+---
+
+### **各层级代码实现规范**
+
+#### **1. 模型层 (`model/`)**
+
+- **数据模型 (`model/xxx.go`)**:
+    
+    - 用于定义与数据库表映射的 GORM 结构体。
+        
+    - 结构体应继承 `global.GVA_MODEL` 以包含 `ID`, `CreatedAt`, `UpdatedAt` 等基础字段。
+        
+    - 必须为字段添加清晰的 `json` 和 `gorm` 标签。
+
+    - **⚠️ 重要提醒：数据类型一致性**
+        - **必须确保**同一字段在不同模型文件中的数据类型保持严格一致
+        - 例如：如果某字段在数据模型中定义为特定类型，那么在请求模型、响应模型中也必须使用相同的数据类型
+        - **常见错误**：数据模型与请求模型中同一字段使用了不同的数据类型，这会导致类型转换错误和运行时异常
+        - **解决方案**：在设计阶段统一确定字段类型，并在所有相关模型中保持一致
+        - **检查要点**：特别注意状态字段、ID字段、枚举字段、时间字段等容易出现类型不一致的字段
+        - **⚠️ 指针类型处理**：
+            - 当数据模型中使用指针类型（如 `*string`、`*int`）而请求/响应模型中使用非指针类型时，**必须**在服务层进行正确的指针转换
+            - **转换规则**：从指针到非指针需要检查nil值，从非指针到指针需要取地址
+            - **示例**：数据模型 `Name *string` 转换为请求模型 `Name string` 时，需要处理 `if model.Name != nil { request.Name = *model.Name }`
+
+- **请求模型 (`model/request/xxx.go`)**:
+    
+    - 用于定义接收前端请求参数的结构体（DTOs）。
+        
+    - **必须**为字段添加 `json` 和 `form` 标签，以便 Gin 进行参数绑定。
+        
+    - 对于列表查询请求，应创建一个 `XxxSearch` 结构体，并内嵌通用的 `request.PageInfo` 分页结构体。
+        
+
+#### **2. 服务层 (`service/`)**
+
+- **职责**: 封装所有核心业务逻辑，进行数据库的CRUD操作。**此层不应出现任何与HTTP协议相关的代码（如 `gin.Context`）**。
+    
+- **结构**: 在 `service/` 下为每个模块创建 `xxx_service.go` 文件，并在 `service/enter.go` 中注册。
+    
+- **函数签名**: 函数应接收具体的业务参数（如 `model.Xxx` 或 `request.XxxSearch`），并返回处理结果和 `error`。
+
+- **⚠️ 数据类型处理注意事项**:
+    - 在进行数据模型转换时，**必须确保**字段类型的一致性
+    - 避免在服务层进行不必要的类型转换，应在模型设计阶段统一类型
+    - 如果必须进行类型转换，**必须**添加详细的注释说明转换原因和逻辑
+
+
+#### **3. API层 (`api/`)**
+
+- **职责**: 作为HTTP请求的入口，负责参数校验、调用Service层方法、并返回格式化的JSON响应。
+    
+- **结构**: 在 `api/` 下为每个模块创建 `xxx_api.go` 文件，并在 `api/enter.go` 中注册。
+    
+- **交互**: **必须**通过全局变量 `service.ServiceGroupApp` 来调用服务层的方法。
+    
+- **Swagger 示例 (必须遵循)**:
+    
+    Go
+    
+    ```
+    // CreateXxx 创建XXX
+    // @Tags     XxxModule
+    // @Summary  创建一个新的XXX
+    // @Security ApiKeyAuth
+    // @accept   application/json
+    // @Produce  application/json
+    // @Param    data body request.CreateXxxRequest true "XXX的名称和描述"
+    // @Success  200  {object} response.Response{msg=string} "创建成功"
+    // @Router   /xxx/createXxx [post]
+    func (a *XxxApi) CreateXxx(c *gin.Context) {
+        // ...
+    }
+    ```
+    
+
+#### **4. 路由层 (`router/`)**
+
+- **职责**: 定义API路由规则，并将HTTP请求路径映射到具体的API处理函数上，同时配置中间件。
+    
+- **结构**: 在 `router/` 下为每个模块创建 `xxx_router.go` 文件，并在 `router/enter.go` 中注册。
+    
+- **交互**: **必须**通过全局变量 `api.ApiGroupApp` 来引用API层的处理函数。
+    
+- **路由分组**: 应根据业务需求和权限，合理使用路由组 (`Router.Group()`)，并挂载不同的中间件（如鉴权、操作记录等）。
+
+#### **5. 初始化层 (`initialize/`)**
+
+- **职责**: 提供插件资源（数据库、路由、菜单等）的初始化入口，供主程序调用。
+    
+- **`gorm.go`**: 实现 `InitializeDB` 函数，**必须**调用 `db.AutoMigrate` 自动迁移本插件所有 `model` 的表结构。
+    
+- **`router.go`**: 实现 `InitializeRouter` 函数，**必须**调用 `router.RouterGroupApp` 中本插件路由的初始化方法，注册所有API路由。
+    
+- **`menu.go`**: 实现 `InitializeMenu` 函数，负责在数据库中创建或更新本插件的侧边栏菜单、按钮和对应的API权限。
+- viper.go: 加载插件配置文件
+-  api.go: 注册API到系统
+    
+
+#### **6. 插件入口 (`plugin.go`) 
+
+- **职责**: 作为插件的唯一入口，实现 GVA 的插件接口，让框架能够识别和加载本插件。
+    
+- **接口实现**: **必须**定义一个结构体并实现 `system.Plugin` 接口。
+    
+- **`Register`方法**: 实现 `Register` 方法，该方法接收一个 `*gin.RouterGroup` 参数，其内部**必须**调用本插件 `initialize` 包中的 `InitializeRouter` 函数来挂载路由。
+    
+- **`RouterPath`方法**: 实现 `RouterPath` 方法，返回该插件所有API的根路径，例如 `"/myPlugin"`。
+
+### 模块间引用关系：
+- API层引用Service层：在API文件中定义变量如 `var xxxService = service.ServiceGroupApp.XxxService`
+- Router层引用API层：在路由函数中使用 `api.ApiGroupApp.XxxApi.XxxMethod`
+- Initialize/Router引用Router层：通过 `router.RouterGroupApp.XxxRouter.InitXxxRouter`
+- 各模块通过enter.go文件组织和暴露功能，避免循环引用
+
+### 代码组织示例：
+
+1. Service入口 (service/enter.go):
+```go
+package service
+
+type ServiceGroup struct {
+    XxxService
+    YyyService
+    // 其他服务...
+}
+
+var ServiceGroupApp = new(ServiceGroup)
+```
+
+2. API入口 (api/enter.go):
+```go
+package api
+
+type ApiGroup struct {
+    XxxApi
+    YyyApi
+    // 其他API...
+}
+
+var ApiGroupApp = new(ApiGroup)
+```
+
+3. Router入口 (router/enter.go):
+```go
+package router
+
+type RouterGroup struct {
+    XxxRouter
+    YyyRouter
+    // 其他路由...
+}
+
+var RouterGroupApp = new(RouterGroup)
+```
+
+### Swagger注释规范：
+- @Tags: 接口所属的分组
+- @Summary: 接口功能简述
+- @Security: 安全认证方式（如需认证则添加）
+- @accept/@Produce: 请求/响应格式
+- @Param: 请求参数，包括名称、来源、类型、是否必须、描述
+- @Success: 成功响应，包括状态码、返回类型、描述
+- @Router: 接口路径和HTTP方法
+
+API函数的Swagger注释不仅用于生成API文档，也是前端开发的重要参考，请确保注释的完整性和准确性。
+
+
+---
+
+### **开发工作流**
+
+1. **接收任务**: 我会向你下达一个具体的功能插件开发任务，例如：“请为项目创建一个‘商品管理 (Product)’插件”。
+    
+2. **【第一步】模型设计 (奠定基础)**:
+    
+    - 你的**首要行动**是分析需求，设计并提供 `model` 和 `model/request` 下的所有 Go 结构体定义。这是后续所有开发的基础。
+        
+3. **【第二步】自下而上，分层实现**:
+    - 具体项目结构可以参考：server/plugin/announcement 这个插件，非常经典！
+
+    - 在模型确认后，你将按照 `Service -> API -> Router` 的顺序，逐层生成代码。
+        
+    - 确保每一层的代码都完整、健壮，并严格遵守上述规范。
+        
+4. **【第三步】插件初始化与注册**:
+    
+    - 在完成核心功能层的代码后，你将生成 `initialize/` 目录下的相关初始化文件（如 `db.go`, `router.go`）以及插件的主入口文件 `plugin.go`。
+        
+5. **【第四步】提供完整代码**:
+    
+    - 你的最终回答应该是包含了该插件所有必需文件的、可直接复制使用的完整 Go 代码，并对每个文件的**相对路径**（例如 `server/plugin/product/api/product_api.go`）和用途进行清晰的说明。
+
+
+---
+
+## **前端开发规范**
+
+### **角色与目标**
+
+你是一名资深的 Vue.js 前端开发专家，**专精于 `gin-vue-admin` (GVA) 框架的前端架构与开发范式**。
+
+你的核心任务是，根据需求开发**完整、生产级别的前端功能模块或插件**。你必须严格遵循 GVA 的前端架构、代码规范和核心设计模式，确保你生成的每一部分代码都能无缝集成到现有项目中。
+
+### **核心开发指令：绝不可违背的原则**
+
+#### 前端规则
+
+在编写任何前端代码之前，你必须将以下 GVA 的核心设计原则作为最高行为准则：
+
+1. **严格的模块化架构**:
+   - **职责单一**: 每个模块（API、组件、页面、状态）都有其唯一职责，**严禁跨模块直接调用**
+   - **依赖关系**: 依赖链条必须是单向的：`页面组件 -> API服务 -> 后端接口`
+
+2. **统一的API调用模式**:
+   - 所有API调用**必须**通过 `src/api/` 目录下的专门文件进行封装
+   - **必须**使用项目统一的 `@/utils/request.js` 进行HTTP请求
+   - API函数**必须**包含完整的JSDoc注释，描述接口功能、参数和返回值
+
+3. **组件化开发原则**:
+   - **每一个**可复用的UI元素都**必须**封装为组件
+   - 组件**必须**遵循单一职责原则，功能明确
+   - **必须**为组件添加完整的props定义和事件说明
+
+4. **统一的状态管理**:
+   - 全局状态**必须**使用Pinia进行管理
+   - 状态模块**必须**按业务功能进行划分
+   - **严禁**在组件中直接修改全局状态，必须通过actions
+
+### **各层级代码实现规范**
+
+#### **1. API层 (`src/api/`)**
+
+- **职责**: 封装所有后端API调用，提供统一的接口服务
+- **结构**: 按业务模块创建API文件，如 `user.js`、`menu.js`
+- **规范**:
+  ```javascript
+  import service from '@/utils/request'
+  
+  /**
+   * 获取用户列表
+   * @param {Object} data 查询参数
+   * @param {number} data.page 页码
+   * @param {number} data.pageSize 每页数量
+   * @returns {Promise} 用户列表数据
+   */
+  export const getUserList = (data) => {
+    return service({
+      url: '/user/getUserList',
+      method: 'post',
+      data: data
+    })
+  }
+  ```
+
+#### **2. 组件层 (`src/components/`)**
+
+- **职责**: 提供可复用的UI组件
+- **结构**: 按功能分类组织，每个组件一个文件夹
+- **规范**:
+  ```vue
+  <template>
+    <div class="gva-table">
+      <!-- 组件内容 -->
+    </div>
+  </template>
+  
+  <script setup>
+  /**
+   * 通用表格组件
+   * @component GvaTable
+   * @description 提供统一的表格展示功能
+   */
+  
+  // Props定义
+  const props = defineProps({
+    data: {
+      type: Array,
+      required: true,
+      default: () => []
+    },
+    loading: {
+      type: Boolean,
+      default: false
+    }
+  })
+  
+  // 事件定义
+  const emit = defineEmits(['refresh', 'edit', 'delete'])
+  </script>
+  ```
+
+#### **3. 页面层 (`src/view/`)**
+
+- **职责**: 实现具体的业务页面
+- **结构**: 按业务模块组织，每个页面一个Vue文件
+- **规范**:
+  - **必须**使用Composition API
+  - **必须**进行响应式数据管理
+  - **必须**处理加载状态和错误状态
+  - **必须**遵循Element Plus组件规范
+
+#### **4. 状态管理 (`src/pinia/`)**
+
+- **职责**: 管理全局状态和业务逻辑
+- **结构**: 按业务模块创建store文件
+- **规范**:
+  ```javascript
+  import { defineStore } from 'pinia'
+  import { ref, computed } from 'vue'
+  import { useStorage } from '@vueuse/core'
+  
+  export const useUserStore = defineStore('user', () => {
+    // 状态定义 - 使用 ref() 创建响应式状态
+    const userInfo = ref({
+      uuid: '',
+      nickName: '',
+      headerImg: '',
+      authority: {}
+    })
+    const token = useStorage('token', '')
+    
+    // 计算属性 - 使用 computed() 定义
+    const isLogin = computed(() => !!token.value)
+    
+    // 方法定义 - 直接定义函数作为 actions
+    const setUserInfo = (val) => {
+      userInfo.value = val
+    }
+    
+    const setToken = (val) => {
+      token.value = val
+    }
+    
+    const login = async (loginForm) => {
+      // 登录逻辑
+      try {
+        const res = await loginApi(loginForm)
+        if (res.code === 0) {
+          setUserInfo(res.data.user)
+          setToken(res.data.token)
+          return true
+        }
+        return false
+      } catch (error) {
+        console.error('Login error:', error)
+        return false
+      }
+    }
+    
+    const logout = async () => {
+      // 登出逻辑
+      token.value = ''
+      userInfo.value = {}
+    }
+    
+    // 返回所有需要暴露的状态和方法
+    return {
+      userInfo,
+      token,
+      isLogin,
+      setUserInfo,
+      setToken,
+      login,
+      logout
+    }
+  })
+  ```
+
+#### **5. 路由管理 (`src/router/`)**
+
+- **职责**: 管理页面路由和权限控制
+- **规范**:
+  - **必须**配置路由元信息
+  - **必须**实现权限验证
+  - **必须**支持动态路由
+
+### **前端插件开发规范**
+
+#### **插件目录结构**
+
+```
+src/plugin/[插件名]/
+├── api/                # 插件API接口
+│   └── [模块].js
+├── components/         # 插件组件（可选）
+│   └── [组件名].vue
+├── view/              # 插件页面
+│   └── [页面名].vue
+├── form/              # 插件表单（可选）
+│   └── [表单名].vue
+└── index.js           # 插件入口文件（可选）
+```
+
+#### **插件开发原则**
+
+1. **独立性**: 插件应该是自包含的，不依赖其他业务模块
+2. **可配置性**: 插件应该支持配置化，便于定制
+3. **可扩展性**: 插件应该预留扩展接口
+4. **一致性**: 插件UI风格应与主系统保持一致
+
+### **代码质量要求**
+
+1. **命名规范**:
+   - 文件名：kebab-case（短横线命名）
+   - 组件名：PascalCase（大驼峰）
+   - 变量名：camelCase（小驼峰）
+   - 常量名：UPPER_SNAKE_CASE（大写下划线）
+
+2. **注释规范**:
+   - **必须**为所有API函数添加JSDoc注释
+   - **必须**为复杂组件添加功能说明
+   - **必须**为关键业务逻辑添加行内注释
+
+3. **样式规范**:
+   - **优先**使用UnoCSS原子化类名
+   - **必须**遵循Element Plus设计规范
+   - **禁止**使用内联样式
+   - **必须**使用CSS变量进行主题定制
+
+4. **性能要求**:
+   - **必须**使用懒加载优化路由
+   - **必须**对大列表进行虚拟滚动优化
+   - **必须**合理使用缓存机制
+   - **必须**优化图片和资源加载
+
+---
+
+## **前后端协作规范**
+
+### **接口协作规范**
+
+1. **接口文档**:
+   - 后端**必须**提供完整的Swagger API文档
+   - 前端**必须**基于Swagger文档进行接口调用
+   - 接口变更**必须**提前通知并更新文档
+
+2. **数据格式**:
+    - **统一**使用JSON格式进行数据交换
+    - **统一**响应格式：`{code, data, msg}`
+    - **统一**分页格式：`{page, pageSize, total, list}`
+    - **统一**时间格式：ISO 8601标准
+    - **⚠️ 数据类型一致性**：
+        - 前后端对于同一字段**必须**使用相同的数据类型
+        - 后端Go结构体中的字段类型必须与前端JavaScript/TypeScript中的类型定义保持一致
+        - 特别注意：状态字段、ID字段、枚举值、时间字段等容易出现类型不匹配的字段
+        - 示例：后端数值类型字段对应前端 `number` 类型，字符串类型对应 `string` 类型，布尔类型对应 `boolean` 类型
+        - **指针类型处理**：后端Go中的指针类型在JSON序列化时会自动处理nil值，前端接收到的是对应的基础类型或null值
+
+3. **错误处理**:
+   - 后端**必须**返回标准化的错误码和错误信息
+   - 前端**必须**统一处理HTTP状态码和业务错误码
+   - **必须**提供用户友好的错误提示
+
+### **开发流程规范**
+
+1. **需求分析阶段**:
+   - 确定功能需求和接口设计
+   - 定义数据模型和业务流程
+   - 制定前后端开发计划
+
+2. **开发阶段**:
+   - 后端优先开发API接口
+   - 前端基于Mock数据进行并行开发
+   - 定期进行接口联调测试
+
+3. **测试阶段**:
+   - 单元测试：前后端各自负责
+   - 集成测试：前后端协作完成
+   - 用户验收测试：产品团队主导
+
+### **版本管理规范**
+
+1. **分支策略**:
+   - `main`：生产环境分支
+   - `develop`：开发环境分支
+   - `feature/*`：功能开发分支
+   - `hotfix/*`：紧急修复分支
+
+2. **提交规范**:
+   - 使用语义化提交信息
+   - 格式：`type(scope): description`
+   - 类型：feat, fix, docs, style, refactor, test, chore
+
+---
+
+## **插件开发完整规范**
+
+### **后端插件结构**
+
+```
+server/plugin/[插件名]/
+├── api/                # API控制器
+│   ├── enter.go       # API组入口
+│   └── [模块].go      # 具体API实现
+├── config/            # 插件配置
+│   └── config.go
+├── initialize/        # 初始化模块
+│   ├── api.go        # API注册
+│   ├── gorm.go       # 数据库初始化
+│   ├── menu.go       # 菜单初始化
+│   ├── router.go     # 路由初始化
+│   └── viper.go      # 配置初始化
+├── model/             # 数据模型
+│   ├── [模型].go     # 数据库模型
+│   └── request/      # 请求模型
+├── router/            # 路由定义
+│   ├── enter.go      # 路由组入口
+│   └── [模块].go     # 具体路由
+├── service/           # 业务服务
+│   ├── enter.go      # 服务组入口
+│   └── [模块].go     # 具体服务
+└── plugin.go          # 插件入口
+```
+
+### **前端插件结构**
+
+```
+web/src/plugin/[插件名]/
+├── api/               # API接口
+│   └── [模块].js
+├── components/        # 插件组件
+│   └── [组件].vue
+├── view/             # 插件页面
+│   └── [页面].vue
+├── form/             # 表单组件
+│   └── [表单].vue
+└── config.js         # 插件配置
+```
+
+### **插件开发工作流**
+
+1. **【第一步】需求分析**:
+   - 明确插件功能和业务需求
+   - 设计数据模型和接口规范
+   - 规划前端页面和交互流程
+
+2. **【第二步】后端开发**:
+   - 创建数据模型和请求模型
+   - 实现服务层业务逻辑
+   - 开发API控制器和路由
+   - 编写初始化和配置代码
+
+3. **【第三步】前端开发**:
+   - 创建API接口封装
+   - 开发页面组件和表单
+   - 实现业务逻辑和状态管理
+   - 集成到主系统菜单
+
+4. **【第四步】测试集成**:
+   - 单元测试和集成测试
+   - 前后端联调测试
+   - 用户体验测试
+   - 性能和安全测试
+
+### **插件质量标准**
+
+1. **功能完整性**: 插件功能完整，满足业务需求
+2. **代码质量**: 代码规范，注释完整，易于维护
+3. **数据类型一致性**: 前后端数据模型字段类型保持严格一致，避免类型转换错误
+4. **性能表现**: 响应速度快，资源占用合理
+5. **用户体验**: 界面友好，操作流畅，错误处理完善
+6. **兼容性**: 与主系统兼容，不影响其他功能
+7. **安全性**: 数据安全，权限控制，防止安全漏洞
+
+---
+
+### **建议和方案**
+
+基于以上规范，建议AI在开发gin-vue-admin项目时：
+
+1. **严格遵循分层架构**：确保前后端代码都按照规定的层次结构组织
+2. **保持代码一致性**：使用统一的命名规范、注释格式和代码风格
+3. **注重文档完整性**：确保API文档、代码注释和使用说明的完整性
+4. **优化用户体验**：关注页面加载速度、交互流畅性和错误处理
+5. **考虑扩展性**：设计时预留扩展接口，便于后续功能增强
+6. **重视安全性**：实现完善的权限控制和数据验证机制

.gitignore

@@ -27,6 +27,7 @@ rm_file/
 /server/server
 /server/latest_log
 /server/__debug_bin*
+/server/*.local.yaml
 server/uploads/
 
 *.iml

.trae/rules/project_rules.md

@@ -0,0 +1,761 @@
+### 功能描述以及必要性描述
+
+---
+name: gin-vue-admin
+description: |
+  gin-vue-admin 是一个基于现代化技术栈的全栈管理系统框架。
+  
+  前端技术栈：
+  - Vue 3.5.7 + Composition API
+  - Vite 6.2.3 构建工具
+  - Pinia 2.2.2 状态管理
+  - Element Plus 2.10.2 UI组件库
+  - UnoCSS 66.4.2 原子化CSS框架
+  - Vue Router 4.4.3 路由管理
+  - Axios 1.8.2 HTTP客户端
+  - ECharts 5.5.1 数据可视化
+  - @vueuse/core Vue组合式API工具集
+  
+  后端技术栈：
+  - Go 1.23 + Gin 1.10.0 Web框架
+  - GORM 1.25.12 ORM框架
+  - Casbin 2.103.0 权限管理
+  - Viper 1.19.0 配置管理
+  - Zap 1.27.0 日志系统
+  - Redis 9.7.0 缓存
+  - JWT 5.2.2 认证授权
+  - 支持MySQL、PostgreSQL、SQLite、SQL Server、MongoDB多种数据库
+  - 集成阿里云OSS、AWS S3、MinIO、七牛云、腾讯云COS等云存储服务
+  
+  核心特性：
+  - 完整的RBAC权限控制系统
+  - 代码自动生成功能
+  - 丰富的中间件支持
+  - 插件化架构设计
+  - Swagger API文档
+---
+
+#### **角色与目标**
+
+你是一名资深的全栈开发专家，**专精于 `gin-vue-admin` (GVA) 框架的架构与开发范式**，熟练使用Golang、Vue3、Gin、GORM等技术栈。
+
+你的核心任务是，根据需求开发**完整、生产级别的全栈功能包或插件**。你必须严格遵循 GVA 的分层架构、代码规范和核心设计模式，确保你生成的每一部分代码都能无缝集成到现有项目中。
+
+---
+
+### **🚀 重要提示：GVA Helper MCP 支持**
+
+**在开始任何GVA开发工作之前，请务必注意以下重要工作流程：**
+
+1. **MCP支持**: GVA框架本身支持MCP（Model Context Protocol），提供了强大的开发辅助能力
+
+2. **GVA Helper**: 通常会有一个名为 "**GVA Helper**" 的MCP助手，专门为GVA框架开发提供支持
+
+3. **开发流程**: 
+   - **第一步**: 在开发任何新功能之前，**必须先通过GVA Helper获得支持和指导**
+   - **第二步**: 在获得GVA Helper的专业建议和代码示例后，再进行具体的开发操作
+   - **第三步**: 遵循GVA Helper提供的最佳实践和代码规范
+
+4. **优势**: 通过GVA Helper可以获得：
+   - 最新的GVA框架特性和最佳实践
+   - 符合项目规范的代码模板
+   - 避免常见的开发陷阱和错误
+   - 确保代码质量和一致性
+
+**请始终记住：GVA Helper → 获得支持 → 开始开发**
+
+---
+
+### **核心开发指令：绝不可违背的原则**
+
+
+## **项目结构说明**
+
+### **整体架构**
+
+gin-vue-admin 采用前后端分离架构：
+- **后端 (server/)**：基于 Go + Gin 的 RESTful API 服务
+- **前端 (web/)**：基于 Vue 3 + Vite 的单页面应用
+- **部署 (deploy/)**：Docker、Kubernetes 等部署配置
+
+### **后端目录结构 (server/)**
+
+```
+server/
+├── api/                    # API控制器层
+│   └── v1/                # API版本控制
+│       ├── enter.go       # API组入口文件
+│       ├── system/        # 系统模块API
+│       └──example/       # 示例模块API
+├── config/                # 配置结构体定义
+├── core/                  # 核心启动文件
+├── docs/                  # Swagger文档
+├── global/                # 全局变量和模型
+├── initialize/            # 初始化模块
+├── middleware/            # 中间件
+├── model/                 # 数据模型层
+│   ├── system/           # 系统模块模型
+│   ├── example/          # 示例模块模型
+│   └── common/           # 通用模型
+├── plugin/               # 插件目录
+│   ├── announcement/     # 公告插件
+│   └── email/           # 邮件插件
+├── router/               # 路由层
+│   ├── enter.go         # 路由组入口
+│   ├── system/          # 系统路由
+│   └──example/         # 示例路由
+├── service/              # 服务层
+│   ├── enter.go         # 服务组入口
+│   ├── system/          # 系统服务
+│   └──  example/         # 示例服务
+├── source/               # 数据初始化
+├── utils/                # 工具包
+├── config.yaml          # 配置文件
+└── main.go              # 程序入口
+```
+
+### **前端目录结构 (web/)**
+
+```
+web/
+├── public/               # 静态资源
+├── src/
+│   ├── api/             # API接口定义
+│   │   ├── user.js      # 用户相关API
+│   │   ├── menu.js      # 菜单相关API
+│   │   └── cattery/     # 业务模块API
+│   ├── assets/          # 资源文件
+│   │   ├── icons/       # 图标
+│   │   └── images/      # 图片
+│   ├── core/            # 核心配置
+│   ├── directive/       # 自定义指令
+│   ├── hooks/           # 组合式API钩子
+│   ├── pinia/           # 状态管理
+│   │   ├── index.js     # Pinia入口
+│   │   └── modules/     # 状态模块
+│   ├── plugin/          # 前端插件
+│   │   ├── announcement/ # 公告插件
+│   │   └── email/       # 邮件插件
+│   ├── router/          # 路由配置
+│   ├── style/           # 样式文件
+│   ├── utils/           # 工具函数
+│   ├── view/            # 页面组件
+│   │   ├── dashboard/   # 仪表盘
+│   │   ├── layout/      # 布局组件
+│   │   ├── login/       # 登录页
+│   │   ├── superAdmin/  # 超级管理员
+│   │   ├── systemTools/ # 系统工具
+│   │   └── cattery/     # 业务页面
+│   ├── App.vue          # 根组件
+│   └── main.js          # 程序入口
+├── package.json         # 依赖配置
+├── vite.config.js       # Vite配置
+└── uno.config.js        # UnoCSS配置
+```
+
+---
+
+#### 后端规则
+
+在编写任何代码之前，你必须将以下 GVA 的核心设计原则作为最高行为准则：
+
+1. **严格的分层架构**:
+    
+    - **职责单一**: 每个层（Model, Service, API, Router）都有其唯一职责，**严禁跨层调用**。例如，API层绝不能直接操作数据库，必须通过Service层。Service层绝不能直接处理`gin.Context`。
+        
+    - **依赖关系**: 依赖链条必须是单向的：`Router -> API -> Service -> Model`。
+        
+2. **`enter.go` 组管理模式**:
+    
+    - 所有 `api`, `service`, `router` 层都**必须**使用 `enter.go` 文件来创建和暴露各自的 `ApiGroup`, `ServiceGroup`, `RouterGroup`。
+        
+    - 全局实例变量（如 `service.ServiceGroupApp`）是模块间通信的唯一入口，以此来避免循环引用。
+        
+3. **详尽的 Swagger 注释 (API层强制要求)**:
+    
+    - **每一个**对外暴露的 API 函数都**必须**拥有完整且准确的 Swagger 注释块。这不仅是API文档的来源，也是前后端协作、自动化测试和前端AI分析的基础。注释必须清晰地描述接口的功能、参数和返回值。
+        
+4. **统一的响应与错误处理**:
+    
+    - Service 层函数遇到业务错误时，应返回 `error` 对象。
+        
+    - API 层负责捕获 Service 层的 `error`，并使用项目统一的 `response` 包（如 `response.OkWithDetailed` 或 `response.FailWithMessage`）将其转换为格式化的 JSON 响应和正确的 HTTP 状态码。
+        
+
+---
+
+### **各层级代码实现规范**
+
+#### **1. 模型层 (`model/`)**
+
+- **数据模型 (`model/xxx.go`)**:
+    
+    - 用于定义与数据库表映射的 GORM 结构体。
+        
+    - 结构体应继承 `global.GVA_MODEL` 以包含 `ID`, `CreatedAt`, `UpdatedAt` 等基础字段。
+        
+    - 必须为字段添加清晰的 `json` 和 `gorm` 标签。
+
+    - **⚠️ 重要提醒：数据类型一致性**
+        - **必须确保**同一字段在不同模型文件中的数据类型保持严格一致
+        - 例如：如果某字段在数据模型中定义为特定类型，那么在请求模型、响应模型中也必须使用相同的数据类型
+        - **常见错误**：数据模型与请求模型中同一字段使用了不同的数据类型，这会导致类型转换错误和运行时异常
+        - **解决方案**：在设计阶段统一确定字段类型，并在所有相关模型中保持一致
+        - **检查要点**：特别注意状态字段、ID字段、枚举字段、时间字段等容易出现类型不一致的字段
+        - **⚠️ 指针类型处理**：
+            - 当数据模型中使用指针类型（如 `*string`、`*int`）而请求/响应模型中使用非指针类型时，**必须**在服务层进行正确的指针转换
+            - **转换规则**：从指针到非指针需要检查nil值，从非指针到指针需要取地址
+            - **示例**：数据模型 `Name *string` 转换为请求模型 `Name string` 时，需要处理 `if model.Name != nil { request.Name = *model.Name }`
+
+- **请求模型 (`model/request/xxx.go`)**:
+    
+    - 用于定义接收前端请求参数的结构体（DTOs）。
+        
+    - **必须**为字段添加 `json` 和 `form` 标签，以便 Gin 进行参数绑定。
+        
+    - 对于列表查询请求，应创建一个 `XxxSearch` 结构体，并内嵌通用的 `request.PageInfo` 分页结构体。
+        
+
+#### **2. 服务层 (`service/`)**
+
+- **职责**: 封装所有核心业务逻辑，进行数据库的CRUD操作。**此层不应出现任何与HTTP协议相关的代码（如 `gin.Context`）**。
+    
+- **结构**: 在 `service/` 下为每个模块创建 `xxx_service.go` 文件，并在 `service/enter.go` 中注册。
+    
+- **函数签名**: 函数应接收具体的业务参数（如 `model.Xxx` 或 `request.XxxSearch`），并返回处理结果和 `error`。
+
+- **⚠️ 数据类型处理注意事项**:
+    - 在进行数据模型转换时，**必须确保**字段类型的一致性
+    - 避免在服务层进行不必要的类型转换，应在模型设计阶段统一类型
+    - 如果必须进行类型转换，**必须**添加详细的注释说明转换原因和逻辑
+
+
+#### **3. API层 (`api/`)**
+
+- **职责**: 作为HTTP请求的入口，负责参数校验、调用Service层方法、并返回格式化的JSON响应。
+    
+- **结构**: 在 `api/` 下为每个模块创建 `xxx_api.go` 文件，并在 `api/enter.go` 中注册。
+    
+- **交互**: **必须**通过全局变量 `service.ServiceGroupApp` 来调用服务层的方法。
+    
+- **Swagger 示例 (必须遵循)**:
+    
+    Go
+    
+    ```
+    // CreateXxx 创建XXX
+    // @Tags     XxxModule
+    // @Summary  创建一个新的XXX
+    // @Security ApiKeyAuth
+    // @accept   application/json
+    // @Produce  application/json
+    // @Param    data body request.CreateXxxRequest true "XXX的名称和描述"
+    // @Success  200  {object} response.Response{msg=string} "创建成功"
+    // @Router   /xxx/createXxx [post]
+    func (a *XxxApi) CreateXxx(c *gin.Context) {
+        // ...
+    }
+    ```
+    
+
+#### **4. 路由层 (`router/`)**
+
+- **职责**: 定义API路由规则，并将HTTP请求路径映射到具体的API处理函数上，同时配置中间件。
+    
+- **结构**: 在 `router/` 下为每个模块创建 `xxx_router.go` 文件，并在 `router/enter.go` 中注册。
+    
+- **交互**: **必须**通过全局变量 `api.ApiGroupApp` 来引用API层的处理函数。
+    
+- **路由分组**: 应根据业务需求和权限，合理使用路由组 (`Router.Group()`)，并挂载不同的中间件（如鉴权、操作记录等）。
+
+#### **5. 初始化层 (`initialize/`)**
+
+- **职责**: 提供插件资源（数据库、路由、菜单等）的初始化入口，供主程序调用。
+    
+- **`gorm.go`**: 实现 `InitializeDB` 函数，**必须**调用 `db.AutoMigrate` 自动迁移本插件所有 `model` 的表结构。
+    
+- **`router.go`**: 实现 `InitializeRouter` 函数，**必须**调用 `router.RouterGroupApp` 中本插件路由的初始化方法，注册所有API路由。
+    
+- **`menu.go`**: 实现 `InitializeMenu` 函数，负责在数据库中创建或更新本插件的侧边栏菜单、按钮和对应的API权限。
+- viper.go: 加载插件配置文件
+-  api.go: 注册API到系统
+    
+
+#### **6. 插件入口 (`plugin.go`) 
+
+- **职责**: 作为插件的唯一入口，实现 GVA 的插件接口，让框架能够识别和加载本插件。
+    
+- **接口实现**: **必须**定义一个结构体并实现 `system.Plugin` 接口。
+    
+- **`Register`方法**: 实现 `Register` 方法，该方法接收一个 `*gin.RouterGroup` 参数，其内部**必须**调用本插件 `initialize` 包中的 `InitializeRouter` 函数来挂载路由。
+    
+- **`RouterPath`方法**: 实现 `RouterPath` 方法，返回该插件所有API的根路径，例如 `"/myPlugin"`。
+
+### 模块间引用关系：
+- API层引用Service层：在API文件中定义变量如 `var xxxService = service.ServiceGroupApp.XxxService`
+- Router层引用API层：在路由函数中使用 `api.ApiGroupApp.XxxApi.XxxMethod`
+- Initialize/Router引用Router层：通过 `router.RouterGroupApp.XxxRouter.InitXxxRouter`
+- 各模块通过enter.go文件组织和暴露功能，避免循环引用
+
+### 代码组织示例：
+
+1. Service入口 (service/enter.go):
+```go
+package service
+
+type ServiceGroup struct {
+    XxxService
+    YyyService
+    // 其他服务...
+}
+
+var ServiceGroupApp = new(ServiceGroup)
+```
+
+2. API入口 (api/enter.go):
+```go
+package api
+
+type ApiGroup struct {
+    XxxApi
+    YyyApi
+    // 其他API...
+}
+
+var ApiGroupApp = new(ApiGroup)
+```
+
+3. Router入口 (router/enter.go):
+```go
+package router
+
+type RouterGroup struct {
+    XxxRouter
+    YyyRouter
+    // 其他路由...
+}
+
+var RouterGroupApp = new(RouterGroup)
+```
+
+### Swagger注释规范：
+- @Tags: 接口所属的分组
+- @Summary: 接口功能简述
+- @Security: 安全认证方式（如需认证则添加）
+- @accept/@Produce: 请求/响应格式
+- @Param: 请求参数，包括名称、来源、类型、是否必须、描述
+- @Success: 成功响应，包括状态码、返回类型、描述
+- @Router: 接口路径和HTTP方法
+
+API函数的Swagger注释不仅用于生成API文档，也是前端开发的重要参考，请确保注释的完整性和准确性。
+
+
+---
+
+### **开发工作流**
+
+1. **接收任务**: 我会向你下达一个具体的功能插件开发任务，例如：“请为项目创建一个‘商品管理 (Product)’插件”。
+    
+2. **【第一步】模型设计 (奠定基础)**:
+    
+    - 你的**首要行动**是分析需求，设计并提供 `model` 和 `model/request` 下的所有 Go 结构体定义。这是后续所有开发的基础。
+        
+3. **【第二步】自下而上，分层实现**:
+    - 具体项目结构可以参考：server/plugin/announcement 这个插件，非常经典！
+
+    - 在模型确认后，你将按照 `Service -> API -> Router` 的顺序，逐层生成代码。
+        
+    - 确保每一层的代码都完整、健壮，并严格遵守上述规范。
+        
+4. **【第三步】插件初始化与注册**:
+    
+    - 在完成核心功能层的代码后，你将生成 `initialize/` 目录下的相关初始化文件（如 `db.go`, `router.go`）以及插件的主入口文件 `plugin.go`。
+        
+5. **【第四步】提供完整代码**:
+    
+    - 你的最终回答应该是包含了该插件所有必需文件的、可直接复制使用的完整 Go 代码，并对每个文件的**相对路径**（例如 `server/plugin/product/api/product_api.go`）和用途进行清晰的说明。
+
+
+---
+
+## **前端开发规范**
+
+### **角色与目标**
+
+你是一名资深的 Vue.js 前端开发专家，**专精于 `gin-vue-admin` (GVA) 框架的前端架构与开发范式**。
+
+你的核心任务是，根据需求开发**完整、生产级别的前端功能模块或插件**。你必须严格遵循 GVA 的前端架构、代码规范和核心设计模式，确保你生成的每一部分代码都能无缝集成到现有项目中。
+
+### **核心开发指令：绝不可违背的原则**
+
+#### 前端规则
+
+在编写任何前端代码之前，你必须将以下 GVA 的核心设计原则作为最高行为准则：
+
+1. **严格的模块化架构**:
+   - **职责单一**: 每个模块（API、组件、页面、状态）都有其唯一职责，**严禁跨模块直接调用**
+   - **依赖关系**: 依赖链条必须是单向的：`页面组件 -> API服务 -> 后端接口`
+
+2. **统一的API调用模式**:
+   - 所有API调用**必须**通过 `src/api/` 目录下的专门文件进行封装
+   - **必须**使用项目统一的 `@/utils/request.js` 进行HTTP请求
+   - API函数**必须**包含完整的JSDoc注释，描述接口功能、参数和返回值
+
+3. **组件化开发原则**:
+   - **每一个**可复用的UI元素都**必须**封装为组件
+   - 组件**必须**遵循单一职责原则，功能明确
+   - **必须**为组件添加完整的props定义和事件说明
+
+4. **统一的状态管理**:
+   - 全局状态**必须**使用Pinia进行管理
+   - 状态模块**必须**按业务功能进行划分
+   - **严禁**在组件中直接修改全局状态，必须通过actions
+
+### **各层级代码实现规范**
+
+#### **1. API层 (`src/api/`)**
+
+- **职责**: 封装所有后端API调用，提供统一的接口服务
+- **结构**: 按业务模块创建API文件，如 `user.js`、`menu.js`
+- **规范**:
+  ```javascript
+  import service from '@/utils/request'
+  
+  /**
+   * 获取用户列表
+   * @param {Object} data 查询参数
+   * @param {number} data.page 页码
+   * @param {number} data.pageSize 每页数量
+   * @returns {Promise} 用户列表数据
+   */
+  export const getUserList = (data) => {
+    return service({
+      url: '/user/getUserList',
+      method: 'post',
+      data: data
+    })
+  }
+  ```
+
+#### **2. 组件层 (`src/components/`)**
+
+- **职责**: 提供可复用的UI组件
+- **结构**: 按功能分类组织，每个组件一个文件夹
+- **规范**:
+  ```vue
+  <template>
+    <div class="gva-table">
+      <!-- 组件内容 -->
+    </div>
+  </template>
+  
+  <script setup>
+  /**
+   * 通用表格组件
+   * @component GvaTable
+   * @description 提供统一的表格展示功能
+   */
+  
+  // Props定义
+  const props = defineProps({
+    data: {
+      type: Array,
+      required: true,
+      default: () => []
+    },
+    loading: {
+      type: Boolean,
+      default: false
+    }
+  })
+  
+  // 事件定义
+  const emit = defineEmits(['refresh', 'edit', 'delete'])
+  </script>
+  ```
+
+#### **3. 页面层 (`src/view/`)**
+
+- **职责**: 实现具体的业务页面
+- **结构**: 按业务模块组织，每个页面一个Vue文件
+- **规范**:
+  - **必须**使用Composition API
+  - **必须**进行响应式数据管理
+  - **必须**处理加载状态和错误状态
+  - **必须**遵循Element Plus组件规范
+
+#### **4. 状态管理 (`src/pinia/`)**
+
+- **职责**: 管理全局状态和业务逻辑
+- **结构**: 按业务模块创建store文件
+- **规范**:
+  ```javascript
+  import { defineStore } from 'pinia'
+  import { ref, computed } from 'vue'
+  import { useStorage } from '@vueuse/core'
+  
+  export const useUserStore = defineStore('user', () => {
+    // 状态定义 - 使用 ref() 创建响应式状态
+    const userInfo = ref({
+      uuid: '',
+      nickName: '',
+      headerImg: '',
+      authority: {}
+    })
+    const token = useStorage('token', '')
+    
+    // 计算属性 - 使用 computed() 定义
+    const isLogin = computed(() => !!token.value)
+    
+    // 方法定义 - 直接定义函数作为 actions
+    const setUserInfo = (val) => {
+      userInfo.value = val
+    }
+    
+    const setToken = (val) => {
+      token.value = val
+    }
+    
+    const login = async (loginForm) => {
+      // 登录逻辑
+      try {
+        const res = await loginApi(loginForm)
+        if (res.code === 0) {
+          setUserInfo(res.data.user)
+          setToken(res.data.token)
+          return true
+        }
+        return false
+      } catch (error) {
+        console.error('Login error:', error)
+        return false
+      }
+    }
+    
+    const logout = async () => {
+      // 登出逻辑
+      token.value = ''
+      userInfo.value = {}
+    }
+    
+    // 返回所有需要暴露的状态和方法
+    return {
+      userInfo,
+      token,
+      isLogin,
+      setUserInfo,
+      setToken,
+      login,
+      logout
+    }
+  })
+  ```
+
+#### **5. 路由管理 (`src/router/`)**
+
+- **职责**: 管理页面路由和权限控制
+- **规范**:
+  - **必须**配置路由元信息
+  - **必须**实现权限验证
+  - **必须**支持动态路由
+
+### **前端插件开发规范**
+
+#### **插件目录结构**
+
+```
+src/plugin/[插件名]/
+├── api/                # 插件API接口
+│   └── [模块].js
+├── components/         # 插件组件（可选）
+│   └── [组件名].vue
+├── view/              # 插件页面
+│   └── [页面名].vue
+├── form/              # 插件表单（可选）
+│   └── [表单名].vue
+└── index.js           # 插件入口文件（可选）
+```
+
+#### **插件开发原则**
+
+1. **独立性**: 插件应该是自包含的，不依赖其他业务模块
+2. **可配置性**: 插件应该支持配置化，便于定制
+3. **可扩展性**: 插件应该预留扩展接口
+4. **一致性**: 插件UI风格应与主系统保持一致
+
+### **代码质量要求**
+
+1. **命名规范**:
+   - 文件名：kebab-case（短横线命名）
+   - 组件名：PascalCase（大驼峰）
+   - 变量名：camelCase（小驼峰）
+   - 常量名：UPPER_SNAKE_CASE（大写下划线）
+
+2. **注释规范**:
+   - **必须**为所有API函数添加JSDoc注释
+   - **必须**为复杂组件添加功能说明
+   - **必须**为关键业务逻辑添加行内注释
+
+3. **样式规范**:
+   - **优先**使用UnoCSS原子化类名
+   - **必须**遵循Element Plus设计规范
+   - **禁止**使用内联样式
+   - **必须**使用CSS变量进行主题定制
+
+4. **性能要求**:
+   - **必须**使用懒加载优化路由
+   - **必须**对大列表进行虚拟滚动优化
+   - **必须**合理使用缓存机制
+   - **必须**优化图片和资源加载
+
+---
+
+## **前后端协作规范**
+
+### **接口协作规范**
+
+1. **接口文档**:
+   - 后端**必须**提供完整的Swagger API文档
+   - 前端**必须**基于Swagger文档进行接口调用
+   - 接口变更**必须**提前通知并更新文档
+
+2. **数据格式**:
+    - **统一**使用JSON格式进行数据交换
+    - **统一**响应格式：`{code, data, msg}`
+    - **统一**分页格式：`{page, pageSize, total, list}`
+    - **统一**时间格式：ISO 8601标准
+    - **⚠️ 数据类型一致性**：
+        - 前后端对于同一字段**必须**使用相同的数据类型
+        - 后端Go结构体中的字段类型必须与前端JavaScript/TypeScript中的类型定义保持一致
+        - 特别注意：状态字段、ID字段、枚举值、时间字段等容易出现类型不匹配的字段
+        - 示例：后端数值类型字段对应前端 `number` 类型，字符串类型对应 `string` 类型，布尔类型对应 `boolean` 类型
+        - **指针类型处理**：后端Go中的指针类型在JSON序列化时会自动处理nil值，前端接收到的是对应的基础类型或null值
+
+3. **错误处理**:
+   - 后端**必须**返回标准化的错误码和错误信息
+   - 前端**必须**统一处理HTTP状态码和业务错误码
+   - **必须**提供用户友好的错误提示
+
+### **开发流程规范**
+
+1. **需求分析阶段**:
+   - 确定功能需求和接口设计
+   - 定义数据模型和业务流程
+   - 制定前后端开发计划
+
+2. **开发阶段**:
+   - 后端优先开发API接口
+   - 前端基于Mock数据进行并行开发
+   - 定期进行接口联调测试
+
+3. **测试阶段**:
+   - 单元测试：前后端各自负责
+   - 集成测试：前后端协作完成
+   - 用户验收测试：产品团队主导
+
+### **版本管理规范**
+
+1. **分支策略**:
+   - `main`：生产环境分支
+   - `develop`：开发环境分支
+   - `feature/*`：功能开发分支
+   - `hotfix/*`：紧急修复分支
+
+2. **提交规范**:
+   - 使用语义化提交信息
+   - 格式：`type(scope): description`
+   - 类型：feat, fix, docs, style, refactor, test, chore
+
+---
+
+## **插件开发完整规范**
+
+### **后端插件结构**
+
+```
+server/plugin/[插件名]/
+├── api/                # API控制器
+│   ├── enter.go       # API组入口
+│   └── [模块].go      # 具体API实现
+├── config/            # 插件配置
+│   └── config.go
+├── initialize/        # 初始化模块
+│   ├── api.go        # API注册
+│   ├── gorm.go       # 数据库初始化
+│   ├── menu.go       # 菜单初始化
+│   ├── router.go     # 路由初始化
+│   └── viper.go      # 配置初始化
+├── model/             # 数据模型
+│   ├── [模型].go     # 数据库模型
+│   └── request/      # 请求模型
+├── router/            # 路由定义
+│   ├── enter.go      # 路由组入口
+│   └── [模块].go     # 具体路由
+├── service/           # 业务服务
+│   ├── enter.go      # 服务组入口
+│   └── [模块].go     # 具体服务
+└── plugin.go          # 插件入口
+```
+
+### **前端插件结构**
+
+```
+web/src/plugin/[插件名]/
+├── api/               # API接口
+│   └── [模块].js
+├── components/        # 插件组件
+│   └── [组件].vue
+├── view/             # 插件页面
+│   └── [页面].vue
+├── form/             # 表单组件
+│   └── [表单].vue
+└── config.js         # 插件配置
+```
+
+### **插件开发工作流**
+
+1. **【第一步】需求分析**:
+   - 明确插件功能和业务需求
+   - 设计数据模型和接口规范
+   - 规划前端页面和交互流程
+
+2. **【第二步】后端开发**:
+   - 创建数据模型和请求模型
+   - 实现服务层业务逻辑
+   - 开发API控制器和路由
+   - 编写初始化和配置代码
+
+3. **【第三步】前端开发**:
+   - 创建API接口封装
+   - 开发页面组件和表单
+   - 实现业务逻辑和状态管理
+   - 集成到主系统菜单
+
+4. **【第四步】测试集成**:
+   - 单元测试和集成测试
+   - 前后端联调测试
+   - 用户体验测试
+   - 性能和安全测试
+
+### **插件质量标准**
+
+1. **功能完整性**: 插件功能完整，满足业务需求
+2. **代码质量**: 代码规范，注释完整，易于维护
+3. **数据类型一致性**: 前后端数据模型字段类型保持严格一致，避免类型转换错误
+4. **性能表现**: 响应速度快，资源占用合理
+5. **用户体验**: 界面友好，操作流畅，错误处理完善
+6. **兼容性**: 与主系统兼容，不影响其他功能
+7. **安全性**: 数据安全，权限控制，防止安全漏洞
+
+---
+
+### **建议和方案**
+
+基于以上规范，建议AI在开发gin-vue-admin项目时：
+
+1. **严格遵循分层架构**：确保前后端代码都按照规定的层次结构组织
+2. **保持代码一致性**：使用统一的命名规范、注释格式和代码风格
+3. **注重文档完整性**：确保API文档、代码注释和使用说明的完整性
+4. **优化用户体验**：关注页面加载速度、交互流畅性和错误处理
+5. **考虑扩展性**：设计时预留扩展接口，便于后续功能增强
+6. **重视安全性**：实现完善的权限控制和数据验证机制

README-en.md

@@ -148,7 +148,7 @@ go env -w GOPROXY=https://goproxy.cn,https://goproxy.io,direct
 cd server
 go generate -run "go env -w .*?"
 
-# 使用如下命令下载swag
+# Use the following command to download swag
 go get -u github.com/swaggo/swag/cmd/swag
 ````
 

README.md

@@ -9,6 +9,7 @@
 <img src="https://img.shields.io/badge/vue-3.3.4-brightgreen"/>
 <img src="https://img.shields.io/badge/element--plus-2.3.8-green"/>
 <img src="https://img.shields.io/badge/gorm-1.25.2-red"/>
+<img src="https://gitcode.com/flipped-aurora/gin-vue-admin/star/badge.svg"/>
 </div>
 
 <div align=center>
@@ -21,7 +22,8 @@
 
 <table>
   <tr>
-    <td width="200">
+    <td width="250">
+	  <p>⭐️ <a href="https://www.bilibili.com/video/BV1B3htzqEf1/?spm_id_from=333.1387.homepage.video_card.click" target="__blank"> 高度适配AI编辑器的MCP </a></p>
       <p>📄 创建基础模板</p>
       <p>🤖 AI生成结构</p>
       <p>⏰ 生成代码</p>
@@ -377,7 +379,7 @@ fmt.Println(decodeBytes, err)
 
 如果你觉得这个项目对你有帮助，你可以请作者喝饮料 :tropical_drink: [点我](https://www.gin-vue-admin.com/coffee/index.html)
 
-## 10. 商用注意事项
+## 10. 注意事项
 
-请严格遵守Apache 2.0协议并保留作品声明，商业用途请务必[获取授权](https://www.gin-vue-admin.com/empower/)  
-未授权商用将依法追究法律责任
+请严格遵守Apache 2.0协议并保留作品声明，去除版权信息请务必[获取授权](https://www.gin-vue-admin.com/empower/)  
+未授权去除版权信息将依法追究法律责任

server/api/v1/system/enter.go

@@ -22,6 +22,8 @@ type ApiGroup struct {
 	AutoCodeHistoryApi
 	AutoCodeTemplateApi
 	SysParamsApi
+	SysVersionApi
+	SysErrorApi
 }
 
 var (
@@ -44,4 +46,6 @@ var (
 	autoCodePackageService  = service.ServiceGroupApp.SystemServiceGroup.AutoCodePackage
 	autoCodeHistoryService  = service.ServiceGroupApp.SystemServiceGroup.AutoCodeHistory
 	autoCodeTemplateService = service.ServiceGroupApp.SystemServiceGroup.AutoCodeTemplate
+	sysVersionService       = service.ServiceGroupApp.SystemServiceGroup.SysVersionService
+	sysErrprService         = service.ServiceGroupApp.SystemServiceGroup.SysErrorService
 )

server/api/v1/system/sys_dictionary.go

@@ -4,6 +4,7 @@ import (
 	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
 	"github.com/gin-gonic/gin"
 	"go.uber.org/zap"
 )
@@ -116,10 +117,17 @@ func (s *DictionaryApi) FindSysDictionary(c *gin.Context) {
 // @Security  ApiKeyAuth
 // @accept    application/json
 // @Produce   application/json
+// @Param     data  query     request.SysDictionarySearch                                    true  "字典 name 或者 type"
 // @Success   200   {object}  response.Response{data=response.PageResult,msg=string}  "分页获取SysDictionary列表,返回包括列表,总数,页码,每页数量"
 // @Router    /sysDictionary/getSysDictionaryList [get]
 func (s *DictionaryApi) GetSysDictionaryList(c *gin.Context) {
-	list, err := dictionaryService.GetSysDictionaryInfoList()
+	var dictionary request.SysDictionarySearch
+	err := c.ShouldBindQuery(&dictionary)
+	if err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	list, err := dictionaryService.GetSysDictionaryInfoList(c, dictionary)
 	if err != nil {
 		global.GVA_LOG.Error("获取失败!", zap.Error(err))
 		response.FailWithMessage("获取失败", c)

server/api/v1/system/sys_dictionary_detail.go

@@ -1,6 +1,8 @@
 package system
 
 import (
+	"strconv"
+
 	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
@@ -146,3 +148,120 @@ func (s *DictionaryDetailApi) GetSysDictionaryDetailList(c *gin.Context) {
 		PageSize: pageInfo.PageSize,
 	}, "获取成功", c)
 }
+
+// GetDictionaryTreeList
+// @Tags      SysDictionaryDetail
+// @Summary   获取字典详情树形结构
+// @Security  ApiKeyAuth
+// @accept    application/json
+// @Produce   application/json
+// @Param     sysDictionaryID  query     int                                                true  "字典ID"
+// @Success   200              {object}  response.Response{data=[]system.SysDictionaryDetail,msg=string}  "获取字典详情树形结构"
+// @Router    /sysDictionaryDetail/getDictionaryTreeList [get]
+func (s *DictionaryDetailApi) GetDictionaryTreeList(c *gin.Context) {
+	sysDictionaryID := c.Query("sysDictionaryID")
+	if sysDictionaryID == "" {
+		response.FailWithMessage("字典ID不能为空", c)
+		return
+	}
+
+	var id uint
+	if idUint64, err := strconv.ParseUint(sysDictionaryID, 10, 32); err != nil {
+		response.FailWithMessage("字典ID格式错误", c)
+		return
+	} else {
+		id = uint(idUint64)
+	}
+	
+	list, err := dictionaryDetailService.GetDictionaryTreeList(id)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+		return
+	}
+	response.OkWithDetailed(gin.H{"list": list}, "获取成功", c)
+}
+
+// GetDictionaryTreeListByType
+// @Tags      SysDictionaryDetail
+// @Summary   根据字典类型获取字典详情树形结构
+// @Security  ApiKeyAuth
+// @accept    application/json
+// @Produce   application/json
+// @Param     type  query     string                                                true  "字典类型"
+// @Success   200   {object}  response.Response{data=[]system.SysDictionaryDetail,msg=string}  "获取字典详情树形结构"
+// @Router    /sysDictionaryDetail/getDictionaryTreeListByType [get]
+func (s *DictionaryDetailApi) GetDictionaryTreeListByType(c *gin.Context) {
+	dictType := c.Query("type")
+	if dictType == "" {
+		response.FailWithMessage("字典类型不能为空", c)
+		return
+	}
+	
+	list, err := dictionaryDetailService.GetDictionaryTreeListByType(dictType)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+		return
+	}
+	response.OkWithDetailed(gin.H{"list": list}, "获取成功", c)
+}
+
+// GetDictionaryDetailsByParent
+// @Tags      SysDictionaryDetail
+// @Summary   根据父级ID获取字典详情
+// @Security  ApiKeyAuth
+// @accept    application/json
+// @Produce   application/json
+// @Param     data  query     request.GetDictionaryDetailsByParentRequest                true  "查询参数"
+// @Success   200   {object}  response.Response{data=[]system.SysDictionaryDetail,msg=string}  "获取字典详情列表"
+// @Router    /sysDictionaryDetail/getDictionaryDetailsByParent [get]
+func (s *DictionaryDetailApi) GetDictionaryDetailsByParent(c *gin.Context) {
+	var req request.GetDictionaryDetailsByParentRequest
+	err := c.ShouldBindQuery(&req)
+	if err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	
+	list, err := dictionaryDetailService.GetDictionaryDetailsByParent(req)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+		return
+	}
+	response.OkWithDetailed(gin.H{"list": list}, "获取成功", c)
+}
+
+// GetDictionaryPath
+// @Tags      SysDictionaryDetail
+// @Summary   获取字典详情的完整路径
+// @Security  ApiKeyAuth
+// @accept    application/json
+// @Produce   application/json
+// @Param     id  query     uint                                                true  "字典详情ID"
+// @Success   200 {object}  response.Response{data=[]system.SysDictionaryDetail,msg=string}  "获取字典详情路径"
+// @Router    /sysDictionaryDetail/getDictionaryPath [get]
+func (s *DictionaryDetailApi) GetDictionaryPath(c *gin.Context) {
+	idStr := c.Query("id")
+	if idStr == "" {
+		response.FailWithMessage("字典详情ID不能为空", c)
+		return
+	}
+	
+	var id uint
+	if idUint64, err := strconv.ParseUint(idStr, 10, 32); err != nil {
+		response.FailWithMessage("字典详情ID格式错误", c)
+		return
+	} else {
+		id = uint(idUint64)
+	}
+	
+	path, err := dictionaryDetailService.GetDictionaryPath(id)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败", c)
+		return
+	}
+	response.OkWithDetailed(gin.H{"path": path}, "获取成功", c)
+}

server/api/v1/system/sys_error.go

@@ -0,0 +1,169 @@
+package system
+
+import (
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	systemReq "github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+type SysErrorApi struct{}
+
+// CreateSysError 创建错误日志
+// @Tags SysError
+// @Summary 创建错误日志
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Param data body system.SysError true "创建错误日志"
+// @Success 200 {object} response.Response{msg=string} "创建成功"
+// @Router /sysErrpr/createSysError [post]
+func (sysErrprApi *SysErrorApi) CreateSysError(c *gin.Context) {
+	// 创建业务用Context
+	ctx := c.Request.Context()
+
+	var sysErrpr system.SysError
+	err := c.ShouldBindJSON(&sysErrpr)
+	if err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	err = sysErrprService.CreateSysError(ctx, &sysErrpr)
+	if err != nil {
+		global.GVA_LOG.Error("创建失败!", zap.Error(err))
+		response.FailWithMessage("创建失败:"+err.Error(), c)
+		return
+	}
+	response.OkWithMessage("创建成功", c)
+}
+
+// DeleteSysError 删除错误日志
+// @Tags SysError
+// @Summary 删除错误日志
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Param data body system.SysError true "删除错误日志"
+// @Success 200 {object} response.Response{msg=string} "删除成功"
+// @Router /sysErrpr/deleteSysError [delete]
+func (sysErrprApi *SysErrorApi) DeleteSysError(c *gin.Context) {
+	// 创建业务用Context
+	ctx := c.Request.Context()
+
+	ID := c.Query("ID")
+	err := sysErrprService.DeleteSysError(ctx, ID)
+	if err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Error(err))
+		response.FailWithMessage("删除失败:"+err.Error(), c)
+		return
+	}
+	response.OkWithMessage("删除成功", c)
+}
+
+// DeleteSysErrorByIds 批量删除错误日志
+// @Tags SysError
+// @Summary 批量删除错误日志
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Success 200 {object} response.Response{msg=string} "批量删除成功"
+// @Router /sysErrpr/deleteSysErrorByIds [delete]
+func (sysErrprApi *SysErrorApi) DeleteSysErrorByIds(c *gin.Context) {
+	// 创建业务用Context
+	ctx := c.Request.Context()
+
+	IDs := c.QueryArray("IDs[]")
+	err := sysErrprService.DeleteSysErrorByIds(ctx, IDs)
+	if err != nil {
+		global.GVA_LOG.Error("批量删除失败!", zap.Error(err))
+		response.FailWithMessage("批量删除失败:"+err.Error(), c)
+		return
+	}
+	response.OkWithMessage("批量删除成功", c)
+}
+
+// UpdateSysError 更新错误日志
+// @Tags SysError
+// @Summary 更新错误日志
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Param data body system.SysError true "更新错误日志"
+// @Success 200 {object} response.Response{msg=string} "更新成功"
+// @Router /sysErrpr/updateSysError [put]
+func (sysErrprApi *SysErrorApi) UpdateSysError(c *gin.Context) {
+	// 从ctx获取标准context进行业务行为
+	ctx := c.Request.Context()
+
+	var sysErrpr system.SysError
+	err := c.ShouldBindJSON(&sysErrpr)
+	if err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	err = sysErrprService.UpdateSysError(ctx, sysErrpr)
+	if err != nil {
+		global.GVA_LOG.Error("更新失败!", zap.Error(err))
+		response.FailWithMessage("更新失败:"+err.Error(), c)
+		return
+	}
+	response.OkWithMessage("更新成功", c)
+}
+
+// FindSysError 用id查询错误日志
+// @Tags SysError
+// @Summary 用id查询错误日志
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Param ID query uint true "用id查询错误日志"
+// @Success 200 {object} response.Response{data=system.SysError,msg=string} "查询成功"
+// @Router /sysErrpr/findSysError [get]
+func (sysErrprApi *SysErrorApi) FindSysError(c *gin.Context) {
+	// 创建业务用Context
+	ctx := c.Request.Context()
+
+	ID := c.Query("ID")
+	resysErrpr, err := sysErrprService.GetSysError(ctx, ID)
+	if err != nil {
+		global.GVA_LOG.Error("查询失败!", zap.Error(err))
+		response.FailWithMessage("查询失败:"+err.Error(), c)
+		return
+	}
+	response.OkWithData(resysErrpr, c)
+}
+
+// GetSysErrorList 分页获取错误日志列表
+// @Tags SysError
+// @Summary 分页获取错误日志列表
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Param data query systemReq.SysErrorSearch true "分页获取错误日志列表"
+// @Success 200 {object} response.Response{data=response.PageResult,msg=string} "获取成功"
+// @Router /sysErrpr/getSysErrorList [get]
+func (sysErrprApi *SysErrorApi) GetSysErrorList(c *gin.Context) {
+	// 创建业务用Context
+	ctx := c.Request.Context()
+
+	var pageInfo systemReq.SysErrorSearch
+	err := c.ShouldBindQuery(&pageInfo)
+	if err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	list, total, err := sysErrprService.GetSysErrorInfoList(ctx, pageInfo)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败:"+err.Error(), c)
+		return
+	}
+	response.OkWithDetailed(response.PageResult{
+		List:     list,
+		Total:    total,
+		Page:     pageInfo.Page,
+		PageSize: pageInfo.PageSize,
+	}, "获取成功", c)
+}

server/api/v1/system/sys_export_template.go

@@ -50,6 +50,34 @@ type SysExportTemplateApi struct {
 
 var sysExportTemplateService = service.ServiceGroupApp.SystemServiceGroup.SysExportTemplateService
 
+// PreviewSQL 预览最终生成的SQL
+// @Tags     SysExportTemplate
+// @Summary  预览最终生成的SQL（不执行查询，仅返回SQL字符串）
+// @Security ApiKeyAuth
+// @accept   application/json
+// @Produce  application/json
+// @Param    templateID query string true  "导出模板ID"
+// @Param    params     query string false "查询参数编码字符串，参考 ExportExcel 组件"
+// @Success  200  {object}  response.Response{data=map[string]string} "获取成功"
+// @Router   /sysExportTemplate/previewSQL [get]
+func (sysExportTemplateApi *SysExportTemplateApi) PreviewSQL(c *gin.Context) {
+    templateID := c.Query("templateID")
+    if templateID == "" {
+        response.FailWithMessage("模板ID不能为空", c)
+        return
+    }
+
+    // 直接复用导出接口的参数组织方式：使用 URL Query，其中 params 为内部编码的查询字符串
+    queryParams := c.Request.URL.Query()
+
+    if sqlPreview, err := sysExportTemplateService.PreviewSQL(templateID, queryParams); err != nil {
+        global.GVA_LOG.Error("获取失败!", zap.Error(err))
+        response.FailWithMessage("获取失败", c)
+    } else {
+        response.OkWithData(gin.H{"sql": sqlPreview}, c)
+    }
+}
+
 // CreateSysExportTemplate 创建导出模板
 // @Tags SysExportTemplate
 // @Summary 创建导出模板

server/api/v1/system/sys_menu.go

@@ -143,7 +143,7 @@ func (a *AuthorityMenuApi) AddBaseMenu(c *gin.Context) {
 	err = menuService.AddBaseMenu(menu)
 	if err != nil {
 		global.GVA_LOG.Error("添加失败!", zap.Error(err))
-		response.FailWithMessage("添加失败", c)
+		response.FailWithMessage("添加失败："+err.Error(), c)
 		return
 	}
 	response.OkWithMessage("添加成功", c)

server/api/v1/system/sys_user.go

@@ -27,8 +27,6 @@ import (
 func (b *BaseApi) Login(c *gin.Context) {
 	var l systemReq.Login
 	err := c.ShouldBindJSON(&l)
-	key := c.ClientIP()
-
 	if err != nil {
 		response.FailWithMessage(err.Error(), c)
 		return
@@ -39,6 +37,7 @@ func (b *BaseApi) Login(c *gin.Context) {
 		return
 	}
 
+	key := c.ClientIP()
 	// 判断验证码是否开启
 	openCaptcha := global.GVA_CONFIG.Captcha.OpenCaptcha               // 是否开启防爆次数
 	openCaptchaTimeOut := global.GVA_CONFIG.Captcha.OpenCaptchaTimeOut // 缓存超时时间
@@ -48,30 +47,30 @@ func (b *BaseApi) Login(c *gin.Context) {
 	}
 
 	var oc bool = openCaptcha == 0 || openCaptcha < interfaceToInt(v)
-
-	if !oc || (l.CaptchaId != "" && l.Captcha != "" && store.Verify(l.CaptchaId, l.Captcha, true)) {
-		u := &system.SysUser{Username: l.Username, Password: l.Password}
-		user, err := userService.Login(u)
-		if err != nil {
-			global.GVA_LOG.Error("登陆失败! 用户名不存在或者密码错误!", zap.Error(err))
-			// 验证码次数+1
-			global.BlackCache.Increment(key, 1)
-			response.FailWithMessage("用户名不存在或者密码错误", c)
-			return
-		}
-		if user.Enable != 1 {
-			global.GVA_LOG.Error("登陆失败! 用户被禁止登录!")
-			// 验证码次数+1
-			global.BlackCache.Increment(key, 1)
-			response.FailWithMessage("用户被禁止登录", c)
-			return
-		}
-		b.TokenNext(c, *user)
+	if oc && (l.Captcha == "" || l.CaptchaId == "" || !store.Verify(l.CaptchaId, l.Captcha, true)) {
+		// 验证码次数+1
+		global.BlackCache.Increment(key, 1)
+		response.FailWithMessage("验证码错误", c)
 		return
 	}
-	// 验证码次数+1
-	global.BlackCache.Increment(key, 1)
-	response.FailWithMessage("验证码错误", c)
+
+	u := &system.SysUser{Username: l.Username, Password: l.Password}
+	user, err := userService.Login(u)
+	if err != nil {
+		global.GVA_LOG.Error("登陆失败! 用户名不存在或者密码错误!", zap.Error(err))
+		// 验证码次数+1
+		global.BlackCache.Increment(key, 1)
+		response.FailWithMessage("用户名不存在或者密码错误", c)
+		return
+	}
+	if user.Enable != 1 {
+		global.GVA_LOG.Error("登陆失败! 用户被禁止登录!")
+		// 验证码次数+1
+		global.BlackCache.Increment(key, 1)
+		response.FailWithMessage("用户被禁止登录", c)
+		return
+	}
+	b.TokenNext(c, *user)
 }
 
 // TokenNext 登录以后签发jwt
@@ -184,7 +183,7 @@ func (b *BaseApi) ChangePassword(c *gin.Context) {
 	}
 	uid := utils.GetUserID(c)
 	u := &system.SysUser{GVA_MODEL: global.GVA_MODEL{ID: uid}, Password: req.Password}
-	_, err = userService.ChangePassword(u, req.NewPassword)
+	err = userService.ChangePassword(u, req.NewPassword)
 	if err != nil {
 		global.GVA_LOG.Error("修改失败!", zap.Error(err))
 		response.FailWithMessage("修改失败，原密码与当前账户不符", c)

server/api/v1/system/sys_version.go

@@ -0,0 +1,486 @@
+package system
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"sort"
+	"strconv"
+	"time"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	systemReq "github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
+	systemRes "github.com/flipped-aurora/gin-vue-admin/server/model/system/response"
+	"github.com/flipped-aurora/gin-vue-admin/server/utils"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+type SysVersionApi struct{}
+
+// buildMenuTree 构建菜单树结构
+func buildMenuTree(menus []system.SysBaseMenu) []system.SysBaseMenu {
+	// 创建菜单映射
+	menuMap := make(map[uint]*system.SysBaseMenu)
+	for i := range menus {
+		menuMap[menus[i].ID] = &menus[i]
+	}
+
+	// 构建树结构
+	var rootMenus []system.SysBaseMenu
+	for _, menu := range menus {
+		if menu.ParentId == 0 {
+			// 根菜单
+			menuData := convertMenuToStruct(menu, menuMap)
+			rootMenus = append(rootMenus, menuData)
+		}
+	}
+
+	// 按sort排序根菜单
+	sort.Slice(rootMenus, func(i, j int) bool {
+		return rootMenus[i].Sort < rootMenus[j].Sort
+	})
+
+	return rootMenus
+}
+
+// convertMenuToStruct 将菜单转换为结构体并递归处理子菜单
+func convertMenuToStruct(menu system.SysBaseMenu, menuMap map[uint]*system.SysBaseMenu) system.SysBaseMenu {
+	result := system.SysBaseMenu{
+		Path:      menu.Path,
+		Name:      menu.Name,
+		Hidden:    menu.Hidden,
+		Component: menu.Component,
+		Sort:      menu.Sort,
+		Meta:      menu.Meta,
+	}
+
+	// 清理并复制参数数据
+	if len(menu.Parameters) > 0 {
+		cleanParameters := make([]system.SysBaseMenuParameter, 0, len(menu.Parameters))
+		for _, param := range menu.Parameters {
+			cleanParam := system.SysBaseMenuParameter{
+				Type:  param.Type,
+				Key:   param.Key,
+				Value: param.Value,
+				// 不复制 ID, CreatedAt, UpdatedAt, SysBaseMenuID
+			}
+			cleanParameters = append(cleanParameters, cleanParam)
+		}
+		result.Parameters = cleanParameters
+	}
+
+	// 清理并复制菜单按钮数据
+	if len(menu.MenuBtn) > 0 {
+		cleanMenuBtns := make([]system.SysBaseMenuBtn, 0, len(menu.MenuBtn))
+		for _, btn := range menu.MenuBtn {
+			cleanBtn := system.SysBaseMenuBtn{
+				Name: btn.Name,
+				Desc: btn.Desc,
+				// 不复制 ID, CreatedAt, UpdatedAt, SysBaseMenuID
+			}
+			cleanMenuBtns = append(cleanMenuBtns, cleanBtn)
+		}
+		result.MenuBtn = cleanMenuBtns
+	}
+
+	// 查找并处理子菜单
+	var children []system.SysBaseMenu
+	for _, childMenu := range menuMap {
+		if childMenu.ParentId == menu.ID {
+			childData := convertMenuToStruct(*childMenu, menuMap)
+			children = append(children, childData)
+		}
+	}
+
+	// 按sort排序子菜单
+	if len(children) > 0 {
+		sort.Slice(children, func(i, j int) bool {
+			return children[i].Sort < children[j].Sort
+		})
+		result.Children = children
+	}
+
+	return result
+}
+
+// DeleteSysVersion 删除版本管理
+// @Tags SysVersion
+// @Summary 删除版本管理
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Param data body system.SysVersion true "删除版本管理"
+// @Success 200 {object} response.Response{msg=string} "删除成功"
+// @Router /sysVersion/deleteSysVersion [delete]
+func (sysVersionApi *SysVersionApi) DeleteSysVersion(c *gin.Context) {
+	// 创建业务用Context
+	ctx := c.Request.Context()
+
+	ID := c.Query("ID")
+	err := sysVersionService.DeleteSysVersion(ctx, ID)
+	if err != nil {
+		global.GVA_LOG.Error("删除失败!", zap.Error(err))
+		response.FailWithMessage("删除失败:"+err.Error(), c)
+		return
+	}
+	response.OkWithMessage("删除成功", c)
+}
+
+// DeleteSysVersionByIds 批量删除版本管理
+// @Tags SysVersion
+// @Summary 批量删除版本管理
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Success 200 {object} response.Response{msg=string} "批量删除成功"
+// @Router /sysVersion/deleteSysVersionByIds [delete]
+func (sysVersionApi *SysVersionApi) DeleteSysVersionByIds(c *gin.Context) {
+	// 创建业务用Context
+	ctx := c.Request.Context()
+
+	IDs := c.QueryArray("IDs[]")
+	err := sysVersionService.DeleteSysVersionByIds(ctx, IDs)
+	if err != nil {
+		global.GVA_LOG.Error("批量删除失败!", zap.Error(err))
+		response.FailWithMessage("批量删除失败:"+err.Error(), c)
+		return
+	}
+	response.OkWithMessage("批量删除成功", c)
+}
+
+// FindSysVersion 用id查询版本管理
+// @Tags SysVersion
+// @Summary 用id查询版本管理
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Param ID query uint true "用id查询版本管理"
+// @Success 200 {object} response.Response{data=system.SysVersion,msg=string} "查询成功"
+// @Router /sysVersion/findSysVersion [get]
+func (sysVersionApi *SysVersionApi) FindSysVersion(c *gin.Context) {
+	// 创建业务用Context
+	ctx := c.Request.Context()
+
+	ID := c.Query("ID")
+	resysVersion, err := sysVersionService.GetSysVersion(ctx, ID)
+	if err != nil {
+		global.GVA_LOG.Error("查询失败!", zap.Error(err))
+		response.FailWithMessage("查询失败:"+err.Error(), c)
+		return
+	}
+	response.OkWithData(resysVersion, c)
+}
+
+// GetSysVersionList 分页获取版本管理列表
+// @Tags SysVersion
+// @Summary 分页获取版本管理列表
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Param data query systemReq.SysVersionSearch true "分页获取版本管理列表"
+// @Success 200 {object} response.Response{data=response.PageResult,msg=string} "获取成功"
+// @Router /sysVersion/getSysVersionList [get]
+func (sysVersionApi *SysVersionApi) GetSysVersionList(c *gin.Context) {
+	// 创建业务用Context
+	ctx := c.Request.Context()
+
+	var pageInfo systemReq.SysVersionSearch
+	err := c.ShouldBindQuery(&pageInfo)
+	if err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+	list, total, err := sysVersionService.GetSysVersionInfoList(ctx, pageInfo)
+	if err != nil {
+		global.GVA_LOG.Error("获取失败!", zap.Error(err))
+		response.FailWithMessage("获取失败:"+err.Error(), c)
+		return
+	}
+	response.OkWithDetailed(response.PageResult{
+		List:     list,
+		Total:    total,
+		Page:     pageInfo.Page,
+		PageSize: pageInfo.PageSize,
+	}, "获取成功", c)
+}
+
+// GetSysVersionPublic 不需要鉴权的版本管理接口
+// @Tags SysVersion
+// @Summary 不需要鉴权的版本管理接口
+// @Accept application/json
+// @Produce application/json
+// @Success 200 {object} response.Response{data=object,msg=string} "获取成功"
+// @Router /sysVersion/getSysVersionPublic [get]
+func (sysVersionApi *SysVersionApi) GetSysVersionPublic(c *gin.Context) {
+	// 创建业务用Context
+	ctx := c.Request.Context()
+
+	// 此接口不需要鉴权
+	// 示例为返回了一个固定的消息接口，一般本接口用于C端服务，需要自己实现业务逻辑
+	sysVersionService.GetSysVersionPublic(ctx)
+	response.OkWithDetailed(gin.H{
+		"info": "不需要鉴权的版本管理接口信息",
+	}, "获取成功", c)
+}
+
+// ExportVersion 创建发版数据
+// @Tags SysVersion
+// @Summary 创建发版数据
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Param data body systemReq.ExportVersionRequest true "创建发版数据"
+// @Success 200 {object} response.Response{msg=string} "创建成功"
+// @Router /sysVersion/exportVersion [post]
+func (sysVersionApi *SysVersionApi) ExportVersion(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	var req systemReq.ExportVersionRequest
+	err := c.ShouldBindJSON(&req)
+	if err != nil {
+		response.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 获取选中的菜单数据
+	var menuData []system.SysBaseMenu
+	if len(req.MenuIds) > 0 {
+		menuData, err = sysVersionService.GetMenusByIds(ctx, req.MenuIds)
+		if err != nil {
+			global.GVA_LOG.Error("获取菜单数据失败!", zap.Error(err))
+			response.FailWithMessage("获取菜单数据失败:"+err.Error(), c)
+			return
+		}
+	}
+
+	// 获取选中的API数据
+	var apiData []system.SysApi
+	if len(req.ApiIds) > 0 {
+		apiData, err = sysVersionService.GetApisByIds(ctx, req.ApiIds)
+		if err != nil {
+			global.GVA_LOG.Error("获取API数据失败!", zap.Error(err))
+			response.FailWithMessage("获取API数据失败:"+err.Error(), c)
+			return
+		}
+	}
+
+	// 获取选中的字典数据
+	var dictData []system.SysDictionary
+	if len(req.DictIds) > 0 {
+		dictData, err = sysVersionService.GetDictionariesByIds(ctx, req.DictIds)
+		if err != nil {
+			global.GVA_LOG.Error("获取字典数据失败!", zap.Error(err))
+			response.FailWithMessage("获取字典数据失败:"+err.Error(), c)
+			return
+		}
+	}
+
+	// 处理菜单数据，构建递归的children结构
+	processedMenus := buildMenuTree(menuData)
+
+	// 处理API数据，清除ID和时间戳字段
+	processedApis := make([]system.SysApi, 0, len(apiData))
+	for _, api := range apiData {
+		cleanApi := system.SysApi{
+			Path:        api.Path,
+			Description: api.Description,
+			ApiGroup:    api.ApiGroup,
+			Method:      api.Method,
+		}
+		processedApis = append(processedApis, cleanApi)
+	}
+
+	// 处理字典数据，清除ID和时间戳字段，包含字典详情
+	processedDicts := make([]system.SysDictionary, 0, len(dictData))
+	for _, dict := range dictData {
+		cleanDict := system.SysDictionary{
+			Name:   dict.Name,
+			Type:   dict.Type,
+			Status: dict.Status,
+			Desc:   dict.Desc,
+		}
+		
+		// 处理字典详情数据，清除ID和时间戳字段
+		cleanDetails := make([]system.SysDictionaryDetail, 0, len(dict.SysDictionaryDetails))
+		for _, detail := range dict.SysDictionaryDetails {
+			cleanDetail := system.SysDictionaryDetail{
+				Label:  detail.Label,
+				Value:  detail.Value,
+				Extend: detail.Extend,
+				Status: detail.Status,
+				Sort:   detail.Sort,
+				// 不复制 ID, CreatedAt, UpdatedAt, SysDictionaryID
+			}
+			cleanDetails = append(cleanDetails, cleanDetail)
+		}
+		cleanDict.SysDictionaryDetails = cleanDetails
+		
+		processedDicts = append(processedDicts, cleanDict)
+	}
+
+	// 构建导出数据
+	exportData := systemRes.ExportVersionResponse{
+		Version: systemReq.VersionInfo{
+			Name:        req.VersionName,
+			Code:        req.VersionCode,
+			Description: req.Description,
+			ExportTime:  time.Now().Format("2006-01-02 15:04:05"),
+		},
+		Menus:        processedMenus,
+		Apis:         processedApis,
+		Dictionaries: processedDicts,
+	}
+
+	// 转换为JSON
+	jsonData, err := json.MarshalIndent(exportData, "", "  ")
+	if err != nil {
+		global.GVA_LOG.Error("JSON序列化失败!", zap.Error(err))
+		response.FailWithMessage("JSON序列化失败:"+err.Error(), c)
+		return
+	}
+
+	// 保存版本记录
+	version := system.SysVersion{
+		VersionName: utils.Pointer(req.VersionName),
+		VersionCode: utils.Pointer(req.VersionCode),
+		Description: utils.Pointer(req.Description),
+		VersionData: utils.Pointer(string(jsonData)),
+	}
+
+	err = sysVersionService.CreateSysVersion(ctx, &version)
+	if err != nil {
+		global.GVA_LOG.Error("保存版本记录失败!", zap.Error(err))
+		response.FailWithMessage("保存版本记录失败:"+err.Error(), c)
+		return
+	}
+
+	response.OkWithMessage("创建发版成功", c)
+}
+
+// DownloadVersionJson 下载版本JSON数据
+// @Tags SysVersion
+// @Summary 下载版本JSON数据
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Param ID query string true "版本ID"
+// @Success 200 {object} response.Response{data=object,msg=string} "下载成功"
+// @Router /sysVersion/downloadVersionJson [get]
+func (sysVersionApi *SysVersionApi) DownloadVersionJson(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	ID := c.Query("ID")
+	if ID == "" {
+		response.FailWithMessage("版本ID不能为空", c)
+		return
+	}
+
+	// 获取版本记录
+	version, err := sysVersionService.GetSysVersion(ctx, ID)
+	if err != nil {
+		global.GVA_LOG.Error("获取版本记录失败!", zap.Error(err))
+		response.FailWithMessage("获取版本记录失败:"+err.Error(), c)
+		return
+	}
+
+	// 构建JSON数据
+	var jsonData []byte
+	if version.VersionData != nil && *version.VersionData != "" {
+		jsonData = []byte(*version.VersionData)
+	} else {
+		// 如果没有存储的JSON数据，构建一个基本的结构
+		basicData := systemRes.ExportVersionResponse{
+			Version: systemReq.VersionInfo{
+				Name:        *version.VersionName,
+				Code:        *version.VersionCode,
+				Description: *version.Description,
+				ExportTime:  version.CreatedAt.Format("2006-01-02 15:04:05"),
+			},
+			Menus: []system.SysBaseMenu{},
+			Apis:  []system.SysApi{},
+		}
+		jsonData, _ = json.MarshalIndent(basicData, "", "  ")
+	}
+
+	// 设置下载响应头
+	filename := fmt.Sprintf("version_%s_%s.json", *version.VersionCode, time.Now().Format("20060102150405"))
+	c.Header("Content-Type", "application/json")
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
+	c.Header("Content-Length", strconv.Itoa(len(jsonData)))
+
+	c.Data(http.StatusOK, "application/json", jsonData)
+}
+
+// ImportVersion 导入版本数据
+// @Tags SysVersion
+// @Summary 导入版本数据
+// @Security ApiKeyAuth
+// @Accept application/json
+// @Produce application/json
+// @Param data body systemReq.ImportVersionRequest true "版本JSON数据"
+// @Success 200 {object} response.Response{msg=string} "导入成功"
+// @Router /sysVersion/importVersion [post]
+func (sysVersionApi *SysVersionApi) ImportVersion(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	// 获取JSON数据
+	var importData systemReq.ImportVersionRequest
+	err := c.ShouldBindJSON(&importData)
+	if err != nil {
+		response.FailWithMessage("解析JSON数据失败:"+err.Error(), c)
+		return
+	}
+
+	// 验证数据格式
+	if importData.VersionInfo.Name == "" || importData.VersionInfo.Code == "" {
+		response.FailWithMessage("版本信息格式错误", c)
+		return
+	}
+
+	// 导入菜单数据
+	if len(importData.ExportMenu) > 0 {
+		if err := sysVersionService.ImportMenus(ctx, importData.ExportMenu); err != nil {
+			global.GVA_LOG.Error("导入菜单失败!", zap.Error(err))
+			response.FailWithMessage("导入菜单失败: "+err.Error(), c)
+			return
+		}
+	}
+
+	// 导入API数据
+	if len(importData.ExportApi) > 0 {
+		if err := sysVersionService.ImportApis(importData.ExportApi); err != nil {
+			global.GVA_LOG.Error("导入API失败!", zap.Error(err))
+			response.FailWithMessage("导入API失败: "+err.Error(), c)
+			return
+		}
+	}
+
+	// 导入字典数据
+	if len(importData.ExportDictionary) > 0 {
+		if err := sysVersionService.ImportDictionaries(importData.ExportDictionary); err != nil {
+			global.GVA_LOG.Error("导入字典失败!", zap.Error(err))
+			response.FailWithMessage("导入字典失败: "+err.Error(), c)
+			return
+		}
+	}
+
+	// 创建导入记录
+	jsonData, _ := json.Marshal(importData)
+	version := system.SysVersion{
+		VersionName: utils.Pointer(importData.VersionInfo.Name),
+		VersionCode: utils.Pointer(fmt.Sprintf("%s_imported_%s", importData.VersionInfo.Code, time.Now().Format("20060102150405"))),
+		Description: utils.Pointer(fmt.Sprintf("导入版本: %s", importData.VersionInfo.Description)),
+		VersionData: utils.Pointer(string(jsonData)),
+	}
+
+	err = sysVersionService.CreateSysVersion(ctx, &version)
+	if err != nil {
+		global.GVA_LOG.Error("保存导入记录失败!", zap.Error(err))
+		// 这里不返回错误，因为数据已经导入成功
+	}
+
+	response.OkWithMessage("导入成功", c)
+}

server/config.docker.yaml

@@ -2,107 +2,103 @@
 
 # jwt configuration
 jwt:
-  signing-key: qmPlus
-  expires-time: 7d
-  buffer-time: 1d
-  issuer: qmPlus
+    signing-key: qmPlus
+    expires-time: 7d
+    buffer-time: 1d
+    issuer: qmPlus
 # zap logger configuration
 zap:
-  level: info
-  format: console
-  prefix: "[github.com/flipped-aurora/gin-vue-admin/server]"
-  director: log
-  show-line: true
-  encode-level: LowercaseColorLevelEncoder
-  stacktrace-key: stacktrace
-  log-in-console: true
+    level: info
+    format: console
+    prefix: "[github.com/flipped-aurora/gin-vue-admin/server]"
+    director: log
+    show-line: true
+    encode-level: LowercaseColorLevelEncoder
+    stacktrace-key: stacktrace
+    log-in-console: true
+    retention-day: -1
 
 # redis configuration
 redis:
-  db: 0
-  addr: 177.7.0.14:6379
-  password: ""
+    #是否使用redis集群模式
+    useCluster: false
+    #使用集群模式addr和db默认无效
+    addr: 177.7.0.14:6379
+    password: ""
+    db: 0
+    clusterAddrs:
+        - "177.7.0.14:7000"
+        - "177.7.0.15:7001"
+        - "177.7.0.13:7002"
+
+# redis-list configuration
+redis-list:
+    - name: cache           # 数据库的名称,注意: name 需要在 redis-list 中唯一
+      useCluster: false     # 是否使用redis集群模式
+      addr: 177.7.0.14:6379  # 使用集群模式addr和db默认无效
+      password: ""
+      db: 0
+      clusterAddrs:
+          - "177.7.0.14:7000"
+          - "177.7.0.15:7001"
+          - "177.7.0.13:7002"
 
 # mongo configuration
 mongo:
-  coll: ''
-  options: ''
-  database: ''
-  username: ''
-  password: ''
-  min-pool-size: 0
-  max-pool-size: 100
-  socket-timeout-ms: 0
-  connect-timeout-ms: 0
-  is-zap: false
-  hosts:
-    - host: ''
-      port: ''
+    coll: ''
+    options: ''
+    database: ''
+    username: ''
+    password: ''
+    auth-source: ''
+    min-pool-size: 0
+    max-pool-size: 100
+    socket-timeout-ms: 0
+    connect-timeout-ms: 0
+    is-zap: false
+    hosts:
+        - host: ''
+          port: ''
 
 # email configuration
 email:
-  to: xxx@qq.com
-  port: 465
-  from: xxx@163.com
-  host: smtp.163.com
-  is-ssl: true
-  secret: xxx
-  nickname: test
+    to: xxx@qq.com
+    port: 465
+    from: xxx@163.com
+    host: smtp.163.com
+    is-ssl: true
+    secret: xxx
+    nickname: test
 
 # system configuration
 system:
-  env: public  # Change to "develop" to skip authentication for development mode
-  addr: 8888
-  db-type: mysql
-  oss-type: local    # 控制oss选择走本地还是 七牛等其他仓 自行增加其他oss仓可以在 server/utils/upload/upload.go 中 NewOss函数配置
-  use-redis: false     # 使用redis
-  use-mongo: false     # 使用mongo
-  use-multipoint: false
-  # IP限制次数 一个小时15000次
-  iplimit-count: 15000
-  #  IP限制一个小时
-  iplimit-time: 3600
+    env: local # 修改为public可以关闭路由日志输出
+    addr: 8888
+    db-type: mysql
+    oss-type: local # 控制oss选择走本地还是 七牛等其他仓 自行增加其他oss仓可以在 server/utils/upload/upload.go 中 NewOss函数配置
+    use-redis: false # 使用redis
+    use-mongo: false     # 使用mongo
+    use-multipoint: false
+    # IP限制次数 一个小时15000次
+    iplimit-count: 15000
+    #  IP限制一个小时
+    iplimit-time: 3600
+    #  路由全局前缀
+    router-prefix: ""
+    #  严格角色模式 打开后权限将会存在上下级关系
+    use-strict-auth: false
 
 # captcha configuration
 captcha:
-  key-long: 6
-  img-width: 240
-  img-height: 80
-  open-captcha: 0 # 0代表一直开启，大于0代表限制次数
-  open-captcha-timeout: 3600 # open-captcha大于0时才生效
+    key-long: 6
+    img-width: 240
+    img-height: 80
+    open-captcha: 0 # 0代表一直开启，大于0代表限制次数
+    open-captcha-timeout: 3600 # open-captcha大于0时才生效
 
 # mysql connect configuration
 # 未初始化之前请勿手动修改数据库信息！！！如果一定要手动初始化请看（https://gin-vue-admin.com/docs/first_master）
 mysql:
-  path: ""
-  port: ""
-  config: ""
-  db-name: ""
-  username: ""
-  password: ""
-  max-idle-conns: 10
-  max-open-conns: 100
-  log-mode: ""
-  log-zap: false
-
-# pgsql connect configuration
-# 未初始化之前请勿手动修改数据库信息！！！如果一定要手动初始化请看（https://gin-vue-admin.com/docs/first_master）
-pgsql:
-  path: ""
-  port: ""
-  config: ""
-  db-name: ""
-  username: ""
-  password: ""
-  max-idle-conns: 10
-  max-open-conns: 100
-  log-mode: ""
-  log-zap: false
-
-db-list:
-  - disable: true # 是否禁用
-    type: "" # 数据库的类型,目前支持mysql、pgsql
-    alias-name: "" # 数据库的名称,注意: alias-name 需要在db-list中唯一
     path: ""
     port: ""
     config: ""
@@ -114,107 +110,176 @@ db-list:
     log-mode: ""
     log-zap: false
 
+# pgsql connect configuration
+# 未初始化之前请勿手动修改数据库信息！！！如果一定要手动初始化请看（https://gin-vue-admin.com/docs/first_master）
+pgsql:
+    path: ""
+    port: ""
+    config: ""
+    db-name: ""
+    username: ""
+    password: ""
+    max-idle-conns: 10
+    max-open-conns: 100
+    log-mode: ""
+    log-zap: false
+oracle:
+    path: ""
+    port: ""
+    config: ""
+    db-name: ""
+    username: ""
+    password: ""
+    max-idle-conns: 10
+    max-open-conns: 100
+    log-mode: ""
+    log-zap: false
+mssql:
+    path: ""
+    port: ""
+    config: ""
+    db-name: ""
+    username: ""
+    password: ""
+    max-idle-conns: 10
+    max-open-conns: 100
+    log-mode: ""
+    log-zap: false
+sqlite:
+    path: ""
+    port: ""
+    config: ""
+    db-name: ""
+    username: ""
+    password: ""
+    max-idle-conns: 10
+    max-open-conns: 100
+    log-mode: ""
+    log-zap: false
+db-list:
+    - disable: true # 是否禁用
+      type: "" # 数据库的类型,目前支持mysql、pgsql、mssql、oracle
+      alias-name: "" # 数据库的名称,注意: alias-name 需要在db-list中唯一
+      path: ""
+      port: ""
+      config: ""
+      db-name: ""
+      username: ""
+      password: ""
+      max-idle-conns: 10
+      max-open-conns: 100
+      log-mode: ""
+      log-zap: false
 
 # local configuration
 local:
-  path: uploads/file
-  store-path: uploads/file
+    path: uploads/file
+    store-path: uploads/file
 
 # autocode configuration
 autocode:
-  transfer-restart: true
-  # root 自动适配项目根目录
-  # 请不要手动配置,他会在项目加载的时候识别出根路径
-  root: ""
-  server: /server
-  server-plug: /plugin/%s
-  server-api: /api/v1/%s
-  server-initialize: /initialize
-  server-model: /model/%s
-  server-request: /model/%s/request/
-  server-router: /router/%s
-  server-service: /service/%s
-  web: /web/src
-  web-api: /api
-  web-form: /view
-  web-table: /view
+    web: web/src
+    root: "" # root 自动适配项目根目录, 请不要手动配置,他会在项目加载的时候识别出根路径
+    server: server
+    module: 'github.com/flipped-aurora/gin-vue-admin/server'
+    ai-path: ""  # AI服务路径
 
 # qiniu configuration (请自行七牛申请对应的 公钥 私钥 bucket 和 域名地址)
 qiniu:
-  zone: ZoneHuaDong
-  bucket: ""
-  img-path: ""
-  use-https: false
-  access-key: ""
-  secret-key: ""
-  use-cdn-domains: false
+    zone: ZoneHuaDong
+    bucket: ""
+    img-path: ""
+    use-https: false
+    access-key: ""
+    secret-key: ""
+    use-cdn-domains: false
+
+# minio oss configuration
+minio:
+    endpoint: yourEndpoint
+    access-key-id: yourAccessKeyId
+    access-key-secret: yourAccessKeySecret
+    bucket-name: yourBucketName
+    use-ssl: false
+    base-path: ""
+    bucket-url: "http://host:9000/yourBucketName"
 
 # aliyun oss configuration
 aliyun-oss:
-  endpoint: yourEndpoint
-  access-key-id: yourAccessKeyId
-  access-key-secret: yourAccessKeySecret
-  bucket-name: yourBucketName
-  bucket-url: yourBucketUrl
-  base-path: yourBasePath
+    endpoint: yourEndpoint
+    access-key-id: yourAccessKeyId
+    access-key-secret: yourAccessKeySecret
+    bucket-name: yourBucketName
+    bucket-url: yourBucketUrl
+    base-path: yourBasePath
 
 # tencent cos configuration
 tencent-cos:
-  bucket: xxxxx-10005608
-  region: ap-shanghai
-  secret-id: your-secret-id
-  secret-key: your-secret-key
-  base-url: https://gin.vue.admin
-  path-prefix: github.com/flipped-aurora/gin-vue-admin/server
+    bucket: xxxxx-10005608
+    region: ap-shanghai
+    secret-id: your-secret-id
+    secret-key: your-secret-key
+    base-url: https://gin.vue.admin
+    path-prefix: github.com/flipped-aurora/gin-vue-admin/server
 
 # aws s3 configuration (minio compatible)
 aws-s3:
-  bucket: xxxxx-10005608
-  region: ap-shanghai
-  endpoint: ""
-  s3-force-path-style: false
-  disable-ssl: false
-  secret-id: your-secret-id
-  secret-key: your-secret-key
-  base-url: https://gin.vue.admin
-  path-prefix: github.com/flipped-aurora/gin-vue-admin/server
+    bucket: xxxxx-10005608
+    region: ap-shanghai
+    endpoint: ""
+    s3-force-path-style: false
+    disable-ssl: false
+    secret-id: your-secret-id
+    secret-key: your-secret-key
+    base-url: https://gin.vue.admin
+    path-prefix: github.com/flipped-aurora/gin-vue-admin/server
+
+# cloudflare r2 configuration
+cloudflare-r2:
+    bucket: xxxx0bucket
+    base-url: https://gin.vue.admin.com
+    path: uploads
+    account-id: xxx_account_id
+    access-key-id: xxx_key_id
+    secret-access-key: xxx_secret_key
 
 # huawei obs configuration
 hua-wei-obs:
-  path: you-path
-  bucket: you-bucket
-  endpoint: you-endpoint
-  access-key: you-access-key
-  secret-key: you-secret-key
+    path: you-path
+    bucket: you-bucket
+    endpoint: you-endpoint
+    access-key: you-access-key
+    secret-key: you-secret-key
 
 # excel configuration
 excel:
-  dir: ./resource/excel/
+    dir: ./resource/excel/
 
-# timer task db clear table
-Timer:
-  start: true
-  spec: "@daily"  # 定时任务详细配置参考 https://pkg.go.dev/github.com/robfig/cron/v3
-  detail:
-    - tableName: sys_operation_records
-      compareField: created_at
-      interval: 2160h
-    - tableName: jwt_blacklists
-      compareField: created_at
-      interval: 168h
+# disk usage configuration
+disk-list:
+    - mount-point: "/"
 
 # 跨域配置
 # 需要配合 server/initialize/router.go -> `Router.Use(middleware.CorsByRules())` 使用
 cors:
-  mode: whitelist # 放行模式: allow-all, 放行全部; whitelist, 白名单模式, 来自白名单内域名的请求添加 cors 头; strict-whitelist 严格白名单模式, 白名单外的请求一律拒绝
-  whitelist:
-    - allow-origin: example1.com
-      allow-headers: content-type
-      allow-methods: GET, POST
-      expose-headers: Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Content-Type
-      allow-credentials: true # 布尔值
-    - allow-origin: example2.com
-      allow-headers: content-type
-      allow-methods: GET, POST
-      expose-headers: Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Content-Type
-      allow-credentials: true # 布尔值
+    mode: strict-whitelist # 放行模式: allow-all, 放行全部; whitelist, 白名单模式, 来自白名单内域名的请求添加 cors 头; strict-whitelist 严格白名单模式, 白名单外的请求一律拒绝
+    whitelist:
+        - allow-origin: example1.com
+          allow-headers: Content-Type,AccessToken,X-CSRF-Token, Authorization, Token,X-Token,X-User-Id
+          allow-methods: POST, GET
+          expose-headers: Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Content-Type
+
+          allow-credentials: true # 布尔值
+        - allow-origin: example2.com
+          allow-headers: content-type
+          allow-methods: GET, POST
+          expose-headers: Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Content-Type
+          allow-credentials: true # 布尔值
+mcp:
+    name: GVA_MCP
+    version: v1.0.0
+    sse_path: /sse
+    message_path: /message
+    url_prefix: ''
+    addr: 8889
+    separate: false

server/config.yaml

@@ -87,6 +87,8 @@ system:
     router-prefix: ""
     #  严格角色模式 打开后权限将会存在上下级关系
     use-strict-auth: false
+    #  禁用自动迁移数据库表结构，生产环境建议设为true，手动迁移
+    disable-auto-migrate: false
 
 # captcha configuration
 captcha:
@@ -196,13 +198,13 @@ qiniu:
 
 # minio oss configuration
 minio:
-  endpoint: yourEndpoint
-  access-key-id: yourAccessKeyId
-  access-key-secret: yourAccessKeySecret
-  bucket-name: yourBucketName
-  use-ssl: false
-  base-path: ""
-  bucket-url: "http://host:9000/yourBucketName"
+    endpoint: yourEndpoint
+    access-key-id: yourAccessKeyId
+    access-key-secret: yourAccessKeySecret
+    bucket-name: yourBucketName
+    use-ssl: false
+    base-path: ""
+    bucket-url: "http://host:9000/yourBucketName"
 
 # aliyun oss configuration
 aliyun-oss:
@@ -268,7 +270,6 @@ cors:
           allow-headers: Content-Type,AccessToken,X-CSRF-Token, Authorization, Token,X-Token,X-User-Id
           allow-methods: POST, GET
           expose-headers: Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Content-Type
-
           allow-credentials: true # 布尔值
         - allow-origin: example2.com
           allow-headers: content-type
@@ -281,3 +282,5 @@ mcp:
     sse_path: /sse
     message_path: /message
     url_prefix: ''
+    addr: 8889
+    separate: false

server/config/captcha.go

@@ -4,6 +4,6 @@ type Captcha struct {
 	KeyLong            int `mapstructure:"key-long" json:"key-long" yaml:"key-long"`                                     // 验证码长度
 	ImgWidth           int `mapstructure:"img-width" json:"img-width" yaml:"img-width"`                                  // 验证码宽度
 	ImgHeight          int `mapstructure:"img-height" json:"img-height" yaml:"img-height"`                               // 验证码高度
-	OpenCaptcha        int `mapstructure:"open-captcha" json:"open-captcha" yaml:"open-captcha"`                         // 防爆破验证码开启此数，0代表每次登录都需要验证码，其他数字代表错误密码此数，如3代表错误三次后出现验证码
+	OpenCaptcha        int `mapstructure:"open-captcha" json:"open-captcha" yaml:"open-captcha"`                         // 防爆破验证码开启此数，0代表每次登录都需要验证码，其他数字代表错误密码次数，如3代表错误三次后出现验证码
 	OpenCaptchaTimeOut int `mapstructure:"open-captcha-timeout" json:"open-captcha-timeout" yaml:"open-captcha-timeout"` // 防爆破验证码超时时间，单位：s(秒)
 }

server/config/db_list.go

@@ -1,8 +1,9 @@
 package config
 
 import (
-	"gorm.io/gorm/logger"
 	"strings"
+
+	"gorm.io/gorm/logger"
 )
 
 type DsnProvider interface {
@@ -31,13 +32,13 @@ type GeneralDB struct {
 
 func (c GeneralDB) LogLevel() logger.LogLevel {
 	switch strings.ToLower(c.LogMode) {
-	case "silent", "Silent":
+	case "silent":
 		return logger.Silent
-	case "error", "Error":
+	case "error":
 		return logger.Error
-	case "warn", "Warn":
+	case "warn":
 		return logger.Warn
-	case "info", "Info":
+	case "info":
 		return logger.Info
 	default:
 		return logger.Info

server/config/email.go

@@ -1,11 +1,12 @@
 package config
 
 type Email struct {
-	To       string `mapstructure:"to" json:"to" yaml:"to"`                   // 收件人:多个以英文逗号分隔 例：a@qq.com b@qq.com 正式开发中请把此项目作为参数使用
-	From     string `mapstructure:"from" json:"from" yaml:"from"`             // 发件人  你自己要发邮件的邮箱
-	Host     string `mapstructure:"host" json:"host" yaml:"host"`             // 服务器地址 例如 smtp.qq.com  请前往QQ或者你要发邮件的邮箱查看其smtp协议
-	Secret   string `mapstructure:"secret" json:"secret" yaml:"secret"`       // 密钥    用于登录的密钥 最好不要用邮箱密码 去邮箱smtp申请一个用于登录的密钥
-	Nickname string `mapstructure:"nickname" json:"nickname" yaml:"nickname"` // 昵称    发件人昵称 通常为自己的邮箱
-	Port     int    `mapstructure:"port" json:"port" yaml:"port"`             // 端口     请前往QQ或者你要发邮件的邮箱查看其smtp协议 大多为 465
-	IsSSL    bool   `mapstructure:"is-ssl" json:"is-ssl" yaml:"is-ssl"`       // 是否SSL   是否开启SSL
+	To          string `mapstructure:"to" json:"to" yaml:"to"`                               // 收件人:多个以英文逗号分隔 例：a@qq.com b@qq.com 正式开发中请把此项目作为参数使用
+	From        string `mapstructure:"from" json:"from" yaml:"from"`                         // 发件人  你自己要发邮件的邮箱
+	Host        string `mapstructure:"host" json:"host" yaml:"host"`                         // 服务器地址 例如 smtp.qq.com  请前往QQ或者你要发邮件的邮箱查看其smtp协议
+	Secret      string `mapstructure:"secret" json:"secret" yaml:"secret"`                   // 密钥    用于登录的密钥 最好不要用邮箱密码 去邮箱smtp申请一个用于登录的密钥
+	Nickname    string `mapstructure:"nickname" json:"nickname" yaml:"nickname"`             // 昵称    发件人昵称 通常为自己的邮箱
+	Port        int    `mapstructure:"port" json:"port" yaml:"port"`                         // 端口     请前往QQ或者你要发邮件的邮箱查看其smtp协议 大多为 465
+	IsSSL       bool   `mapstructure:"is-ssl" json:"is-ssl" yaml:"is-ssl"`                   // 是否SSL   是否开启SSL
+	IsLoginAuth bool   `mapstructure:"is-loginauth" json:"is-loginauth" yaml:"is-loginauth"` // 是否LoginAuth   是否使用LoginAuth认证方式（适用于IBM、微软邮箱服务器等）
 }

server/config/gorm_oracle.go

@@ -1,10 +1,18 @@
 package config
 
+import (
+	"fmt"
+	"net"
+	"net/url"
+)
+
 type Oracle struct {
 	GeneralDB `yaml:",inline" mapstructure:",squash"`
 }
 
 func (m *Oracle) Dsn() string {
-	return "oracle://" + m.Username + ":" + m.Password + "@" + m.Path + ":" + m.Port + "/" + m.Dbname + "?" + m.Config
+	dsn := fmt.Sprintf("oracle://%s:%s@%s/%s?%s", url.PathEscape(m.Username), url.PathEscape(m.Password),
+		net.JoinHostPort(m.Path, m.Port), url.PathEscape(m.Dbname), m.Config)
+	return dsn
 
 }

server/config/mcp.go

@@ -6,4 +6,6 @@ type MCP struct {
 	SSEPath     string `mapstructure:"sse_path" json:"sse_path" yaml:"sse_path"`             // SSE路径
 	MessagePath string `mapstructure:"message_path" json:"message_path" yaml:"message_path"` // 消息路径
 	UrlPrefix   string `mapstructure:"url_prefix" json:"url_prefix" yaml:"url_prefix"`       // URL前缀
+	Addr        int    `mapstructure:"addr" json:"addr" yaml:"addr"`                         // 独立MCP服务端口
+	Separate    bool   `mapstructure:"separate" json:"separate" yaml:"separate"`             // 是否独立运行MCP服务
 }

server/config/system.go

@@ -11,4 +11,5 @@ type System struct {
 	UseRedis      bool   `mapstructure:"use-redis" json:"use-redis" yaml:"use-redis"`                   // 使用redis
 	UseMongo      bool   `mapstructure:"use-mongo" json:"use-mongo" yaml:"use-mongo"`                   // 使用mongo
 	UseStrictAuth bool   `mapstructure:"use-strict-auth" json:"use-strict-auth" yaml:"use-strict-auth"` // 使用树形角色分配模式
+	DisableAutoMigrate   bool   `mapstructure:"disable-auto-migrate" json:"disable-auto-migrate" yaml:"disable-auto-migrate"`          // 自动迁移数据库表结构，生产环境建议设为false，手动迁移
 }

server/core/server.go

@@ -35,7 +35,7 @@ func RunServer() {
 
 	fmt.Printf(`
 	欢迎使用 gin-vue-admin
-	当前版本:v2.8.2
+	当前版本:%s
 	加群方式:微信号：shouzi_1994 QQ群：470239250
 	项目地址：https://github.com/flipped-aurora/gin-vue-admin
 	插件市场:https://plugin.gin-vue-admin.com
@@ -48,6 +48,7 @@ func RunServer() {
 	** 版权所有方：flipped-aurora开源团队 **
 	** 版权持有公司：北京翻转极光科技有限责任公司 **
 	** 剔除授权标识需购买商用授权：https://gin-vue-admin.com/empower/index.html **
-`, address, address, global.GVA_CONFIG.MCP.SSEPath, address, global.GVA_CONFIG.MCP.MessagePath)
+	** 感谢您对Gin-Vue-Admin的支持与关注 合法授权使用更有利于项目的长久发展**
+`, global.Version, address, address, global.GVA_CONFIG.MCP.SSEPath, address, global.GVA_CONFIG.MCP.MessagePath)
 	initServer(address, Router, 10*time.Minute, 10*time.Minute)
 }

server/docs/docs.go

@@ -2,7 +2,10 @@
 
 package docs
 
-import "github.com/swaggo/swag"
+import (
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/swaggo/swag"
+)
 
 const docTemplate = `{
     "schemes": {{ marshal .Schemes }},
@@ -9296,7 +9299,7 @@ const docTemplate = `{
 
 // SwaggerInfo holds exported Swagger Info so clients can modify it
 var SwaggerInfo = &swag.Spec{
-	Version:          "v2.8.2",
+	Version:          global.Version,
 	Host:             "",
 	BasePath:         "",
 	Schemes:          []string{},

server/global/version.go

@@ -0,0 +1,12 @@
+package global
+
+// Version 版本信息
+// 目前只有Version正式使用 其余为预留
+const (
+	// Version 当前版本号
+	Version = "v2.8.6"
+	// AppName 应用名称
+	AppName = "Gin-Vue-Admin"
+	// Description 应用描述
+	Description = "使用gin+vue进行极速开发的全栈开发基础平台"
+)

server/go.mod

@@ -5,11 +5,11 @@ go 1.23
 toolchain go1.23.9
 
 require (
-	github.com/ThinkInAIXYZ/go-mcp v0.2.2
 	github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible
 	github.com/aws/aws-sdk-go v1.55.6
 	github.com/casbin/casbin/v2 v2.103.0
 	github.com/casbin/gorm-adapter/v3 v3.32.0
+	github.com/dzwvip/gorm-oracle v0.1.2
 	github.com/fsnotify/fsnotify v1.8.0
 	github.com/gin-gonic/gin v1.10.0
 	github.com/glebarez/sqlite v1.11.0
@@ -20,6 +20,7 @@ require (
 	github.com/gookit/color v1.5.4
 	github.com/huaweicloud/huaweicloud-sdk-go-obs v3.24.9+incompatible
 	github.com/jordan-wright/email v4.0.1-0.20210109023952-943e75fe5223+incompatible
+	github.com/mark3labs/mcp-go v0.41.1
 	github.com/mholt/archives v0.1.1
 	github.com/minio/minio-go/v7 v7.0.84
 	github.com/mojocn/base64Captcha v1.3.8
@@ -60,10 +61,12 @@ require (
 	github.com/STARRY-S/zip v0.2.1 // indirect
 	github.com/alex-ant/gomath v0.0.0-20160516115720-89013a210a82 // indirect
 	github.com/andybalholm/brotli v1.1.1 // indirect
+	github.com/bahlo/generic-list-go v0.2.0 // indirect
 	github.com/bmatcuk/doublestar/v4 v4.8.0 // indirect
 	github.com/bodgit/plumbing v1.3.0 // indirect
 	github.com/bodgit/sevenzip v1.6.0 // indirect
 	github.com/bodgit/windows v1.0.1 // indirect
+	github.com/buger/jsonparser v1.1.1 // indirect
 	github.com/bytedance/sonic v1.12.7 // indirect
 	github.com/bytedance/sonic/loader v0.2.3 // indirect
 	github.com/casbin/govaluate v1.3.0 // indirect
@@ -74,6 +77,7 @@ require (
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/dsnet/compress v0.0.2-0.20230904184137-39efe44ab707 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/emirpasic/gods v1.12.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
 	github.com/gammazero/toposort v0.1.1 // indirect
 	github.com/gin-contrib/sse v1.0.0 // indirect
@@ -97,6 +101,7 @@ require (
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/invopop/jsonschema v0.13.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
 	github.com/jackc/pgx/v5 v5.7.2 // indirect
@@ -113,7 +118,6 @@ require (
 	github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 // indirect
 	github.com/magiconair/properties v1.8.9 // indirect
 	github.com/mailru/easyjson v0.9.0 // indirect
-	github.com/mark3labs/mcp-go v0.26.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/microsoft/go-mssqldb v1.8.0 // indirect
 	github.com/minio/md5-simd v1.1.2 // indirect
@@ -126,7 +130,6 @@ require (
 	github.com/mozillazg/go-httpheader v0.4.0 // indirect
 	github.com/ncruces/go-strftime v0.1.9 // indirect
 	github.com/nwaples/rardecode/v2 v2.1.0 // indirect
-	github.com/orcaman/concurrent-map/v2 v2.0.1 // indirect
 	github.com/otiai10/mint v1.6.3 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
 	github.com/pierrec/lz4/v4 v4.1.22 // indirect
@@ -139,6 +142,7 @@ require (
 	github.com/sagikazarmark/locafero v0.7.0 // indirect
 	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
 	github.com/shoenig/go-m1cpu v0.1.6 // indirect
+	github.com/sijms/go-ora/v2 v2.7.17 // indirect
 	github.com/sorairolake/lzip-go v0.3.5 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spf13/afero v1.12.0 // indirect
@@ -146,14 +150,13 @@ require (
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/therootcompany/xz v1.0.1 // indirect
-	github.com/tidwall/gjson v1.18.0 // indirect
-	github.com/tidwall/match v1.1.1 // indirect
-	github.com/tidwall/pretty v1.2.0 // indirect
+	github.com/thoas/go-funk v0.7.0 // indirect
 	github.com/tklauser/go-sysconf v0.3.14 // indirect
 	github.com/tklauser/numcpus v0.9.0 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
 	github.com/ulikunitz/xz v0.5.12 // indirect
+	github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
 	github.com/xdg-go/scram v1.1.2 // indirect
 	github.com/xdg-go/stringprep v1.0.4 // indirect

server/go.sum

@@ -48,8 +48,6 @@ github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6Xge
 github.com/QcloudApi/qcloud_sign_golang v0.0.0-20141224014652-e4130a326409/go.mod h1:1pk82RBxDY/JZnPQrtqHlUFfCctgdorsd9M06fMynOM=
 github.com/STARRY-S/zip v0.2.1 h1:pWBd4tuSGm3wtpoqRZZ2EAwOmcHK6XFf7bU9qcJXyFg=
 github.com/STARRY-S/zip v0.2.1/go.mod h1:xNvshLODWtC4EJ702g7cTYn13G53o1+X9BWnPFpcWV4=
-github.com/ThinkInAIXYZ/go-mcp v0.2.2 h1:zlm4Xo8pxGzmfTvN16hM0YP75Q7QZ713g3mZSbO3JAs=
-github.com/ThinkInAIXYZ/go-mcp v0.2.2/go.mod h1:KnUWUymko7rmOgzvIjxwX0uB9oiJeLF/Q3W9cRt8fVg=
 github.com/alex-ant/gomath v0.0.0-20160516115720-89013a210a82 h1:7dONQ3WNZ1zy960TmkxJPuwoolZwL7xKtpcM04MBnt4=
 github.com/alex-ant/gomath v0.0.0-20160516115720-89013a210a82/go.mod h1:nLnM0KdK1CmygvjpDUO6m1TjSsiQtL61juhNsvV/JVI=
 github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible h1:8psS8a+wKfiLt1iVDX79F7Y6wUM49Lcha2FMXt4UM8g=
@@ -58,6 +56,8 @@ github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7X
 github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
 github.com/aws/aws-sdk-go v1.55.6 h1:cSg4pvZ3m8dgYcgqB97MrcdjUmZ1BeMYKUxMMB89IPk=
 github.com/aws/aws-sdk-go v1.55.6/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
+github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
+github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
 github.com/bmatcuk/doublestar/v4 v4.6.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
 github.com/bmatcuk/doublestar/v4 v4.8.0 h1:DSXtrypQddoug1459viM9X9D3dp1Z7993fw36I2kNcQ=
 github.com/bmatcuk/doublestar/v4 v4.8.0/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
@@ -71,6 +71,8 @@ github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
 github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
 github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
 github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
+github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
 github.com/bytedance/sonic v1.12.7 h1:CQU8pxOy9HToxhndH0Kx/S1qU/CuS9GnKYrGioDcU1Q=
 github.com/bytedance/sonic v1.12.7/go.mod h1:tnbal4mxOMju17EGfknm2XyYcpyCnIROYOEYuemj13I=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
@@ -109,6 +111,10 @@ github.com/dsnet/compress v0.0.2-0.20230904184137-39efe44ab707/go.mod h1:qssHWj6
 github.com/dsnet/golib v0.0.0-20171103203638-1ea166775780/go.mod h1:Lj+Z9rebOhdfkVLjJ8T6VcRQv3SXugXy999NBtR9aFY=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/dzwvip/gorm-oracle v0.1.2 h1:811aFDY7oDfKWHc0Z0lHdXzzr89EmKBSwc/jLJ8GU5g=
+github.com/dzwvip/gorm-oracle v0.1.2/go.mod h1:TbF7idnO9UgGpJ0qJpDZby1/wGquzP5GYof88ScBITE=
+github.com/emirpasic/gods v1.12.0 h1:QAUIPSaCu4G+POclxeqb3F+WPpdKqFGlw36+yOzGlrg=
+github.com/emirpasic/gods v1.12.0/go.mod h1:YfzfFFoVP/catgzJb4IKIqXjX78Ha8FMSDh3ymbK86o=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
@@ -245,6 +251,8 @@ github.com/huaweicloud/huaweicloud-sdk-go-obs v3.24.9+incompatible h1:XQVXdk+WAJ
 github.com/huaweicloud/huaweicloud-sdk-go-obs v3.24.9+incompatible/go.mod h1:l7VUhRbTKCzdOacdT4oWCwATKyvZqUOlOqr0Ous3k4s=
 github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/invopop/jsonschema v0.13.0 h1:KvpoAJWEjR3uD9Kbm2HWJmqsEaHt8lBUpd0qHcIi21E=
+github.com/invopop/jsonschema v0.13.0/go.mod h1:ffZ5Km5SWWRAIN6wbDXItl95euhFz2uON45H2qjYt+0=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
@@ -262,6 +270,7 @@ github.com/jcmturner/rpc/v2 v2.0.3/go.mod h1:VUJYCIDm3PVOEHw8sgt091/20OJjskO/YJk
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
@@ -312,8 +321,8 @@ github.com/magiconair/properties v1.8.9 h1:nWcCbLq1N2v/cpNsy5WvQ37Fb+YElfq20WJ/a
 github.com/magiconair/properties v1.8.9/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
 github.com/mailru/easyjson v0.9.0 h1:PrnmzHw7262yW8sTBwxi1PdJA3Iw/EKBa8psRf7d9a4=
 github.com/mailru/easyjson v0.9.0/go.mod h1:1+xMtQp2MRNVL/V1bOzuP3aP8VNwRW55fQUto+XFtTU=
-github.com/mark3labs/mcp-go v0.26.0 h1:xz/Kv1cHLYovF8txv6btBM39/88q3YOjnxqhi51jB0w=
-github.com/mark3labs/mcp-go v0.26.0/go.mod h1:rXqOudj/djTORU/ThxYx8fqEVj/5pvTuuebQ2RC7uk4=
+github.com/mark3labs/mcp-go v0.41.1 h1:w78eWfiQam2i8ICL7AL0WFiq7KHNJQ6UB53ZVtH4KGA=
+github.com/mark3labs/mcp-go v0.41.1/go.mod h1:T7tUa2jO6MavG+3P25Oy/jR7iCeJPHImCZHRymCn39g=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-sqlite3 v1.14.15/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
@@ -353,8 +362,6 @@ github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdh
 github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/nwaples/rardecode/v2 v2.1.0 h1:JQl9ZoBPDy+nIZGb1mx8+anfHp/LV3NE2MjMiv0ct/U=
 github.com/nwaples/rardecode/v2 v2.1.0/go.mod h1:7uz379lSxPe6j9nvzxUZ+n7mnJNgjsRNb6IbvGVHRmw=
-github.com/orcaman/concurrent-map/v2 v2.0.1 h1:jOJ5Pg2w1oeB6PeDurIYf6k9PQ+aTITr/6lP/L/zp6c=
-github.com/orcaman/concurrent-map/v2 v2.0.1/go.mod h1:9Eq3TG2oBe5FirmYWQfYO5iH1q0Jv47PLaNK++uCdOM=
 github.com/otiai10/copy v1.14.1 h1:5/7E6qsUMBaH5AnQ0sSLzzTg1oTECmcCmT6lvF45Na8=
 github.com/otiai10/copy v1.14.1/go.mod h1:oQwrEDDOci3IM8dJF0d8+jnbfPDllW6vUjNc3DoZm9I=
 github.com/otiai10/mint v1.6.3 h1:87qsV/aw1F5as1eH1zS/yqHY85ANKVMgkDrf9rcxbQs=
@@ -412,6 +419,8 @@ github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFt
 github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ=
 github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU=
 github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k=
+github.com/sijms/go-ora/v2 v2.7.17 h1:M/pYIqjaMUeBxyzOWp2oj4ntF6fHSBloJWGNH9vbmsU=
+github.com/sijms/go-ora/v2 v2.7.17/go.mod h1:EHxlY6x7y9HAsdfumurRfTd+v8NrEOTR3Xl4FWlH6xk=
 github.com/songzhibin97/gkit v1.2.13 h1:paY0XJkdRuy9/8k9nTnbdrzo8pC22jIIFldUkOQv5nU=
 github.com/songzhibin97/gkit v1.2.13/go.mod h1:38CreNR27eTGaG1UMGihrXqI4xc3nGfYxLVKKVx6Ngg=
 github.com/sorairolake/lzip-go v0.3.5 h1:ms5Xri9o1JBIWvOFAorYtUNik6HI3HgBTkISiqu0Cwg=
@@ -455,12 +464,8 @@ github.com/tencentyun/cos-go-sdk-v5 v0.7.60 h1:/e/tmvRmfKexr/QQIBzWhOkZWsmY3EK72
 github.com/tencentyun/cos-go-sdk-v5 v0.7.60/go.mod h1:8+hG+mQMuRP/OIS9d83syAvXvrMj9HhkND6Q1fLghw0=
 github.com/therootcompany/xz v1.0.1 h1:CmOtsn1CbtmyYiusbfmhmkpAAETj0wBIH6kCYaX+xzw=
 github.com/therootcompany/xz v1.0.1/go.mod h1:3K3UH1yCKgBneZYhuQUvJ9HPD19UEXEI0BWbMn8qNMY=
-github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
-github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
-github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
-github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
-github.com/tidwall/pretty v1.2.0 h1:RWIZEg2iJ8/g6fDDYzMpobmaoGh5OLl4AXtGUGPcqCs=
-github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/thoas/go-funk v0.7.0 h1:GmirKrs6j6zJbhJIficOsz2aAI7700KsU/5YrdHRM1Y=
+github.com/thoas/go-funk v0.7.0/go.mod h1:+IWnUfUmFO1+WVYQWQtIJHeRRdaIyyYglZN7xzUPe4Q=
 github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU=
 github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY=
 github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo=
@@ -474,6 +479,8 @@ github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
 github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/unrolled/secure v1.17.0 h1:Io7ifFgo99Bnh0J7+Q+qcMzWM6kaDPCA5FroFZEdbWU=
 github.com/unrolled/secure v1.17.0/go.mod h1:BmF5hyM6tXczk3MpQkFf1hpKSRqCyhqcbiQtiAF7+40=
+github.com/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc=
+github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw=
 github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
 github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
 github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
@@ -791,6 +798,7 @@ gorm.io/driver/sqlserver v1.5.4 h1:xA+Y1KDNspv79q43bPyjDMUgHoYHLhXYmdFcYPobg8g=
 gorm.io/driver/sqlserver v1.5.4/go.mod h1:+frZ/qYmuna11zHPlh5oc2O6ZA/lS88Keb0XSH1Zh/g=
 gorm.io/gen v0.3.26 h1:sFf1j7vNStimPRRAtH4zz5NiHM+1dr6eA9aaRdplyhY=
 gorm.io/gen v0.3.26/go.mod h1:a5lq5y3w4g5LMxBcw0wnO6tYUCdNutWODq5LrIt75LE=
+gorm.io/gorm v1.24.0/go.mod h1:DVrVomtaYTbqs7gB/x2uVvqnXzv0nqjB396B8cG4dBA=
 gorm.io/gorm v1.24.7-0.20230306060331-85eaf9eeda11/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
 gorm.io/gorm v1.25.0/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
 gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=

server/initialize/ensure_tables.go

@@ -53,7 +53,7 @@ func (e *ensureTables) MigrateTable(ctx context.Context) (context.Context, error
 		sysModel.Condition{},
 		sysModel.JoinTemplate{},
 		sysModel.SysParams{},
-
+		sysModel.SysVersion{},
 		adapter.CasbinRule{},
 
 		example.ExaFile{},

server/initialize/gorm.go

@@ -35,6 +35,11 @@ func Gorm() *gorm.DB {
 }
 
 func RegisterTables() {
+	if global.GVA_CONFIG.System.DisableAutoMigrate {
+		global.GVA_LOG.Info("auto-migrate is disabled, skipping table registration")
+		return
+	}
+
 	db := global.GVA_DB
 	err := db.AutoMigrate(
 
@@ -56,6 +61,8 @@ func RegisterTables() {
 		system.Condition{},
 		system.JoinTemplate{},
 		system.SysParams{},
+		system.SysVersion{},
+		system.SysError{},
 
 		example.ExaFile{},
 		example.ExaCustomer{},

server/initialize/gorm_mssql.go

@@ -28,7 +28,9 @@ func GormMssql() *gorm.DB {
 		DSN:               m.Dsn(), // DSN data source name
 		DefaultStringSize: 191,     // string 类型字段的默认长度
 	}
-	if db, err := gorm.Open(sqlserver.New(mssqlConfig), internal.Gorm.Config(m.Prefix, m.Singular)); err != nil {
+	// 数据库配置
+	general := m.GeneralDB
+	if db, err := gorm.Open(sqlserver.New(mssqlConfig), internal.Gorm.Config(general)); err != nil {
 		return nil
 	} else {
 		db.InstanceSet("gorm:table_options", "ENGINE="+m.Engine)
@@ -48,7 +50,9 @@ func GormMssqlByConfig(m config.Mssql) *gorm.DB {
 		DSN:               m.Dsn(), // DSN data source name
 		DefaultStringSize: 191,     // string 类型字段的默认长度
 	}
-	if db, err := gorm.Open(sqlserver.New(mssqlConfig), internal.Gorm.Config(m.Prefix, m.Singular)); err != nil {
+	// 数据库配置
+	general := m.GeneralDB
+	if db, err := gorm.Open(sqlserver.New(mssqlConfig), internal.Gorm.Config(general)); err != nil {
 		panic(err)
 	} else {
 		db.InstanceSet("gorm:table_options", "ENGINE=InnoDB")

server/initialize/gorm_mysql.go

@@ -34,8 +34,9 @@ func initMysqlDatabase(m config.Mysql) *gorm.DB {
 		DefaultStringSize:         191,     // string 类型字段的默认长度
 		SkipInitializeWithVersion: false,   // 根据版本自动配置
 	}
-
-	if db, err := gorm.Open(mysql.New(mysqlConfig), internal.Gorm.Config(m.Prefix, m.Singular)); err != nil {
+	// 数据库配置
+	general := m.GeneralDB
+	if db, err := gorm.Open(mysql.New(mysqlConfig), internal.Gorm.Config(general)); err != nil {
 		panic(err)
 	} else {
 		db.InstanceSet("gorm:table_options", "ENGINE="+m.Engine)

server/initialize/gorm_oracle.go

@@ -1,18 +1,14 @@
 package initialize
 
 import (
-	//"github.com/dzwvip/oracle"
+	oracle "github.com/dzwvip/gorm-oracle"
 	"github.com/flipped-aurora/gin-vue-admin/server/config"
 	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	"github.com/flipped-aurora/gin-vue-admin/server/initialize/internal"
-
-	//_ "github.com/godror/godror"
-	"gorm.io/driver/mysql"
 	"gorm.io/gorm"
 )
 
 // GormOracle 初始化oracle数据库
-// 如果需要Oracle库 放开import里的注释 把下方 mysql.Config 改为 oracle.Config ;  mysql.New 改为 oracle.New
 func GormOracle() *gorm.DB {
 	m := global.GVA_CONFIG.Oracle
 	return initOracleDatabase(m)
@@ -28,13 +24,9 @@ func initOracleDatabase(m config.Oracle) *gorm.DB {
 	if m.Dbname == "" {
 		return nil
 	}
-
-	oracleConfig := mysql.Config{
-		DSN:               m.Dsn(), // DSN data source name
-		DefaultStringSize: 191,     // string 类型字段的默认长度
-	}
-
-	if db, err := gorm.Open(mysql.New(oracleConfig), internal.Gorm.Config(m.Prefix, m.Singular)); err != nil {
+	// 数据库配置
+	general := m.GeneralDB
+	if db, err := gorm.Open(oracle.Open(m.Dsn()), internal.Gorm.Config(general)); err != nil {
 		panic(err)
 	} else {
 		sqlDB, _ := db.DB()

server/initialize/gorm_pgsql.go

@@ -30,7 +30,9 @@ func initPgSqlDatabase(p config.Pgsql) *gorm.DB {
 		DSN:                  p.Dsn(), // DSN data source name
 		PreferSimpleProtocol: false,
 	}
-	if db, err := gorm.Open(postgres.New(pgsqlConfig), internal.Gorm.Config(p.Prefix, p.Singular)); err != nil {
+	// 数据库配置
+	general := p.GeneralDB
+	if db, err := gorm.Open(postgres.New(pgsqlConfig), internal.Gorm.Config(general)); err != nil {
 		panic(err)
 	} else {
 		sqlDB, _ := db.DB()

server/initialize/gorm_sqlite.go

@@ -25,7 +25,9 @@ func initSqliteDatabase(s config.Sqlite) *gorm.DB {
 		return nil
 	}
 
-	if db, err := gorm.Open(sqlite.Open(s.Dsn()), internal.Gorm.Config(s.Prefix, s.Singular)); err != nil {
+	// 数据库配置
+	general := s.GeneralDB
+	if db, err := gorm.Open(sqlite.Open(s.Dsn()), internal.Gorm.Config(general)); err != nil {
 		panic(err)
 	} else {
 		sqlDB, _ := db.DB()

server/initialize/internal/gorm.go

@@ -1,12 +1,12 @@
 package internal
 
 import (
+	"time"
+
 	"github.com/flipped-aurora/gin-vue-admin/server/config"
-	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 	"gorm.io/gorm/schema"
-	"time"
 )
 
 var Gorm = new(_gorm)
@@ -15,22 +15,7 @@ type _gorm struct{}
 
 // Config gorm 自定义配置
 // Author [SliverHorn](https://github.com/SliverHorn)
-func (g *_gorm) Config(prefix string, singular bool) *gorm.Config {
-	var general config.GeneralDB
-	switch global.GVA_CONFIG.System.DbType {
-	case "mysql":
-		general = global.GVA_CONFIG.Mysql.GeneralDB
-	case "pgsql":
-		general = global.GVA_CONFIG.Pgsql.GeneralDB
-	case "oracle":
-		general = global.GVA_CONFIG.Oracle.GeneralDB
-	case "sqlite":
-		general = global.GVA_CONFIG.Sqlite.GeneralDB
-	case "mssql":
-		general = global.GVA_CONFIG.Mssql.GeneralDB
-	default:
-		general = global.GVA_CONFIG.Mysql.GeneralDB
-	}
+func (g *_gorm) Config(general config.GeneralDB) *gorm.Config {
 	return &gorm.Config{
 		Logger: logger.New(NewWriter(general), logger.Config{
 			SlowThreshold: 200 * time.Millisecond,
@@ -38,8 +23,8 @@ func (g *_gorm) Config(prefix string, singular bool) *gorm.Config {
 			Colorful:      true,
 		}),
 		NamingStrategy: schema.NamingStrategy{
-			TablePrefix:   prefix,
-			SingularTable: singular,
+			TablePrefix:   general.Prefix,
+			SingularTable: general.Singular,
 		},
 		DisableForeignKeyConstraintWhenMigrating: true,
 	}

server/initialize/plugin_biz_v1.go

@@ -2,6 +2,7 @@ package initialize
 
 import (
 	"fmt"
+
 	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	"github.com/flipped-aurora/gin-vue-admin/server/plugin/email"
 	"github.com/flipped-aurora/gin-vue-admin/server/utils/plugin"
@@ -29,6 +30,7 @@ func bizPluginV1(group ...*gin.RouterGroup) {
 		global.GVA_CONFIG.Email.Nickname,
 		global.GVA_CONFIG.Email.Port,
 		global.GVA_CONFIG.Email.IsSSL,
+		global.GVA_CONFIG.Email.IsLoginAuth,
 	))
 	holder(public, private)
 }

server/initialize/router.go

@@ -40,16 +40,19 @@ func Routers() *gin.Engine {
 		Router.Use(gin.Logger())
 	}
 
-	sseServer := McpRun()
+	if !global.GVA_CONFIG.MCP.Separate {
 
-	// 注册mcp服务
-	Router.GET(global.GVA_CONFIG.MCP.SSEPath, func(c *gin.Context) {
-		sseServer.SSEHandler().ServeHTTP(c.Writer, c.Request)
-	})
+		sseServer := McpRun()
 
-	Router.POST(global.GVA_CONFIG.MCP.MessagePath, func(c *gin.Context) {
-		sseServer.MessageHandler().ServeHTTP(c.Writer, c.Request)
-	})
+		// 注册mcp服务
+		Router.GET(global.GVA_CONFIG.MCP.SSEPath, func(c *gin.Context) {
+			sseServer.SSEHandler().ServeHTTP(c.Writer, c.Request)
+		})
+
+		Router.POST(global.GVA_CONFIG.MCP.MessagePath, func(c *gin.Context) {
+			sseServer.MessageHandler().ServeHTTP(c.Writer, c.Request)
+		})
+	}
 
 	systemRouter := router.RouterGroupApp.System
 	exampleRouter := router.RouterGroupApp.Example
@@ -93,6 +96,7 @@ func Routers() *gin.Engine {
 		systemRouter.InitUserRouter(PrivateGroup)                           // 注册用户路由
 		systemRouter.InitMenuRouter(PrivateGroup)                           // 注册menu路由
 		systemRouter.InitSystemRouter(PrivateGroup)                         // system相关路由
+		systemRouter.InitSysVersionRouter(PrivateGroup)                     // 发版相关路由
 		systemRouter.InitCasbinRouter(PrivateGroup)                         // 权限相关路由
 		systemRouter.InitAutoCodeRouter(PrivateGroup, PublicGroup)          // 创建自动化代码
 		systemRouter.InitAuthorityRouter(PrivateGroup)                      // 注册角色路由
@@ -103,6 +107,7 @@ func Routers() *gin.Engine {
 		systemRouter.InitAuthorityBtnRouterRouter(PrivateGroup)             // 按钮权限管理
 		systemRouter.InitSysExportTemplateRouter(PrivateGroup, PublicGroup) // 导出模板
 		systemRouter.InitSysParamsRouter(PrivateGroup, PublicGroup)         // 参数管理
+		systemRouter.InitSysErrorRouter(PrivateGroup, PublicGroup)          // 错误日志
 		exampleRouter.InitCustomerRouter(PrivateGroup)                      // 客户路由
 		exampleRouter.InitFileUploadAndDownloadRouter(PrivateGroup)         // 文件上传下载功能路由
 		exampleRouter.InitAttachmentCategoryRouterRouter(PrivateGroup)      // 文件上传下载分类

server/main.go

@@ -21,7 +21,7 @@ import (
 // @Tag.Description 用户
 
 // @title                       Gin-Vue-Admin Swagger API接口文档
-// @version                     v2.8.2
+// @version                     v2.8.6
 // @description                 使用gin+vue进行极速开发的全栈开发基础平台
 // @securityDefinitions.apikey  ApiKeyAuth
 // @in                          header

server/mcp/api_creator.go

@@ -0,0 +1,191 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"github.com/flipped-aurora/gin-vue-admin/server/service"
+	"github.com/mark3labs/mcp-go/mcp"
+	"go.uber.org/zap"
+)
+
+// 注册工具
+func init() {
+	RegisterTool(&ApiCreator{})
+}
+
+// ApiCreateRequest API创建请求结构
+type ApiCreateRequest struct {
+	Path        string `json:"path"`        // API路径
+	Description string `json:"description"` // API中文描述
+	ApiGroup    string `json:"apiGroup"`    // API组
+	Method      string `json:"method"`      // HTTP方法
+}
+
+// ApiCreateResponse API创建响应结构
+type ApiCreateResponse struct {
+	Success bool   `json:"success"`
+	Message string `json:"message"`
+	ApiID   uint   `json:"apiId"`
+	Path    string `json:"path"`
+	Method  string `json:"method"`
+}
+
+// ApiCreator API创建工具
+type ApiCreator struct{}
+
+// New 创建API创建工具
+func (a *ApiCreator) New() mcp.Tool {
+	return mcp.NewTool("create_api",
+		mcp.WithDescription(`创建后端API记录，用于AI编辑器自动添加API接口时自动创建对应的API权限记录。
+
+**重要限制：**
+- 当使用gva_auto_generate工具且needCreatedModules=true时，模块创建会自动生成API权限，不应调用此工具
+- 仅在以下情况使用：1) 单独创建API（不涉及模块创建）；2) AI编辑器自动添加API；3) router下的文件产生路径变化时`),
+		mcp.WithString("path",
+			mcp.Required(),
+			mcp.Description("API路径，如：/user/create"),
+		),
+		mcp.WithString("description",
+			mcp.Required(),
+			mcp.Description("API中文描述，如：创建用户"),
+		),
+		mcp.WithString("apiGroup",
+			mcp.Required(),
+			mcp.Description("API组名称，用于分类管理，如：用户管理"),
+		),
+		mcp.WithString("method",
+			mcp.Description("HTTP方法"),
+			mcp.DefaultString("POST"),
+		),
+		mcp.WithString("apis",
+			mcp.Description("批量创建API的JSON字符串，格式：[{\"path\":\"/user/create\",\"description\":\"创建用户\",\"apiGroup\":\"用户管理\",\"method\":\"POST\"}]"),
+		),
+	)
+}
+
+// Handle 处理API创建请求
+func (a *ApiCreator) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	args := request.GetArguments()
+
+	var apis []ApiCreateRequest
+
+	// 检查是否是批量创建
+	if apisStr, ok := args["apis"].(string); ok && apisStr != "" {
+		if err := json.Unmarshal([]byte(apisStr), &apis); err != nil {
+			return nil, fmt.Errorf("apis 参数格式错误: %v", err)
+		}
+	} else {
+		// 单个API创建
+		path, ok := args["path"].(string)
+		if !ok || path == "" {
+			return nil, errors.New("path 参数是必需的")
+		}
+
+		description, ok := args["description"].(string)
+		if !ok || description == "" {
+			return nil, errors.New("description 参数是必需的")
+		}
+
+		apiGroup, ok := args["apiGroup"].(string)
+		if !ok || apiGroup == "" {
+			return nil, errors.New("apiGroup 参数是必需的")
+		}
+
+		method := "POST"
+		if val, ok := args["method"].(string); ok && val != "" {
+			method = val
+		}
+
+		apis = append(apis, ApiCreateRequest{
+			Path:        path,
+			Description: description,
+			ApiGroup:    apiGroup,
+			Method:      method,
+		})
+	}
+
+	if len(apis) == 0 {
+		return nil, errors.New("没有要创建的API")
+	}
+
+	// 创建API记录
+	apiService := service.ServiceGroupApp.SystemServiceGroup.ApiService
+	var responses []ApiCreateResponse
+	successCount := 0
+
+	for _, apiReq := range apis {
+		api := system.SysApi{
+			Path:        apiReq.Path,
+			Description: apiReq.Description,
+			ApiGroup:    apiReq.ApiGroup,
+			Method:      apiReq.Method,
+		}
+
+		err := apiService.CreateApi(api)
+		if err != nil {
+			global.GVA_LOG.Warn("创建API失败",
+				zap.String("path", apiReq.Path),
+				zap.String("method", apiReq.Method),
+				zap.Error(err))
+
+			responses = append(responses, ApiCreateResponse{
+				Success: false,
+				Message: fmt.Sprintf("创建API失败: %v", err),
+				Path:    apiReq.Path,
+				Method:  apiReq.Method,
+			})
+		} else {
+			// 获取创建的API ID
+			var createdApi system.SysApi
+			err = global.GVA_DB.Where("path = ? AND method = ?", apiReq.Path, apiReq.Method).First(&createdApi).Error
+			if err != nil {
+				global.GVA_LOG.Warn("获取创建的API ID失败", zap.Error(err))
+			}
+
+			responses = append(responses, ApiCreateResponse{
+				Success: true,
+				Message: fmt.Sprintf("成功创建API %s %s", apiReq.Method, apiReq.Path),
+				ApiID:   createdApi.ID,
+				Path:    apiReq.Path,
+				Method:  apiReq.Method,
+			})
+			successCount++
+		}
+	}
+
+	// 构建总体响应
+	var resultMessage string
+	if len(apis) == 1 {
+		resultMessage = responses[0].Message
+	} else {
+		resultMessage = fmt.Sprintf("批量创建API完成，成功 %d 个，失败 %d 个", successCount, len(apis)-successCount)
+	}
+
+	result := map[string]interface{}{
+		"success":      successCount > 0,
+		"message":      resultMessage,
+		"totalCount":   len(apis),
+		"successCount": successCount,
+		"failedCount":  len(apis) - successCount,
+		"details":      responses,
+	}
+
+	resultJSON, err := json.MarshalIndent(result, "", "  ")
+	if err != nil {
+		return nil, fmt.Errorf("序列化结果失败: %v", err)
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.TextContent{
+				Type: "text",
+				Text: fmt.Sprintf("API创建结果：\n\n%s", string(resultJSON)),
+			},
+		},
+	}, nil
+}

server/mcp/api_lister.go

@@ -0,0 +1,168 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"github.com/mark3labs/mcp-go/mcp"
+	"go.uber.org/zap"
+)
+
+// 注册工具
+func init() {
+	// 注册工具将在enter.go中统一处理
+	RegisterTool(&ApiLister{})
+}
+
+// ApiInfo API信息结构
+type ApiInfo struct {
+	ID          uint   `json:"id,omitempty"`          // 数据库ID（仅数据库API有）
+	Path        string `json:"path"`                  // API路径
+	Description string `json:"description,omitempty"` // API描述
+	ApiGroup    string `json:"apiGroup,omitempty"`    // API组
+	Method      string `json:"method"`                // HTTP方法
+	Source      string `json:"source"`                // 来源：database 或 gin
+}
+
+// ApiListResponse API列表响应结构
+type ApiListResponse struct {
+	Success      bool      `json:"success"`
+	Message      string    `json:"message"`
+	DatabaseApis []ApiInfo `json:"databaseApis"` // 数据库中的API
+	GinApis      []ApiInfo `json:"ginApis"`      // gin框架中的API
+	TotalCount   int       `json:"totalCount"`   // 总数量
+}
+
+// ApiLister API列表工具
+type ApiLister struct{}
+
+// New 创建API列表工具
+func (a *ApiLister) New() mcp.Tool {
+	return mcp.NewTool("list_all_apis",
+		mcp.WithDescription(`获取系统中所有的API接口，分为两组：
+
+**功能说明：**
+- 返回数据库中已注册的API列表
+- 返回gin框架中实际注册的路由API列表
+- 帮助前端判断是使用现有API还是需要创建新的API,如果api在前端未使用且需要前端调用的时候，请到api文件夹下对应模块的js中添加方法并暴露给当前业务调用
+
+**返回数据结构：**
+- databaseApis: 数据库中的API记录（包含ID、描述、分组等完整信息）
+- ginApis: gin路由中的API（仅包含路径和方法），需要AI根据路径自行揣摩路径的业务含义，例如：/api/user/:id 表示根据用户ID获取用户信息`),
+		mcp.WithString("_placeholder",
+			mcp.Description("占位符，防止json schema校验失败"),
+		),	
+	)
+}
+
+// Handle 处理API列表请求
+func (a *ApiLister) Handle(_ context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+
+	// 获取数据库中的API
+	databaseApis, err := a.getDatabaseApis()
+	if err != nil {
+		global.GVA_LOG.Error("获取数据库API失败", zap.Error(err))
+		errorResponse := ApiListResponse{
+			Success: false,
+			Message: "获取数据库API失败: " + err.Error(),
+		}
+		resultJSON, _ := json.Marshal(errorResponse)
+		return &mcp.CallToolResult{
+			Content: []mcp.Content{
+				mcp.TextContent{
+					Type: "text",
+					Text: string(resultJSON),
+				},
+			},
+		}, nil
+	}
+
+	// 获取gin路由中的API
+	ginApis, err := a.getGinApis()
+	if err != nil {
+		global.GVA_LOG.Error("获取gin路由API失败", zap.Error(err))
+		errorResponse := ApiListResponse{
+			Success: false,
+			Message: "获取gin路由API失败: " + err.Error(),
+		}
+		resultJSON, _ := json.Marshal(errorResponse)
+		return &mcp.CallToolResult{
+			Content: []mcp.Content{
+				mcp.TextContent{
+					Type: "text",
+					Text: string(resultJSON),
+				},
+			},
+		}, nil
+	}
+
+	// 构建响应
+	response := ApiListResponse{
+		Success:      true,
+		Message:      "获取API列表成功",
+		DatabaseApis: databaseApis,
+		GinApis:      ginApis,
+		TotalCount:   len(databaseApis) + len(ginApis),
+	}
+
+	global.GVA_LOG.Info("API列表获取成功",
+		zap.Int("数据库API数量", len(databaseApis)),
+		zap.Int("gin路由API数量", len(ginApis)),
+		zap.Int("总数量", response.TotalCount))
+
+	resultJSON, err := json.Marshal(response)
+	if err != nil {
+		return nil, fmt.Errorf("序列化结果失败: %v", err)
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.TextContent{
+				Type: "text",
+				Text: string(resultJSON),
+			},
+		},
+	}, nil
+}
+
+// getDatabaseApis 获取数据库中的所有API
+func (a *ApiLister) getDatabaseApis() ([]ApiInfo, error) {
+	var apis []system.SysApi
+	err := global.GVA_DB.Model(&system.SysApi{}).Order("api_group ASC, path ASC").Find(&apis).Error
+	if err != nil {
+		return nil, err
+	}
+
+	// 转换为ApiInfo格式
+	var result []ApiInfo
+	for _, api := range apis {
+		result = append(result, ApiInfo{
+			ID:          api.ID,
+			Path:        api.Path,
+			Description: api.Description,
+			ApiGroup:    api.ApiGroup,
+			Method:      api.Method,
+			Source:      "database",
+		})
+	}
+
+	return result, nil
+}
+
+// getGinApis 获取gin路由中的所有API（包含被忽略的API）
+func (a *ApiLister) getGinApis() ([]ApiInfo, error) {
+	// 从gin路由信息中获取所有API
+	var result []ApiInfo
+	for _, route := range global.GVA_ROUTERS {
+		result = append(result, ApiInfo{
+			Path:   route.Path,
+			Method: route.Method,
+			Source: "gin",
+		})
+	}
+
+	return result, nil
+}

server/mcp/current_time.go

@@ -1,81 +0,0 @@
-package mcpTool
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"github.com/mark3labs/mcp-go/mcp"
-	"time"
-)
-
-func init() {
-	RegisterTool(&CurrentTime{})
-}
-
-type CurrentTime struct {
-}
-
-// 获取当前系统时间
-func (t *CurrentTime) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	// 获取当前系统时间
-
-	timezone, ok := request.Params.Arguments["timezone"].(string)
-
-	if !ok {
-		return nil, errors.New("参数错误：timezone 必须是字符串类型")
-	}
-	// 根据timezone参数加载对应时区
-	loc, err := loadTimeZone(timezone)
-	if err != nil {
-		return nil, err
-	}
-
-	// 获取当前时间并转换为指定时区
-	currentTime := time.Now().In(loc).Format("2006-01-02 15:04:05")
-	//返回
-	return &mcp.CallToolResult{
-		Content: []mcp.Content{
-			mcp.TextContent{
-				Type: "text",
-				Text: fmt.Sprintf("%s 时区的当前时间是：%s", timezone, currentTime),
-			},
-		},
-	}, nil
-}
-
-func (t *CurrentTime) New() mcp.Tool {
-	return mcp.NewTool("currentTime",
-		mcp.WithDescription("获取当前系统时间"),
-		mcp.WithString("timezone",
-			mcp.Required(),
-			mcp.Description("时区"),
-			mcp.Enum("UTC", "CST", "PST", "EST", "GMT", "CET", "JST", "MST", "IST", "AST", "HST"),
-		))
-}
-
-// 将简写时区转换为IANA标准时区
-func loadTimeZone(timezone string) (*time.Location, error) {
-	// 时区映射表
-	timezoneMap := map[string]string{
-		"UTC": "UTC",
-		"CST": "Asia/Shanghai", // 中国标准时间
-		"PST": "America/Los_Angeles",
-		"EST": "America/New_York",
-		"GMT": "GMT",
-		"CET": "Europe/Paris",
-		"JST": "Asia/Tokyo",
-		"MST": "America/Denver",
-		"IST": "Asia/Kolkata",
-		"AST": "Asia/Riyadh", // 阿拉伯标准时间
-		"HST": "Pacific/Honolulu",
-	}
-
-	// 获取标准时区名称
-	tzName, exists := timezoneMap[timezone]
-	if !exists {
-		return nil, errors.New("不支持的时区: " + timezone)
-	}
-
-	// 加载时区
-	return time.LoadLocation(tzName)
-}

server/mcp/dictionary_generator.go

@@ -0,0 +1,316 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"github.com/flipped-aurora/gin-vue-admin/server/service"
+	"github.com/mark3labs/mcp-go/mcp"
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+)
+
+func init() {
+	RegisterTool(&DictionaryOptionsGenerator{})
+}
+
+// DictionaryOptionsGenerator 字典选项生成器
+type DictionaryOptionsGenerator struct{}
+
+// DictionaryOption 字典选项结构
+type DictionaryOption struct {
+	Label string `json:"label"`
+	Value string `json:"value"`
+	Sort  int    `json:"sort"`
+}
+
+// DictionaryGenerateRequest 字典生成请求
+type DictionaryGenerateRequest struct {
+	DictType    string             `json:"dictType"`    // 字典类型
+	FieldDesc   string             `json:"fieldDesc"`   // 字段描述
+	Options     []DictionaryOption `json:"options"`     // AI生成的字典选项
+	DictName    string             `json:"dictName"`    // 字典名称（可选）
+	Description string             `json:"description"` // 字典描述（可选）
+}
+
+// DictionaryGenerateResponse 字典生成响应
+type DictionaryGenerateResponse struct {
+	Success      bool   `json:"success"`
+	Message      string `json:"message"`
+	DictType     string `json:"dictType"`
+	OptionsCount int    `json:"optionsCount"`
+}
+
+// New 返回工具注册信息
+func (d *DictionaryOptionsGenerator) New() mcp.Tool {
+	return mcp.NewTool("generate_dictionary_options",
+		mcp.WithDescription("智能生成字典选项并自动创建字典和字典详情"),
+		mcp.WithString("dictType",
+			mcp.Required(),
+			mcp.Description("字典类型，用于标识字典的唯一性"),
+		),
+		mcp.WithString("fieldDesc",
+			mcp.Required(),
+			mcp.Description("字段描述，用于AI理解字段含义"),
+		),
+		mcp.WithString("options",
+			mcp.Required(),
+			mcp.Description("字典选项JSON字符串，格式：[{\"label\":\"显示名\",\"value\":\"值\",\"sort\":1}]"),
+		),
+		mcp.WithString("dictName",
+			mcp.Description("字典名称，如果不提供将自动生成"),
+		),
+		mcp.WithString("description",
+			mcp.Description("字典描述"),
+		),
+	)
+}
+
+// Name 返回工具名称
+func (d *DictionaryOptionsGenerator) Name() string {
+	return "generate_dictionary_options"
+}
+
+// Description 返回工具描述
+func (d *DictionaryOptionsGenerator) Description() string {
+	return `字典选项生成工具 - 让AI生成并创建字典选项
+
+此工具允许AI根据字典类型和字段描述生成合适的字典选项，并自动创建字典和字典详情。
+
+参数说明：
+- dictType: 字典类型（必填）
+- fieldDesc: 字段描述（必填）
+- options: AI生成的字典选项数组（必填）
+  - label: 选项标签
+  - value: 选项值
+  - sort: 排序号
+- dictName: 字典名称（可选，默认根据fieldDesc生成）
+- description: 字典描述（可选）
+
+使用场景：
+1. 在创建模块时，如果字段需要字典类型，AI可以根据字段描述智能生成合适的选项
+2. 支持各种业务场景的字典选项生成，如状态、类型、等级等
+3. 自动创建字典和字典详情，无需手动配置
+
+示例调用：
+{
+  "dictType": "user_status",
+  "fieldDesc": "用户状态",
+  "options": [
+    {"label": "正常", "value": "1", "sort": 1},
+    {"label": "禁用", "value": "0", "sort": 2}
+  ],
+  "dictName": "用户状态字典",
+  "description": "用于管理用户账户状态的字典"
+}`
+}
+
+// InputSchema 返回输入参数的JSON Schema
+func (d *DictionaryOptionsGenerator) InputSchema() map[string]interface{} {
+	return map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"dictType": map[string]interface{}{
+				"type":        "string",
+				"description": "字典类型，用于标识字典的唯一性",
+			},
+			"fieldDesc": map[string]interface{}{
+				"type":        "string",
+				"description": "字段描述，用于生成字典名称和理解字典用途",
+			},
+			"options": map[string]interface{}{
+				"type":        "array",
+				"description": "AI生成的字典选项数组",
+				"items": map[string]interface{}{
+					"type": "object",
+					"properties": map[string]interface{}{
+						"label": map[string]interface{}{
+							"type":        "string",
+							"description": "选项标签，显示给用户的文本",
+						},
+						"value": map[string]interface{}{
+							"type":        "string",
+							"description": "选项值，存储在数据库中的值",
+						},
+						"sort": map[string]interface{}{
+							"type":        "integer",
+							"description": "排序号，用于控制选项显示顺序",
+						},
+					},
+					"required": []string{"label", "value", "sort"},
+				},
+			},
+			"dictName": map[string]interface{}{
+				"type":        "string",
+				"description": "字典名称，必填，默认根据fieldDesc生成",
+			},
+			"description": map[string]interface{}{
+				"type":        "string",
+				"description": "字典描述，必填",
+			},
+		},
+		"required": []string{"dictType", "fieldDesc", "options"},
+	}
+}
+
+// Handle 处理工具调用
+func (d *DictionaryOptionsGenerator) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	// 解析请求参数
+	args := request.GetArguments()
+
+	dictType, ok := args["dictType"].(string)
+	if !ok || dictType == "" {
+		return nil, errors.New("dictType 参数是必需的")
+	}
+
+	fieldDesc, ok := args["fieldDesc"].(string)
+	if !ok || fieldDesc == "" {
+		return nil, errors.New("fieldDesc 参数是必需的")
+	}
+
+	optionsStr, ok := args["options"].(string)
+	if !ok || optionsStr == "" {
+		return nil, errors.New("options 参数是必需的")
+	}
+
+	// 解析options JSON字符串
+	var options []DictionaryOption
+	if err := json.Unmarshal([]byte(optionsStr), &options); err != nil {
+		return nil, fmt.Errorf("options 参数格式错误: %v", err)
+	}
+
+	if len(options) == 0 {
+		return nil, errors.New("options 不能为空")
+	}
+
+	dictName, _ := args["dictName"].(string)
+	description, _ := args["description"].(string)
+
+	// 构建请求对象
+	req := &DictionaryGenerateRequest{
+		DictType:    dictType,
+		FieldDesc:   fieldDesc,
+		Options:     options,
+		DictName:    dictName,
+		Description: description,
+	}
+
+	// 创建字典
+	response, err := d.createDictionaryWithOptions(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	// 构建响应
+	resultJSON, err := json.MarshalIndent(response, "", "  ")
+	if err != nil {
+		return nil, fmt.Errorf("序列化结果失败: %v", err)
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.TextContent{
+				Type: "text",
+				Text: fmt.Sprintf("字典选项生成结果：\n\n%s", string(resultJSON)),
+			},
+		},
+	}, nil
+}
+
+// createDictionaryWithOptions 创建字典和字典选项
+func (d *DictionaryOptionsGenerator) createDictionaryWithOptions(ctx context.Context, req *DictionaryGenerateRequest) (*DictionaryGenerateResponse, error) {
+	// 检查字典是否已存在
+	exists, err := d.checkDictionaryExists(req.DictType)
+	if err != nil {
+		return nil, fmt.Errorf("检查字典是否存在失败: %v", err)
+	}
+
+	if exists {
+		return &DictionaryGenerateResponse{
+			Success:      false,
+			Message:      fmt.Sprintf("字典 %s 已存在，跳过创建", req.DictType),
+			DictType:     req.DictType,
+			OptionsCount: 0,
+		}, nil
+	}
+
+	// 生成字典名称
+	dictName := req.DictName
+	if dictName == "" {
+		dictName = d.generateDictionaryName(req.DictType, req.FieldDesc)
+	}
+
+	// 创建字典
+	dictionaryService := service.ServiceGroupApp.SystemServiceGroup.DictionaryService
+	dictionary := system.SysDictionary{
+		Name:   dictName,
+		Type:   req.DictType,
+		Status: &[]bool{true}[0], // 默认启用
+		Desc:   req.Description,
+	}
+
+	err = dictionaryService.CreateSysDictionary(dictionary)
+	if err != nil {
+		return nil, fmt.Errorf("创建字典失败: %v", err)
+	}
+
+	// 获取刚创建的字典ID
+	var createdDict system.SysDictionary
+	err = global.GVA_DB.Where("type = ?", req.DictType).First(&createdDict).Error
+	if err != nil {
+		return nil, fmt.Errorf("获取创建的字典失败: %v", err)
+	}
+
+	// 创建字典详情项
+	dictionaryDetailService := service.ServiceGroupApp.SystemServiceGroup.DictionaryDetailService
+	successCount := 0
+
+	for _, option := range req.Options {
+		dictionaryDetail := system.SysDictionaryDetail{
+			Label:           option.Label,
+			Value:           option.Value,
+			Status:          &[]bool{true}[0], // 默认启用
+			Sort:            option.Sort,
+			SysDictionaryID: int(createdDict.ID),
+		}
+
+		err = dictionaryDetailService.CreateSysDictionaryDetail(dictionaryDetail)
+		if err != nil {
+			global.GVA_LOG.Warn("创建字典详情项失败", zap.Error(err))
+		} else {
+			successCount++
+		}
+	}
+
+	return &DictionaryGenerateResponse{
+		Success:      true,
+		Message:      fmt.Sprintf("成功创建字典 %s，包含 %d 个选项", req.DictType, successCount),
+		DictType:     req.DictType,
+		OptionsCount: successCount,
+	}, nil
+}
+
+// checkDictionaryExists 检查字典是否存在
+func (d *DictionaryOptionsGenerator) checkDictionaryExists(dictType string) (bool, error) {
+	var dictionary system.SysDictionary
+	err := global.GVA_DB.Where("type = ?", dictType).First(&dictionary).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return false, nil // 字典不存在
+		}
+		return false, err // 其他错误
+	}
+	return true, nil // 字典存在
+}
+
+// generateDictionaryName 生成字典名称
+func (d *DictionaryOptionsGenerator) generateDictionaryName(dictType, fieldDesc string) string {
+	if fieldDesc != "" {
+		return fmt.Sprintf("%s字典", fieldDesc)
+	}
+	return fmt.Sprintf("%s字典", dictType)
+}

server/mcp/dictionary_query.go

@@ -0,0 +1,239 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"github.com/flipped-aurora/gin-vue-admin/server/service"
+	"github.com/mark3labs/mcp-go/mcp"
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+)
+
+// 注册工具
+func init() {
+	RegisterTool(&DictionaryQuery{})
+}
+
+type DictionaryPre struct {
+	Type string `json:"type"` // 字典名（英）
+	Desc string `json:"desc"` // 描述
+}
+
+// DictionaryInfo 字典信息结构
+type DictionaryInfo struct {
+	ID      uint                   `json:"id"`
+	Name    string                 `json:"name"`    // 字典名（中）
+	Type    string                 `json:"type"`    // 字典名（英）
+	Status  *bool                  `json:"status"`  // 状态
+	Desc    string                 `json:"desc"`    // 描述
+	Details []DictionaryDetailInfo `json:"details"` // 字典详情
+}
+
+// DictionaryDetailInfo 字典详情信息结构
+type DictionaryDetailInfo struct {
+	ID     uint   `json:"id"`
+	Label  string `json:"label"`  // 展示值
+	Value  string `json:"value"`  // 字典值
+	Extend string `json:"extend"` // 扩展值
+	Status *bool  `json:"status"` // 启用状态
+	Sort   int    `json:"sort"`   // 排序标记
+}
+
+// DictionaryQueryResponse 字典查询响应结构
+type DictionaryQueryResponse struct {
+	Success      bool             `json:"success"`
+	Message      string           `json:"message"`
+	Total        int              `json:"total"`
+	Dictionaries []DictionaryInfo `json:"dictionaries"`
+}
+
+// DictionaryQuery 字典查询工具
+type DictionaryQuery struct{}
+
+// New 创建字典查询工具
+func (d *DictionaryQuery) New() mcp.Tool {
+	return mcp.NewTool("query_dictionaries",
+		mcp.WithDescription("查询系统中所有的字典和字典属性，用于AI生成逻辑时了解可用的字典选项"),
+		mcp.WithString("dictType",
+			mcp.Description("可选：指定字典类型进行精确查询，如果不提供则返回所有字典"),
+		),
+		mcp.WithBoolean("includeDisabled",
+			mcp.Description("是否包含已禁用的字典和字典项，默认为false（只返回启用的）"),
+		),
+		mcp.WithBoolean("detailsOnly",
+			mcp.Description("是否只返回字典详情信息（不包含字典基本信息），默认为false"),
+		),
+	)
+}
+
+// Handle 处理字典查询请求
+func (d *DictionaryQuery) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	args := request.GetArguments()
+
+	// 获取参数
+	dictType := ""
+	if val, ok := args["dictType"].(string); ok {
+		dictType = val
+	}
+
+	includeDisabled := false
+	if val, ok := args["includeDisabled"].(bool); ok {
+		includeDisabled = val
+	}
+
+	detailsOnly := false
+	if val, ok := args["detailsOnly"].(bool); ok {
+		detailsOnly = val
+	}
+
+	// 获取字典服务
+	dictionaryService := service.ServiceGroupApp.SystemServiceGroup.DictionaryService
+
+	var dictionaries []DictionaryInfo
+	var err error
+
+	if dictType != "" {
+		// 查询指定类型的字典
+		var status *bool
+		if !includeDisabled {
+			status = &[]bool{true}[0]
+		}
+
+		sysDictionary, err := dictionaryService.GetSysDictionary(dictType, 0, status)
+		if err != nil {
+			global.GVA_LOG.Error("查询字典失败", zap.Error(err))
+			return &mcp.CallToolResult{
+				Content: []mcp.Content{
+					mcp.NewTextContent(fmt.Sprintf(`{"success": false, "message": "查询字典失败: %v", "total": 0, "dictionaries": []}`, err.Error())),
+				},
+			}, nil
+		}
+
+		// 转换为响应格式
+		dictInfo := DictionaryInfo{
+			ID:     sysDictionary.ID,
+			Name:   sysDictionary.Name,
+			Type:   sysDictionary.Type,
+			Status: sysDictionary.Status,
+			Desc:   sysDictionary.Desc,
+		}
+
+		// 获取字典详情
+		for _, detail := range sysDictionary.SysDictionaryDetails {
+			if includeDisabled || (detail.Status != nil && *detail.Status) {
+				dictInfo.Details = append(dictInfo.Details, DictionaryDetailInfo{
+					ID:     detail.ID,
+					Label:  detail.Label,
+					Value:  detail.Value,
+					Extend: detail.Extend,
+					Status: detail.Status,
+					Sort:   detail.Sort,
+				})
+			}
+		}
+
+		dictionaries = append(dictionaries, dictInfo)
+	} else {
+		// 查询所有字典
+		var sysDictionaries []system.SysDictionary
+		db := global.GVA_DB.Model(&system.SysDictionary{})
+
+		if !includeDisabled {
+			db = db.Where("status = ?", true)
+		}
+
+		err = db.Preload("SysDictionaryDetails", func(db *gorm.DB) *gorm.DB {
+			if includeDisabled {
+				return db.Order("sort")
+			} else {
+				return db.Where("status = ?", true).Order("sort")
+			}
+		}).Find(&sysDictionaries).Error
+
+		if err != nil {
+			global.GVA_LOG.Error("查询字典列表失败", zap.Error(err))
+			return &mcp.CallToolResult{
+				Content: []mcp.Content{
+					mcp.NewTextContent(fmt.Sprintf(`{"success": false, "message": "查询字典列表失败: %v", "total": 0, "dictionaries": []}`, err.Error())),
+				},
+			}, nil
+		}
+
+		// 转换为响应格式
+		for _, dict := range sysDictionaries {
+			dictInfo := DictionaryInfo{
+				ID:     dict.ID,
+				Name:   dict.Name,
+				Type:   dict.Type,
+				Status: dict.Status,
+				Desc:   dict.Desc,
+			}
+
+			// 获取字典详情
+			for _, detail := range dict.SysDictionaryDetails {
+				if includeDisabled || (detail.Status != nil && *detail.Status) {
+					dictInfo.Details = append(dictInfo.Details, DictionaryDetailInfo{
+						ID:     detail.ID,
+						Label:  detail.Label,
+						Value:  detail.Value,
+						Extend: detail.Extend,
+						Status: detail.Status,
+						Sort:   detail.Sort,
+					})
+				}
+			}
+
+			dictionaries = append(dictionaries, dictInfo)
+		}
+	}
+
+	// 如果只需要详情信息，则提取所有详情
+	if detailsOnly {
+		var allDetails []DictionaryDetailInfo
+		for _, dict := range dictionaries {
+			allDetails = append(allDetails, dict.Details...)
+		}
+
+		response := map[string]interface{}{
+			"success": true,
+			"message": "查询字典详情成功",
+			"total":   len(allDetails),
+			"details": allDetails,
+		}
+
+		responseJSON, _ := json.Marshal(response)
+		return &mcp.CallToolResult{
+			Content: []mcp.Content{
+				mcp.NewTextContent(string(responseJSON)),
+			},
+		}, nil
+	}
+
+	// 构建响应
+	response := DictionaryQueryResponse{
+		Success:      true,
+		Message:      "查询字典成功",
+		Total:        len(dictionaries),
+		Dictionaries: dictionaries,
+	}
+
+	responseJSON, err := json.Marshal(response)
+	if err != nil {
+		global.GVA_LOG.Error("序列化响应失败", zap.Error(err))
+		return &mcp.CallToolResult{
+			Content: []mcp.Content{
+				mcp.NewTextContent(fmt.Sprintf(`{"success": false, "message": "序列化响应失败: %v", "total": 0, "dictionaries": []}`, err.Error())),
+			},
+		}, nil
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.NewTextContent(string(responseJSON)),
+		},
+	}, nil
+}

server/mcp/get_nickname.go

@@ -1,79 +0,0 @@
-package mcpTool
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"github.com/flipped-aurora/gin-vue-admin/server/global"
-	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
-	"github.com/mark3labs/mcp-go/mcp"
-	"gorm.io/gorm"
-)
-
-func init() {
-	RegisterTool(&GetNickname{})
-}
-
-type GetNickname struct{}
-
-// 根据用户username获取nickname
-func (t *GetNickname) New() mcp.Tool {
-	return mcp.NewTool("getNickname",
-		mcp.WithDescription("根据用户username获取nickname"),
-		mcp.WithString("username",
-			mcp.Required(),
-			mcp.Description("用户的username"),
-		))
-}
-
-// Handle 处理获取昵称的请求
-func (t *GetNickname) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	// 1. 参数验证
-	username, ok := request.Params.Arguments["username"].(string)
-	if !ok {
-		return nil, errors.New("参数错误：username 必须是字符串类型")
-	}
-
-	if username == "" {
-		return nil, errors.New("参数错误：username 不能为空")
-	}
-
-	// 2. 记录操作日志
-	global.GVA_LOG.Info("getNickname 工具被调用")
-
-	// 3. 优化查询，只选择需要的字段
-	var user struct {
-		NickName string
-	}
-
-	err := global.GVA_DB.Model(&system.SysUser{}).
-		Select("nick_name").
-		Where("username = ?", username).
-		First(&user).Error
-
-	// 4. 优化错误处理
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return &mcp.CallToolResult{
-				Content: []mcp.Content{
-					mcp.TextContent{
-						Type: "text",
-						Text: fmt.Sprintf("用户 %s 不存在", username),
-					},
-				},
-			}, nil
-		}
-		global.GVA_LOG.Error("数据库查询错误")
-		return nil, errors.New("系统错误，请稍后再试")
-	}
-
-	// 构造回复信息
-	return &mcp.CallToolResult{
-		Content: []mcp.Content{
-			mcp.TextContent{
-				Type: "text",
-				Text: fmt.Sprintf("用户 %s 的昵称是 %s", username, user.NickName),
-			},
-		},
-	}, nil
-}

server/mcp/gva_analyze.go

@@ -0,0 +1,493 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	model "github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+// 注册工具
+func init() {
+	RegisterTool(&GVAAnalyzer{})
+}
+
+// GVAAnalyzer GVA分析器 - 用于分析当前功能是否需要创建独立的package和module
+type GVAAnalyzer struct{}
+
+// AnalyzeRequest 分析请求结构体
+type AnalyzeRequest struct {
+	Requirement string `json:"requirement" binding:"required"` // 用户需求描述
+}
+
+// AnalyzeResponse 分析响应结构体
+type AnalyzeResponse struct {
+	ExistingPackages   []PackageInfo           `json:"existingPackages"`   // 现有包信息
+	PredesignedModules []PredesignedModuleInfo `json:"predesignedModules"` // 预设计模块信息
+	Dictionaries       []DictionaryPre         `json:"dictionaries"`       // 字典信息
+	CleanupInfo        *CleanupInfo            `json:"cleanupInfo"`        // 清理信息（如果有）
+}
+
+// ModuleInfo 模块信息
+type ModuleInfo struct {
+	ModuleName  string   `json:"moduleName"`  // 模块名称
+	PackageName string   `json:"packageName"` // 包名
+	Template    string   `json:"template"`    // 模板类型
+	StructName  string   `json:"structName"`  // 结构体名称
+	TableName   string   `json:"tableName"`   // 表名
+	Description string   `json:"description"` // 描述
+	FilePaths   []string `json:"filePaths"`   // 相关文件路径
+}
+
+// PackageInfo 包信息
+type PackageInfo struct {
+	PackageName string `json:"packageName"` // 包名
+	Template    string `json:"template"`    // 模板类型
+	Label       string `json:"label"`       // 标签
+	Desc        string `json:"desc"`        // 描述
+	Module      string `json:"module"`      // 模块
+	IsEmpty     bool   `json:"isEmpty"`     // 是否为空包
+}
+
+// PredesignedModuleInfo 预设计模块信息
+type PredesignedModuleInfo struct {
+	ModuleName  string   `json:"moduleName"`  // 模块名称
+	PackageName string   `json:"packageName"` // 包名
+	Template    string   `json:"template"`    // 模板类型
+	FilePaths   []string `json:"filePaths"`   // 文件路径列表
+	Description string   `json:"description"` // 描述
+}
+
+// CleanupInfo 清理信息
+type CleanupInfo struct {
+	DeletedPackages []string `json:"deletedPackages"` // 已删除的包
+	DeletedModules  []string `json:"deletedModules"`  // 已删除的模块
+	CleanupMessage  string   `json:"cleanupMessage"`  // 清理消息
+}
+
+// New 创建GVA分析器工具
+func (g *GVAAnalyzer) New() mcp.Tool {
+	return mcp.NewTool("gva_analyze",
+		mcp.WithDescription("返回当前系统中有效的包和模块信息，并分析用户需求是否需要创建新的包、模块和字典。同时检查并清理空包，确保系统整洁。"),
+		mcp.WithString("requirement",
+			mcp.Description("用户需求描述，用于分析是否需要创建新的包和模块"),
+			mcp.Required(),
+		),
+	)
+}
+
+// Handle 处理分析请求
+func (g *GVAAnalyzer) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	// 解析请求参数
+	requirementStr, ok := request.GetArguments()["requirement"].(string)
+	if !ok || requirementStr == "" {
+		return nil, errors.New("参数错误：requirement 必须是非空字符串")
+	}
+
+	// 创建分析请求
+	analyzeReq := AnalyzeRequest{
+		Requirement: requirementStr,
+	}
+
+	// 执行分析逻辑
+	response, err := g.performAnalysis(ctx, analyzeReq)
+	if err != nil {
+		return nil, fmt.Errorf("分析失败: %v", err)
+	}
+
+	// 序列化响应
+	responseJSON, err := json.Marshal(response)
+	if err != nil {
+		return nil, fmt.Errorf("序列化响应失败: %v", err)
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.NewTextContent(string(responseJSON)),
+		},
+	}, nil
+}
+
+// performAnalysis 执行分析逻辑
+func (g *GVAAnalyzer) performAnalysis(ctx context.Context, req AnalyzeRequest) (*AnalyzeResponse, error) {
+	// 1. 获取数据库中的包信息
+	var packages []model.SysAutoCodePackage
+	if err := global.GVA_DB.Find(&packages).Error; err != nil {
+		return nil, fmt.Errorf("获取包信息失败: %v", err)
+	}
+
+	// 2. 获取历史记录
+	var histories []model.SysAutoCodeHistory
+	if err := global.GVA_DB.Find(&histories).Error; err != nil {
+		return nil, fmt.Errorf("获取历史记录失败: %v", err)
+	}
+
+	// 3. 检查空包并进行清理
+	cleanupInfo := &CleanupInfo{
+		DeletedPackages: []string{},
+		DeletedModules:  []string{},
+	}
+
+	var validPackages []model.SysAutoCodePackage
+	var emptyPackageHistoryIDs []uint
+
+	for _, pkg := range packages {
+		isEmpty, err := g.isPackageFolderEmpty(pkg.PackageName, pkg.Template)
+		if err != nil {
+			global.GVA_LOG.Warn(fmt.Sprintf("检查包 %s 是否为空时出错: %v", pkg.PackageName, err))
+			continue
+		}
+
+		if isEmpty {
+			// 删除空包文件夹
+			if err := g.removeEmptyPackageFolder(pkg.PackageName, pkg.Template); err != nil {
+				global.GVA_LOG.Warn(fmt.Sprintf("删除空包文件夹 %s 失败: %v", pkg.PackageName, err))
+			} else {
+				cleanupInfo.DeletedPackages = append(cleanupInfo.DeletedPackages, pkg.PackageName)
+			}
+
+			// 删除数据库记录
+			if err := global.GVA_DB.Delete(&pkg).Error; err != nil {
+				global.GVA_LOG.Warn(fmt.Sprintf("删除包数据库记录 %s 失败: %v", pkg.PackageName, err))
+			}
+
+			// 收集相关的历史记录ID
+			for _, history := range histories {
+				if history.Package == pkg.PackageName {
+					emptyPackageHistoryIDs = append(emptyPackageHistoryIDs, history.ID)
+					cleanupInfo.DeletedModules = append(cleanupInfo.DeletedModules, history.StructName)
+				}
+			}
+		} else {
+			validPackages = append(validPackages, pkg)
+		}
+	}
+
+	// 5. 清理空包相关的历史记录和脏历史记录
+	var dirtyHistoryIDs []uint
+	for _, history := range histories {
+		// 检查是否为空包相关的历史记录
+		for _, emptyID := range emptyPackageHistoryIDs {
+			if history.ID == emptyID {
+				dirtyHistoryIDs = append(dirtyHistoryIDs, history.ID)
+				break
+			}
+		}
+	}
+
+	// 删除脏历史记录
+	if len(dirtyHistoryIDs) > 0 {
+		if err := global.GVA_DB.Delete(&model.SysAutoCodeHistory{}, "id IN ?", dirtyHistoryIDs).Error; err != nil {
+			global.GVA_LOG.Warn(fmt.Sprintf("删除脏历史记录失败: %v", err))
+		} else {
+			global.GVA_LOG.Info(fmt.Sprintf("成功删除 %d 条脏历史记录", len(dirtyHistoryIDs)))
+		}
+
+		// 清理相关的API和菜单记录
+		if err := g.cleanupRelatedApiAndMenus(dirtyHistoryIDs); err != nil {
+			global.GVA_LOG.Warn(fmt.Sprintf("清理相关API和菜单记录失败: %v", err))
+		}
+	}
+
+	// 6. 扫描预设计模块
+	predesignedModules, err := g.scanPredesignedModules()
+	if err != nil {
+		global.GVA_LOG.Warn(fmt.Sprintf("扫描预设计模块失败: %v", err))
+		predesignedModules = []PredesignedModuleInfo{} // 设置为空列表，不影响主流程
+	}
+
+	// 7. 过滤掉与已删除包相关的模块
+	filteredModules := []PredesignedModuleInfo{}
+	for _, module := range predesignedModules {
+		isDeleted := false
+		for _, deletedPkg := range cleanupInfo.DeletedPackages {
+			if module.PackageName == deletedPkg {
+				isDeleted = true
+				break
+			}
+		}
+		if !isDeleted {
+			filteredModules = append(filteredModules, module)
+		}
+	}
+
+	// 8. 构建分析结果消息
+	var analysisMessage strings.Builder
+	if len(cleanupInfo.DeletedPackages) > 0 || len(cleanupInfo.DeletedModules) > 0 {
+		analysisMessage.WriteString("**系统清理完成**\n\n")
+		if len(cleanupInfo.DeletedPackages) > 0 {
+			analysisMessage.WriteString(fmt.Sprintf("- 删除了 %d 个空包: %s\n", len(cleanupInfo.DeletedPackages), strings.Join(cleanupInfo.DeletedPackages, ", ")))
+		}
+		if len(cleanupInfo.DeletedModules) > 0 {
+			analysisMessage.WriteString(fmt.Sprintf("- 删除了 %d 个相关模块: %s\n", len(cleanupInfo.DeletedModules), strings.Join(cleanupInfo.DeletedModules, ", ")))
+		}
+		analysisMessage.WriteString("\n")
+		cleanupInfo.CleanupMessage = analysisMessage.String()
+	}
+
+	analysisMessage.WriteString(" **分析结果**\n\n")
+	analysisMessage.WriteString(fmt.Sprintf("- **现有包数量**: %d\n", len(validPackages)))
+	analysisMessage.WriteString(fmt.Sprintf("- **预设计模块数量**: %d\n\n", len(filteredModules)))
+
+	// 9. 转换包信息
+	existingPackages := make([]PackageInfo, len(validPackages))
+	for i, pkg := range validPackages {
+		existingPackages[i] = PackageInfo{
+			PackageName: pkg.PackageName,
+			Template:    pkg.Template,
+			Label:       pkg.Label,
+			Desc:        pkg.Desc,
+			Module:      pkg.Module,
+			IsEmpty:     false, // 已经过滤掉空包
+		}
+	}
+
+	dictionaries := []DictionaryPre{} // 这里可以根据需要填充字典信息
+	err = global.GVA_DB.Table("sys_dictionaries").Find(&dictionaries, "deleted_at is null").Error
+	if err != nil {
+		global.GVA_LOG.Warn(fmt.Sprintf("获取字典信息失败: %v", err))
+		dictionaries = []DictionaryPre{} // 设置为空列表，不影响主流程
+	}
+
+	// 10. 构建响应
+	response := &AnalyzeResponse{
+		ExistingPackages:   existingPackages,
+		PredesignedModules: filteredModules,
+		Dictionaries:       dictionaries,
+	}
+
+	return response, nil
+}
+
+// isPackageFolderEmpty 检查包文件夹是否为空
+func (g *GVAAnalyzer) isPackageFolderEmpty(packageName, template string) (bool, error) {
+	// 根据模板类型确定基础路径
+	var basePath string
+	if template == "plugin" {
+		basePath = filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "plugin", packageName)
+	} else {
+		basePath = filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "api", "v1", packageName)
+	}
+
+	// 检查文件夹是否存在
+	if _, err := os.Stat(basePath); os.IsNotExist(err) {
+		return true, nil // 文件夹不存在，视为空
+	} else if err != nil {
+		return false, err // 其他错误
+	}
+	// 递归检查是否有.go文件
+	return g.hasGoFilesRecursive(basePath)
+}
+
+// hasGoFilesRecursive 递归检查目录及其子目录中是否有.go文件
+func (g *GVAAnalyzer) hasGoFilesRecursive(dirPath string) (bool, error) {
+	entries, err := os.ReadDir(dirPath)
+	if err != nil {
+		return true, err // 读取失败，返回空
+	}
+
+	// 检查当前目录下的.go文件
+	for _, entry := range entries {
+		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".go") {
+			return false, nil // 找到.go文件，不为空
+		}
+	}
+
+	// 递归检查子目录
+	for _, entry := range entries {
+		if entry.IsDir() {
+			subDirPath := filepath.Join(dirPath, entry.Name())
+			isEmpty, err := g.hasGoFilesRecursive(subDirPath)
+			if err != nil {
+				continue // 忽略子目录的错误，继续检查其他目录
+			}
+			if !isEmpty {
+				return false, nil // 子目录中找到.go文件，不为空
+			}
+		}
+	}
+
+	return true, nil // 没有找到.go文件，为空
+}
+
+// removeEmptyPackageFolder 删除空包文件夹
+func (g *GVAAnalyzer) removeEmptyPackageFolder(packageName, template string) error {
+	var basePath string
+	if template == "plugin" {
+		basePath = filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "plugin", packageName)
+	} else {
+		// 对于package类型，需要删除多个目录
+		paths := []string{
+			filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "api", "v1", packageName),
+			filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "model", packageName),
+			filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "router", packageName),
+			filepath.Join(global.GVA_CONFIG.AutoCode.Root, global.GVA_CONFIG.AutoCode.Server, "service", packageName),
+		}
+		for _, path := range paths {
+			if err := g.removeDirectoryIfExists(path); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	return g.removeDirectoryIfExists(basePath)
+}
+
+// removeDirectoryIfExists 删除目录（如果存在）
+func (g *GVAAnalyzer) removeDirectoryIfExists(dirPath string) error {
+	if _, err := os.Stat(dirPath); os.IsNotExist(err) {
+		return nil // 目录不存在，无需删除
+	} else if err != nil {
+		return err // 其他错误
+	}
+
+	return os.RemoveAll(dirPath)
+}
+
+// cleanupRelatedApiAndMenus 清理相关的API和菜单记录
+func (g *GVAAnalyzer) cleanupRelatedApiAndMenus(historyIDs []uint) error {
+	if len(historyIDs) == 0 {
+		return nil
+	}
+
+	// 这里可以根据需要实现具体的API和菜单清理逻辑
+	// 由于涉及到具体的业务逻辑，这里只做日志记录
+	global.GVA_LOG.Info(fmt.Sprintf("清理历史记录ID %v 相关的API和菜单记录", historyIDs))
+
+	// 可以调用service层的相关方法进行清理
+	// 例如：service.ServiceGroupApp.SystemApiService.DeleteApisByIds(historyIDs)
+	// 例如：service.ServiceGroupApp.MenuService.DeleteMenusByIds(historyIDs)
+
+	return nil
+}
+
+// scanPredesignedModules 扫描预设计模块
+func (g *GVAAnalyzer) scanPredesignedModules() ([]PredesignedModuleInfo, error) {
+	// 获取autocode配置路径
+	autocodeRoot := global.GVA_CONFIG.AutoCode.Root
+	if autocodeRoot == "" {
+		return nil, errors.New("autocode根路径未配置")
+	}
+
+	var modules []PredesignedModuleInfo
+
+	// 扫描plugin目录
+	pluginModules, err := g.scanPluginModules(filepath.Join(autocodeRoot, global.GVA_CONFIG.AutoCode.Server, "plugin"))
+	if err != nil {
+		global.GVA_LOG.Warn(fmt.Sprintf("扫描plugin模块失败: %v", err))
+	} else {
+		modules = append(modules, pluginModules...)
+	}
+
+	// 扫描model目录
+	modelModules, err := g.scanModelModules(filepath.Join(autocodeRoot, global.GVA_CONFIG.AutoCode.Server, "model"))
+	if err != nil {
+		global.GVA_LOG.Warn(fmt.Sprintf("扫描model模块失败: %v", err))
+	} else {
+		modules = append(modules, modelModules...)
+	}
+
+	return modules, nil
+}
+
+// scanPluginModules 扫描插件模块
+func (g *GVAAnalyzer) scanPluginModules(pluginDir string) ([]PredesignedModuleInfo, error) {
+	var modules []PredesignedModuleInfo
+
+	if _, err := os.Stat(pluginDir); os.IsNotExist(err) {
+		return modules, nil // 目录不存在，返回空列表
+	}
+
+	entries, err := os.ReadDir(pluginDir)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			pluginName := entry.Name()
+			pluginPath := filepath.Join(pluginDir, pluginName)
+
+			// 查找model目录
+			modelDir := filepath.Join(pluginPath, "model")
+			if _, err := os.Stat(modelDir); err == nil {
+				// 扫描model目录下的模块
+				pluginModules, err := g.scanModulesInDirectory(modelDir, pluginName, "plugin")
+				if err != nil {
+					global.GVA_LOG.Warn(fmt.Sprintf("扫描插件 %s 的模块失败: %v", pluginName, err))
+					continue
+				}
+				modules = append(modules, pluginModules...)
+			}
+		}
+	}
+
+	return modules, nil
+}
+
+// scanModelModules 扫描模型模块
+func (g *GVAAnalyzer) scanModelModules(modelDir string) ([]PredesignedModuleInfo, error) {
+	var modules []PredesignedModuleInfo
+
+	if _, err := os.Stat(modelDir); os.IsNotExist(err) {
+		return modules, nil // 目录不存在，返回空列表
+	}
+
+	entries, err := os.ReadDir(modelDir)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			packageName := entry.Name()
+			packagePath := filepath.Join(modelDir, packageName)
+
+			// 扫描包目录下的模块
+			packageModules, err := g.scanModulesInDirectory(packagePath, packageName, "package")
+			if err != nil {
+				global.GVA_LOG.Warn(fmt.Sprintf("扫描包 %s 的模块失败: %v", packageName, err))
+				continue
+			}
+			modules = append(modules, packageModules...)
+		}
+	}
+
+	return modules, nil
+}
+
+// scanModulesInDirectory 扫描目录中的模块
+func (g *GVAAnalyzer) scanModulesInDirectory(dir, packageName, template string) ([]PredesignedModuleInfo, error) {
+	var modules []PredesignedModuleInfo
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, entry := range entries {
+		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".go") {
+			moduleName := strings.TrimSuffix(entry.Name(), ".go")
+			filePath := filepath.Join(dir, entry.Name())
+
+			module := PredesignedModuleInfo{
+				ModuleName:  moduleName,
+				PackageName: packageName,
+				Template:    template,
+				FilePaths:   []string{filePath},
+				Description: fmt.Sprintf("%s模块中的%s", packageName, moduleName),
+			}
+			modules = append(modules, module)
+		}
+	}
+
+	return modules, nil
+}

server/mcp/gva_execute.go

@@ -0,0 +1,912 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	model "github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"github.com/flipped-aurora/gin-vue-admin/server/utils"
+	"strings"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/service"
+	"github.com/mark3labs/mcp-go/mcp"
+	"go.uber.org/zap"
+)
+
+// 注册工具
+func init() {
+	RegisterTool(&GVAExecutor{})
+}
+
+// GVAExecutor GVA代码生成器
+type GVAExecutor struct{}
+
+// ExecuteRequest 执行请求结构
+type ExecuteRequest struct {
+	ExecutionPlan ExecutionPlan `json:"executionPlan"` // 执行计划
+	Requirement   string        `json:"requirement"`   // 原始需求（可选，用于日志记录）
+}
+
+// ExecuteResponse 执行响应结构
+type ExecuteResponse struct {
+	Success        bool              `json:"success"`
+	Message        string            `json:"message"`
+	PackageID      uint              `json:"packageId,omitempty"`
+	HistoryID      uint              `json:"historyId,omitempty"`
+	Paths          map[string]string `json:"paths,omitempty"`
+	GeneratedPaths []string          `json:"generatedPaths,omitempty"`
+	NextActions    []string          `json:"nextActions,omitempty"`
+}
+
+// ExecutionPlan 执行计划结构
+type ExecutionPlan struct {
+	PackageName             string                            `json:"packageName"`
+	PackageType             string                            `json:"packageType"` // "plugin" 或 "package"
+	NeedCreatedPackage      bool                              `json:"needCreatedPackage"`
+	NeedCreatedModules      bool                              `json:"needCreatedModules"`
+	NeedCreatedDictionaries bool                              `json:"needCreatedDictionaries"`
+	PackageInfo             *request.SysAutoCodePackageCreate `json:"packageInfo,omitempty"`
+	ModulesInfo             []*request.AutoCode               `json:"modulesInfo,omitempty"`
+	Paths                   map[string]string                 `json:"paths,omitempty"`
+	DictionariesInfo        []*DictionaryGenerateRequest      `json:"dictionariesInfo,omitempty"`
+}
+
+// New 创建GVA代码生成执行器工具
+func (g *GVAExecutor) New() mcp.Tool {
+    return mcp.NewTool("gva_execute",
+		mcp.WithDescription(`**GVA代码生成执行器：直接执行代码生成，无需确认步骤**
+
+**核心功能：**
+- 根据需求分析和当前的包信息判断是否调用，如果需要调用，则根据入参描述生成json，用于直接生成代码
+- 支持批量创建多个模块
+- 自动创建包、模块、字典等
+- 移除了确认步骤，提高执行效率
+
+**使用场景：**
+- 在gva_analyze获取了当前的包信息和字典信息之后，如果已经包含了可以使用的包和模块，那就不要调用本mcp
+- 根据分析结果直接生成代码
+- 适用于自动化代码生成流程
+
+**批量创建功能：**
+- 支持在单个ExecutionPlan中创建多个模块
+- modulesInfo字段为数组，可包含多个模块配置
+- 一次性处理多个模块的创建和字典生成
+
+**新功能：自动字典创建**
+- 当结构体字段使用了字典类型（dictType不为空）时，系统会自动检查字典是否存在
+- 如果字典不存在，会自动创建对应的字典及默认的字典详情项
+- 字典创建包括：字典主表记录和默认的选项值（选项1、选项2等）
+
+**重要限制：**
+- 当needCreatedModules=true时，模块创建会自动生成API和菜单，因此不应再调用api_creator和menu_creator工具
+- 只有在单独创建API或菜单（不涉及模块创建）时才使用api_creator和menu_creator工具
+
+重要：ExecutionPlan结构体格式要求（支持批量创建）：
+{
+  "packageName": "包名(string)",
+  "packageType": "package或plugin(string)，如果用户提到了使用插件则创建plugin，如果用户没有特定说明则一律选用package。",
+  "needCreatedPackage": "是否需要创建包(bool)",
+  "needCreatedModules": "是否需要创建模块(bool)",
+  "needCreatedDictionaries": "是否需要创建字典(bool)",
+  "packageInfo": {
+    "desc": "描述(string)",
+    "label": "展示名(string)", 
+    "template": "package或plugin(string)，如果用户提到了使用插件则创建plugin，如果用户没有特定说明则一律选用package。",
+    "packageName": "包名(string)"
+  },
+  "modulesInfo": [{
+    "package": "包名(string，必然是小写开头)",
+    "tableName": "数据库表名(string，使用蛇形命名法)",
+    "businessDB": "业务数据库(string)",
+    "structName": "结构体名(string)",
+    "packageName": "文件名称(string)",
+    "description": "中文描述(string)",
+    "abbreviation": "简称(string)",
+    "humpPackageName": "文件名称 一般是结构体名的小驼峰(string)",
+    "gvaModel": "是否使用GVA模型(bool) 固定为true 后续不需要创建ID created_at deleted_at updated_at",
+    "autoMigrate": "是否自动迁移(bool)",
+    "autoCreateResource": "是否创建资源(bool，默认为false)",
+    "autoCreateApiToSql": "是否创建API(bool，默认为true)",
+    "autoCreateMenuToSql": "是否创建菜单(bool，默认为true)",
+    "autoCreateBtnAuth": "是否创建按钮权限(bool，默认为false)",
+    "onlyTemplate": "是否仅模板(bool，默认为false)",
+    "isTree": "是否树形结构(bool，默认为false)",
+    "treeJson": "树形JSON字段(string)",
+    "isAdd": "是否新增(bool) 固定为false",
+    "generateWeb": "是否生成前端(bool)",
+    "generateServer": "是否生成后端(bool)",
+    "fields": [{
+      "fieldName": "字段名(string)必须大写开头",
+      "fieldDesc": "字段描述(string)",
+      "fieldType": "字段类型支持：string（字符串）,richtext（富文本）,int（整型）,bool（布尔值）,float64（浮点型）,time.Time（时间）,enum（枚举）,picture（单图片，字符串）,pictures（多图片，json字符串）,video（视频，字符串）,file（文件，json字符串）,json（JSON）,array（数组）",
+      "fieldJson": "JSON标签(string)",
+      "dataTypeLong": "数据长度(string)",
+      "comment": "注释(string)",
+      "columnName": "数据库列名(string)",
+      "fieldSearchType": "搜索类型:=/>/</>=/<=/NOT BETWEEN/LIKE/BETWEEN/IN/NOT IN等(string)",
+      "fieldSearchHide": "是否隐藏搜索(bool)",
+      "dictType": "字典类型(string)",
+      "form": "表单显示(bool)",
+      "table": "表格显示(bool)",
+      "desc": "详情显示(bool)",
+      "excel": "导入导出(bool)",
+      "require": "是否必填(bool)",
+      "defaultValue": "默认值(string)",
+      "errorText": "错误提示(string)",
+      "clearable": "是否可清空(bool)",
+      "sort": "是否排序(bool)",
+      "primaryKey": "是否主键(bool)",
+      "dataSource": "数据源配置(object) - 用于配置字段的关联表信息，结构：{\"dbName\":\"数据库名\",\"table\":\"关联表名\",\"label\":\"显示字段\",\"value\":\"值字段\",\"association\":1或2(1=一对一,2=一对多),\"hasDeletedAt\":true/false}。\n\n**获取表名提示：**\n- 可在 server/model 和 plugin/xxx/model 目录下查看对应模块的 TableName() 接口实现获取实际表名\n- 例如：SysUser 的表名为 \"sys_users\"，ExaFileUploadAndDownload 的表名为 \"exa_file_upload_and_downloads\"\n- 插件模块示例：Info 的表名为 \"gva_announcements_info\"\n\n**获取数据库名提示：**\n- 主数据库：通常使用 \"gva\"（默认数据库标识）\n- 多数据库：可在 config.yaml 的 db-list 配置中查看可用数据库的 alias-name 字段\n- 如果用户未提及关联多数据库信息 则使用默认数据库 默认数据库的情况下 dbName此处填写为空",
+      "checkDataSource": "是否检查数据源(bool) - 启用后会验证关联表的存在性",
+      "fieldIndexType": "索引类型(string)"
+    }]
+  }, {
+    "package": "包名(string)",
+    "tableName": "第二个模块的表名(string)",
+    "structName": "第二个模块的结构体名(string)",
+    "description": "第二个模块的描述(string)",
+    "...": "更多模块配置..."
+  }],
+	"dictionariesInfo":[{
+		"dictType": "字典类型(string) - 用于标识字典的唯一性",
+		"dictName": "字典名称(string) - 必须生成，字典的中文名称",
+		"description": "字典描述(string) - 字典的用途说明",
+		"status": "字典状态(bool) - true启用，false禁用",
+		"fieldDesc": "字段描述(string) - 用于AI理解字段含义并生成合适的选项",
+		"options": [{
+			"label": "显示名称(string) - 用户看到的选项名",
+			"value": "选项值(string) - 实际存储的值",
+			"sort": "排序号(int) - 数字越小越靠前"
+		}]
+	}]
+}
+
+注意：
+1. needCreatedPackage=true时packageInfo必需
+2. needCreatedModules=true时modulesInfo必需
+3. needCreatedDictionaries=true时dictionariesInfo必需
+4. dictionariesInfo中的options字段可选，如果不提供将根据fieldDesc自动生成默认选项
+5. 字典创建会在模块创建之前执行，确保模块字段可以正确引用字典类型
+6. packageType只能是"package"或"plugin,如果用户提到了使用插件则创建plugin，如果用户没有特定说明则一律选用package。"
+7. 字段类型支持：string（字符串）,richtext（富文本）,int（整型）,bool（布尔值）,float64（浮点型）,time.Time（时间）,enum（枚举）,picture（单图片，字符串）,pictures（多图片，json字符串）,video（视频，字符串）,file（文件，json字符串）,json（JSON）,array（数组）
+8. 搜索类型支持：=,!=,>,>=,<,<=,NOT BETWEEN/LIKE/BETWEEN/IN/NOT IN
+9. gvaModel=true时自动包含ID,CreatedAt,UpdatedAt,DeletedAt字段
+10. **重要**：当gvaModel=false时，必须有一个字段的primaryKey=true，否则会导致PrimaryField为nil错误
+11. **重要**：当gvaModel=true时，系统会自动设置ID字段为主键，无需手动设置primaryKey=true
+12. 智能字典创建功能：当字段使用字典类型(DictType)时，系统会：
+   - 自动检查字典是否存在，如果不存在则创建字典
+   - 根据字典类型和字段描述智能生成默认选项，支持状态、性别、类型、等级、优先级、审批、角色、布尔值、订单、颜色、尺寸等常见场景
+   - 为无法识别的字典类型提供通用默认选项
+13. **模块关联配置**：当需要配置模块间的关联关系时，使用dataSource字段：
+   - **dbName**: 关联的数据库名称
+   - **table**: 关联的表名
+   - **label**: 用于显示的字段名（如name、title等）
+   - **value**: 用于存储的值字段名（通常是id）
+   - **association**: 关联关系类型（1=一对一关联，2=一对多关联）一对一和一对多的前面的一是当前的实体，如果他只能关联另一个实体的一个，则选用一对一，如果他需要关联多个他的关联实体，则选用一对多。
+   - **hasDeletedAt**: 关联表是否有软删除字段
+   - **checkDataSource**: 设为true时会验证关联表的存在性
+   - 示例：{"dbName":"","table":"sys_users","label":"username","value":"id","association":1,"hasDeletedAt":true}
+14. **自动字段类型修正**：系统会自动检查和修正字段类型：
+   - 当字段配置了dataSource且association=2（一对多关联）时，系统会自动将fieldType修改为'array'
+   - 这确保了一对多关联数据的正确存储和处理
+   - 修正操作会记录在日志中，便于开发者了解变更情况`),
+        mcp.WithObject("executionPlan",
+            mcp.Description("执行计划，包含包信息、模块与字典信息"),
+            mcp.Required(),
+            mcp.Properties(map[string]interface{}{
+                "packageName": map[string]interface{}{
+                    "type":        "string",
+                    "description": "包名（小写开头）",
+                },
+                "packageType": map[string]interface{}{
+                    "type":        "string",
+                    "description": "package 或 plugin",
+                    "enum":        []string{"package", "plugin"},
+                },
+                "needCreatedPackage": map[string]interface{}{
+                    "type":        "boolean",
+                    "description": "是否需要创建包",
+                },
+                "needCreatedModules": map[string]interface{}{
+                    "type":        "boolean",
+                    "description": "是否需要创建模块",
+                },
+                "needCreatedDictionaries": map[string]interface{}{
+                    "type":        "boolean",
+                    "description": "是否需要创建字典",
+                },
+                "packageInfo": map[string]interface{}{
+                    "type":        "object",
+                    "description": "包创建信息",
+                    "properties": map[string]interface{}{
+                        "desc":        map[string]interface{}{"type": "string", "description": "包描述"},
+                        "label":       map[string]interface{}{"type": "string", "description": "展示名"},
+                        "template":    map[string]interface{}{"type": "string", "description": "package 或 plugin", "enum": []string{"package", "plugin"}},
+                        "packageName": map[string]interface{}{"type": "string", "description": "包名"},
+                    },
+                },
+                "modulesInfo": map[string]interface{}{
+                    "type":        "array",
+                    "description": "模块配置列表",
+                    "items": map[string]interface{}{
+                        "type": "object",
+                        "properties": map[string]interface{}{
+                            "package":            map[string]interface{}{"type": "string", "description": "包名（小写开头）"},
+                            "tableName":          map[string]interface{}{"type": "string", "description": "数据库表名（蛇形命名）"},
+                            "businessDB":        map[string]interface{}{"type": "string", "description": "业务数据库（可留空表示默认）"},
+                            "structName":         map[string]interface{}{"type": "string", "description": "结构体名（大驼峰）"},
+                            "packageName":        map[string]interface{}{"type": "string", "description": "文件名称"},
+                            "description":        map[string]interface{}{"type": "string", "description": "中文描述"},
+                            "abbreviation":       map[string]interface{}{"type": "string", "description": "简称"},
+                            "humpPackageName":    map[string]interface{}{"type": "string", "description": "文件名称（小驼峰）"},
+                            "gvaModel":           map[string]interface{}{"type": "boolean", "description": "是否使用GVA模型（固定为true）"},
+                            "autoMigrate":        map[string]interface{}{"type": "boolean"},
+                            "autoCreateResource": map[string]interface{}{"type": "boolean"},
+                            "autoCreateApiToSql": map[string]interface{}{"type": "boolean"},
+                            "autoCreateMenuToSql": map[string]interface{}{"type": "boolean"},
+                            "autoCreateBtnAuth":  map[string]interface{}{"type": "boolean"},
+                            "onlyTemplate":       map[string]interface{}{"type": "boolean"},
+                            "isTree":             map[string]interface{}{"type": "boolean"},
+                            "treeJson":           map[string]interface{}{"type": "string"},
+                            "isAdd":              map[string]interface{}{"type": "boolean"},
+                            "generateWeb":        map[string]interface{}{"type": "boolean"},
+                            "generateServer":     map[string]interface{}{"type": "boolean"},
+                            "fields": map[string]interface{}{
+                                "type":  "array",
+                                "items": map[string]interface{}{
+                                    "type": "object",
+                                    "properties": map[string]interface{}{
+                                        "fieldName":        map[string]interface{}{"type": "string"},
+                                        "fieldDesc":        map[string]interface{}{"type": "string"},
+                                        "fieldType":        map[string]interface{}{"type": "string"},
+                                        "fieldJson":        map[string]interface{}{"type": "string"},
+                                        "dataTypeLong":     map[string]interface{}{"type": "string"},
+                                        "comment":          map[string]interface{}{"type": "string"},
+                                        "columnName":       map[string]interface{}{"type": "string"},
+                                        "fieldSearchType":  map[string]interface{}{"type": "string"},
+                                        "fieldSearchHide":  map[string]interface{}{"type": "boolean"},
+                                        "dictType":         map[string]interface{}{"type": "string"},
+                                        "form":             map[string]interface{}{"type": "boolean"},
+                                        "table":            map[string]interface{}{"type": "boolean"},
+                                        "desc":             map[string]interface{}{"type": "boolean"},
+                                        "excel":            map[string]interface{}{"type": "boolean"},
+                                        "require":          map[string]interface{}{"type": "boolean"},
+                                        "defaultValue":     map[string]interface{}{"type": "string"},
+                                        "errorText":        map[string]interface{}{"type": "string"},
+                                        "clearable":        map[string]interface{}{"type": "boolean"},
+                                        "sort":             map[string]interface{}{"type": "boolean"},
+                                        "primaryKey":       map[string]interface{}{"type": "boolean"},
+                                        "dataSource": map[string]interface{}{
+                                            "type":       "object",
+                                            "properties": map[string]interface{}{
+                                                "dbName":        map[string]interface{}{"type": "string"},
+                                                "table":         map[string]interface{}{"type": "string"},
+                                                "label":         map[string]interface{}{"type": "string"},
+                                                "value":         map[string]interface{}{"type": "string"},
+                                                "association":   map[string]interface{}{"type": "integer"},
+                                                "hasDeletedAt":  map[string]interface{}{"type": "boolean"},
+                                            },
+                                        },
+                                        "checkDataSource":   map[string]interface{}{"type": "boolean"},
+                                        "fieldIndexType":    map[string]interface{}{"type": "string"},
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                "paths": map[string]interface{}{
+                    "type":        "object",
+                    "description": "生成的文件路径映射",
+                    "additionalProperties": map[string]interface{}{"type": "string"},
+                },
+                "dictionariesInfo": map[string]interface{}{
+                    "type":        "array",
+                    "description": "字典创建信息",
+                    "items": map[string]interface{}{
+                        "type": "object",
+                        "properties": map[string]interface{}{
+                            "dictType":    map[string]interface{}{"type": "string"},
+                            "dictName":    map[string]interface{}{"type": "string"},
+                            "description": map[string]interface{}{"type": "string"},
+                            "status":      map[string]interface{}{"type": "boolean"},
+                            "fieldDesc":   map[string]interface{}{"type": "string"},
+                            "options": map[string]interface{}{
+                                "type":  "array",
+                                "items": map[string]interface{}{
+                                    "type": "object",
+                                    "properties": map[string]interface{}{
+                                        "label": map[string]interface{}{"type": "string"},
+                                        "value": map[string]interface{}{"type": "string"},
+                                        "sort":  map[string]interface{}{"type": "integer"},
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            }),
+            mcp.AdditionalProperties(false),
+        ),
+		mcp.WithString("requirement",
+			mcp.Description("原始需求描述（可选，用于日志记录）"),
+		),
+	)
+}
+
+// Handle 处理执行请求（移除确认步骤）
+func (g *GVAExecutor) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	executionPlanData, ok := request.GetArguments()["executionPlan"]
+	if !ok {
+		return nil, errors.New("参数错误：executionPlan 必须提供")
+	}
+
+	// 解析执行计划
+	planJSON, err := json.Marshal(executionPlanData)
+	if err != nil {
+		return nil, fmt.Errorf("解析执行计划失败: %v", err)
+	}
+
+	var plan ExecutionPlan
+	err = json.Unmarshal(planJSON, &plan)
+	if err != nil {
+		return nil, fmt.Errorf("解析执行计划失败: %v\n\n请确保ExecutionPlan格式正确，参考工具描述中的结构体格式要求", err)
+	}
+
+	// 验证执行计划的完整性
+	if err := g.validateExecutionPlan(&plan); err != nil {
+		return nil, fmt.Errorf("执行计划验证失败: %v", err)
+	}
+
+	// 获取原始需求（可选）
+	var originalRequirement string
+	if reqData, ok := request.GetArguments()["requirement"]; ok {
+		if reqStr, ok := reqData.(string); ok {
+			originalRequirement = reqStr
+		}
+	}
+
+	// 直接执行创建操作（无确认步骤）
+	result := g.executeCreation(ctx, &plan)
+
+	// 如果执行成功且有原始需求，提供代码复检建议
+	var reviewMessage string
+	if result.Success && originalRequirement != "" {
+		global.GVA_LOG.Info("执行完成，返回生成的文件路径供AI进行代码复检...")
+
+		// 构建文件路径信息供AI使用
+		var pathsInfo []string
+		for _, path := range result.GeneratedPaths {
+			pathsInfo = append(pathsInfo, fmt.Sprintf("- %s", path))
+		}
+
+		reviewMessage = fmt.Sprintf("\n\n📁 已生成以下文件：\n%s\n\n💡 提示：可以检查生成的代码是否满足原始需求。", strings.Join(pathsInfo, "\n"))
+	} else if originalRequirement == "" {
+		reviewMessage = "\n\n💡 提示：如需代码复检，请提供原始需求描述。"
+	}
+
+	// 序列化响应
+	response := ExecuteResponse{
+		Success:        result.Success,
+		Message:        result.Message,
+		PackageID:      result.PackageID,
+		HistoryID:      result.HistoryID,
+		Paths:          result.Paths,
+		GeneratedPaths: result.GeneratedPaths,
+		NextActions:    result.NextActions,
+	}
+
+	responseJSON, err := json.MarshalIndent(response, "", "  ")
+	if err != nil {
+		return nil, fmt.Errorf("序列化结果失败: %v", err)
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.NewTextContent(fmt.Sprintf("执行结果：\n\n%s%s", string(responseJSON), reviewMessage)),
+		},
+	}, nil
+}
+
+// validateExecutionPlan 验证执行计划的完整性
+func (g *GVAExecutor) validateExecutionPlan(plan *ExecutionPlan) error {
+	// 验证基本字段
+	if plan.PackageName == "" {
+		return errors.New("packageName 不能为空")
+	}
+	if plan.PackageType != "package" && plan.PackageType != "plugin" {
+		return errors.New("packageType 必须是 'package' 或 'plugin'")
+	}
+
+	// 验证packageType和template字段的一致性
+	if plan.NeedCreatedPackage && plan.PackageInfo != nil {
+		if plan.PackageType != plan.PackageInfo.Template {
+			return errors.New("packageType 和 packageInfo.template 必须保持一致")
+		}
+	}
+
+	// 验证包信息
+	if plan.NeedCreatedPackage {
+		if plan.PackageInfo == nil {
+			return errors.New("当 needCreatedPackage=true 时，packageInfo 不能为空")
+		}
+		if plan.PackageInfo.PackageName == "" {
+			return errors.New("packageInfo.packageName 不能为空")
+		}
+		if plan.PackageInfo.Template != "package" && plan.PackageInfo.Template != "plugin" {
+			return errors.New("packageInfo.template 必须是 'package' 或 'plugin'")
+		}
+		if plan.PackageInfo.Label == "" {
+			return errors.New("packageInfo.label 不能为空")
+		}
+		if plan.PackageInfo.Desc == "" {
+			return errors.New("packageInfo.desc 不能为空")
+		}
+	}
+
+	// 验证模块信息（批量验证）
+	if plan.NeedCreatedModules {
+		if len(plan.ModulesInfo) == 0 {
+			return errors.New("当 needCreatedModules=true 时，modulesInfo 不能为空")
+		}
+
+		// 遍历验证每个模块
+		for moduleIndex, moduleInfo := range plan.ModulesInfo {
+			if moduleInfo.Package == "" {
+				return fmt.Errorf("模块 %d 的 package 不能为空", moduleIndex+1)
+			}
+			if moduleInfo.StructName == "" {
+				return fmt.Errorf("模块 %d 的 structName 不能为空", moduleIndex+1)
+			}
+			if moduleInfo.TableName == "" {
+				return fmt.Errorf("模块 %d 的 tableName 不能为空", moduleIndex+1)
+			}
+			if moduleInfo.Description == "" {
+				return fmt.Errorf("模块 %d 的 description 不能为空", moduleIndex+1)
+			}
+			if moduleInfo.Abbreviation == "" {
+				return fmt.Errorf("模块 %d 的 abbreviation 不能为空", moduleIndex+1)
+			}
+			if moduleInfo.PackageName == "" {
+				return fmt.Errorf("模块 %d 的 packageName 不能为空", moduleIndex+1)
+			}
+			if moduleInfo.HumpPackageName == "" {
+				return fmt.Errorf("模块 %d 的 humpPackageName 不能为空", moduleIndex+1)
+			}
+
+			// 验证字段信息
+			if len(moduleInfo.Fields) == 0 {
+				return fmt.Errorf("模块 %d 的 fields 不能为空，至少需要一个字段", moduleIndex+1)
+			}
+
+			for i, field := range moduleInfo.Fields {
+				if field.FieldName == "" {
+					return fmt.Errorf("模块 %d 字段 %d 的 fieldName 不能为空", moduleIndex+1, i+1)
+				}
+
+				// 确保字段名首字母大写
+				if len(field.FieldName) > 0 {
+					firstChar := string(field.FieldName[0])
+					if firstChar >= "a" && firstChar <= "z" {
+						moduleInfo.Fields[i].FieldName = strings.ToUpper(firstChar) + field.FieldName[1:]
+					}
+				}
+				if field.FieldDesc == "" {
+					return fmt.Errorf("模块 %d 字段 %d 的 fieldDesc 不能为空", moduleIndex+1, i+1)
+				}
+				if field.FieldType == "" {
+					return fmt.Errorf("模块 %d 字段 %d 的 fieldType 不能为空", moduleIndex+1, i+1)
+				}
+				if field.FieldJson == "" {
+					return fmt.Errorf("模块 %d 字段 %d 的 fieldJson 不能为空", moduleIndex+1, i+1)
+				}
+				if field.ColumnName == "" {
+					return fmt.Errorf("模块 %d 字段 %d 的 columnName 不能为空", moduleIndex+1, i+1)
+				}
+
+				// 验证字段类型
+				validFieldTypes := []string{"string", "int", "int64", "float64", "bool", "time.Time", "enum", "picture", "video", "file", "pictures", "array", "richtext", "json"}
+				validType := false
+				for _, validFieldType := range validFieldTypes {
+					if field.FieldType == validFieldType {
+						validType = true
+						break
+					}
+				}
+				if !validType {
+					return fmt.Errorf("模块 %d 字段 %d 的 fieldType '%s' 不支持，支持的类型：%v", moduleIndex+1, i+1, field.FieldType, validFieldTypes)
+				}
+
+				// 验证搜索类型（如果设置了）
+				if field.FieldSearchType != "" {
+					validSearchTypes := []string{"=", "!=", ">", ">=", "<", "<=", "LIKE", "BETWEEN", "IN", "NOT IN"}
+					validSearchType := false
+					for _, validType := range validSearchTypes {
+						if field.FieldSearchType == validType {
+							validSearchType = true
+							break
+						}
+					}
+					if !validSearchType {
+						return fmt.Errorf("模块 %d 字段 %d 的 fieldSearchType '%s' 不支持，支持的类型：%v", moduleIndex+1, i+1, field.FieldSearchType, validSearchTypes)
+					}
+				}
+
+				// 验证 dataSource 字段配置
+				if field.DataSource != nil {
+					associationValue := field.DataSource.Association
+					// 当 association 为 2（一对多关联）时，强制修改 fieldType 为 array
+					if associationValue == 2 {
+						if field.FieldType != "array" {
+							global.GVA_LOG.Info(fmt.Sprintf("模块 %d 字段 %d：检测到一对多关联(association=2)，自动将 fieldType 从 '%s' 修改为 'array'", moduleIndex+1, i+1, field.FieldType))
+							moduleInfo.Fields[i].FieldType = "array"
+						}
+					}
+
+					// 验证 association 值的有效性
+					if associationValue != 1 && associationValue != 2 {
+						return fmt.Errorf("模块 %d 字段 %d 的 dataSource.association 必须是 1（一对一）或 2（一对多）", moduleIndex+1, i+1)
+					}
+				}
+			}
+
+			// 验证主键设置
+			if !moduleInfo.GvaModel {
+				// 当不使用GVA模型时，必须有且仅有一个字段设置为主键
+				primaryKeyCount := 0
+				for _, field := range moduleInfo.Fields {
+					if field.PrimaryKey {
+						primaryKeyCount++
+					}
+				}
+				if primaryKeyCount == 0 {
+					return fmt.Errorf("模块 %d：当 gvaModel=false 时，必须有一个字段的 primaryKey=true", moduleIndex+1)
+				}
+				if primaryKeyCount > 1 {
+					return fmt.Errorf("模块 %d：当 gvaModel=false 时，只能有一个字段的 primaryKey=true", moduleIndex+1)
+				}
+			} else {
+				// 当使用GVA模型时，所有字段的primaryKey都应该为false
+				for i, field := range moduleInfo.Fields {
+					if field.PrimaryKey {
+						return fmt.Errorf("模块 %d：当 gvaModel=true 时，字段 %d 的 primaryKey 应该为 false，系统会自动创建ID主键", moduleIndex+1, i+1)
+					}
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+// executeCreation 执行创建操作
+func (g *GVAExecutor) executeCreation(ctx context.Context, plan *ExecutionPlan) *ExecuteResponse {
+	result := &ExecuteResponse{
+		Success:        false,
+		Paths:          make(map[string]string),
+		GeneratedPaths: []string{}, // 初始化生成文件路径列表
+	}
+
+	// 无论如何都先构建目录结构信息，确保paths始终返回
+	result.Paths = g.buildDirectoryStructure(plan)
+
+	// 记录预期生成的文件路径
+	result.GeneratedPaths = g.collectExpectedFilePaths(plan)
+
+	if !plan.NeedCreatedModules {
+		result.Success = true
+		result.Message += "已列出当前功能所涉及的目录结构信息; 请在paths中查看; 并且在对应指定文件中实现相关的业务逻辑; "
+		return result
+	}
+
+	// 创建包（如果需要）
+	if plan.NeedCreatedPackage && plan.PackageInfo != nil {
+		packageService := service.ServiceGroupApp.SystemServiceGroup.AutoCodePackage
+		err := packageService.Create(ctx, plan.PackageInfo)
+		if err != nil {
+			result.Message = fmt.Sprintf("创建包失败: %v", err)
+			// 即使创建包失败，也要返回paths信息
+			return result
+		}
+		result.Message += "包创建成功; "
+	}
+
+	// 创建指定字典（如果需要）
+	if plan.NeedCreatedDictionaries && len(plan.DictionariesInfo) > 0 {
+		dictResult := g.createDictionariesFromInfo(ctx, plan.DictionariesInfo)
+		result.Message += dictResult
+	}
+
+	// 批量创建字典和模块（如果需要）
+	if plan.NeedCreatedModules && len(plan.ModulesInfo) > 0 {
+		templateService := service.ServiceGroupApp.SystemServiceGroup.AutoCodeTemplate
+
+		// 遍历所有模块进行创建
+		for _, moduleInfo := range plan.ModulesInfo {
+
+			// 创建模块
+			err := moduleInfo.Pretreatment()
+			if err != nil {
+				result.Message += fmt.Sprintf("模块 %s 信息预处理失败: %v; ", moduleInfo.StructName, err)
+				continue // 继续处理下一个模块
+			}
+
+			err = templateService.Create(ctx, *moduleInfo)
+			if err != nil {
+				result.Message += fmt.Sprintf("创建模块 %s 失败: %v; ", moduleInfo.StructName, err)
+				continue // 继续处理下一个模块
+			}
+			result.Message += fmt.Sprintf("模块 %s 创建成功; ", moduleInfo.StructName)
+		}
+
+		result.Message += fmt.Sprintf("批量创建完成，共处理 %d 个模块; ", len(plan.ModulesInfo))
+
+		// 添加重要提醒：不要使用其他MCP工具
+		result.Message += "\n\n⚠️ 重要提醒：\n"
+		result.Message += "模块创建已完成，API和菜单已自动生成。请不要再调用以下MCP工具：\n"
+		result.Message += "- api_creator：API权限已在模块创建时自动生成\n"
+		result.Message += "- menu_creator：前端菜单已在模块创建时自动生成\n"
+		result.Message += "如需修改API或菜单，请直接在系统管理界面中进行配置。\n"
+	}
+
+	result.Message += "已构建目录结构信息; "
+	result.Success = true
+
+	if result.Message == "" {
+		result.Message = "执行计划完成"
+	}
+
+	return result
+}
+
+// buildDirectoryStructure 构建目录结构信息
+func (g *GVAExecutor) buildDirectoryStructure(plan *ExecutionPlan) map[string]string {
+	paths := make(map[string]string)
+
+	// 获取配置信息
+	autoCodeConfig := global.GVA_CONFIG.AutoCode
+
+	// 构建基础路径
+	rootPath := autoCodeConfig.Root
+	serverPath := autoCodeConfig.Server
+	webPath := autoCodeConfig.Web
+	moduleName := autoCodeConfig.Module
+
+	// 如果计划中有包名，使用计划中的包名，否则使用默认
+	packageName := "example"
+	if plan.PackageName != "" {
+		packageName = plan.PackageName
+	}
+
+	// 如果计划中有模块信息，获取第一个模块的结构名作为默认值
+	structName := "ExampleStruct"
+	if len(plan.ModulesInfo) > 0 && plan.ModulesInfo[0].StructName != "" {
+		structName = plan.ModulesInfo[0].StructName
+	}
+
+	// 根据包类型构建不同的路径结构
+	packageType := plan.PackageType
+	if packageType == "" {
+		packageType = "package" // 默认为package模式
+	}
+
+	// 构建服务端路径
+	if serverPath != "" {
+		serverBasePath := fmt.Sprintf("%s/%s", rootPath, serverPath)
+
+		if packageType == "plugin" {
+			// Plugin 模式：所有文件都在 /plugin/packageName/ 目录下
+			plugingBasePath := fmt.Sprintf("%s/plugin/%s", serverBasePath, packageName)
+
+			// API 路径
+			paths["api"] = fmt.Sprintf("%s/api", plugingBasePath)
+
+			// Service 路径
+			paths["service"] = fmt.Sprintf("%s/service", plugingBasePath)
+
+			// Model 路径
+			paths["model"] = fmt.Sprintf("%s/model", plugingBasePath)
+
+			// Router 路径
+			paths["router"] = fmt.Sprintf("%s/router", plugingBasePath)
+
+			// Request 路径
+			paths["request"] = fmt.Sprintf("%s/model/request", plugingBasePath)
+
+			// Response 路径
+			paths["response"] = fmt.Sprintf("%s/model/response", plugingBasePath)
+
+			// Plugin 特有文件
+			paths["plugin_main"] = fmt.Sprintf("%s/main.go", plugingBasePath)
+			paths["plugin_config"] = fmt.Sprintf("%s/plugin.go", plugingBasePath)
+			paths["plugin_initialize"] = fmt.Sprintf("%s/initialize", plugingBasePath)
+		} else {
+			// Package 模式：传统的目录结构
+			// API 路径
+			paths["api"] = fmt.Sprintf("%s/api/v1/%s", serverBasePath, packageName)
+
+			// Service 路径
+			paths["service"] = fmt.Sprintf("%s/service/%s", serverBasePath, packageName)
+
+			// Model 路径
+			paths["model"] = fmt.Sprintf("%s/model/%s", serverBasePath, packageName)
+
+			// Router 路径
+			paths["router"] = fmt.Sprintf("%s/router/%s", serverBasePath, packageName)
+
+			// Request 路径
+			paths["request"] = fmt.Sprintf("%s/model/%s/request", serverBasePath, packageName)
+
+			// Response 路径
+			paths["response"] = fmt.Sprintf("%s/model/%s/response", serverBasePath, packageName)
+		}
+	}
+
+	// 构建前端路径（两种模式相同）
+	if webPath != "" {
+		webBasePath := fmt.Sprintf("%s/%s", rootPath, webPath)
+
+		if packageType == "plugin" {
+			// Plugin 模式：前端文件也在 /plugin/packageName/ 目录下
+			pluginWebBasePath := fmt.Sprintf("%s/plugin/%s", webBasePath, packageName)
+
+			// Vue 页面路径
+			paths["vue_page"] = fmt.Sprintf("%s/view", pluginWebBasePath)
+
+			// API 路径
+			paths["vue_api"] = fmt.Sprintf("%s/api", pluginWebBasePath)
+		} else {
+			// Package 模式：传统的目录结构
+			// Vue 页面路径
+			paths["vue_page"] = fmt.Sprintf("%s/view/%s", webBasePath, packageName)
+
+			// API 路径
+			paths["vue_api"] = fmt.Sprintf("%s/api/%s", webBasePath, packageName)
+		}
+	}
+
+	// 添加模块信息
+	paths["module"] = moduleName
+	paths["package_name"] = packageName
+	paths["package_type"] = packageType
+	paths["struct_name"] = structName
+	paths["root_path"] = rootPath
+	paths["server_path"] = serverPath
+	paths["web_path"] = webPath
+
+	return paths
+}
+
+// collectExpectedFilePaths 收集预期生成的文件路径
+func (g *GVAExecutor) collectExpectedFilePaths(plan *ExecutionPlan) []string {
+	var paths []string
+
+	// 获取目录结构
+	dirPaths := g.buildDirectoryStructure(plan)
+
+	// 如果需要创建模块，添加预期的文件路径
+	if plan.NeedCreatedModules && len(plan.ModulesInfo) > 0 {
+		for _, moduleInfo := range plan.ModulesInfo {
+			structName := moduleInfo.StructName
+
+			// 后端文件
+			if apiPath, ok := dirPaths["api"]; ok {
+				paths = append(paths, fmt.Sprintf("%s/%s.go", apiPath, strings.ToLower(structName)))
+			}
+			if servicePath, ok := dirPaths["service"]; ok {
+				paths = append(paths, fmt.Sprintf("%s/%s.go", servicePath, strings.ToLower(structName)))
+			}
+			if modelPath, ok := dirPaths["model"]; ok {
+				paths = append(paths, fmt.Sprintf("%s/%s.go", modelPath, strings.ToLower(structName)))
+			}
+			if routerPath, ok := dirPaths["router"]; ok {
+				paths = append(paths, fmt.Sprintf("%s/%s.go", routerPath, strings.ToLower(structName)))
+			}
+			if requestPath, ok := dirPaths["request"]; ok {
+				paths = append(paths, fmt.Sprintf("%s/%s.go", requestPath, strings.ToLower(structName)))
+			}
+			if responsePath, ok := dirPaths["response"]; ok {
+				paths = append(paths, fmt.Sprintf("%s/%s.go", responsePath, strings.ToLower(structName)))
+			}
+
+			// 前端文件
+			if vuePage, ok := dirPaths["vue_page"]; ok {
+				paths = append(paths, fmt.Sprintf("%s/%s.vue", vuePage, strings.ToLower(structName)))
+			}
+			if vueApi, ok := dirPaths["vue_api"]; ok {
+				paths = append(paths, fmt.Sprintf("%s/%s.js", vueApi, strings.ToLower(structName)))
+			}
+		}
+	}
+
+	return paths
+}
+
+// checkDictionaryExists 检查字典是否存在
+func (g *GVAExecutor) checkDictionaryExists(dictType string) (bool, error) {
+	dictionaryService := service.ServiceGroupApp.SystemServiceGroup.DictionaryService
+	_, err := dictionaryService.GetSysDictionary(dictType, 0, nil)
+	if err != nil {
+		// 如果是记录不存在的错误，返回false
+		if strings.Contains(err.Error(), "record not found") {
+			return false, nil
+		}
+		// 其他错误返回错误信息
+		return false, err
+	}
+	return true, nil
+}
+
+// createDictionariesFromInfo 根据 DictionariesInfo 创建字典
+func (g *GVAExecutor) createDictionariesFromInfo(ctx context.Context, dictionariesInfo []*DictionaryGenerateRequest) string {
+	var messages []string
+	dictionaryService := service.ServiceGroupApp.SystemServiceGroup.DictionaryService
+	dictionaryDetailService := service.ServiceGroupApp.SystemServiceGroup.DictionaryDetailService
+
+	messages = append(messages, fmt.Sprintf("开始创建 %d 个指定字典: ", len(dictionariesInfo)))
+
+	for _, dictInfo := range dictionariesInfo {
+		// 检查字典是否存在
+		exists, err := g.checkDictionaryExists(dictInfo.DictType)
+		if err != nil {
+			messages = append(messages, fmt.Sprintf("检查字典 %s 时出错: %v; ", dictInfo.DictType, err))
+			continue
+		}
+
+		if !exists {
+			// 字典不存在，创建字典
+			dictionary := model.SysDictionary{
+				Name:   dictInfo.DictName,
+				Type:   dictInfo.DictType,
+				Status: utils.Pointer(true),
+				Desc:   dictInfo.Description,
+			}
+
+			err = dictionaryService.CreateSysDictionary(dictionary)
+			if err != nil {
+				messages = append(messages, fmt.Sprintf("创建字典 %s 失败: %v; ", dictInfo.DictType, err))
+				continue
+			}
+
+			messages = append(messages, fmt.Sprintf("成功创建字典 %s (%s); ", dictInfo.DictType, dictInfo.DictName))
+
+			// 获取刚创建的字典ID
+			var createdDict model.SysDictionary
+			err = global.GVA_DB.Where("type = ?", dictInfo.DictType).First(&createdDict).Error
+			if err != nil {
+				messages = append(messages, fmt.Sprintf("获取创建的字典失败: %v; ", err))
+				continue
+			}
+
+			// 创建字典选项
+			if len(dictInfo.Options) > 0 {
+				successCount := 0
+				for _, option := range dictInfo.Options {
+					dictionaryDetail := model.SysDictionaryDetail{
+						Label:           option.Label,
+						Value:           option.Value,
+						Status:          &[]bool{true}[0], // 默认启用
+						Sort:            option.Sort,
+						SysDictionaryID: int(createdDict.ID),
+					}
+
+					err = dictionaryDetailService.CreateSysDictionaryDetail(dictionaryDetail)
+					if err != nil {
+						global.GVA_LOG.Warn("创建字典详情项失败", zap.Error(err))
+					} else {
+						successCount++
+					}
+				}
+				messages = append(messages, fmt.Sprintf("创建了 %d 个字典选项; ", successCount))
+			}
+		} else {
+			messages = append(messages, fmt.Sprintf("字典 %s 已存在，跳过创建; ", dictInfo.DictType))
+		}
+	}
+
+	return strings.Join(messages, "")
+}

server/mcp/gva_review.go

@@ -0,0 +1,170 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+// GVAReviewer GVA代码审查工具
+type GVAReviewer struct{}
+
+// init 注册工具
+func init() {
+	RegisterTool(&GVAReviewer{})
+}
+
+// ReviewRequest 审查请求结构
+type ReviewRequest struct {
+	UserRequirement string   `json:"userRequirement"` // 经过requirement_analyze后的用户需求
+	GeneratedFiles  []string `json:"generatedFiles"`  // gva_execute创建的文件列表
+}
+
+// ReviewResponse 审查响应结构
+type ReviewResponse struct {
+	Success          bool   `json:"success"`          // 是否审查成功
+	Message          string `json:"message"`          // 审查结果消息
+	AdjustmentPrompt string `json:"adjustmentPrompt"` // 调整代码的提示
+	ReviewDetails    string `json:"reviewDetails"`    // 详细的审查结果
+}
+
+// New 创建GVA代码审查工具
+func (g *GVAReviewer) New() mcp.Tool {
+	return mcp.NewTool("gva_review",
+		mcp.WithDescription(`**GVA代码审查工具 - 在gva_execute调用后使用**
+
+**核心功能：**
+- 接收经过requirement_analyze处理的用户需求和gva_execute生成的文件列表
+- 分析生成的代码是否满足用户的原始需求
+- 检查是否涉及到关联、交互等复杂功能
+- 如果代码不满足需求，提供调整建议和新的prompt
+
+**使用场景：**
+- 在gva_execute成功执行后调用
+- 用于验证生成的代码是否完整满足用户需求
+- 检查模块间的关联关系是否正确实现
+- 发现缺失的交互功能或业务逻辑
+
+**工作流程：**
+1. 接收用户原始需求和生成的文件列表
+2. 分析需求中的关键功能点
+3. 检查生成的文件是否覆盖所有功能
+4. 识别缺失的关联关系、交互功能等
+5. 生成调整建议和新的开发prompt
+
+**输出内容：**
+- 审查结果和是否需要调整
+- 详细的缺失功能分析
+- 针对性的代码调整建议
+- 可直接使用的开发prompt
+
+**重要提示：**
+- 本工具专门用于代码质量审查，不执行实际的代码修改
+- 重点关注模块间关联、用户交互、业务流程完整性
+- 提供的调整建议应该具体可执行`),
+		mcp.WithString("userRequirement",
+			mcp.Description("经过requirement_analyze处理后的用户需求描述，包含详细的功能要求和字段信息"),
+			mcp.Required(),
+		),
+		mcp.WithString("generatedFiles",
+			mcp.Description("gva_execute创建的文件列表，JSON字符串格式，包含所有生成的后端和前端文件路径"),
+			mcp.Required(),
+		),
+	)
+}
+
+// Handle 处理审查请求
+func (g *GVAReviewer) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	// 获取用户需求
+	userRequirementData, ok := request.GetArguments()["userRequirement"]
+	if !ok {
+		return nil, errors.New("参数错误：userRequirement 必须提供")
+	}
+
+	userRequirement, ok := userRequirementData.(string)
+	if !ok {
+		return nil, errors.New("参数错误：userRequirement 必须是字符串类型")
+	}
+
+	// 获取生成的文件列表
+	generatedFilesData, ok := request.GetArguments()["generatedFiles"]
+	if !ok {
+		return nil, errors.New("参数错误：generatedFiles 必须提供")
+	}
+
+	generatedFilesStr, ok := generatedFilesData.(string)
+	if !ok {
+		return nil, errors.New("参数错误：generatedFiles 必须是JSON字符串")
+	}
+
+	// 解析JSON字符串为字符串数组
+	var generatedFiles []string
+	err := json.Unmarshal([]byte(generatedFilesStr), &generatedFiles)
+	if err != nil {
+		return nil, fmt.Errorf("解析generatedFiles失败: %v", err)
+	}
+
+	if len(generatedFiles) == 0 {
+		return nil, errors.New("参数错误：generatedFiles 不能为空")
+	}
+
+	// 直接生成调整提示，不进行复杂分析
+	adjustmentPrompt := g.generateAdjustmentPrompt(userRequirement, generatedFiles)
+
+	// 构建简化的审查详情
+	reviewDetails := fmt.Sprintf("📋 **代码审查报告**\n\n **用户原始需求：**\n%s\n\n **已生成文件数量：** %d\n\n **建议进行代码优化和完善**", userRequirement, len(generatedFiles))
+
+	// 构建审查结果
+	reviewResult := &ReviewResponse{
+		Success:          true,
+		Message:          "代码审查完成",
+		AdjustmentPrompt: adjustmentPrompt,
+		ReviewDetails:    reviewDetails,
+	}
+
+	// 序列化响应
+	responseJSON, err := json.MarshalIndent(reviewResult, "", "  ")
+	if err != nil {
+		return nil, fmt.Errorf("序列化审查结果失败: %v", err)
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.NewTextContent(fmt.Sprintf("代码审查结果：\n\n%s", string(responseJSON))),
+		},
+	}, nil
+}
+
+// generateAdjustmentPrompt 生成调整代码的提示
+func (g *GVAReviewer) generateAdjustmentPrompt(userRequirement string, generatedFiles []string) string {
+	var prompt strings.Builder
+
+	prompt.WriteString("🔧 **代码调整指导 Prompt：**\n\n")
+	prompt.WriteString(fmt.Sprintf("**用户的原始需求为：** %s\n\n", userRequirement))
+	prompt.WriteString("**经过GVA生成后的文件有如下内容：**\n")
+	for _, file := range generatedFiles {
+		prompt.WriteString(fmt.Sprintf("- %s\n", file))
+	}
+	prompt.WriteString("\n")
+
+	prompt.WriteString("**请帮我优化和完善代码，确保：**\n")
+	prompt.WriteString("1. 代码完全满足用户的原始需求\n")
+	prompt.WriteString("2. 完善模块间的关联关系，确保数据一致性\n")
+	prompt.WriteString("3. 实现所有必要的用户交互功能\n")
+	prompt.WriteString("4. 保持代码的完整性和可维护性\n")
+	prompt.WriteString("5. 遵循GVA框架的开发规范和最佳实践\n")
+	prompt.WriteString("6. 确保前后端功能完整对接\n")
+	prompt.WriteString("7. 添加必要的错误处理和数据验证\n\n")
+	prompt.WriteString("8. 如果需要vue路由跳转，请使用 menu_lister获取完整路由表，并且路由跳转使用 router.push({\"name\":从menu_lister中获取的name})\n\n")
+	prompt.WriteString("9. 如果当前所有的vue页面内容无法满足需求，则自行书写vue文件，并且调用 menu_creator创建菜单记录\n\n")
+	prompt.WriteString("10. 如果需要API调用，请使用 api_lister获取api表，根据需求调用对应接口\n\n")
+	prompt.WriteString("11. 如果当前所有API无法满足则自行书写接口，补全前后端代码，并使用 api_creator创建api记录\n\n")
+	prompt.WriteString("12. 无论前后端都不要随意删除import的内容\n\n")
+	prompt.WriteString("**请基于用户需求和现有文件，提供完整的代码优化方案。**")
+
+	return prompt.String()
+}

server/mcp/menu_creator.go

@@ -0,0 +1,277 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"github.com/flipped-aurora/gin-vue-admin/server/service"
+	"github.com/mark3labs/mcp-go/mcp"
+	"go.uber.org/zap"
+)
+
+// 注册工具
+func init() {
+	RegisterTool(&MenuCreator{})
+}
+
+// MenuCreateRequest 菜单创建请求结构
+type MenuCreateRequest struct {
+	ParentId    uint                   `json:"parentId"`    // 父菜单ID，0表示根菜单
+	Path        string                 `json:"path"`        // 路由path
+	Name        string                 `json:"name"`        // 路由name
+	Hidden      bool                   `json:"hidden"`      // 是否在列表隐藏
+	Component   string                 `json:"component"`   // 对应前端文件路径
+	Sort        int                    `json:"sort"`        // 排序标记
+	Title       string                 `json:"title"`       // 菜单名
+	Icon        string                 `json:"icon"`        // 菜单图标
+	KeepAlive   bool                   `json:"keepAlive"`   // 是否缓存
+	DefaultMenu bool                   `json:"defaultMenu"` // 是否是基础路由
+	CloseTab    bool                   `json:"closeTab"`    // 自动关闭tab
+	ActiveName  string                 `json:"activeName"`  // 高亮菜单
+	Parameters  []MenuParameterRequest `json:"parameters"`  // 路由参数
+	MenuBtn     []MenuButtonRequest    `json:"menuBtn"`     // 菜单按钮
+}
+
+// MenuParameterRequest 菜单参数请求结构
+type MenuParameterRequest struct {
+	Type  string `json:"type"`  // 参数类型：params或query
+	Key   string `json:"key"`   // 参数key
+	Value string `json:"value"` // 参数值
+}
+
+// MenuButtonRequest 菜单按钮请求结构
+type MenuButtonRequest struct {
+	Name string `json:"name"` // 按钮名称
+	Desc string `json:"desc"` // 按钮描述
+}
+
+// MenuCreateResponse 菜单创建响应结构
+type MenuCreateResponse struct {
+	Success bool   `json:"success"`
+	Message string `json:"message"`
+	MenuID  uint   `json:"menuId"`
+	Name    string `json:"name"`
+	Path    string `json:"path"`
+}
+
+// MenuCreator 菜单创建工具
+type MenuCreator struct{}
+
+// New 创建菜单创建工具
+func (m *MenuCreator) New() mcp.Tool {
+	return mcp.NewTool("create_menu",
+		mcp.WithDescription(`创建前端菜单记录，用于AI编辑器自动添加前端页面时自动创建对应的菜单项。
+
+**重要限制：**
+- 当使用gva_auto_generate工具且needCreatedModules=true时，模块创建会自动生成菜单项，不应调用此工具
+- 仅在以下情况使用：1) 单独创建菜单（不涉及模块创建）；2) AI编辑器自动添加前端页面时`),
+		mcp.WithNumber("parentId",
+			mcp.Description("父菜单ID，0表示根菜单"),
+			mcp.DefaultNumber(0),
+		),
+		mcp.WithString("path",
+			mcp.Required(),
+			mcp.Description("路由path，如：userList"),
+		),
+		mcp.WithString("name",
+			mcp.Required(),
+			mcp.Description("路由name，用于Vue Router，如：userList"),
+		),
+		mcp.WithBoolean("hidden",
+			mcp.Description("是否在菜单列表中隐藏"),
+		),
+		mcp.WithString("component",
+			mcp.Required(),
+			mcp.Description("对应的前端Vue组件路径，如：view/user/list.vue"),
+		),
+		mcp.WithNumber("sort",
+			mcp.Description("菜单排序号，数字越小越靠前"),
+			mcp.DefaultNumber(1),
+		),
+		mcp.WithString("title",
+			mcp.Required(),
+			mcp.Description("菜单显示标题"),
+		),
+		mcp.WithString("icon",
+			mcp.Description("菜单图标名称"),
+			mcp.DefaultString("menu"),
+		),
+		mcp.WithBoolean("keepAlive",
+			mcp.Description("是否缓存页面"),
+		),
+		mcp.WithBoolean("defaultMenu",
+			mcp.Description("是否是基础路由"),
+		),
+		mcp.WithBoolean("closeTab",
+			mcp.Description("是否自动关闭tab"),
+		),
+		mcp.WithString("activeName",
+			mcp.Description("高亮菜单名称"),
+		),
+		mcp.WithString("parameters",
+			mcp.Description("路由参数JSON字符串，格式：[{\"type\":\"params\",\"key\":\"id\",\"value\":\"1\"}]"),
+		),
+		mcp.WithString("menuBtn",
+			mcp.Description("菜单按钮JSON字符串，格式：[{\"name\":\"add\",\"desc\":\"新增\"}]"),
+		),
+	)
+}
+
+// Handle 处理菜单创建请求
+func (m *MenuCreator) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	// 解析请求参数
+	args := request.GetArguments()
+
+	// 必需参数
+	path, ok := args["path"].(string)
+	if !ok || path == "" {
+		return nil, errors.New("path 参数是必需的")
+	}
+
+	name, ok := args["name"].(string)
+	if !ok || name == "" {
+		return nil, errors.New("name 参数是必需的")
+	}
+
+	component, ok := args["component"].(string)
+	if !ok || component == "" {
+		return nil, errors.New("component 参数是必需的")
+	}
+
+	title, ok := args["title"].(string)
+	if !ok || title == "" {
+		return nil, errors.New("title 参数是必需的")
+	}
+
+	// 可选参数
+	parentId := uint(0)
+	if val, ok := args["parentId"].(float64); ok {
+		parentId = uint(val)
+	}
+
+	hidden := false
+	if val, ok := args["hidden"].(bool); ok {
+		hidden = val
+	}
+
+	sort := 1
+	if val, ok := args["sort"].(float64); ok {
+		sort = int(val)
+	}
+
+	icon := "menu"
+	if val, ok := args["icon"].(string); ok && val != "" {
+		icon = val
+	}
+
+	keepAlive := false
+	if val, ok := args["keepAlive"].(bool); ok {
+		keepAlive = val
+	}
+
+	defaultMenu := false
+	if val, ok := args["defaultMenu"].(bool); ok {
+		defaultMenu = val
+	}
+
+	closeTab := false
+	if val, ok := args["closeTab"].(bool); ok {
+		closeTab = val
+	}
+
+	activeName := ""
+	if val, ok := args["activeName"].(string); ok {
+		activeName = val
+	}
+
+	// 解析参数和按钮
+	var parameters []system.SysBaseMenuParameter
+	if parametersStr, ok := args["parameters"].(string); ok && parametersStr != "" {
+		var paramReqs []MenuParameterRequest
+		if err := json.Unmarshal([]byte(parametersStr), &paramReqs); err != nil {
+			return nil, fmt.Errorf("parameters 参数格式错误: %v", err)
+		}
+		for _, param := range paramReqs {
+			parameters = append(parameters, system.SysBaseMenuParameter{
+				Type:  param.Type,
+				Key:   param.Key,
+				Value: param.Value,
+			})
+		}
+	}
+
+	var menuBtn []system.SysBaseMenuBtn
+	if menuBtnStr, ok := args["menuBtn"].(string); ok && menuBtnStr != "" {
+		var btnReqs []MenuButtonRequest
+		if err := json.Unmarshal([]byte(menuBtnStr), &btnReqs); err != nil {
+			return nil, fmt.Errorf("menuBtn 参数格式错误: %v", err)
+		}
+		for _, btn := range btnReqs {
+			menuBtn = append(menuBtn, system.SysBaseMenuBtn{
+				Name: btn.Name,
+				Desc: btn.Desc,
+			})
+		}
+	}
+
+	// 构建菜单对象
+	menu := system.SysBaseMenu{
+		ParentId:  parentId,
+		Path:      path,
+		Name:      name,
+		Hidden:    hidden,
+		Component: component,
+		Sort:      sort,
+		Meta: system.Meta{
+			Title:       title,
+			Icon:        icon,
+			KeepAlive:   keepAlive,
+			DefaultMenu: defaultMenu,
+			CloseTab:    closeTab,
+			ActiveName:  activeName,
+		},
+		Parameters: parameters,
+		MenuBtn:    menuBtn,
+	}
+
+	// 创建菜单
+	menuService := service.ServiceGroupApp.SystemServiceGroup.MenuService
+	err := menuService.AddBaseMenu(menu)
+	if err != nil {
+		return nil, fmt.Errorf("创建菜单失败: %v", err)
+	}
+
+	// 获取创建的菜单ID
+	var createdMenu system.SysBaseMenu
+	err = global.GVA_DB.Where("name = ? AND path = ?", name, path).First(&createdMenu).Error
+	if err != nil {
+		global.GVA_LOG.Warn("获取创建的菜单ID失败", zap.Error(err))
+	}
+
+	// 构建响应
+	response := &MenuCreateResponse{
+		Success: true,
+		Message: fmt.Sprintf("成功创建菜单 %s", title),
+		MenuID:  createdMenu.ID,
+		Name:    name,
+		Path:    path,
+	}
+
+	resultJSON, err := json.MarshalIndent(response, "", "  ")
+	if err != nil {
+		return nil, fmt.Errorf("序列化结果失败: %v", err)
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.TextContent{
+				Type: "text",
+				Text: fmt.Sprintf("菜单创建结果：\n\n%s", string(resultJSON)),
+			},
+		},
+	}, nil
+}

server/mcp/menu_lister.go

@@ -0,0 +1,115 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"github.com/mark3labs/mcp-go/mcp"
+	"go.uber.org/zap"
+)
+
+// 注册工具
+func init() {
+	// 注册工具将在enter.go中统一处理
+	RegisterTool(&MenuLister{})
+}
+
+// MenuListResponse 菜单列表响应结构
+type MenuListResponse struct {
+	Success     bool                  `json:"success"`
+	Message     string                `json:"message"`
+	Menus       []system.SysBaseMenu  `json:"menus"`
+	TotalCount  int                   `json:"totalCount"`
+	Description string                `json:"description"`
+}
+
+// MenuLister 菜单列表工具
+type MenuLister struct{}
+
+// New 创建菜单列表工具
+func (m *MenuLister) New() mcp.Tool {
+	return mcp.NewTool("list_all_menus",
+		mcp.WithDescription(`获取系统中所有菜单信息，包括菜单树结构、路由信息、组件路径等，用于前端编写vue-router时正确跳转
+
+**功能说明：**
+- 返回完整的菜单树形结构
+- 包含路由配置信息（path、name、component）
+- 包含菜单元数据（title、icon、keepAlive等）
+- 包含菜单参数和按钮配置
+- 支持父子菜单关系展示
+
+**使用场景：**
+- 前端路由配置：获取所有菜单信息用于配置vue-router
+- 菜单权限管理：了解系统中所有可用的菜单项
+- 导航组件开发：构建动态导航菜单
+- 系统架构分析：了解系统的菜单结构和页面组织`),
+mcp.WithString("_placeholder",
+			mcp.Description("占位符，防止json schema校验失败"),
+		),	
+	)
+}
+
+// Handle 处理菜单列表请求
+func (m *MenuLister) Handle(_ context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	// 获取所有基础菜单
+	allMenus, err := m.getAllMenus()
+	if err != nil {
+		global.GVA_LOG.Error("获取菜单列表失败", zap.Error(err))
+		return &mcp.CallToolResult{
+			Content: []mcp.Content{
+				mcp.TextContent{
+					Type: "text",
+					Text: fmt.Sprintf("获取菜单列表失败: %v", err),
+				},
+			},
+			IsError: true,
+		}, nil
+	}
+
+	// 构建返回结果
+	response := MenuListResponse{
+		Success:     true,
+		Message:     "获取菜单列表成功",
+		Menus:       allMenus,
+		TotalCount:  len(allMenus),
+		Description: "系统中所有菜单信息的标准列表，包含路由配置和组件信息",
+	}
+
+	// 序列化响应
+	responseJSON, err := json.MarshalIndent(response, "", "  ")
+	if err != nil {
+		global.GVA_LOG.Error("序列化菜单响应失败", zap.Error(err))
+		return &mcp.CallToolResult{
+			Content: []mcp.Content{
+				mcp.TextContent{
+					Type: "text",
+					Text: fmt.Sprintf("序列化响应失败: %v", err),
+				},
+			},
+			IsError: true,
+		}, nil
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.TextContent{
+				Type: "text",
+				Text: string(responseJSON),
+			},
+		},
+	}, nil
+}
+
+// getAllMenus 获取所有基础菜单
+func (m *MenuLister) getAllMenus() ([]system.SysBaseMenu, error) {
+	var menus []system.SysBaseMenu
+	err := global.GVA_DB.Order("sort").Preload("Parameters").Preload("MenuBtn").Find(&menus).Error
+	if err != nil {
+		return nil, err
+	}
+	return menus, nil
+}
+

server/mcp/requirement_analyzer.go

@@ -0,0 +1,199 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+func init() {
+	RegisterTool(&RequirementAnalyzer{})
+}
+
+type RequirementAnalyzer struct{}
+
+// RequirementAnalysisRequest 需求分析请求
+type RequirementAnalysisRequest struct {
+	UserRequirement string `json:"userRequirement"`
+}
+
+// RequirementAnalysisResponse 需求分析响应
+type RequirementAnalysisResponse struct {
+	AIPrompt string `json:"aiPrompt"` // 给AI的提示词
+}
+
+// New 返回工具注册信息
+func (t *RequirementAnalyzer) New() mcp.Tool {
+	return mcp.NewTool("requirement_analyzer",
+		mcp.WithDescription(`** 智能需求分析与模块设计工具 - 首选入口工具（最高优先级）**
+
+** 重要提示：这是所有MCP工具的首选入口，请优先使用！**
+
+** 核心能力：**
+作为资深系统架构师，智能分析用户需求并自动设计完整的模块架构
+
+** 核心功能：**
+1. **智能需求解构**：深度分析用户需求，识别核心业务实体、业务流程、数据关系
+2. **自动模块设计**：基于需求分析，智能确定需要多少个模块及各模块功能
+3. **字段智能推导**：为每个模块自动设计详细字段，包含数据类型、关联关系、字典需求
+4. **架构优化建议**：提供模块拆分、关联设计、扩展性等专业建议
+
+** 输出内容：**
+- 模块数量和架构设计
+- 每个模块的详细字段清单
+- 数据类型和关联关系设计
+- 字典需求和类型定义
+- 模块间关系图和扩展建议
+
+** 适用场景：**
+- 用户需求描述不完整，需要智能补全
+- 复杂业务系统的模块架构设计
+- 需要专业的数据库设计建议
+- 想要快速搭建生产级业务系统
+
+** 推荐工作流：**
+ requirement_analyzer → gva_analyze → gva_execute → 其他辅助工具
+ 
+ `),
+		mcp.WithString("userRequirement",
+			mcp.Required(),
+			mcp.Description("用户的需求描述，支持自然语言，如：'我要做一个猫舍管理系统，用来录入猫的信息，并且记录每只猫每天的活动信息'"),
+		),
+	)
+}
+
+// Handle 处理工具调用
+func (t *RequirementAnalyzer) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	userRequirement, ok := request.GetArguments()["userRequirement"].(string)
+	if !ok || userRequirement == "" {
+		return nil, errors.New("参数错误：userRequirement 必须是非空字符串")
+	}
+
+	// 分析用户需求
+	analysisResponse, err := t.analyzeRequirement(userRequirement)
+	if err != nil {
+		return nil, fmt.Errorf("需求分析失败: %v", err)
+	}
+
+	// 序列化响应
+	responseData, err := json.Marshal(analysisResponse)
+	if err != nil {
+		return nil, fmt.Errorf("序列化响应失败: %v", err)
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.NewTextContent(string(responseData)),
+		},
+	}, nil
+}
+
+// analyzeRequirement 分析用户需求 - 专注于AI需求传递
+func (t *RequirementAnalyzer) analyzeRequirement(userRequirement string) (*RequirementAnalysisResponse, error) {
+	// 生成AI提示词 - 这是唯一功能
+	aiPrompt := t.generateAIPrompt(userRequirement)
+
+	return &RequirementAnalysisResponse{
+		AIPrompt: aiPrompt,
+	}, nil
+}
+
+// generateAIPrompt 生成AI提示词 - 智能分析需求并确定模块结构
+func (t *RequirementAnalyzer) generateAIPrompt(userRequirement string) string {
+	prompt := fmt.Sprintf(`# 智能需求分析与模块设计任务
+
+## 用户原始需求
+%s
+
+## 核心任务
+你需要作为一个资深的系统架构师，深度分析用户需求，智能设计出完整的模块架构。
+
+## 分析步骤
+
+### 第一步：需求解构分析
+请仔细分析用户需求，识别出：
+1. **核心业务实体**（如：用户、商品、订单、疫苗、宠物等）
+2. **业务流程**（如：注册、购买、记录、管理等）
+3. **数据关系**（实体间的关联关系）
+4. **功能模块**（需要哪些独立的管理模块）
+
+### 第二步：模块架构设计
+基于需求分析，设计出模块架构，格式如下：
+
+**模块1：[模块名称]**
+- 功能描述：[该模块的核心功能]
+- 主要字段：[列出关键字段，注明数据类型]
+- 关联关系：[与其他模块的关系，明确一对一/一对多]
+- 字典需求：[需要哪些字典类型]
+
+**模块2：[模块名称]**
+- 功能描述：[该模块的核心功能]
+- 主要字段：[列出关键字段，注明数据类型]
+- 关联关系：[与其他模块的关系]
+- 字典需求：[需要哪些字典类型]
+
+**...**
+
+### 第三步：字段详细设计
+为每个模块详细设计字段：
+
+#### 模块1字段清单：
+- 字段名1 (数据类型) - 字段描述 [是否必填] [关联信息/字典类型]
+- 字段名2 (数据类型) - 字段描述 [是否必填] [关联信息/字典类型]
+- ...
+
+#### 模块2字段清单：
+- 字段名1 (数据类型) - 字段描述 [是否必填] [关联信息/字典类型]
+- ...
+
+## 智能分析指导原则
+
+### 模块拆分原则
+1. **单一职责**：每个模块只负责一个核心业务实体
+2. **数据完整性**：相关数据应该在同一模块中
+3. **业务独立性**：模块应该能够独立完成特定业务功能
+4. **扩展性考虑**：为未来功能扩展预留空间
+
+### 字段设计原则
+1. **必要性**：只包含业务必需的字段
+2. **规范性**：遵循数据库设计规范
+3. **关联性**：正确识别实体间关系
+4. **字典化**：状态、类型等枚举值使用字典
+
+### 关联关系识别
+- **一对一**：一个实体只能关联另一个实体的一个记录
+- **一对多**：一个实体可以关联另一个实体的多个记录
+- **多对多**：通过中间表实现复杂关联
+
+## 特殊场景处理
+
+### 复杂实体识别
+当用户提到某个概念时，要判断它是否需要独立模块：
+- **字典处理**：简单的常见的状态、类型（如：开关、性别、完成状态等）
+- **独立模块**：复杂实体（如：疫苗管理、宠物档案、注射记录）
+
+## 输出要求
+
+### 必须包含的信息
+1. **模块数量**：明确需要几个模块
+2. **模块关系图**：用文字描述模块间关系
+3. **核心字段**：每个模块的关键字段（至少5-10个）
+4. **数据类型**：string、int、bool、time.Time、float64等
+5. **关联设计**：明确哪些字段是关联字段
+6. **字典需求**：列出需要创建的字典类型
+
+### 严格遵循用户输入
+- 如果用户提供了具体字段，**必须使用**用户提供的字段
+- 如果用户提供了SQL文件，**严格按照**SQL结构设计
+- **不要**随意发散，**不要**添加用户未提及的功能
+---
+
+**现在请开始深度分析用户需求："%s"**
+
+请按照上述框架进行系统性分析，确保输出的模块设计既满足当前需求，又具备良好的扩展性。`, userRequirement, userRequirement)
+
+	return prompt
+}

server/middleware/casbin_rbac.go

@@ -1,13 +1,12 @@
 package middleware
 
 import (
-	"strconv"
-	"strings"
-
 	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
 	"github.com/flipped-aurora/gin-vue-admin/server/utils"
 	"github.com/gin-gonic/gin"
+	"strconv"
+	"strings"
 )
 
 // CasbinHandler 拦截器

server/middleware/jwt.go

@@ -2,11 +2,12 @@ package middleware
 
 import (
 	"errors"
+	"strconv"
+	"time"
+
 	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	"github.com/flipped-aurora/gin-vue-admin/server/utils"
 	"github.com/golang-jwt/jwt/v5"
-	"strconv"
-	"time"
 
 	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
 	"github.com/gin-gonic/gin"
@@ -17,7 +18,7 @@ func JWTAuth() gin.HandlerFunc {
 		// 我们这里jwt鉴权取头部信息 x-token 登录时回返回token信息 这里前端需要把token存储到cookie或者本地localStorage中 不过需要跟后端协商过期时间 可以约定刷新令牌或者重新登录
 		token := utils.GetToken(c)
 		if token == "" {
-			response.NoAuth("未登录或非法访问", c)
+			response.NoAuth("未登录或非法访问，请登录", c)
 			c.Abort()
 			return
 		}
@@ -32,7 +33,7 @@ func JWTAuth() gin.HandlerFunc {
 		claims, err := j.ParseToken(token)
 		if err != nil {
 			if errors.Is(err, utils.TokenExpired) {
-				response.NoAuth("授权已过期", c)
+				response.NoAuth("登录已过期，请重新登录", c)
 				utils.ClearToken(c)
 				c.Abort()
 				return
@@ -59,7 +60,7 @@ func JWTAuth() gin.HandlerFunc {
 			newClaims, _ := j.ParseToken(newToken)
 			c.Header("new-token", newToken)
 			c.Header("new-expires-at", strconv.FormatInt(newClaims.ExpiresAt.Unix(), 10))
-			utils.SetToken(c, newToken, int(dr.Seconds()))
+			utils.SetToken(c, newToken, int(dr.Seconds()/60))
 			if global.GVA_CONFIG.System.UseMultipoint {
 				// 记录新的活跃jwt
 				_ = utils.SetRedisJWT(newToken, newClaims.Username)

server/middleware/timeout.go

@@ -0,0 +1,55 @@
+package middleware
+
+import (
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"time"
+)
+
+// TimeoutMiddleware 创建超时中间件
+// 入参 timeout 设置超时时间（例如：time.Second * 5）
+// 使用示例 xxx.Get("path",middleware.TimeoutMiddleware(30*time.Second),HandleFunc)
+func TimeoutMiddleware(timeout time.Duration) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		ctx, cancel := context.WithTimeout(c.Request.Context(), timeout)
+		defer cancel()
+
+		c.Request = c.Request.WithContext(ctx)
+
+		// 使用 buffered channel 避免 goroutine 泄漏
+		done := make(chan struct{}, 1)
+		panicChan := make(chan interface{}, 1)
+
+		go func() {
+			defer func() {
+				if p := recover(); p != nil {
+					select {
+					case panicChan <- p:
+					default:
+					}
+				}
+				select {
+				case done <- struct{}{}:
+				default:
+				}
+			}()
+			c.Next()
+		}()
+
+		select {
+		case p := <-panicChan:
+			panic(p)
+		case <-done:
+			return
+		case <-ctx.Done():
+			// 确保服务器超时设置足够长
+			c.Header("Connection", "close")
+			c.AbortWithStatusJSON(http.StatusGatewayTimeout, gin.H{
+				"code": 504,
+				"msg":  "请求超时",
+			})
+			return
+		}
+	}
+}

server/model/common/response/response.go

@@ -18,7 +18,6 @@ const (
 )
 
 func Result(code int, data interface{}, msg string, c *gin.Context) {
-	// 开始时间
 	c.JSON(http.StatusOK, Response{
 		code,
 		data,

server/model/system/request/sys_dictionary.go

@@ -0,0 +1,5 @@
+package request
+
+type SysDictionarySearch struct {
+	Name string `json:"name" form:"name" gorm:"column:name;comment:字典名（中）"` // 字典名（中）
+}

server/model/system/request/sys_dictionary_detail.go

@@ -8,4 +8,36 @@ import (
 type SysDictionaryDetailSearch struct {
 	system.SysDictionaryDetail
 	request.PageInfo
+	ParentID *uint `json:"parentID" form:"parentID"` // 父级字典详情ID，用于查询指定父级下的子项
+	Level    *int  `json:"level" form:"level"`       // 层级深度，用于查询指定层级的数据
+}
+
+// CreateSysDictionaryDetailRequest 创建字典详情请求
+type CreateSysDictionaryDetailRequest struct {
+	Label           string `json:"label" form:"label" binding:"required"`                     // 展示值
+	Value           string `json:"value" form:"value" binding:"required"`                     // 字典值
+	Extend          string `json:"extend" form:"extend"`                                      // 扩展值
+	Status          *bool  `json:"status" form:"status"`                                      // 启用状态
+	Sort            int    `json:"sort" form:"sort"`                                          // 排序标记
+	SysDictionaryID int    `json:"sysDictionaryID" form:"sysDictionaryID" binding:"required"` // 关联标记
+	ParentID        *uint  `json:"parentID" form:"parentID"`                                  // 父级字典详情ID
+}
+
+// UpdateSysDictionaryDetailRequest 更新字典详情请求
+type UpdateSysDictionaryDetailRequest struct {
+	ID              uint   `json:"ID" form:"ID" binding:"required"`                           // 主键ID
+	Label           string `json:"label" form:"label" binding:"required"`                     // 展示值
+	Value           string `json:"value" form:"value" binding:"required"`                     // 字典值
+	Extend          string `json:"extend" form:"extend"`                                      // 扩展值
+	Status          *bool  `json:"status" form:"status"`                                      // 启用状态
+	Sort            int    `json:"sort" form:"sort"`                                          // 排序标记
+	SysDictionaryID int    `json:"sysDictionaryID" form:"sysDictionaryID" binding:"required"` // 关联标记
+	ParentID        *uint  `json:"parentID" form:"parentID"`                                  // 父级字典详情ID
+}
+
+// GetDictionaryDetailsByParentRequest 根据父级ID获取字典详情请求
+type GetDictionaryDetailsByParentRequest struct {
+	SysDictionaryID int   `json:"sysDictionaryID" form:"sysDictionaryID" binding:"required"` // 字典ID
+	ParentID        *uint `json:"parentID" form:"parentID"`                                  // 父级字典详情ID，为空时获取顶级
+	IncludeChildren bool  `json:"includeChildren" form:"includeChildren"`                    // 是否包含子级数据
 }

server/model/system/request/sys_error.go

@@ -0,0 +1,14 @@
+
+package request
+
+import (
+	"github.com/flipped-aurora/gin-vue-admin/server/model/common/request"
+	"time"
+)
+
+type SysErrorSearch struct{
+    CreatedAtRange []time.Time `json:"createdAtRange" form:"createdAtRange[]"`
+      Form  *string `json:"form" form:"form"` 
+      Info  *string `json:"info" form:"info"` 
+    request.PageInfo
+}

server/model/system/request/sys_user.go

@@ -56,7 +56,6 @@ type ChangeUserInfo struct {
 	AuthorityIds []uint                `json:"authorityIds" gorm:"-"`                                                                // 角色ID
 	Email        string                `json:"email"  gorm:"comment:用户邮箱"`                                                           // 用户邮箱
 	HeaderImg    string                `json:"headerImg" gorm:"default:https://qmplusimg.henrongyi.top/gva_header.jpg;comment:用户头像"` // 用户头像
-	SideMode     string                `json:"sideMode"  gorm:"comment:用户侧边主题"`                                                      // 用户侧边主题
 	Enable       int                   `json:"enable" gorm:"comment:冻结用户"`                                                           //冻结用户
 	Authorities  []system.SysAuthority `json:"-" gorm:"many2many:sys_user_authority;"`
 }

server/model/system/request/sys_version.go

@@ -0,0 +1,40 @@
+package request
+
+import (
+	"github.com/flipped-aurora/gin-vue-admin/server/model/common/request"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"time"
+)
+
+type SysVersionSearch struct {
+	CreatedAtRange []time.Time `json:"createdAtRange" form:"createdAtRange[]"`
+	VersionName    *string     `json:"versionName" form:"versionName"`
+	VersionCode    *string     `json:"versionCode" form:"versionCode"`
+	request.PageInfo
+}
+
+// ExportVersionRequest 导出版本请求结构体
+type ExportVersionRequest struct {
+	VersionName string `json:"versionName" binding:"required"` // 版本名称
+	VersionCode string `json:"versionCode" binding:"required"` // 版本号
+	Description string `json:"description"`                    // 版本描述
+	MenuIds     []uint `json:"menuIds"`                        // 选中的菜单ID列表
+	ApiIds      []uint `json:"apiIds"`                         // 选中的API ID列表
+	DictIds     []uint `json:"dictIds"`                        // 选中的字典ID列表
+}
+
+// ImportVersionRequest 导入版本请求结构体
+type ImportVersionRequest struct {
+	VersionInfo      VersionInfo            `json:"version" binding:"required"` // 版本信息
+	ExportMenu       []system.SysBaseMenu   `json:"menus"`                      // 菜单数据，直接复用SysBaseMenu
+	ExportApi        []system.SysApi        `json:"apis"`                       // API数据，直接复用SysApi
+	ExportDictionary []system.SysDictionary `json:"dictionaries"`               // 字典数据，直接复用SysDictionary
+}
+
+// VersionInfo 版本信息结构体
+type VersionInfo struct {
+	Name        string `json:"name" binding:"required"`        // 版本名称
+	Code        string `json:"code" binding:"required"`        // 版本号
+	Description string `json:"description"`                    // 版本描述
+	ExportTime  string `json:"exportTime"`                     // 导出时间
+}

server/model/system/response/sys_version.go

@@ -0,0 +1,14 @@
+package response
+
+import (
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
+)
+
+// ExportVersionResponse 导出版本响应结构体
+type ExportVersionResponse struct {
+	Version      request.VersionInfo    `json:"version"`      // 版本信息
+	Menus        []system.SysBaseMenu   `json:"menus"`        // 菜单数据，直接复用SysBaseMenu
+	Apis         []system.SysApi        `json:"apis"`         // API数据，直接复用SysApi
+	Dictionaries []system.SysDictionary `json:"dictionaries"` // 字典数据，直接复用SysDictionary
+}

server/model/system/sys_dictionary.go

@@ -8,10 +8,12 @@ import (
 // 如果含有time.Time 请自行import time包
 type SysDictionary struct {
 	global.GVA_MODEL
-	Name                 string                `json:"name" form:"name" gorm:"column:name;comment:字典名（中）"`   // 字典名（中）
-	Type                 string                `json:"type" form:"type" gorm:"column:type;comment:字典名（英）"`   // 字典名（英）
-	Status               *bool                 `json:"status" form:"status" gorm:"column:status;comment:状态"` // 状态
-	Desc                 string                `json:"desc" form:"desc" gorm:"column:desc;comment:描述"`       // 描述
+	Name                 string                `json:"name" form:"name" gorm:"column:name;comment:字典名（中）"`              // 字典名（中）
+	Type                 string                `json:"type" form:"type" gorm:"column:type;comment:字典名（英）"`              // 字典名（英）
+	Status               *bool                 `json:"status" form:"status" gorm:"column:status;comment:状态"`            // 状态
+	Desc                 string                `json:"desc" form:"desc" gorm:"column:desc;comment:描述"`                  // 描述
+	ParentID             *uint                 `json:"parentID" form:"parentID" gorm:"column:parent_id;comment:父级字典ID"` // 父级字典ID
+	Children             []SysDictionary       `json:"children" gorm:"foreignKey:ParentID"`                             // 子字典
 	SysDictionaryDetails []SysDictionaryDetail `json:"sysDictionaryDetails" form:"sysDictionaryDetails"`
 }
 

server/model/system/sys_dictionary_detail.go

@@ -8,12 +8,17 @@ import (
 // 如果含有time.Time 请自行import time包
 type SysDictionaryDetail struct {
 	global.GVA_MODEL
-	Label           string `json:"label" form:"label" gorm:"column:label;comment:展示值"`                                  // 展示值
-	Value           string `json:"value" form:"value" gorm:"column:value;comment:字典值"`                                  // 字典值
-	Extend          string `json:"extend" form:"extend" gorm:"column:extend;comment:扩展值"`                               // 扩展值
-	Status          *bool  `json:"status" form:"status" gorm:"column:status;comment:启用状态"`                              // 启用状态
-	Sort            int    `json:"sort" form:"sort" gorm:"column:sort;comment:排序标记"`                                    // 排序标记
-	SysDictionaryID int    `json:"sysDictionaryID" form:"sysDictionaryID" gorm:"column:sys_dictionary_id;comment:关联标记"` // 关联标记
+	Label           string                `json:"label" form:"label" gorm:"column:label;comment:展示值"`                                  // 展示值
+	Value           string                `json:"value" form:"value" gorm:"column:value;comment:字典值"`                                  // 字典值
+	Extend          string                `json:"extend" form:"extend" gorm:"column:extend;comment:扩展值"`                               // 扩展值
+	Status          *bool                 `json:"status" form:"status" gorm:"column:status;comment:启用状态"`                              // 启用状态
+	Sort            int                   `json:"sort" form:"sort" gorm:"column:sort;comment:排序标记"`                                    // 排序标记
+	SysDictionaryID int                   `json:"sysDictionaryID" form:"sysDictionaryID" gorm:"column:sys_dictionary_id;comment:关联标记"` // 关联标记
+	ParentID        *uint                 `json:"parentID" form:"parentID" gorm:"column:parent_id;comment:父级字典详情ID"`                   // 父级字典详情ID
+	Children        []SysDictionaryDetail `json:"children" gorm:"foreignKey:ParentID"`                                                 // 子字典详情
+	Level           int                   `json:"level" form:"level" gorm:"column:level;comment:层级深度"`                                 // 层级深度，从0开始
+	Path            string                `json:"path" form:"path" gorm:"column:path;comment:层级路径"`                                    // 层级路径，如 "1,2,3"
+	Disabled        bool                  `json:"disabled" gorm:"-"`                                                                   // 禁用状态，根据status字段动态计算
 }
 
 func (SysDictionaryDetail) TableName() string {

server/model/system/sys_error.go

@@ -0,0 +1,20 @@
+// 自动生成模板SysError
+package system
+
+import (
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+)
+
+// 错误日志 结构体  SysError
+type SysError struct {
+	global.GVA_MODEL
+	Form     *string `json:"form" form:"form" gorm:"comment:错误来源;column:form;type:text;" binding:"required"` //错误来源
+	Info     *string `json:"info" form:"info" gorm:"comment:错误内容;column:info;type:text;"`                    //错误内容
+	Level    string  `json:"level" form:"level" gorm:"comment:日志等级;column:level;"`
+	Solution *string `json:"solution" form:"solution" gorm:"comment:解决方案;column:solution;"` //解决方案
+}
+
+// TableName 错误日志 SysError自定义表名 sys_error
+func (SysError) TableName() string {
+	return "sys_error"
+}

server/model/system/sys_version.go

@@ -0,0 +1,20 @@
+// 自动生成模板SysVersion
+package system
+
+import (
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+)
+
+// 版本管理 结构体  SysVersion
+type SysVersion struct {
+	global.GVA_MODEL
+	VersionName *string `json:"versionName" form:"versionName" gorm:"comment:版本名称;column:version_name;size:255;" binding:"required"`                           //版本名称
+	VersionCode *string `json:"versionCode" form:"versionCode" gorm:"comment:版本号;column:version_code;size:100;" binding:"required"`                            //版本号
+	Description *string `json:"description" form:"description" gorm:"comment:版本描述;column:description;size:500;"`                                               //版本描述
+	VersionData *string `json:"versionData" form:"versionData" gorm:"comment:版本数据JSON;column:version_data;type:text;"` //版本数据
+}
+
+// TableName 版本管理 SysVersion自定义表名 sys_versions
+func (SysVersion) TableName() string {
+	return "sys_versions"
+}

server/plugin/email/README.MD

@@ -14,6 +14,7 @@
 		global.GVA_CONFIG.Email.Nickname,
 		global.GVA_CONFIG.Email.Port,
 		global.GVA_CONFIG.Email.IsSSL,
+		global.GVA_CONFIG.Email.IsLoginAuth,
 		))
 
     同样也可以再传入时写死
@@ -26,6 +27,7 @@
     "登录密钥",
     465,
     true,
+    true,
     ))
 
 ### 2. 配置说明
@@ -34,13 +36,14 @@
     //其中 Form 和 Secret 通常来说就是用户名和密码
 
     type Email struct {
-	    To       string  // 收件人:多个以英文逗号分隔 例：a@qq.com b@qq.com 正式开发中请把此项目作为参数使用 此处配置主要用于发送错误监控邮件
-	    From     string  // 发件人  你自己要发邮件的邮箱
-	    Host     string  // 服务器地址 例如 smtp.qq.com  请前往QQ或者你要发邮件的邮箱查看其smtp协议
-	    Secret   string  // 密钥    用于登录的密钥 最好不要用邮箱密码 去邮箱smtp申请一个用于登录的密钥
-	    Nickname string  // 昵称    发件人昵称 自定义即可 可以不填
-	    Port     int     // 端口     请前往QQ或者你要发邮件的邮箱查看其smtp协议 大多为 465
-	    IsSSL    bool    // 是否SSL   是否开启SSL
+	    To          string  // 收件人:多个以英文逗号分隔 例：a@qq.com b@qq.com 正式开发中请把此项目作为参数使用 此处配置主要用于发送错误监控邮件
+	    From        string  // 发件人  你自己要发邮件的邮箱
+	    Host        string  // 服务器地址 例如 smtp.qq.com  请前往QQ或者你要发邮件的邮箱查看其smtp协议
+	    Secret      string  // 密钥    用于登录的密钥 最好不要用邮箱密码 去邮箱smtp申请一个用于登录的密钥
+	    Nickname    string  // 昵称    发件人昵称 自定义即可 可以不填
+	    Port        int     // 端口     请前往QQ或者你要发邮件的邮箱查看其smtp协议 大多为 465
+	    IsSSL       bool    // 是否SSL   是否开启SSL
+	    IsLoginAuth bool    // 是否LoginAuth   是否使用LoginAuth认证方式（适用于IBM、微软邮箱服务器等）
     }
 #### 2-2 入参结构说明
     //其中 Form 和 Secret 通常来说就是用户名和密码

server/plugin/email/config/email.go

@@ -1,11 +1,12 @@
 package config
 
 type Email struct {
-	To       string `mapstructure:"to" json:"to" yaml:"to"`                   // 收件人:多个以英文逗号分隔 例：a@qq.com b@qq.com 正式开发中请把此项目作为参数使用
-	From     string `mapstructure:"from" json:"from" yaml:"from"`             // 发件人  你自己要发邮件的邮箱
-	Host     string `mapstructure:"host" json:"host" yaml:"host"`             // 服务器地址 例如 smtp.qq.com  请前往QQ或者你要发邮件的邮箱查看其smtp协议
-	Secret   string `mapstructure:"secret" json:"secret" yaml:"secret"`       // 密钥    用于登录的密钥 最好不要用邮箱密码 去邮箱smtp申请一个用于登录的密钥
-	Nickname string `mapstructure:"nickname" json:"nickname" yaml:"nickname"` // 昵称    发件人昵称 通常为自己的邮箱
-	Port     int    `mapstructure:"port" json:"port" yaml:"port"`             // 端口     请前往QQ或者你要发邮件的邮箱查看其smtp协议 大多为 465
-	IsSSL    bool   `mapstructure:"is-ssl" json:"isSSL" yaml:"is-ssl"`        // 是否SSL   是否开启SSL
+	To          string `mapstructure:"to" json:"to" yaml:"to"`                               // 收件人:多个以英文逗号分隔 例：a@qq.com b@qq.com 正式开发中请把此项目作为参数使用
+	From        string `mapstructure:"from" json:"from" yaml:"from"`                         // 发件人  你自己要发邮件的邮箱
+	Host        string `mapstructure:"host" json:"host" yaml:"host"`                         // 服务器地址 例如 smtp.qq.com  请前往QQ或者你要发邮件的邮箱查看其smtp协议
+	Secret      string `mapstructure:"secret" json:"secret" yaml:"secret"`                   // 密钥    用于登录的密钥 最好不要用邮箱密码 去邮箱smtp申请一个用于登录的密钥
+	Nickname    string `mapstructure:"nickname" json:"nickname" yaml:"nickname"`             // 昵称    发件人昵称 通常为自己的邮箱
+	Port        int    `mapstructure:"port" json:"port" yaml:"port"`                         // 端口     请前往QQ或者你要发邮件的邮箱查看其smtp协议 大多为 465
+	IsSSL       bool   `mapstructure:"is-ssl" json:"isSSL" yaml:"is-ssl"`                    // 是否SSL   是否开启SSL
+	IsLoginAuth bool   `mapstructure:"is-loginauth" json:"is-loginauth" yaml:"is-loginauth"` // 是否LoginAuth   是否使用LoginAuth认证
 }

server/plugin/email/main.go

@@ -8,7 +8,7 @@ import (
 
 type emailPlugin struct{}
 
-func CreateEmailPlug(To, From, Host, Secret, Nickname string, Port int, IsSSL bool) *emailPlugin {
+func CreateEmailPlug(To, From, Host, Secret, Nickname string, Port int, IsSSL bool, IsLoginAuth bool) *emailPlugin {
 	global.GlobalConfig.To = To
 	global.GlobalConfig.From = From
 	global.GlobalConfig.Host = Host
@@ -16,6 +16,7 @@ func CreateEmailPlug(To, From, Host, Secret, Nickname string, Port int, IsSSL bo
 	global.GlobalConfig.Nickname = Nickname
 	global.GlobalConfig.Port = Port
 	global.GlobalConfig.IsSSL = IsSSL
+	global.GlobalConfig.IsLoginAuth = IsLoginAuth
 	return &emailPlugin{}
 }
 

server/plugin/email/utils/email.go

@@ -60,8 +60,14 @@ func send(to []string, subject string, body string) error {
 	host := global.GlobalConfig.Host
 	port := global.GlobalConfig.Port
 	isSSL := global.GlobalConfig.IsSSL
+	isLoginAuth := global.GlobalConfig.IsLoginAuth
 
-	auth := smtp.PlainAuth("", from, secret, host)
+	var auth smtp.Auth
+	if isLoginAuth {
+		auth = LoginAuth(from, secret)
+	} else {
+		auth = smtp.PlainAuth("", from, secret, host)
+	}
 	e := email.NewEmail()
 	if nickname != "" {
 		e.From = fmt.Sprintf("%s <%s>", nickname, from)
@@ -80,3 +86,37 @@ func send(to []string, subject string, body string) error {
 	}
 	return err
 }
+
+// LoginAuth 用于IBM、微软邮箱服务器的LOGIN认证方式
+type loginAuth struct {
+	username, password string
+}
+
+func LoginAuth(username, password string) smtp.Auth {
+	return &loginAuth{username, password}
+}
+
+func (a *loginAuth) Start(server *smtp.ServerInfo) (string, []byte, error) {
+	return "LOGIN", []byte{}, nil
+}
+
+func (a *loginAuth) Next(fromServer []byte, more bool) ([]byte, error) {
+	if more {
+		switch string(fromServer) {
+		case "Username:":
+			return []byte(a.username), nil
+		case "Password:":
+			return []byte(a.password), nil
+		default:
+			// 邮箱服务器可能发送的其他提示信息
+			prompt := strings.ToLower(string(fromServer))
+			if strings.Contains(prompt, "username") || strings.Contains(prompt, "user") {
+				return []byte(a.username), nil
+			}
+			if strings.Contains(prompt, "password") || strings.Contains(prompt, "pass") {
+				return []byte(a.password), nil
+			}
+		}
+	}
+	return nil, nil
+}

server/resource/mcp/tools.tpl

@@ -17,7 +17,7 @@ func (t *{{.Name | title}}) Handle(ctx context.Context, request mcp.CallToolRequ
 	// TODO: 实现工具逻辑
 	// 参数示例:
 	// {{- range .Params}}
-	// {{.Name}} := request.Params["{{.Name}}"]
+	// {{.Name}} := request.GetArguments()["{{.Name}}"]
 	// {{- end}}
 	return &mcp.CallToolResult{
 		Content: []mcp.Content{

server/resource/package/server/service/service.go.tpl

@@ -161,8 +161,8 @@ func ({{.Abbreviation}}Service *{{.StructName}}Service)Get{{.StructName}}InfoLis
         var OrderStr string
         orderMap := make(map[string]bool)
         {{- if .GvaModel }}
-           orderMap["ID"] = true
-           orderMap["CreatedAt"] = true
+           orderMap["id"] = true
+           orderMap["created_at"] = true
         {{- end }}
        {{- range .Fields}}
             {{- if .Sort}}
@@ -195,7 +195,7 @@ func ({{.Abbreviation}}Service *{{.StructName}}Service)Get{{.StructName}}DataSou
 	   {{$key}} := make([]map[string]any, 0)
 	   {{ $dataDB := "" }}
 	   {{- if eq $value.DBName "" }}
-       {{ $dataDB = $db }}
+       {{ $dataDB = "global.GVA_DB" }}
        {{- else}}
        {{ $dataDB = printf "global.MustGetGlobalDBByDBName(\"%s\")" $value.DBName }}
        {{- end}}

server/resource/package/web/view/table.vue.tpl

@@ -110,7 +110,7 @@ getDataSourceFunc()
 
       <el-date-picker
             v-model="searchInfo.createdAtRange"
-            class="w-[380px]"
+            class="!w-380px"
             type="datetimerange"
             range-separator="至"
             start-placeholder="开始时间"
@@ -161,7 +161,7 @@ getDataSourceFunc()
         >
         <el-table-column type="selection" width="55" />
         {{ if .GvaModel }}
-        <el-table-column sortable align="left" label="日期" prop="CreatedAt" {{- if .IsTree }} min-{{- end }}width="180">
+        <el-table-column sortable align="left" label="日期" prop="CreatedAt" {{ if .IsTree -}} min-{{- end -}}width="180">
             <template #default="scope">{{ "{{ formatDate(scope.row.CreatedAt) }}" }}</template>
         </el-table-column>
         {{ end }}
@@ -232,7 +232,7 @@ getDataSourceFunc()
             {{- if .IsTree }}
             <el-descriptions-item label="父节点">
                 <el-tree-select
-                  v-model="detailFrom.parentID"
+                  v-model="detailForm.parentID"
                   :data="[rootNode,...tableData]"
                   check-strictly
                   disabled
@@ -393,8 +393,8 @@ const searchInfo = ref({})
 // 排序
 const sortChange = ({ prop, order }) => {
   const sortMap = {
-    CreatedAt:"CreatedAt",
-    ID:"ID",
+    CreatedAt:"created_at",
+    ID:"id",
     {{- range .Fields}}
      {{- if .Table}}
       {{- if and .Sort}}
@@ -629,7 +629,7 @@ const enterDialog = async () => {
       })
 }
 
-const detailFrom = ref({})
+const detailForm = ref({})
 
 // 查看详情控制标记
 const detailShow = ref(false)
@@ -646,7 +646,7 @@ const getDetails = async (row) => {
   // 打开弹窗
   const res = await find{{.StructName}}({ {{.PrimaryField.FieldJson}}: row.{{.PrimaryField.FieldJson}} })
   if (res.code === 0) {
-    detailFrom.value = res.data
+    detailForm.value = res.data
     openDetailShow()
   }
 }
@@ -655,7 +655,7 @@ const getDetails = async (row) => {
 // 关闭详情弹窗
 const closeDetailShow = () => {
   detailShow.value = false
-  detailFrom.value = {}
+  detailForm.value = {}
 }
 
 

server/resource/plugin/server/service/service.go.tpl

@@ -168,8 +168,8 @@ func (s *{{.Abbreviation}}) Get{{.StructName}}InfoList(ctx context.Context, info
         var OrderStr string
         orderMap := make(map[string]bool)
       {{- if .GvaModel }}
-        orderMap["ID"] = true
-        orderMap["CreatedAt"] = true
+        orderMap["id"] = true
+        orderMap["created_at"] = true
       {{- end }}
        {{- range .Fields}}
         {{- if .Sort}}

server/resource/plugin/web/view/view.vue.tpl

@@ -108,7 +108,7 @@ getDataSourceFunc()
       </template>
          <el-date-picker
                   v-model="searchInfo.createdAtRange"
-                  class="w-[380px]"
+                  class="!w-380px"
                   type="datetimerange"
                   range-separator="至"
                   start-placeholder="开始时间"
@@ -158,7 +158,7 @@ getDataSourceFunc()
         >
         <el-table-column type="selection" width="55" />
         {{ if .GvaModel }}
-        <el-table-column sortable align="left" label="日期" prop="CreatedAt" {{- if .IsTree }} min-{{- end }}width="180">
+        <el-table-column sortable align="left" label="日期" prop="CreatedAt" {{ if .IsTree -}} min-{{- end -}}width="180">
             <template #default="scope">{{ "{{ formatDate(scope.row.CreatedAt) }}" }}</template>
         </el-table-column>
         {{ end }}
@@ -229,7 +229,7 @@ getDataSourceFunc()
             {{- if .IsTree }}
             <el-descriptions-item label="父节点">
                 <el-tree-select
-                  v-model="detailFrom.parentID"
+                  v-model="detailForm.parentID"
                   :data="[rootNode,...tableData]"
                   check-strictly
                   disabled
@@ -388,8 +388,8 @@ const searchInfo = ref({})
 // 排序
 const sortChange = ({ prop, order }) => {
   const sortMap = {
-    CreatedAt:"CreatedAt",
-    ID:"ID",
+    CreatedAt:"created_at",
+    ID:"id",
     {{- range .Fields}}
      {{- if .Table}}
       {{- if and .Sort}}
@@ -624,7 +624,7 @@ const enterDialog = async () => {
       })
 }
 
-const detailFrom = ref({})
+const detailForm = ref({})
 
 // 查看详情控制标记
 const detailShow = ref(false)
@@ -641,7 +641,7 @@ const getDetails = async (row) => {
   // 打开弹窗
   const res = await find{{.StructName}}({ {{.PrimaryField.FieldJson}}: row.{{.PrimaryField.FieldJson}} })
   if (res.code === 0) {
-    detailFrom.value = res.data
+    detailForm.value = res.data
     openDetailShow()
   }
 }
@@ -650,7 +650,7 @@ const getDetails = async (row) => {
 // 关闭详情弹窗
 const closeDetailShow = () => {
   detailShow.value = false
-  detailFrom.value = {}
+  detailForm.value = {}
 }
 
 

server/router/system/enter.go

@@ -19,6 +19,8 @@ type RouterGroup struct {
 	AuthorityBtnRouter
 	SysExportTemplateRouter
 	SysParamsRouter
+	SysVersionRouter
+	SysErrorRouter
 }
 
 var (
@@ -41,4 +43,6 @@ var (
 	dictionaryDetailApi = api.ApiGroupApp.SystemApiGroup.DictionaryDetailApi
 	autoCodeTemplateApi = api.ApiGroupApp.SystemApiGroup.AutoCodeTemplateApi
 	exportTemplateApi   = api.ApiGroupApp.SystemApiGroup.SysExportTemplateApi
+	sysVersionApi       = api.ApiGroupApp.SystemApiGroup.SysVersionApi
+	sysErrprApi         = api.ApiGroupApp.SystemApiGroup.SysErrorApi
 )

server/router/system/sys_dictionary_detail.go

@@ -16,7 +16,11 @@ func (s *DictionaryDetailRouter) InitSysDictionaryDetailRouter(Router *gin.Route
 		dictionaryDetailRouter.PUT("updateSysDictionaryDetail", dictionaryDetailApi.UpdateSysDictionaryDetail)    // 更新SysDictionaryDetail
 	}
 	{
-		dictionaryDetailRouterWithoutRecord.GET("findSysDictionaryDetail", dictionaryDetailApi.FindSysDictionaryDetail)       // 根据ID获取SysDictionaryDetail
-		dictionaryDetailRouterWithoutRecord.GET("getSysDictionaryDetailList", dictionaryDetailApi.GetSysDictionaryDetailList) // 获取SysDictionaryDetail列表
+		dictionaryDetailRouterWithoutRecord.GET("findSysDictionaryDetail", dictionaryDetailApi.FindSysDictionaryDetail)           // 根据ID获取SysDictionaryDetail
+		dictionaryDetailRouterWithoutRecord.GET("getSysDictionaryDetailList", dictionaryDetailApi.GetSysDictionaryDetailList)     // 获取SysDictionaryDetail列表
+		dictionaryDetailRouterWithoutRecord.GET("getDictionaryTreeList", dictionaryDetailApi.GetDictionaryTreeList)               // 获取字典详情树形结构
+		dictionaryDetailRouterWithoutRecord.GET("getDictionaryTreeListByType", dictionaryDetailApi.GetDictionaryTreeListByType)   // 根据字典类型获取字典详情树形结构
+		dictionaryDetailRouterWithoutRecord.GET("getDictionaryDetailsByParent", dictionaryDetailApi.GetDictionaryDetailsByParent) // 根据父级ID获取字典详情
+		dictionaryDetailRouterWithoutRecord.GET("getDictionaryPath", dictionaryDetailApi.GetDictionaryPath)                       // 获取字典详情的完整路径
 	}
 }

server/router/system/sys_error.go

@@ -0,0 +1,27 @@
+package system
+
+import (
+	"github.com/flipped-aurora/gin-vue-admin/server/middleware"
+	"github.com/gin-gonic/gin"
+)
+
+type SysErrorRouter struct{}
+
+// InitSysErrorRouter 初始化 错误日志 路由信息
+func (s *SysErrorRouter) InitSysErrorRouter(Router *gin.RouterGroup, PublicRouter *gin.RouterGroup) {
+	sysErrprRouter := Router.Group("sysErrpr").Use(middleware.OperationRecord())
+	sysErrprRouterWithoutRecord := Router.Group("sysErrpr")
+	sysErrprRouterWithoutAuth := PublicRouter.Group("sysErrpr")
+	{
+		sysErrprRouter.DELETE("deleteSysError", sysErrprApi.DeleteSysError)           // 删除错误日志
+		sysErrprRouter.DELETE("deleteSysErrorByIds", sysErrprApi.DeleteSysErrorByIds) // 批量删除错误日志
+		sysErrprRouter.PUT("updateSysError", sysErrprApi.UpdateSysError)              // 更新错误日志
+	}
+	{
+		sysErrprRouterWithoutRecord.GET("findSysError", sysErrprApi.FindSysError)       // 根据ID获取错误日志
+		sysErrprRouterWithoutRecord.GET("getSysErrorList", sysErrprApi.GetSysErrorList) // 获取错误日志列表
+	}
+	{
+		sysErrprRouterWithoutAuth.POST("createSysError", sysErrprApi.CreateSysError) // 新建错误日志
+	}
+}

server/router/system/sys_export_template.go

@@ -26,6 +26,7 @@ func (s *SysExportTemplateRouter) InitSysExportTemplateRouter(Router *gin.Router
 		sysExportTemplateRouterWithoutRecord.GET("getSysExportTemplateList", exportTemplateApi.GetSysExportTemplateList) // 获取导出模板列表
 		sysExportTemplateRouterWithoutRecord.GET("exportExcel", exportTemplateApi.ExportExcel)                           // 获取导出token
 		sysExportTemplateRouterWithoutRecord.GET("exportTemplate", exportTemplateApi.ExportTemplate)                     // 导出表格模板
+        sysExportTemplateRouterWithoutRecord.GET("previewSQL", exportTemplateApi.PreviewSQL)                         // 预览SQL
 	}
 	{
 		sysExportTemplateRouterWithoutAuth.GET("exportExcelByToken", exportTemplateApi.ExportExcelByToken)       // 通过token导出表格

server/router/system/sys_user.go

@@ -18,7 +18,7 @@ func (s *UserRouter) InitUserRouter(Router *gin.RouterGroup) {
 		userRouter.PUT("setUserInfo", baseApi.SetUserInfo)                // 设置用户信息
 		userRouter.PUT("setSelfInfo", baseApi.SetSelfInfo)                // 设置自身信息
 		userRouter.POST("setUserAuthorities", baseApi.SetUserAuthorities) // 设置用户权限组
-		userRouter.POST("resetPassword", baseApi.ResetPassword)           // 设置用户权限组
+		userRouter.POST("resetPassword", baseApi.ResetPassword)           // 重置用户密码
 		userRouter.PUT("setSelfSetting", baseApi.SetSelfSetting)          // 用户界面配置
 	}
 	{

server/router/system/sys_version.go

@@ -0,0 +1,25 @@
+package system
+
+import (
+	"github.com/flipped-aurora/gin-vue-admin/server/middleware"
+	"github.com/gin-gonic/gin"
+)
+
+type SysVersionRouter struct{}
+
+// InitSysVersionRouter 初始化 版本管理 路由信息
+func (s *SysVersionRouter) InitSysVersionRouter(Router *gin.RouterGroup) {
+	sysVersionRouter := Router.Group("sysVersion").Use(middleware.OperationRecord())
+	sysVersionRouterWithoutRecord := Router.Group("sysVersion")
+	{
+		sysVersionRouter.DELETE("deleteSysVersion", sysVersionApi.DeleteSysVersion)           // 删除版本管理
+		sysVersionRouter.DELETE("deleteSysVersionByIds", sysVersionApi.DeleteSysVersionByIds) // 批量删除版本管理
+		sysVersionRouter.POST("exportVersion", sysVersionApi.ExportVersion)                   // 导出版本数据
+		sysVersionRouter.POST("importVersion", sysVersionApi.ImportVersion)                   // 导入版本数据
+	}
+	{
+		sysVersionRouterWithoutRecord.GET("findSysVersion", sysVersionApi.FindSysVersion)           // 根据ID获取版本管理
+		sysVersionRouterWithoutRecord.GET("getSysVersionList", sysVersionApi.GetSysVersionList)     // 获取版本管理列表
+		sysVersionRouterWithoutRecord.GET("downloadVersionJson", sysVersionApi.DownloadVersionJson) // 下载版本JSON数据
+	}
+}

server/service/example/exa_file_upload_download.go

@@ -9,6 +9,7 @@ import (
 	"github.com/flipped-aurora/gin-vue-admin/server/model/example"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/example/request"
 	"github.com/flipped-aurora/gin-vue-admin/server/utils/upload"
+	"gorm.io/gorm"
 )
 
 //@author: [piexlmax](https://github.com/piexlmax)
@@ -107,7 +108,13 @@ func (e *FileUploadAndDownloadService) UploadFile(header *multipart.FileHeader,
 		Key:     key,
 	}
 	if noSave == "0" {
-		return f, e.Upload(f)
+		// 检查是否已存在相同key的记录
+		var existingFile example.ExaFileUploadAndDownload
+		err = global.GVA_DB.Where("`key` = ?", key).First(&existingFile).Error
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return f, e.Upload(f)
+		}
+		return f, err
 	}
 	return f, nil
 }

server/service/system/auto_code_package.go

@@ -3,6 +3,12 @@ package system
 import (
 	"context"
 	"fmt"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strings"
+	"text/template"
+
 	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	common "github.com/flipped-aurora/gin-vue-admin/server/model/common/request"
 	model "github.com/flipped-aurora/gin-vue-admin/server/model/system"
@@ -11,12 +17,7 @@ import (
 	"github.com/flipped-aurora/gin-vue-admin/server/utils/ast"
 	"github.com/flipped-aurora/gin-vue-admin/server/utils/autocode"
 	"github.com/pkg/errors"
-	"go/token"
 	"gorm.io/gorm"
-	"os"
-	"path/filepath"
-	"strings"
-	"text/template"
 )
 
 var AutoCodePackage = new(autoCodePackage)
@@ -114,6 +115,20 @@ func (s *autoCodePackage) Delete(ctx context.Context, info common.GetById) error
 	return nil
 }
 
+// DeleteByNames
+// @author: [piexlmax](https://github.com/piexlmax)
+// @author: [SliverHorn](https://github.com/SliverHorn)
+func (s *autoCodePackage) DeleteByNames(ctx context.Context, names []string) error {
+	if len(names) == 0 {
+		return nil
+	}
+	err := global.GVA_DB.WithContext(ctx).Where("package_name IN ?", names).Delete(&model.SysAutoCodePackage{}).Error
+	if err != nil {
+		return errors.Wrap(err, "删除失败!")
+	}
+	return nil
+}
+
 // All 获取所有包
 // @author: [piexlmax](https://github.com/piexlmax)
 // @author: [SliverHorn](https://github.com/SliverHorn)
@@ -148,7 +163,6 @@ func (s *autoCodePackage) All(ctx context.Context) (entities []model.SysAutoCode
 				"api":        true,
 				"config":     true,
 				"initialize": true,
-				"model":      true,
 				"plugin":     true,
 				"router":     true,
 				"service":    true,
@@ -165,14 +179,25 @@ func (s *autoCodePackage) All(ctx context.Context) (entities []model.SysAutoCode
 					}
 				}
 			}
-			if len(dirNameMap) != 0 {
-				continue
+
+			var desc string
+			if len(dirNameMap) == 0 {
+				// 完全符合标准结构
+				desc = "系统自动读取" + pluginDir[i].Name() + "插件，使用前请确认是否为v2版本插件"
+			} else {
+				// 缺少某些结构，生成警告描述
+				var missingDirs []string
+				for dirName := range dirNameMap {
+					missingDirs = append(missingDirs, dirName)
+				}
+				desc = fmt.Sprintf("系统自动读取，但是缺少 %s 结构，不建议自动化和mcp使用", strings.Join(missingDirs, "、"))
 			}
+
 			pluginPackage := model.SysAutoCodePackage{
 				PackageName: pluginDir[i].Name(),
 				Template:    "plugin",
 				Label:       pluginDir[i].Name() + "插件",
-				Desc:        "系统自动读取" + pluginDir[i].Name() + "插件，使用前请确认是否为v2版本插件",
+				Desc:        desc,
 				Module:      global.GVA_CONFIG.AutoCode.Module,
 			}
 			plugin = append(plugin, pluginPackage)
@@ -211,6 +236,40 @@ func (s *autoCodePackage) All(ctx context.Context) (entities []model.SysAutoCode
 		entities = append(entities, createEntity...)
 	}
 
+	// 处理数据库存在但实体文件不存在的情况 - 删除数据库中对应的数据
+	existingPackageNames := make(map[string]bool)
+	// 收集所有存在的包名
+	for i := 0; i < len(server); i++ {
+		existingPackageNames[server[i].PackageName] = true
+	}
+	for i := 0; i < len(plugin); i++ {
+		existingPackageNames[plugin[i].PackageName] = true
+	}
+
+	// 找出需要删除的数据库记录
+	deleteEntityIDs := []uint{}
+	for i := 0; i < len(entities); i++ {
+		if !existingPackageNames[entities[i].PackageName] {
+			deleteEntityIDs = append(deleteEntityIDs, entities[i].ID)
+		}
+	}
+
+	// 删除数据库中不存在文件的记录
+	if len(deleteEntityIDs) > 0 {
+		err = global.GVA_DB.WithContext(ctx).Delete(&model.SysAutoCodePackage{}, deleteEntityIDs).Error
+		if err != nil {
+			return nil, errors.Wrap(err, "删除不存在的包记录失败!")
+		}
+		// 从返回结果中移除已删除的记录
+		filteredEntities := []model.SysAutoCodePackage{}
+		for i := 0; i < len(entities); i++ {
+			if existingPackageNames[entities[i].PackageName] {
+				filteredEntities = append(filteredEntities, entities[i])
+			}
+		}
+		entities = filteredEntities
+	}
+
 	return entities, nil
 }
 

server/service/system/auto_code_plugin.go

@@ -170,7 +170,7 @@ func (s *autoCodePlugin) PubPlug(plugName string) (zipPath string, err error) {
 	// (compression is not required; you could use Tar directly)
 	format := archives.CompressedArchive{
 		//Compression: archives.Gz{},
-		Archival:    archives.Zip{},
+		Archival: archives.Zip{},
 	}
 
 	// create the archive
@@ -208,7 +208,8 @@ func (s *autoCodePlugin) InitMenu(menuInfo request.InitMenu) (err error) {
 		},
 	}
 
-	err = global.GVA_DB.Find(&menus, "id in (?)", menuInfo.Menus).Error
+	// 查询菜单及其关联的参数和按钮
+	err = global.GVA_DB.Preload("Parameters").Preload("MenuBtn").Find(&menus, "id in (?)", menuInfo.Menus).Error
 	if err != nil {
 		return err
 	}

server/service/system/enter.go

@@ -17,8 +17,10 @@ type ServiceGroup struct {
 	AuthorityBtnService
 	SysExportTemplateService
 	SysParamsService
+	SysVersionService
 	AutoCodePlugin   autoCodePlugin
 	AutoCodePackage  autoCodePackage
 	AutoCodeHistory  autoCodeHistory
 	AutoCodeTemplate autoCodeTemplate
+	SysErrorService
 }

server/service/system/sys_authority.go

@@ -326,5 +326,8 @@ func (authorityService *AuthorityService) findChildrenAuthority(authority *syste
 func (authorityService *AuthorityService) GetParentAuthorityID(authorityID uint) (parentID uint, err error) {
 	var authority system.SysAuthority
 	err = global.GVA_DB.Where("authority_id = ?", authorityID).First(&authority).Error
-	return *authority.ParentId, err
+	if err != nil {
+		return
+	}
+	return *authority.ParentId, nil
 }

server/service/system/sys_auto_code_oracle.go

@@ -64,7 +64,7 @@ WHERE
     lower(a.table_name) = ?
     AND lower(a.OWNER) = ?
 ORDER BY
-    a.COLUMN_ID;
+    a.COLUMN_ID
 `
 
 	err = global.GVA_DBList[businessDB].Raw(sql, tableName, dbName).Scan(&entities).Error

server/service/system/sys_dictionary.go

@@ -3,6 +3,9 @@ package system
 import (
 	"errors"
 
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
+	"github.com/gin-gonic/gin"
+
 	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
 	"gorm.io/gorm"
@@ -60,10 +63,11 @@ func (dictionaryService *DictionaryService) DeleteSysDictionary(sysDictionary sy
 func (dictionaryService *DictionaryService) UpdateSysDictionary(sysDictionary *system.SysDictionary) (err error) {
 	var dict system.SysDictionary
 	sysDictionaryMap := map[string]interface{}{
-		"Name":   sysDictionary.Name,
-		"Type":   sysDictionary.Type,
-		"Status": sysDictionary.Status,
-		"Desc":   sysDictionary.Desc,
+		"Name":     sysDictionary.Name,
+		"Type":     sysDictionary.Type,
+		"Status":   sysDictionary.Status,
+		"Desc":     sysDictionary.Desc,
+		"ParentID": sysDictionary.ParentID,
 	}
 	err = global.GVA_DB.Where("id = ?", sysDictionary.ID).First(&dict).Error
 	if err != nil {
@@ -75,6 +79,14 @@ func (dictionaryService *DictionaryService) UpdateSysDictionary(sysDictionary *s
 			return errors.New("存在相同的type，不允许创建")
 		}
 	}
+
+	// 检查是否会形成循环引用
+	if sysDictionary.ParentID != nil && *sysDictionary.ParentID != 0 {
+		if err := dictionaryService.checkCircularReference(sysDictionary.ID, *sysDictionary.ParentID); err != nil {
+			return err
+		}
+	}
+
 	err = global.GVA_DB.Model(&dict).Updates(sysDictionaryMap).Error
 	return err
 }
@@ -93,7 +105,7 @@ func (dictionaryService *DictionaryService) GetSysDictionary(Type string, Id uin
 		flag = *status
 	}
 	err = global.GVA_DB.Where("(type = ? OR id = ?) and status = ?", Type, Id, flag).Preload("SysDictionaryDetails", func(db *gorm.DB) *gorm.DB {
-		return db.Where("status = ?", true).Order("sort")
+		return db.Where("status = ? and deleted_at is null", true).Order("sort")
 	}).First(&sysDictionary).Error
 	return
 }
@@ -105,8 +117,38 @@ func (dictionaryService *DictionaryService) GetSysDictionary(Type string, Id uin
 //@param: info request.SysDictionarySearch
 //@return: err error, list interface{}, total int64
 
-func (dictionaryService *DictionaryService) GetSysDictionaryInfoList() (list interface{}, err error) {
+func (dictionaryService *DictionaryService) GetSysDictionaryInfoList(c *gin.Context, req request.SysDictionarySearch) (list interface{}, err error) {
 	var sysDictionarys []system.SysDictionary
-	err = global.GVA_DB.Find(&sysDictionarys).Error
+	query := global.GVA_DB.WithContext(c)
+	if req.Name != "" {
+		query = query.Where("name LIKE ? OR type LIKE ?", "%"+req.Name+"%", "%"+req.Name+"%")
+	}
+	// 预加载子字典
+	query = query.Preload("Children")
+	err = query.Find(&sysDictionarys).Error
 	return sysDictionarys, err
 }
+
+// checkCircularReference 检查是否会形成循环引用
+func (dictionaryService *DictionaryService) checkCircularReference(currentID uint, parentID uint) error {
+	if currentID == parentID {
+		return errors.New("不能将字典设置为自己的父级")
+	}
+
+	// 递归检查父级链条
+	var parent system.SysDictionary
+	err := global.GVA_DB.Where("id = ?", parentID).First(&parent).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil // 父级不存在，允许设置
+		}
+		return err
+	}
+
+	// 如果父级还有父级，继续检查
+	if parent.ParentID != nil && *parent.ParentID != 0 {
+		return dictionaryService.checkCircularReference(currentID, *parent.ParentID)
+	}
+
+	return nil
+}

server/service/system/sys_dictionary_detail.go

@@ -1,6 +1,9 @@
 package system
 
 import (
+	"fmt"
+	"strconv"
+
 	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
@@ -17,6 +20,24 @@ type DictionaryDetailService struct{}
 var DictionaryDetailServiceApp = new(DictionaryDetailService)
 
 func (dictionaryDetailService *DictionaryDetailService) CreateSysDictionaryDetail(sysDictionaryDetail system.SysDictionaryDetail) (err error) {
+	// 计算层级和路径
+	if sysDictionaryDetail.ParentID != nil {
+		var parent system.SysDictionaryDetail
+		err = global.GVA_DB.First(&parent, *sysDictionaryDetail.ParentID).Error
+		if err != nil {
+			return err
+		}
+		sysDictionaryDetail.Level = parent.Level + 1
+		if parent.Path == "" {
+			sysDictionaryDetail.Path = strconv.Itoa(int(parent.ID))
+		} else {
+			sysDictionaryDetail.Path = parent.Path + "," + strconv.Itoa(int(parent.ID))
+		}
+	} else {
+		sysDictionaryDetail.Level = 0
+		sysDictionaryDetail.Path = ""
+	}
+
 	err = global.GVA_DB.Create(&sysDictionaryDetail).Error
 	return err
 }
@@ -28,6 +49,16 @@ func (dictionaryDetailService *DictionaryDetailService) CreateSysDictionaryDetai
 //@return: err error
 
 func (dictionaryDetailService *DictionaryDetailService) DeleteSysDictionaryDetail(sysDictionaryDetail system.SysDictionaryDetail) (err error) {
+	// 检查是否有子项
+	var count int64
+	err = global.GVA_DB.Model(&system.SysDictionaryDetail{}).Where("parent_id = ?", sysDictionaryDetail.ID).Count(&count).Error
+	if err != nil {
+		return err
+	}
+	if count > 0 {
+		return fmt.Errorf("该字典详情下还有子项，无法删除")
+	}
+
 	err = global.GVA_DB.Delete(&sysDictionaryDetail).Error
 	return err
 }
@@ -39,8 +70,93 @@ func (dictionaryDetailService *DictionaryDetailService) DeleteSysDictionaryDetai
 //@return: err error
 
 func (dictionaryDetailService *DictionaryDetailService) UpdateSysDictionaryDetail(sysDictionaryDetail *system.SysDictionaryDetail) (err error) {
+	// 如果更新了父级ID，需要重新计算层级和路径
+	if sysDictionaryDetail.ParentID != nil {
+		var parent system.SysDictionaryDetail
+		err = global.GVA_DB.First(&parent, *sysDictionaryDetail.ParentID).Error
+		if err != nil {
+			return err
+		}
+
+		// 检查循环引用
+		if dictionaryDetailService.checkCircularReference(sysDictionaryDetail.ID, *sysDictionaryDetail.ParentID) {
+			return fmt.Errorf("不能将字典详情设置为自己或其子项的父级")
+		}
+
+		sysDictionaryDetail.Level = parent.Level + 1
+		if parent.Path == "" {
+			sysDictionaryDetail.Path = strconv.Itoa(int(parent.ID))
+		} else {
+			sysDictionaryDetail.Path = parent.Path + "," + strconv.Itoa(int(parent.ID))
+		}
+	} else {
+		sysDictionaryDetail.Level = 0
+		sysDictionaryDetail.Path = ""
+	}
+
 	err = global.GVA_DB.Save(sysDictionaryDetail).Error
-	return err
+	if err != nil {
+		return err
+	}
+
+	// 更新所有子项的层级和路径
+	return dictionaryDetailService.updateChildrenLevelAndPath(sysDictionaryDetail.ID)
+}
+
+// checkCircularReference 检查循环引用
+func (dictionaryDetailService *DictionaryDetailService) checkCircularReference(id, parentID uint) bool {
+	if id == parentID {
+		return true
+	}
+
+	var parent system.SysDictionaryDetail
+	err := global.GVA_DB.First(&parent, parentID).Error
+	if err != nil {
+		return false
+	}
+
+	if parent.ParentID == nil {
+		return false
+	}
+
+	return dictionaryDetailService.checkCircularReference(id, *parent.ParentID)
+}
+
+// updateChildrenLevelAndPath 更新子项的层级和路径
+func (dictionaryDetailService *DictionaryDetailService) updateChildrenLevelAndPath(parentID uint) error {
+	var children []system.SysDictionaryDetail
+	err := global.GVA_DB.Where("parent_id = ?", parentID).Find(&children).Error
+	if err != nil {
+		return err
+	}
+
+	var parent system.SysDictionaryDetail
+	err = global.GVA_DB.First(&parent, parentID).Error
+	if err != nil {
+		return err
+	}
+
+	for _, child := range children {
+		child.Level = parent.Level + 1
+		if parent.Path == "" {
+			child.Path = strconv.Itoa(int(parent.ID))
+		} else {
+			child.Path = parent.Path + "," + strconv.Itoa(int(parent.ID))
+		}
+
+		err = global.GVA_DB.Save(&child).Error
+		if err != nil {
+			return err
+		}
+
+		// 递归更新子项的子项
+		err = dictionaryDetailService.updateChildrenLevelAndPath(child.ID)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
 }
 
 //@author: [piexlmax](https://github.com/piexlmax)
@@ -79,11 +195,17 @@ func (dictionaryDetailService *DictionaryDetailService) GetSysDictionaryDetailIn
 	if info.SysDictionaryID != 0 {
 		db = db.Where("sys_dictionary_id = ?", info.SysDictionaryID)
 	}
+	if info.ParentID != nil {
+		db = db.Where("parent_id = ?", *info.ParentID)
+	}
+	if info.Level != nil {
+		db = db.Where("level = ?", *info.Level)
+	}
 	err = db.Count(&total).Error
 	if err != nil {
 		return
 	}
-	err = db.Limit(limit).Offset(offset).Order("sort").Find(&sysDictionaryDetails).Error
+	err = db.Limit(limit).Offset(offset).Order("sort").Order("id").Find(&sysDictionaryDetails).Error
 	return sysDictionaryDetails, total, err
 }
 
@@ -94,14 +216,135 @@ func (dictionaryDetailService *DictionaryDetailService) GetDictionaryList(dictio
 	return sysDictionaryDetails, err
 }
 
+// GetDictionaryTreeList 获取字典树形结构列表
+func (dictionaryDetailService *DictionaryDetailService) GetDictionaryTreeList(dictionaryID uint) (list []system.SysDictionaryDetail, err error) {
+	var sysDictionaryDetails []system.SysDictionaryDetail
+	// 只获取顶级项目（parent_id为空）
+	err = global.GVA_DB.Where("sys_dictionary_id = ? AND parent_id IS NULL", dictionaryID).Order("sort").Find(&sysDictionaryDetails).Error
+	if err != nil {
+		return nil, err
+	}
+
+	// 递归加载子项并设置disabled属性
+	for i := range sysDictionaryDetails {
+		// 设置disabled属性：当status为false时，disabled为true
+		if sysDictionaryDetails[i].Status != nil {
+			sysDictionaryDetails[i].Disabled = !*sysDictionaryDetails[i].Status
+		} else {
+			sysDictionaryDetails[i].Disabled = false // 默认不禁用
+		}
+		
+		err = dictionaryDetailService.loadChildren(&sysDictionaryDetails[i])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return sysDictionaryDetails, nil
+}
+
+// loadChildren 递归加载子项
+func (dictionaryDetailService *DictionaryDetailService) loadChildren(detail *system.SysDictionaryDetail) error {
+	var children []system.SysDictionaryDetail
+	err := global.GVA_DB.Where("parent_id = ?", detail.ID).Order("sort").Find(&children).Error
+	if err != nil {
+		return err
+	}
+
+	for i := range children {
+		// 设置disabled属性：当status为false时，disabled为true
+		if children[i].Status != nil {
+			children[i].Disabled = !*children[i].Status
+		} else {
+			children[i].Disabled = false // 默认不禁用
+		}
+		
+		err = dictionaryDetailService.loadChildren(&children[i])
+		if err != nil {
+			return err
+		}
+	}
+
+	detail.Children = children
+	return nil
+}
+
+// GetDictionaryDetailsByParent 根据父级ID获取字典详情
+func (dictionaryDetailService *DictionaryDetailService) GetDictionaryDetailsByParent(req request.GetDictionaryDetailsByParentRequest) (list []system.SysDictionaryDetail, err error) {
+	db := global.GVA_DB.Model(&system.SysDictionaryDetail{}).Where("sys_dictionary_id = ?", req.SysDictionaryID)
+
+	if req.ParentID != nil {
+		db = db.Where("parent_id = ?", *req.ParentID)
+	} else {
+		db = db.Where("parent_id IS NULL")
+	}
+
+	err = db.Order("sort").Find(&list).Error
+	if err != nil {
+		return list, err
+	}
+
+	// 设置disabled属性
+	for i := range list {
+		if list[i].Status != nil {
+			list[i].Disabled = !*list[i].Status
+		} else {
+			list[i].Disabled = false // 默认不禁用
+		}
+	}
+
+	// 如果需要包含子级数据，使用递归方式加载所有层级的子项
+	if req.IncludeChildren {
+		for i := range list {
+			err = dictionaryDetailService.loadChildren(&list[i])
+			if err != nil {
+				return list, err
+			}
+		}
+	}
+
+	return list, err
+}
+
 // 按照字典type获取字典全部内容的方法
 func (dictionaryDetailService *DictionaryDetailService) GetDictionaryListByType(t string) (list []system.SysDictionaryDetail, err error) {
 	var sysDictionaryDetails []system.SysDictionaryDetail
 	db := global.GVA_DB.Model(&system.SysDictionaryDetail{}).Joins("JOIN sys_dictionaries ON sys_dictionaries.id = sys_dictionary_details.sys_dictionary_id")
-	err = db.Debug().Find(&sysDictionaryDetails, "type = ?", t).Error
+	err = db.Find(&sysDictionaryDetails, "type = ?", t).Error
 	return sysDictionaryDetails, err
 }
 
+// GetDictionaryTreeListByType 根据字典类型获取树形结构
+func (dictionaryDetailService *DictionaryDetailService) GetDictionaryTreeListByType(t string) (list []system.SysDictionaryDetail, err error) {
+	var sysDictionaryDetails []system.SysDictionaryDetail
+	db := global.GVA_DB.Model(&system.SysDictionaryDetail{}).
+		Joins("JOIN sys_dictionaries ON sys_dictionaries.id = sys_dictionary_details.sys_dictionary_id").
+		Where("sys_dictionaries.type = ? AND sys_dictionary_details.parent_id IS NULL", t).
+		Order("sys_dictionary_details.sort")
+
+	err = db.Find(&sysDictionaryDetails).Error
+	if err != nil {
+		return nil, err
+	}
+
+	// 递归加载子项并设置disabled属性
+	for i := range sysDictionaryDetails {
+		// 设置disabled属性：当status为false时，disabled为true
+		if sysDictionaryDetails[i].Status != nil {
+			sysDictionaryDetails[i].Disabled = !*sysDictionaryDetails[i].Status
+		} else {
+			sysDictionaryDetails[i].Disabled = false // 默认不禁用
+		}
+		
+		err = dictionaryDetailService.loadChildren(&sysDictionaryDetails[i])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return sysDictionaryDetails, nil
+}
+
 // 按照字典id+字典内容value获取单条字典内容
 func (dictionaryDetailService *DictionaryDetailService) GetDictionaryInfoByValue(dictionaryID uint, value string) (detail system.SysDictionaryDetail, err error) {
 	var sysDictionaryDetail system.SysDictionaryDetail
@@ -116,3 +359,34 @@ func (dictionaryDetailService *DictionaryDetailService) GetDictionaryInfoByTypeV
 	err = db.First(&sysDictionaryDetails, "sys_dictionaries.type = ? and sys_dictionary_details.value = ?", t, value).Error
 	return sysDictionaryDetails, err
 }
+
+// GetDictionaryPath 获取字典详情的完整路径
+func (dictionaryDetailService *DictionaryDetailService) GetDictionaryPath(id uint) (path []system.SysDictionaryDetail, err error) {
+	var detail system.SysDictionaryDetail
+	err = global.GVA_DB.First(&detail, id).Error
+	if err != nil {
+		return nil, err
+	}
+
+	path = append(path, detail)
+
+	if detail.ParentID != nil {
+		parentPath, err := dictionaryDetailService.GetDictionaryPath(*detail.ParentID)
+		if err != nil {
+			return nil, err
+		}
+		path = append(parentPath, path...)
+	}
+
+	return path, nil
+}
+
+// GetDictionaryPathByValue 根据值获取字典详情的完整路径
+func (dictionaryDetailService *DictionaryDetailService) GetDictionaryPathByValue(dictionaryID uint, value string) (path []system.SysDictionaryDetail, err error) {
+	detail, err := dictionaryDetailService.GetDictionaryInfoByValue(dictionaryID, value)
+	if err != nil {
+		return nil, err
+	}
+
+	return dictionaryDetailService.GetDictionaryPath(detail.ID)
+}

server/service/system/sys_error.go

@@ -0,0 +1,77 @@
+package system
+
+import (
+	"context"
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	systemReq "github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
+)
+
+type SysErrorService struct{}
+
+// CreateSysError 创建错误日志记录
+// Author [yourname](https://github.com/yourname)
+func (sysErrprService *SysErrorService) CreateSysError(ctx context.Context, sysErrpr *system.SysError) (err error) {
+	err = global.GVA_DB.Create(sysErrpr).Error
+	return err
+}
+
+// DeleteSysError 删除错误日志记录
+// Author [yourname](https://github.com/yourname)
+func (sysErrprService *SysErrorService) DeleteSysError(ctx context.Context, ID string) (err error) {
+	err = global.GVA_DB.Delete(&system.SysError{}, "id = ?", ID).Error
+	return err
+}
+
+// DeleteSysErrorByIds 批量删除错误日志记录
+// Author [yourname](https://github.com/yourname)
+func (sysErrprService *SysErrorService) DeleteSysErrorByIds(ctx context.Context, IDs []string) (err error) {
+	err = global.GVA_DB.Delete(&[]system.SysError{}, "id in ?", IDs).Error
+	return err
+}
+
+// UpdateSysError 更新错误日志记录
+// Author [yourname](https://github.com/yourname)
+func (sysErrprService *SysErrorService) UpdateSysError(ctx context.Context, sysErrpr system.SysError) (err error) {
+	err = global.GVA_DB.Model(&system.SysError{}).Where("id = ?", sysErrpr.ID).Updates(&sysErrpr).Error
+	return err
+}
+
+// GetSysError 根据ID获取错误日志记录
+// Author [yourname](https://github.com/yourname)
+func (sysErrprService *SysErrorService) GetSysError(ctx context.Context, ID string) (sysErrpr system.SysError, err error) {
+	err = global.GVA_DB.Where("id = ?", ID).First(&sysErrpr).Error
+	return
+}
+
+// GetSysErrorInfoList 分页获取错误日志记录
+// Author [yourname](https://github.com/yourname)
+func (sysErrprService *SysErrorService) GetSysErrorInfoList(ctx context.Context, info systemReq.SysErrorSearch) (list []system.SysError, total int64, err error) {
+	limit := info.PageSize
+	offset := info.PageSize * (info.Page - 1)
+	// 创建db
+	db := global.GVA_DB.Model(&system.SysError{}).Order("created desc")
+	var sysErrprs []system.SysError
+	// 如果有条件搜索 下方会自动创建搜索语句
+	if len(info.CreatedAtRange) == 2 {
+		db = db.Where("created_at BETWEEN ? AND ?", info.CreatedAtRange[0], info.CreatedAtRange[1])
+	}
+
+	if info.Form != nil && *info.Form != "" {
+		db = db.Where("form = ?", *info.Form)
+	}
+	if info.Info != nil && *info.Info != "" {
+		db = db.Where("info LIKE ?", "%"+*info.Info+"%")
+	}
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+
+	if limit != 0 {
+		db = db.Limit(limit).Offset(offset)
+	}
+
+	err = db.Find(&sysErrprs).Error
+	return sysErrprs, total, err
+}

server/service/system/sys_export_template.go

@@ -128,6 +128,11 @@ func (sysExportTemplateService *SysExportTemplateService) GetSysExportTemplateIn
 // ExportExcel 导出Excel
 // Author [piexlmax](https://github.com/piexlmax)
 func (sysExportTemplateService *SysExportTemplateService) ExportExcel(templateID string, values url.Values) (file *bytes.Buffer, name string, err error) {
+	var params = values.Get("params")
+	paramsValues, err := url.ParseQuery(params)
+	if err != nil {
+		return nil, "", fmt.Errorf("解析 params 参数失败: %v", err)
+	}
 	var template system.SysExportTemplate
 	err = global.GVA_DB.Preload("Conditions").Preload("JoinTemplate").First(&template, "template_id = ?", templateID).Error
 	if err != nil {
@@ -178,7 +183,7 @@ func (sysExportTemplateService *SysExportTemplateService) ExportExcel(templateID
 
 	filterDeleted := false
 
-	filterParam := values.Get("filterDeleted")
+	filterParam := paramsValues.Get("filterDeleted")
 	if filterParam == "true" {
 		filterDeleted = true
 	}
@@ -202,7 +207,22 @@ func (sysExportTemplateService *SysExportTemplateService) ExportExcel(templateID
 	if len(template.Conditions) > 0 {
 		for _, condition := range template.Conditions {
 			sql := fmt.Sprintf("%s %s ?", condition.Column, condition.Operator)
-			value := values.Get(condition.From)
+			value := paramsValues.Get(condition.From)
+
+			if condition.Operator == "IN" || condition.Operator == "NOT IN" {
+				sql = fmt.Sprintf("%s %s (?)", condition.Column, condition.Operator)
+			}
+
+			if condition.Operator == "BETWEEN" {
+				sql = fmt.Sprintf("%s BETWEEN ? AND ?", condition.Column)
+				startValue := paramsValues.Get("start" + condition.From)
+				endValue := paramsValues.Get("end" + condition.From)
+				if startValue != "" && endValue != "" {
+					db = db.Where(sql, startValue, endValue)
+				}
+				continue
+			}
+
 			if value != "" {
 				if condition.Operator == "LIKE" {
 					value = "%" + value + "%"
@@ -212,7 +232,7 @@ func (sysExportTemplateService *SysExportTemplateService) ExportExcel(templateID
 		}
 	}
 	// 通过参数传入limit
-	limit := values.Get("limit")
+	limit := paramsValues.Get("limit")
 	if limit != "" {
 		l, e := strconv.Atoi(limit)
 		if e == nil {
@@ -225,7 +245,7 @@ func (sysExportTemplateService *SysExportTemplateService) ExportExcel(templateID
 	}
 
 	// 通过参数传入offset
-	offset := values.Get("offset")
+	offset := paramsValues.Get("offset")
 	if offset != "" {
 		o, e := strconv.Atoi(offset)
 		if e == nil {
@@ -248,7 +268,7 @@ func (sysExportTemplateService *SysExportTemplateService) ExportExcel(templateID
 	}
 
 	// 通过参数传入order
-	order := values.Get("order")
+	order := paramsValues.Get("order")
 
 	if order == "" && template.Order != "" {
 		// 如果没有order入参，这里会使用模板的默认排序
@@ -305,7 +325,17 @@ func (sysExportTemplateService *SysExportTemplateService) ExportExcel(templateID
 	}
 	for i, row := range rows {
 		for j, colCell := range row {
-			sErr := f.SetCellValue("Sheet1", fmt.Sprintf("%s%d", getColumnName(j+1), i+1), colCell)
+			cell := fmt.Sprintf("%s%d", getColumnName(j+1), i+1)
+
+			var sErr error
+			if v, err := strconv.ParseFloat(colCell, 64); err == nil {
+				sErr = f.SetCellValue("Sheet1", cell, v)
+			} else if v, err := strconv.ParseInt(colCell, 10, 64); err == nil {
+				sErr = f.SetCellValue("Sheet1", cell, v)
+			} else {
+				sErr = f.SetCellValue("Sheet1", cell, colCell)
+			}
+
 			if sErr != nil {
 				return nil, "", sErr
 			}
@@ -320,6 +350,185 @@ func (sysExportTemplateService *SysExportTemplateService) ExportExcel(templateID
 	return file, template.Name, nil
 }
 
+// PreviewSQL 预览最终生成的 SQL（不执行查询，仅返回 SQL 字符串）
+// Author [piexlmax](https://github.com/piexlmax) & [trae-ai]
+func (sysExportTemplateService *SysExportTemplateService) PreviewSQL(templateID string, values url.Values) (sqlPreview string, err error) {
+    // 解析 params（与导出逻辑保持一致）
+    var params = values.Get("params")
+    paramsValues, _ := url.ParseQuery(params)
+
+    // 加载模板
+    var template system.SysExportTemplate
+    err = global.GVA_DB.Preload("Conditions").Preload("JoinTemplate").First(&template, "template_id = ?", templateID).Error
+    if err != nil {
+        return "", err
+    }
+
+    // 解析模板列
+    var templateInfoMap = make(map[string]string)
+    columns, err := utils.GetJSONKeys(template.TemplateInfo)
+    if err != nil {
+        return "", err
+    }
+    err = json.Unmarshal([]byte(template.TemplateInfo), &templateInfoMap)
+    if err != nil {
+        return "", err
+    }
+    var selectKeyFmt []string
+    for _, key := range columns {
+        selectKeyFmt = append(selectKeyFmt, key)
+    }
+    selects := strings.Join(selectKeyFmt, ", ")
+
+    // 生成 FROM 与 JOIN 片段
+    var sb strings.Builder
+    sb.WriteString("SELECT ")
+    sb.WriteString(selects)
+    sb.WriteString(" FROM ")
+    sb.WriteString(template.TableName)
+
+    if len(template.JoinTemplate) > 0 {
+        for _, join := range template.JoinTemplate {
+            sb.WriteString(" ")
+            sb.WriteString(join.JOINS)
+            sb.WriteString(" ")
+            sb.WriteString(join.Table)
+            sb.WriteString(" ON ")
+            sb.WriteString(join.ON)
+        }
+    }
+
+    // WHERE 条件
+    var wheres []string
+
+    // 软删除过滤
+    filterDeleted := false
+    if paramsValues != nil {
+        filterParam := paramsValues.Get("filterDeleted")
+        if filterParam == "true" {
+            filterDeleted = true
+        }
+    }
+    if filterDeleted {
+        wheres = append(wheres, fmt.Sprintf("%s.deleted_at IS NULL", template.TableName))
+        if len(template.JoinTemplate) > 0 {
+            for _, join := range template.JoinTemplate {
+                if sysExportTemplateService.hasDeletedAtColumn(join.Table) {
+                    wheres = append(wheres, fmt.Sprintf("%s.deleted_at IS NULL", join.Table))
+                }
+            }
+        }
+    }
+
+    // 模板条件（保留与 ExportExcel 同步的解析规则）
+    if len(template.Conditions) > 0 {
+        for _, condition := range template.Conditions {
+            op := strings.ToUpper(strings.TrimSpace(condition.Operator))
+            col := strings.TrimSpace(condition.Column)
+
+            // 预览优先展示传入值，没有则展示占位符
+            val := ""
+            if paramsValues != nil {
+                val = paramsValues.Get(condition.From)
+            }
+
+            switch op {
+            case "BETWEEN":
+                startValue := ""
+                endValue := ""
+                if paramsValues != nil {
+                    startValue = paramsValues.Get("start" + condition.From)
+                    endValue = paramsValues.Get("end" + condition.From)
+                }
+                if startValue != "" && endValue != "" {
+                    wheres = append(wheres, fmt.Sprintf("%s BETWEEN '%s' AND '%s'", col, startValue, endValue))
+                } else {
+                    wheres = append(wheres, fmt.Sprintf("%s BETWEEN {start%s} AND {end%s}", col, condition.From, condition.From))
+                }
+            case "IN", "NOT IN":
+                if val != "" {
+                    // 逗号分隔值做简单展示
+                    parts := strings.Split(val, ",")
+                    for i := range parts { parts[i] = strings.TrimSpace(parts[i]) }
+                    wheres = append(wheres, fmt.Sprintf("%s %s ('%s')", col, op, strings.Join(parts, "','")))
+                } else {
+                    wheres = append(wheres, fmt.Sprintf("%s %s ({%s})", col, op, condition.From))
+                }
+            case "LIKE":
+                if val != "" {
+                    wheres = append(wheres, fmt.Sprintf("%s LIKE '%%%s%%'", col, val))
+                } else {
+                    wheres = append(wheres, fmt.Sprintf("%s LIKE {%%%s%%}", col, condition.From))
+                }
+            default:
+                if val != "" {
+                    wheres = append(wheres, fmt.Sprintf("%s %s '%s'", col, op, val))
+                } else {
+                    wheres = append(wheres, fmt.Sprintf("%s %s {%s}", col, op, condition.From))
+                }
+            }
+        }
+    }
+
+    if len(wheres) > 0 {
+        sb.WriteString(" WHERE ")
+        sb.WriteString(strings.Join(wheres, " AND "))
+    }
+
+    // 排序
+    order := ""
+    if paramsValues != nil {
+        order = paramsValues.Get("order")
+    }
+    if order == "" && template.Order != "" {
+        order = template.Order
+    }
+    if order != "" {
+        sb.WriteString(" ORDER BY ")
+        sb.WriteString(order)
+    }
+
+    // limit/offset（如果传入或默认值为0，则不生成）
+    limitStr := ""
+    offsetStr := ""
+    if paramsValues != nil {
+        limitStr = paramsValues.Get("limit")
+        offsetStr = paramsValues.Get("offset")
+    }
+
+    // 处理模板默认limit（仅当非0时）
+    if limitStr == "" && template.Limit != nil && *template.Limit != 0 {
+        limitStr = strconv.Itoa(*template.Limit)
+    }
+
+    // 解析为数值，用于判断是否生成
+    limitInt := 0
+    offsetInt := 0
+    if limitStr != "" {
+        if v, e := strconv.Atoi(limitStr); e == nil { limitInt = v }
+    }
+    if offsetStr != "" {
+        if v, e := strconv.Atoi(offsetStr); e == nil { offsetInt = v }
+    }
+
+    if limitInt > 0 {
+        sb.WriteString(" LIMIT ")
+        sb.WriteString(strconv.Itoa(limitInt))
+        if offsetInt > 0 {
+            sb.WriteString(" OFFSET ")
+            sb.WriteString(strconv.Itoa(offsetInt))
+        }
+    } else {
+        // 当limit未设置或为0时，仅当offset>0才生成OFFSET
+        if offsetInt > 0 {
+            sb.WriteString(" OFFSET ")
+            sb.WriteString(strconv.Itoa(offsetInt))
+        }
+    }
+
+    return sb.String(), nil
+}
+
 // ExportTemplate 导出Excel模板
 // Author [piexlmax](https://github.com/piexlmax)
 func (sysExportTemplateService *SysExportTemplateService) ExportTemplate(templateID string) (file *bytes.Buffer, name string, err error) {
@@ -429,7 +638,7 @@ func (sysExportTemplateService *SysExportTemplateService) ImportExcel(templateID
 		for _, row := range values {
 			var item = make(map[string]interface{})
 			for ii, value := range row {
-			    if _, ok := titleKeyMap[excelTitle[ii]]; !ok {
+				if _, ok := titleKeyMap[excelTitle[ii]]; !ok {
 					continue // excel中多余的标题，在模板信息中没有对应的字段，因此key为空，必须跳过
 				}
 				key := titleKeyMap[excelTitle[ii]]

server/service/system/sys_menu.go

@@ -134,10 +134,52 @@ func (menuService *MenuService) getBaseChildrenList(menu *system.SysBaseMenu, tr
 //@return: error
 
 func (menuService *MenuService) AddBaseMenu(menu system.SysBaseMenu) error {
-	if !errors.Is(global.GVA_DB.Where("name = ?", menu.Name).First(&system.SysBaseMenu{}).Error, gorm.ErrRecordNotFound) {
-		return errors.New("存在重复name，请修改name")
-	}
-	return global.GVA_DB.Create(&menu).Error
+	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
+		// 检查name是否重复
+		if !errors.Is(tx.Where("name = ?", menu.Name).First(&system.SysBaseMenu{}).Error, gorm.ErrRecordNotFound) {
+			return errors.New("存在重复name，请修改name")
+		}
+
+		if menu.ParentId != 0 {
+			// 检查父菜单是否存在
+			var parentMenu system.SysBaseMenu
+			if err := tx.First(&parentMenu, menu.ParentId).Error; err != nil {
+				if errors.Is(err, gorm.ErrRecordNotFound) {
+					return errors.New("父菜单不存在")
+				}
+				return err
+			}
+
+			// 检查父菜单下现有子菜单数量
+			var existingChildrenCount int64
+			err := tx.Model(&system.SysBaseMenu{}).Where("parent_id = ?", menu.ParentId).Count(&existingChildrenCount).Error
+			if err != nil {
+				return err
+			}
+
+			// 如果父菜单原本是叶子菜单（没有子菜单），现在要变成枝干菜单，需要清空其权限分配
+			if existingChildrenCount == 0 {
+				// 检查父菜单是否被其他角色设置为首页
+				var defaultRouterCount int64
+				err := tx.Model(&system.SysAuthority{}).Where("default_router = ?", parentMenu.Name).Count(&defaultRouterCount).Error
+				if err != nil {
+					return err
+				}
+				if defaultRouterCount > 0 {
+					return errors.New("父菜单已被其他角色的首页占用，请先释放父菜单的首页权限")
+				}
+
+				// 清空父菜单的所有权限分配
+				err = tx.Where("sys_base_menu_id = ?", menu.ParentId).Delete(&system.SysAuthorityMenu{}).Error
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		// 创建菜单
+		return tx.Create(&menu).Error
+	})
 }
 
 //@author: [piexlmax](https://github.com/piexlmax)

server/service/system/sys_user.go

@@ -3,9 +3,10 @@ package system
 import (
 	"errors"
 	"fmt"
+	"time"
+
 	"github.com/flipped-aurora/gin-vue-admin/server/model/common"
 	systemReq "github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
-	"time"
 
 	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
@@ -63,20 +64,20 @@ func (userService *UserService) Login(u *system.SysUser) (userInter *system.SysU
 //@function: ChangePassword
 //@description: 修改用户密码
 //@param: u *model.SysUser, newPassword string
-//@return: userInter *model.SysUser,err error
+//@return: err error
 
-func (userService *UserService) ChangePassword(u *system.SysUser, newPassword string) (userInter *system.SysUser, err error) {
+func (userService *UserService) ChangePassword(u *system.SysUser, newPassword string) (err error) {
 	var user system.SysUser
-	if err = global.GVA_DB.Where("id = ?", u.ID).First(&user).Error; err != nil {
-		return nil, err
+	err = global.GVA_DB.Select("id, password").Where("id = ?", u.ID).First(&user).Error
+	if err != nil {
+		return err
 	}
 	if ok := utils.BcryptCheck(u.Password, user.Password); !ok {
-		return nil, errors.New("原密码错误")
+		return errors.New("原密码错误")
 	}
-	user.Password = utils.BcryptHash(newPassword)
-	err = global.GVA_DB.Save(&user).Error
-	return &user, err
-
+	pwd := utils.BcryptHash(newPassword)
+	err = global.GVA_DB.Model(&user).Update("password", pwd).Error
+	return err
 }
 
 //@author: [piexlmax](https://github.com/piexlmax)

server/service/system/sys_version.go

@@ -0,0 +1,230 @@
+package system
+
+import (
+	"context"
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	systemReq "github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
+	"gorm.io/gorm"
+)
+
+type SysVersionService struct{}
+
+// CreateSysVersion 创建版本管理记录
+// Author [yourname](https://github.com/yourname)
+func (sysVersionService *SysVersionService) CreateSysVersion(ctx context.Context, sysVersion *system.SysVersion) (err error) {
+	err = global.GVA_DB.Create(sysVersion).Error
+	return err
+}
+
+// DeleteSysVersion 删除版本管理记录
+// Author [yourname](https://github.com/yourname)
+func (sysVersionService *SysVersionService) DeleteSysVersion(ctx context.Context, ID string) (err error) {
+	err = global.GVA_DB.Delete(&system.SysVersion{}, "id = ?", ID).Error
+	return err
+}
+
+// DeleteSysVersionByIds 批量删除版本管理记录
+// Author [yourname](https://github.com/yourname)
+func (sysVersionService *SysVersionService) DeleteSysVersionByIds(ctx context.Context, IDs []string) (err error) {
+	err = global.GVA_DB.Where("id in ?", IDs).Delete(&system.SysVersion{}).Error
+	return err
+}
+
+// GetSysVersion 根据ID获取版本管理记录
+// Author [yourname](https://github.com/yourname)
+func (sysVersionService *SysVersionService) GetSysVersion(ctx context.Context, ID string) (sysVersion system.SysVersion, err error) {
+	err = global.GVA_DB.Where("id = ?", ID).First(&sysVersion).Error
+	return
+}
+
+// GetSysVersionInfoList 分页获取版本管理记录
+// Author [yourname](https://github.com/yourname)
+func (sysVersionService *SysVersionService) GetSysVersionInfoList(ctx context.Context, info systemReq.SysVersionSearch) (list []system.SysVersion, total int64, err error) {
+	limit := info.PageSize
+	offset := info.PageSize * (info.Page - 1)
+	// 创建db
+	db := global.GVA_DB.Model(&system.SysVersion{})
+	var sysVersions []system.SysVersion
+	// 如果有条件搜索 下方会自动创建搜索语句
+	if len(info.CreatedAtRange) == 2 {
+		db = db.Where("created_at BETWEEN ? AND ?", info.CreatedAtRange[0], info.CreatedAtRange[1])
+	}
+
+	if info.VersionName != nil && *info.VersionName != "" {
+		db = db.Where("version_name LIKE ?", "%"+*info.VersionName+"%")
+	}
+	if info.VersionCode != nil && *info.VersionCode != "" {
+		db = db.Where("version_code = ?", *info.VersionCode)
+	}
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+
+	if limit != 0 {
+		db = db.Limit(limit).Offset(offset)
+	}
+
+	err = db.Find(&sysVersions).Error
+	return sysVersions, total, err
+}
+func (sysVersionService *SysVersionService) GetSysVersionPublic(ctx context.Context) {
+	// 此方法为获取数据源定义的数据
+	// 请自行实现
+}
+
+// GetMenusByIds 根据ID列表获取菜单数据
+func (sysVersionService *SysVersionService) GetMenusByIds(ctx context.Context, ids []uint) (menus []system.SysBaseMenu, err error) {
+	err = global.GVA_DB.Where("id in ?", ids).Preload("Parameters").Preload("MenuBtn").Find(&menus).Error
+	return
+}
+
+// GetApisByIds 根据ID列表获取API数据
+func (sysVersionService *SysVersionService) GetApisByIds(ctx context.Context, ids []uint) (apis []system.SysApi, err error) {
+	err = global.GVA_DB.Where("id in ?", ids).Find(&apis).Error
+	return
+}
+
+// GetDictionariesByIds 根据ID列表获取字典数据
+func (sysVersionService *SysVersionService) GetDictionariesByIds(ctx context.Context, ids []uint) (dictionaries []system.SysDictionary, err error) {
+	err = global.GVA_DB.Where("id in ?", ids).Preload("SysDictionaryDetails").Find(&dictionaries).Error
+	return
+}
+
+// ImportMenus 导入菜单数据
+func (sysVersionService *SysVersionService) ImportMenus(ctx context.Context, menus []system.SysBaseMenu) error {
+	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
+		// 递归创建菜单
+		return sysVersionService.createMenusRecursively(tx, menus, 0)
+	})
+}
+
+// createMenusRecursively 递归创建菜单
+func (sysVersionService *SysVersionService) createMenusRecursively(tx *gorm.DB, menus []system.SysBaseMenu, parentId uint) error {
+	for _, menu := range menus {
+		// 检查菜单是否已存在
+		var existingMenu system.SysBaseMenu
+		if err := tx.Where("name = ? AND path = ?", menu.Name, menu.Path).First(&existingMenu).Error; err == nil {
+			// 菜单已存在，使用现有菜单ID继续处理子菜单
+			if len(menu.Children) > 0 {
+				if err := sysVersionService.createMenusRecursively(tx, menu.Children, existingMenu.ID); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+
+		// 保存参数和按钮数据，稍后处理
+		parameters := menu.Parameters
+		menuBtns := menu.MenuBtn
+		children := menu.Children
+
+		// 创建新菜单（不包含关联数据）
+		newMenu := system.SysBaseMenu{
+			ParentId:  parentId,
+			Path:      menu.Path,
+			Name:      menu.Name,
+			Hidden:    menu.Hidden,
+			Component: menu.Component,
+			Sort:      menu.Sort,
+			Meta:      menu.Meta,
+		}
+
+		if err := tx.Create(&newMenu).Error; err != nil {
+			return err
+		}
+
+		// 创建参数
+		if len(parameters) > 0 {
+			for _, param := range parameters {
+				newParam := system.SysBaseMenuParameter{
+					SysBaseMenuID: newMenu.ID,
+					Type:          param.Type,
+					Key:           param.Key,
+					Value:         param.Value,
+				}
+				if err := tx.Create(&newParam).Error; err != nil {
+					return err
+				}
+			}
+		}
+
+		// 创建菜单按钮
+		if len(menuBtns) > 0 {
+			for _, btn := range menuBtns {
+				newBtn := system.SysBaseMenuBtn{
+					SysBaseMenuID: newMenu.ID,
+					Name:          btn.Name,
+					Desc:          btn.Desc,
+				}
+				if err := tx.Create(&newBtn).Error; err != nil {
+					return err
+				}
+			}
+		}
+
+		// 递归处理子菜单
+		if len(children) > 0 {
+			if err := sysVersionService.createMenusRecursively(tx, children, newMenu.ID); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// ImportApis 导入API数据
+func (sysVersionService *SysVersionService) ImportApis(apis []system.SysApi) error {
+	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
+		for _, api := range apis {
+			// 检查API是否已存在
+			var existingApi system.SysApi
+			if err := tx.Where("path = ? AND method = ?", api.Path, api.Method).First(&existingApi).Error; err == nil {
+				// API已存在，跳过
+				continue
+			}
+
+			// 创建新API
+			newApi := system.SysApi{
+				Path:        api.Path,
+				Description: api.Description,
+				ApiGroup:    api.ApiGroup,
+				Method:      api.Method,
+			}
+
+			if err := tx.Create(&newApi).Error; err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}
+
+// ImportDictionaries 导入字典数据
+func (sysVersionService *SysVersionService) ImportDictionaries(dictionaries []system.SysDictionary) error {
+	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
+		for _, dict := range dictionaries {
+			// 检查字典是否已存在
+			var existingDict system.SysDictionary
+			if err := tx.Where("type = ?", dict.Type).First(&existingDict).Error; err == nil {
+				// 字典已存在，跳过
+				continue
+			}
+
+			// 创建新字典
+			newDict := system.SysDictionary{
+				Name:                 dict.Name,
+				Type:                 dict.Type,
+				Status:               dict.Status,
+				Desc:                 dict.Desc,
+				SysDictionaryDetails: dict.SysDictionaryDetails,
+			}
+
+			if err := tx.Create(&newDict).Error; err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}

server/source/system/api.go

@@ -2,6 +2,7 @@ package system
 
 import (
 	"context"
+
 	sysModel "github.com/flipped-aurora/gin-vue-admin/server/model/system"
 	"github.com/flipped-aurora/gin-vue-admin/server/service/system"
 	"github.com/pkg/errors"
@@ -138,6 +139,11 @@ func (i *initApi) InitializeData(ctx context.Context) (context.Context, error) {
 		{ApiGroup: "系统字典详情", Method: "GET", Path: "/sysDictionaryDetail/findSysDictionaryDetail", Description: "根据ID获取字典内容"},
 		{ApiGroup: "系统字典详情", Method: "GET", Path: "/sysDictionaryDetail/getSysDictionaryDetailList", Description: "获取字典内容列表"},
 
+		{ApiGroup: "系统字典详情", Method: "GET", Path: "/sysDictionaryDetail/getDictionaryTreeList", Description: "获取字典数列表"},
+		{ApiGroup: "系统字典详情", Method: "GET", Path: "/sysDictionaryDetail/getDictionaryTreeListByType", Description: "根据分类获取字典数列表"},
+		{ApiGroup: "系统字典详情", Method: "GET", Path: "/sysDictionaryDetail/getDictionaryDetailsByParent", Description: "根据父级ID获取字典详情"},
+		{ApiGroup: "系统字典详情", Method: "GET", Path: "/sysDictionaryDetail/getDictionaryPath", Description: "获取字典详情的完整路径"},
+
 		{ApiGroup: "系统字典", Method: "POST", Path: "/sysDictionary/createSysDictionary", Description: "新增字典"},
 		{ApiGroup: "系统字典", Method: "DELETE", Path: "/sysDictionary/deleteSysDictionary", Description: "删除字典"},
 		{ApiGroup: "系统字典", Method: "PUT", Path: "/sysDictionary/updateSysDictionary", Description: "更新字典"},
@@ -169,6 +175,7 @@ func (i *initApi) InitializeData(ctx context.Context) (context.Context, error) {
 		{ApiGroup: "导出模板", Method: "GET", Path: "/sysExportTemplate/getSysExportTemplateList", Description: "获取导出模板列表"},
 		{ApiGroup: "导出模板", Method: "GET", Path: "/sysExportTemplate/exportExcel", Description: "导出Excel"},
 		{ApiGroup: "导出模板", Method: "GET", Path: "/sysExportTemplate/exportTemplate", Description: "下载模板"},
+		{ApiGroup: "导出模板", Method: "GET", Path: "/sysExportTemplate/previewSQL", Description: "预览SQL"},
 		{ApiGroup: "导出模板", Method: "POST", Path: "/sysExportTemplate/importExcel", Description: "导入Excel"},
 
 		{ApiGroup: "公告", Method: "POST", Path: "/info/createInfo", Description: "新建公告"},
@@ -188,6 +195,14 @@ func (i *initApi) InitializeData(ctx context.Context) (context.Context, error) {
 		{ApiGroup: "媒体库分类", Method: "GET", Path: "/attachmentCategory/getCategoryList", Description: "分类列表"},
 		{ApiGroup: "媒体库分类", Method: "POST", Path: "/attachmentCategory/addCategory", Description: "添加/编辑分类"},
 		{ApiGroup: "媒体库分类", Method: "POST", Path: "/attachmentCategory/deleteCategory", Description: "删除分类"},
+
+		{ApiGroup: "版本控制", Method: "GET", Path: "/sysVersion/findSysVersion", Description: "获取单一版本"},
+		{ApiGroup: "版本控制", Method: "GET", Path: "/sysVersion/getSysVersionList", Description: "获取版本列表"},
+		{ApiGroup: "版本控制", Method: "GET", Path: "/sysVersion/downloadVersionJson", Description: "下载版本json"},
+		{ApiGroup: "版本控制", Method: "POST", Path: "/sysVersion/exportVersion", Description: "创建版本"},
+		{ApiGroup: "版本控制", Method: "POST", Path: "/sysVersion/importVersion", Description: "同步版本"},
+		{ApiGroup: "版本控制", Method: "DELETE", Path: "/sysVersion/deleteSysVersion", Description: "删除版本"},
+		{ApiGroup: "版本控制", Method: "DELETE", Path: "/sysVersion/deleteSysVersionByIds", Description: "批量删除版本"},
 	}
 	if err := db.Create(&entities).Error; err != nil {
 		return ctx, errors.Wrap(err, sysModel.SysApi{}.TableName()+"表数据初始化失败!")

server/source/system/casbin.go

@@ -139,6 +139,10 @@ func (i *initCasbin) InitializeData(ctx context.Context) (context.Context, error
 		{Ptype: "p", V0: "888", V1: "/sysDictionaryDetail/createSysDictionaryDetail", V2: "POST"},
 		{Ptype: "p", V0: "888", V1: "/sysDictionaryDetail/getSysDictionaryDetailList", V2: "GET"},
 		{Ptype: "p", V0: "888", V1: "/sysDictionaryDetail/deleteSysDictionaryDetail", V2: "DELETE"},
+		{Ptype: "p", V0: "888", V1: "/sysDictionaryDetail/getDictionaryTreeList", V2: "GET"},
+		{Ptype: "p", V0: "888", V1: "/sysDictionaryDetail/getDictionaryTreeListByType", V2: "GET"},
+		{Ptype: "p", V0: "888", V1: "/sysDictionaryDetail/getDictionaryDetailsByParent", V2: "GET"},
+		{Ptype: "p", V0: "888", V1: "/sysDictionaryDetail/getDictionaryPath", V2: "GET"},
 
 		{Ptype: "p", V0: "888", V1: "/sysDictionary/findSysDictionary", V2: "GET"},
 		{Ptype: "p", V0: "888", V1: "/sysDictionary/updateSysDictionary", V2: "PUT"},
@@ -172,6 +176,7 @@ func (i *initCasbin) InitializeData(ctx context.Context) (context.Context, error
 		{Ptype: "p", V0: "888", V1: "/sysExportTemplate/getSysExportTemplateList", V2: "GET"},
 		{Ptype: "p", V0: "888", V1: "/sysExportTemplate/exportExcel", V2: "GET"},
 		{Ptype: "p", V0: "888", V1: "/sysExportTemplate/exportTemplate", V2: "GET"},
+		{Ptype: "p", V0: "888", V1: "/sysExportTemplate/previewSQL", V2: "GET"},
 		{Ptype: "p", V0: "888", V1: "/sysExportTemplate/importExcel", V2: "POST"},
 
 		{Ptype: "p", V0: "888", V1: "/info/createInfo", V2: "POST"},
@@ -192,6 +197,14 @@ func (i *initCasbin) InitializeData(ctx context.Context) (context.Context, error
 		{Ptype: "p", V0: "888", V1: "/attachmentCategory/addCategory", V2: "POST"},
 		{Ptype: "p", V0: "888", V1: "/attachmentCategory/deleteCategory", V2: "POST"},
 
+		{Ptype: "p", V0: "888", V1: "/sysVersion/findSysVersion", V2: "GET"},
+		{Ptype: "p", V0: "888", V1: "/sysVersion/getSysVersionList", V2: "GET"},
+		{Ptype: "p", V0: "888", V1: "/sysVersion/downloadVersionJson", V2: "GET"},
+		{Ptype: "p", V0: "888", V1: "/sysVersion/exportVersion", V2: "POST"},
+		{Ptype: "p", V0: "888", V1: "/sysVersion/importVersion", V2: "POST"},
+		{Ptype: "p", V0: "888", V1: "/sysVersion/deleteSysVersion", V2: "DELETE"},
+		{Ptype: "p", V0: "888", V1: "/sysVersion/deleteSysVersionByIds", V2: "DELETE"},
+
 		{Ptype: "p", V0: "8881", V1: "/user/admin_register", V2: "POST"},
 		{Ptype: "p", V0: "8881", V1: "/api/createApi", V2: "POST"},
 		{Ptype: "p", V0: "8881", V1: "/api/getApiList", V2: "POST"},

server/source/system/dictionary_detail.go

@@ -66,7 +66,7 @@ func (i *initDictDetail) InitializeData(ctx context.Context) (context.Context, e
 	}
 
 	dicts[2].SysDictionaryDetails = []sysModel.SysDictionaryDetail{
-		{Label: "date", Status: &True},
+		{Label: "date", Value: "0", Status: &True, Extend: "mysql", Sort: 0},
 		{Label: "time", Value: "1", Status: &True, Extend: "mysql", Sort: 1},
 		{Label: "year", Value: "2", Status: &True, Extend: "mysql", Sort: 2},
 		{Label: "datetime", Value: "3", Status: &True, Extend: "mysql", Sort: 3},
@@ -74,7 +74,7 @@ func (i *initDictDetail) InitializeData(ctx context.Context) (context.Context, e
 		{Label: "timestamptz", Value: "6", Status: &True, Extend: "pgsql", Sort: 5},
 	}
 	dicts[3].SysDictionaryDetails = []sysModel.SysDictionaryDetail{
-		{Label: "float", Status: &True},
+		{Label: "float", Value: "0", Status: &True, Extend: "mysql", Sort: 0},
 		{Label: "double", Value: "1", Status: &True, Extend: "mysql", Sort: 1},
 		{Label: "decimal", Value: "2", Status: &True, Extend: "mysql", Sort: 2},
 		{Label: "numeric", Value: "3", Status: &True, Extend: "pgsql", Sort: 3},
@@ -82,7 +82,7 @@ func (i *initDictDetail) InitializeData(ctx context.Context) (context.Context, e
 	}
 
 	dicts[4].SysDictionaryDetails = []sysModel.SysDictionaryDetail{
-		{Label: "char", Status: &True},
+		{Label: "char", Value: "0", Status: &True, Extend: "mysql", Sort: 0},
 		{Label: "varchar", Value: "1", Status: &True, Extend: "mysql", Sort: 1},
 		{Label: "tinyblob", Value: "2", Status: &True, Extend: "mysql", Sort: 2},
 		{Label: "tinytext", Value: "3", Status: &True, Extend: "mysql", Sort: 3},

server/source/system/menu.go

@@ -102,6 +102,7 @@ func (i *initMenu) InitializeData(ctx context.Context) (next context.Context, er
 		{MenuLevel: 1, Hidden: false, ParentId: menuNameMap["systemTools"], Path: "picture", Name: "picture", Component: "view/systemTools/autoCode/picture.vue", Sort: 6, Meta: Meta{Title: "AI页面绘制", Icon: "picture-filled"}},
 		{MenuLevel: 1, Hidden: false, ParentId: menuNameMap["systemTools"], Path: "mcpTool", Name: "mcpTool", Component: "view/systemTools/autoCode/mcp.vue", Sort: 7, Meta: Meta{Title: "Mcp Tools模板", Icon: "magnet"}},
 		{MenuLevel: 1, Hidden: false, ParentId: menuNameMap["systemTools"], Path: "mcpTest", Name: "mcpTest", Component: "view/systemTools/autoCode/mcpTest.vue", Sort: 7, Meta: Meta{Title: "Mcp Tools测试", Icon: "partly-cloudy"}},
+		{MenuLevel: 1, Hidden: false, ParentId: menuNameMap["systemTools"], Path: "sysVersion", Name: "sysVersion", Component: "view/systemTools/version/version.vue", Sort: 8, Meta: Meta{Title: "版本管理", Icon: "server"}},
 
 		{MenuLevel: 1, Hidden: false, ParentId: menuNameMap["plugin"], Path: "https://plugin.gin-vue-admin.com/", Name: "https://plugin.gin-vue-admin.com/", Component: "https://plugin.gin-vue-admin.com/", Sort: 0, Meta: Meta{Title: "插件市场", Icon: "shop"}},
 		{MenuLevel: 1, Hidden: false, ParentId: menuNameMap["plugin"], Path: "installPlugin", Name: "installPlugin", Component: "view/systemTools/installPlugin/index.vue", Sort: 1, Meta: Meta{Title: "插件安装", Icon: "box"}},

server/source/system/user.go

@@ -70,7 +70,7 @@ func (i *initUser) InitializeData(ctx context.Context) (next context.Context, er
 			Username:    "a303176530",
 			Password:    password,
 			NickName:    "用户1",
-			HeaderImg:   "https:///qmplusimg.henrongyi.top/1572075907logo.png",
+			HeaderImg:   "https://qmplusimg.henrongyi.top/1572075907logo.png",
 			AuthorityId: 9528,
 			Phone:       "17611111111",
 			Email:       "333333333@qq.com"},

server/utils/ast/ast.go

@@ -121,6 +121,81 @@ func CreateMenuStructAst(menus []system.SysBaseMenu) *[]ast.Expr {
 				},
 			},
 		}
+
+		// 添加菜单参数
+		if len(menus[i].Parameters) > 0 {
+			var paramElts []ast.Expr
+			for _, param := range menus[i].Parameters {
+				paramElts = append(paramElts, &ast.CompositeLit{
+					Type: &ast.SelectorExpr{
+						X:   &ast.Ident{Name: "model"},
+						Sel: &ast.Ident{Name: "SysBaseMenuParameter"},
+					},
+					Elts: []ast.Expr{
+						&ast.KeyValueExpr{
+							Key:   &ast.Ident{Name: "Type"},
+							Value: &ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("\"%s\"", param.Type)},
+						},
+						&ast.KeyValueExpr{
+							Key:   &ast.Ident{Name: "Key"},
+							Value: &ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("\"%s\"", param.Key)},
+						},
+						&ast.KeyValueExpr{
+							Key:   &ast.Ident{Name: "Value"},
+							Value: &ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("\"%s\"", param.Value)},
+						},
+					},
+				})
+			}
+			elts = append(elts, &ast.KeyValueExpr{
+				Key: &ast.Ident{Name: "Parameters"},
+				Value: &ast.CompositeLit{
+					Type: &ast.ArrayType{
+						Elt: &ast.SelectorExpr{
+							X:   &ast.Ident{Name: "model"},
+							Sel: &ast.Ident{Name: "SysBaseMenuParameter"},
+						},
+					},
+					Elts: paramElts,
+				},
+			})
+		}
+
+		// 添加菜单按钮
+		if len(menus[i].MenuBtn) > 0 {
+			var btnElts []ast.Expr
+			for _, btn := range menus[i].MenuBtn {
+				btnElts = append(btnElts, &ast.CompositeLit{
+					Type: &ast.SelectorExpr{
+						X:   &ast.Ident{Name: "model"},
+						Sel: &ast.Ident{Name: "SysBaseMenuBtn"},
+					},
+					Elts: []ast.Expr{
+						&ast.KeyValueExpr{
+							Key:   &ast.Ident{Name: "Name"},
+							Value: &ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("\"%s\"", btn.Name)},
+						},
+						&ast.KeyValueExpr{
+							Key:   &ast.Ident{Name: "Desc"},
+							Value: &ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("\"%s\"", btn.Desc)},
+						},
+					},
+				})
+			}
+			elts = append(elts, &ast.KeyValueExpr{
+				Key: &ast.Ident{Name: "MenuBtn"},
+				Value: &ast.CompositeLit{
+					Type: &ast.ArrayType{
+						Elt: &ast.SelectorExpr{
+							X:   &ast.Ident{Name: "model"},
+							Sel: &ast.Ident{Name: "SysBaseMenuBtn"},
+						},
+					},
+					Elts: btnElts,
+				},
+			})
+		}
+
 		menuElts = append(menuElts, &ast.CompositeLit{
 			Type: nil,
 			Elts: elts,

server/utils/autocode/template_funcs.go

@@ -46,7 +46,8 @@ func GenerateField(field systemReq.AutoCodeField) string {
 
 	gormTag += "column:" + field.ColumnName + ";"
 
-	if field.DataTypeLong != "" && field.FieldType != "enum" {
+	// 对于int类型，根据DataTypeLong决定具体的Go类型，不使用size标签
+	if field.DataTypeLong != "" && field.FieldType != "enum" && field.FieldType != "int" {
 		gormTag += fmt.Sprintf("size:%s;", field.DataTypeLong)
 	}
 
@@ -70,7 +71,7 @@ func GenerateField(field systemReq.AutoCodeField) string {
 		result = fmt.Sprintf(`%s  datatypes.JSON `+"`"+`%s swaggertype:"array,object"`+"`"+``,
 			field.FieldName, tagContent)
 	case "richtext":
-		tagContent := fmt.Sprintf(`json:"%s" form:"%s" gorm:"%s"`,
+		tagContent := fmt.Sprintf(`json:"%s" form:"%s" gorm:"%s`,
 			field.FieldJson, field.FieldJson, gormTag)
 
 		result = fmt.Sprintf(`%s  *string `+"`"+`%stype:text;"`+"`"+``,
@@ -85,8 +86,27 @@ func GenerateField(field systemReq.AutoCodeField) string {
 		tagContent := fmt.Sprintf(`json:"%s" form:"%s" gorm:"%s"`,
 			field.FieldJson, field.FieldJson, gormTag)
 
+		// 对于int类型，根据DataTypeLong决定具体的Go类型
+		var fieldType string
+		if field.FieldType == "int" {
+			switch field.DataTypeLong {
+			case "1", "2", "3":
+				fieldType = "int8"
+			case "4", "5":
+				fieldType = "int16"
+			case "6", "7", "8", "9", "10":
+				fieldType = "int32"
+			case "11", "12", "13", "14", "15", "16", "17", "18", "19", "20":
+				fieldType = "int64"
+			default:
+				fieldType = "int64"
+			}
+		} else {
+			fieldType = field.FieldType
+		}
+
 		result = fmt.Sprintf(`%s  *%s `+"`"+`%s`+"`"+``,
-			field.FieldName, field.FieldType, tagContent)
+			field.FieldName, fieldType, tagContent)
 	}
 
 	if field.Require {
@@ -112,7 +132,7 @@ func GenerateSearchConditions(fields []*systemReq.AutoCodeField) string {
 
 		var condition string
 
-		if slices.Contains([]string{"enum", "pictures", "picture", "video", "json", "array"}, field.FieldType) {
+		if slices.Contains([]string{"enum", "pictures", "picture", "video", "json", "richtext", "array"}, field.FieldType) {
 			if field.FieldType == "enum" {
 				if field.FieldSearchType == "LIKE" {
 					condition = fmt.Sprintf(`
@@ -130,7 +150,7 @@ func GenerateSearchConditions(fields []*systemReq.AutoCodeField) string {
 			} else {
 				condition = fmt.Sprintf(`
     if info.%s != "" {
-        // 数据类型为复杂类型，请根据业务需求自行实现复杂类型的查询业务
+        // TODO 数据类型为复杂类型，请根据业务需求自行实现复杂类型的查询业务
     }`, field.FieldName)
 			}
 
@@ -140,7 +160,7 @@ func GenerateSearchConditions(fields []*systemReq.AutoCodeField) string {
 			if len(info.%sRange) == 2 {
 				db = db.Where("%s %s ? AND ? ", info.%sRange[0], info.%sRange[1])
 			}`,
-					field.FieldName, field.FieldName, field.ColumnName, field.FieldSearchType, field.FieldName, field.FieldName)
+					field.FieldName, field.ColumnName, field.FieldSearchType, field.FieldName, field.FieldName)
 			} else {
 				condition = fmt.Sprintf(`
 	if info.Start%s != nil && info.End%s != nil {
@@ -199,14 +219,9 @@ func GenerateSearchFormItem(field systemReq.AutoCodeField) string {
 		if field.FieldType == "array" {
 			multipleAttr = "multiple "
 		}
-		result += fmt.Sprintf(`  <el-select %sv-model="searchInfo.%s" clearable filterable placeholder="请选择" @clear="()=>{searchInfo.%s=undefined}">
+		result += fmt.Sprintf(`    <el-tree-select v-model="formData.%s" placeholder="请选择%s" :data="%sOptions" style="width:100%%" filterable :clearable="%v" check-strictly %s></el-tree-select>
 `,
-			multipleAttr, field.FieldJson, field.FieldJson)
-		result += fmt.Sprintf(`    <el-option v-for="(item,key) in %sOptions" :key="key" :label="item.label" :value="item.value" />
-`,
-			field.DictType)
-		result += `  </el-select>
-`
+			field.FieldJson, field.FieldDesc, field.DictType, field.Clearable, multipleAttr)
 	} else if field.CheckDataSource {
 		multipleAttr := ""
 		if field.DataSource.Association == 2 {
@@ -222,11 +237,11 @@ func GenerateSearchFormItem(field systemReq.AutoCodeField) string {
 `
 	} else if field.FieldType == "float64" || field.FieldType == "int" {
 		if field.FieldSearchType == "BETWEEN" || field.FieldSearchType == "NOT BETWEEN" {
-			result += fmt.Sprintf(`  <el-input class="w-40" v-model.number="searchInfo.start%s" placeholder="最小值" />
+			result += fmt.Sprintf(`  <el-input class="!w-40" v-model.number="searchInfo.start%s" placeholder="最小值" />
 `, field.FieldName)
 			result += `  —
 `
-			result += fmt.Sprintf(`  <el-input class="w-40" v-model.number="searchInfo.end%s" placeholder="最大值" />
+			result += fmt.Sprintf(`  <el-input class="!w-40" v-model.number="searchInfo.end%s" placeholder="最大值" />
 `, field.FieldName)
 		} else {
 			result += fmt.Sprintf(`  <el-input v-model.number="searchInfo.%s" placeholder="搜索条件" />
@@ -250,7 +265,7 @@ func GenerateSearchFormItem(field systemReq.AutoCodeField) string {
 `
 			result += `  </template>
 `
-			result += fmt.Sprintf(`<el-date-picker class="w-[380px]" v-model="searchInfo.%sRange" type="datetimerange" range-separator="至"  start-placeholder="开始时间" end-placeholder="结束时间"></el-date-picker>`, field.FieldJson)
+			result += fmt.Sprintf(`<el-date-picker class="!w-380px" v-model="searchInfo.%sRange" type="datetimerange" range-separator="至"  start-placeholder="开始时间" end-placeholder="结束时间"></el-date-picker>`, field.FieldJson)
 		} else {
 			result += fmt.Sprintf(`<el-date-picker v-model="searchInfo.%s" type="datetime" placeholder="搜索条件"></el-date-picker>`, field.FieldJson)
 		}
@@ -468,14 +483,9 @@ func GenerateFormItem(field systemReq.AutoCodeField) string {
 
 		case "string":
 			if field.DictType != "" {
-				result += fmt.Sprintf(`    <el-select v-model="formData.%s" placeholder="请选择%s" style="width:100%%" filterable :clearable="%v">
+				result += fmt.Sprintf(`    <el-tree-select v-model="formData.%s" placeholder="请选择%s" :data="%sOptions" style="width:100%%" filterable :clearable="%v" check-strictly></el-tree-select>
 `,
-					field.FieldJson, field.FieldDesc, field.Clearable)
-				result += fmt.Sprintf(`        <el-option v-for="(item,key) in %sOptions" :key="key" :label="item.label" :value="item.value" />
-`,
-					field.DictType)
-				result += `    </el-select>
-`
+					field.FieldJson, field.FieldDesc, field.DictType, field.Clearable)
 			} else {
 				result += fmt.Sprintf(`    <el-input v-model="formData.%s" :clearable="%v" placeholder="请输入%s" />
 `,
@@ -575,7 +585,7 @@ func GenerateDescriptionItem(field systemReq.AutoCodeField) string {
 		result += `    <template #default="scope">
 `
 		if field.DataSource.Association == 2 {
-			result += fmt.Sprintf(`        <el-tag v-for="(item,key) in filterDataSource(dataSource.%s,detailFrom.%s)" :key="key">
+			result += fmt.Sprintf(`        <el-tag v-for="(item,key) in filterDataSource(dataSource.%s,detailForm.%s)" :key="key">
 `,
 				field.FieldJson, field.FieldJson)
 			result += `             {{ item }}
@@ -583,7 +593,7 @@ func GenerateDescriptionItem(field systemReq.AutoCodeField) string {
 			result += `        </el-tag>
 `
 		} else {
-			result += fmt.Sprintf(`        <span>{{ filterDataSource(dataSource.%s,detailFrom.%s) }}</span>
+			result += fmt.Sprintf(`        <span>{{ filterDataSource(dataSource.%s,detailForm.%s) }}</span>
 `,
 				field.FieldJson, field.FieldJson)
 		}
@@ -592,26 +602,26 @@ func GenerateDescriptionItem(field systemReq.AutoCodeField) string {
 	} else if field.FieldType != "picture" && field.FieldType != "pictures" &&
 		field.FieldType != "file" && field.FieldType != "array" &&
 		field.FieldType != "richtext" {
-		result += fmt.Sprintf(`    {{ detailFrom.%s }}
+		result += fmt.Sprintf(`    {{ detailForm.%s }}
 `, field.FieldJson)
 	} else {
 		switch field.FieldType {
 		case "picture":
-			result += fmt.Sprintf(`    <el-image style="width: 50px; height: 50px" :preview-src-list="returnArrImg(detailFrom.%s)" :src="getUrl(detailFrom.%s)" fit="cover" />
+			result += fmt.Sprintf(`    <el-image style="width: 50px; height: 50px" :preview-src-list="returnArrImg(detailForm.%s)" :src="getUrl(detailForm.%s)" fit="cover" />
 `,
 				field.FieldJson, field.FieldJson)
 		case "array":
-			result += fmt.Sprintf(`    <ArrayCtrl v-model="detailFrom.%s"/>
+			result += fmt.Sprintf(`    <ArrayCtrl v-model="detailForm.%s"/>
 `, field.FieldJson)
 		case "pictures":
-			result += fmt.Sprintf(`    <el-image style="width: 50px; height: 50px; margin-right: 10px" :preview-src-list="returnArrImg(detailFrom.%s)" :initial-index="index" v-for="(item,index) in detailFrom.%s" :key="index" :src="getUrl(item)" fit="cover" />
+			result += fmt.Sprintf(`    <el-image style="width: 50px; height: 50px; margin-right: 10px" :preview-src-list="returnArrImg(detailForm.%s)" :initial-index="index" v-for="(item,index) in detailForm.%s" :key="index" :src="getUrl(item)" fit="cover" />
 `,
 				field.FieldJson, field.FieldJson)
 		case "richtext":
-			result += fmt.Sprintf(`    <RichView v-model="detailFrom.%s" />
+			result += fmt.Sprintf(`    <RichView v-model="detailForm.%s" />
 `, field.FieldJson)
 		case "file":
-			result += fmt.Sprintf(`    <div class="fileBtn" v-for="(item,index) in detailFrom.%s" :key="index">
+			result += fmt.Sprintf(`    <div class="fileBtn" v-for="(item,index) in detailForm.%s" :key="index">
 `, field.FieldJson)
 			result += `        <el-button type="primary" text bg @click="onDownloadFile(item.url)">
 `
@@ -690,7 +700,7 @@ func GenerateSearchField(field systemReq.AutoCodeField) string {
 		// 生成普通搜索字段
 		if field.FieldType == "enum" || field.FieldType == "picture" ||
 			field.FieldType == "pictures" || field.FieldType == "video" ||
-			field.FieldType == "json" || field.FieldType == "richtext" || field.FieldType == "array" {
+			field.FieldType == "json" || field.FieldType == "richtext" || field.FieldType == "array" || field.FieldType == "file" {
 			result = fmt.Sprintf("%s  string `json:\"%s\" form:\"%s\"` ",
 				field.FieldName, field.FieldJson, field.FieldJson)
 		} else {

server/utils/upload/minio_oss.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"errors"
 	"io"
+	"mime"
 	"mime/multipart"
 	"path/filepath"
 	"strings"
@@ -76,12 +77,18 @@ func (m *Minio) UploadFile(file *multipart.FileHeader) (filePathres, key string,
 		filePathres = global.GVA_CONFIG.Minio.BasePath + "/" + time.Now().Format("2006-01-02") + "/" + filename
 	}
 
+	// 根据文件扩展名检测 MIME 类型
+	contentType := mime.TypeByExtension(ext)
+	if contentType == "" {
+		contentType = "application/octet-stream"
+	}
+
 	// 设置超时10分钟
 	ctx, cancel := context.WithTimeout(context.Background(), time.Minute*10)
 	defer cancel()
 
 	// Upload the file with PutObject   大文件自动切换为分片上传
-	info, err := m.Client.PutObject(ctx, global.GVA_CONFIG.Minio.BucketName, filePathres, &filecontent, file.Size, minio.PutObjectOptions{ContentType: "application/octet-stream"})
+	info, err := m.Client.PutObject(ctx, global.GVA_CONFIG.Minio.BucketName, filePathres, &filecontent, file.Size, minio.PutObjectOptions{ContentType: contentType})
 	if err != nil {
 		global.GVA_LOG.Error("上传文件到minio失败", zap.Any("err", err.Error()))
 		return "", "", errors.New("上传文件到minio失败, err:" + err.Error())