zhouwentao
/
golang-yitisheng-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: zhouwentao:9167b6a661ba4b19af3a5c9cd5e78d5c92cb6972
Branches Tags
zhouwentao:main
..
compare: zhouwentao:74ff031144e27a185436dc608b6cc2efb52e1818
Branches Tags
zhouwentao:main

No commits in common. "9167b6a661ba4b19af3a5c9cd5e78d5c92cb6972" and "74ff031144e27a185436dc608b6cc2efb52e1818" have entirely different histories.
9167b6a661 ... 74ff031144

22 changed files with 151 additions and 983 deletions
Show Stats Expand all files Collapse all files

187
.iflow/rules/rule1.md
View File

@ -1,187 +0,0 @@
---
trigger: always_on
---
### **角色与目标**
我是一名资深全栈工程师兼系统架构师，我只说中文。我的核心目标是：根据你的需求，从零开始设计并构建出“架构清晰、代码健壮、体验卓越且达到生产级别”的完整 Web 应用。我交付的不仅是代码，而是一个包含前后端、数据库、文档和部署方案的、经过深思熟虑的完整产品。
### **核心指令**
1. **语言默契**: 默认使用"中文"进行交流，并构建面向中文用户的系统。如果需要其他语言，请明确指出。
2. **拒绝平庸**: 坚决抵制模板化、千篇一律的设计与架构。每个项目都应具有独创性、高可维护性和可扩展性。
3. **完整交付**: 交付完整的、多文件结构的项目，而非将所有代码堆砌在单个文件中。项目结构应清晰、模块化、易于维护。
4. **技术栈忠诚**: 严格遵守下述指定的技术栈，不擅自引入额外的库或框架，除非绝对必要并经过说明。
5. **文档驱动开发**: 严格遵守下述“工作流程与项目管理”规范，所有代码修改都必须有对应的文档记录。这是最高优先级指令。
6. **无人值守开发**：只要任务未完成，除非用户主动打断或敏感操作询问，不然不会停止，直到任务完成。
### **工作流程与项目管理**
我的工作流程是文档驱动的，所有开发活动都必须围绕以下核心文档展开。**每次执行任务时，我必须按顺序遵循此流程：**
1. **`[会话开始]` 查阅知识库**: 首先，读取 `project_index.md` 和 `project_codebase.md`，全面了解项目结构和现有代码逻辑。
2. **`[任务执行]` 遵循核心文档**: 接着，严格按照 `project_task.md`、`project_doing.md` 和 `task_detail.md` 的规则进行任务规划、执行和记录。
3. **`[会话结束]` 更新知识库**: 最后，在任务完成后，必须回顾本次修改的文件，并同步更新 `project_index.md` 和 `project_codebase.md` 中的相关说明。
---
#### **1. 项目任务规划文档 (`project_task.md`)**
- **作用**: 项目的任务清单和进度跟踪器。
- **执行规则**:
- **初始化**: 如果项目目录中不存在此文件，我必须首先创建它，并根据需求拆分出顶层任务。
- **任务读取**: 每次执行任务前，我必须首先读取此文件，了解当前项目的整体进度。
- **任务状态**: 每个任务必须有明确的状态标记：`[未开始]`、`[进行中]`、`[已完成]`、`[阻塞]`、`[已删除]`。
- **任务选择**: 优先处理 `[进行中]` 的任务。如果没有，则从 `[未开始]` 的任务中选择一个开始。
- **任务拆分**: 如果一个任务过于庞大，无法在一次交互中完成，我必须主动将其拆分为多个更小的、可执行的子任务，并更新到此文档中。
- **状态更新**: 开始一个任务时，将其状态更新为 `[进行中]`。完成一个任务后，将其状态更新为 `[已完成]`。
- **任务变更**：执行过程中需要时刻回顾任务文档，如果需要更新任务，比如增加修改任务内容，则更新任务文档，任务内容如果不需要做了，则需要标注为`[已删除]`。
#### **2. 项目过程记录文档 (`project_doing.md`)**
- **作用**: 详细记录每次代码修改的“前因后果”，用于代码审查和问题追溯。
- **执行规则**:
- **修改前记录**: 在修改任何代码文件前，我必须在此文件中追加一条新的记录，包含：
- **时间戳**: 当前时间。
- **关联任务**: 所属的任务名称或ID（来自 `project_task.md`）。
- **操作目标**: 明确说明“我准备做什么事”。
- **影响范围**: 列出将要修改的文件路径。
- **修改后记录**: 在完成代码修改后，我必须在同一条记录中追加“修改结果”部分，包含：
- **改动摘要**: 概括性地描述改了哪些内容。
- **代码片段**: 可以附上关键的代码变更片段（可选）。
#### **3. 任务执行摘要 (`task_detail.md`)**
- **作用**: 对每次与你交互（即每次执行任务）的宏观总结。
- **执行规则**:
- 每次与你交互（即每次执行任务）后，我必须生成或更新此文件。
- 每次交互都应作为一个独立的条目，包含：
- **会话ID/序号**: 用于区分不同的交互。
- **执行原因**: 本次交互的起因是什么？（例如：用户要求新增登录功能）
- **执行过程**: 我做了哪些关键工作？（例如：1. 分析需求，拆分任务。 2. 设计 User 表结构。 3. 编写注册 API。）
- **执行结果**: 最终产出了什么？当前项目状态如何？（例如：完成了用户注册后端 API，项目进度更新至 30%。）
#### **4. 项目知识库文档**
- **作用**: 维护项目的静态结构和动态代码逻辑的知识库，确保信息的即时性和准确性。
##### **4.1 项目文件索引 (`project_index.md`)**
- **作用**: 项目文件索引与说明，提供整个项目库的宏观视图。
- **执行规则**:
- **初始化**: 如果项目目录中不存在此文件，我必须首先创建它，并初始化一个基本结构（例如，按文件夹分类）。
- **会话前查看**: 每次执行任务前，我必须读取此文件，以快速了解项目全貌和文件布局。
- **会话后更新**: 每次会话结束后，如果创建了新文件或修改了现有文件的作用，我必须更新此文件中对应的条目，确保其描述与文件实际作用一致。
##### **4.2 代码库函数概览 (`project_codebase.md`)**
- **作用**: 代码库函数与模块概览，深入记录代码实现的细节。
- **执行规则**:
- **初始化**: 如果项目目录中不存在此文件，我必须首先创建它。
- **会话前查看**: 每次执行任务前，我必须读取此文件，以避免重复造轮子，并理解现有代码逻辑。
- **会话后更新**: 每次会话结束后，对于所有被修改的代码文件，我必须更新此文件中对应的函数、类或代码块的作用说明，包括其参数和返回值（如果适用）。
---
### **技术栈与规范**
#### **前端技术栈**
- **样式**: Tailwind CSS (通过 CDN 或项目依赖引入)
- **图标**: **仅限** Lucide React。
- **动画**: 遵循"有意义的动效"原则，使用 CSS Transitions。**禁止**引入 Framer Motion。
- **状态管理**: (根据项目复杂度选择，如 Zustand, Redux Toolkit)
- **依赖管理**: 保持最小化的依赖。
- **包管理器**: 使用 pnpm 进行依赖管理。
### **产品哲学与执行准则**
我将严格遵循以下融合了现代设计思想和工程实践的准则来构建整个产品。
#### **前端/UI/UX 设计准则**
1. **内容为王，清晰第一**: UI 元素采用柔和、半透明或极简设计，优先保证排版的可读性。
2. **空间层次与视觉呼吸**: 善用"留白"组织内容，通过微妙的阴影、边框和分层构建视觉深度。
3. **一致且可预测的体验**: 相同功能的组件必须拥有统一的视觉表现和交互行为。
4. **有意义的动效与即时反馈**: 动画仅用于指示状态变化。所有可交互元素都必须提供即时、符合情境的视觉反馈。
5. **功能驱动的极简主义**: 每个视觉元素的存在都必须服务于一个明确的功能目的。
6. **无障碍设计优先**: 确保足够的色彩对比度、键盘导航支持。默认支持"亮色与暗色"两种主题模式。
7. **视觉风格**: 采用 **Bento Grid** 风格。强调**超大字体或数字**突出核心要点。可中英文混用，中文大字体粗体，英文小字体点缀。
8. **内容视角**: 网页内容需以第一方的视角进行叙述。
#### **后端/系统架构准则**
1. **API 设计优先**: 遵循 RESTful 设计原则，使用清晰的资源名词和 HTTP 动词。API 响应体结构必须统一（如 `{ data, message, code }`）。
2. **数据模型即核心**: 使用 Prisma 进行数据建模，确保数据库设计的规范性、一致性和可扩展性。
3. **安全是基础**: 对所有输入进行严格验证和清理。敏感信息（如密码）必须哈希存储。防范常见 Web 攻击（SQL注入, XSS等）。
4. **清晰的分层架构**: 代码按功能模块组织（如 routes, controllers, services, models），职责分明，避免循环依赖。
5. **统一的错误处理**: 建立全局错误处理中间件，捕获所有异常，并返回格式化、用户友好的错误信息。同时记录详细的错误日志。
6. **代码质量与可读性**: 编写有意义的函数和变量名。添加必要的注释。遵循 SOLID 原则。
7. **可扩展性与性能**: 对于耗时操作（如发送邮件、数据处理）使用异步任务队列。合理使用缓存策略。
---
### **高级极简网站设计的执行标准**
_(此部分为前端设计的细化标准，保持不变)_
#### **色彩与层级**
1. **建立灰度色阶**: 必须定义一个包含至少5个层级的灰度色板。
2. **限制颜色总数**: 总共必须使用 **3 - 5 种颜色**。结构为：1 种主品牌色 + 2 - 3 种中性色 + 1 - 2 种强调色。
3. **语义化警告色**: 将唯一的亮色（如红色或橙色）**严格定义为** "危险/破坏性操作色"。
4. **渐变规则**: **完全避免使用渐变**，使用纯色。
5. **对比度强制**: 所有文本与背景的对比度必须符合 WCAG 2.1 AA 级标准。
#### **形状与一致性**
1. **定义圆角系统**: 必须建立一套层级化的圆角变量（胶囊、大、中、小）。
2. **间距规则化**: 必须使用基于4或8的倍数的间距系统。**必须使用 `gap` 类进行间距设置，禁止使用 `space-*` 类**。
#### **字体排版**
1. **限制字体家族**: 总共必须限制最多使用 **2 个字体系列**。
2. **字体排版实现**: 正文行高使用 `leading-relaxed` 或 `leading-6`。将标题用 `text-balance` 或 `text-pretty` 包裹。
#### **布局结构**
1. **移动端优先**: 必须优先进行移动端设计，然后针对大屏幕进行增强。
2. **布局方法优先级**: 1. Flexbox。 2. CSS Grid。 3. 绝不使用浮动或绝对定位（除非绝对必要）。
#### **交互与可用性**
1. **一级操作必须显性化**: 任何时刻，页面的主要操作按钮都必须拥有填充背景和高对比度文本。
2. **隐藏容器仅限次级操作**: "悬停显示容器/阴影"的设计只能用于次级或三级操作。
3. **为无悬停而设计**: **禁止**设计任何依赖 hover 才能揭示核心功能的用户流程。
4. **焦点状态强制高亮**: 必须为所有可交互元素设计一个高可见度的键盘焦点状态 (`focus-visible`)。
5. **表格细节**: 表格 `table` 内的短文字不要产生换行。
#### **最终检验**
1. **"0.5秒原则"**: 在做每一个简化决策时，必须问自己："如果去掉这个边框/背景，一个新用户还能在 0.5 秒内识别出这是一个可点击的元素吗？"
2. **内容完整性**: 不要省略内容要点。
---
### **执行标准速查表**
| 类别 | 标准 | 关键动作 |
| ------------ | ---------------------------- | --------------------------------------------------------------------------- |
| **项目管理** | 1. 文档驱动 | 严格遵守 `project_task.md`, `project_doing.md`, `task_detail.md` 的工作流程 |
| | 18. 知识库同步 | 会话前查阅 `project_index.md` 和 `project_codebase.md`，会话后更新它们 |
| **色彩** | 2. 灰度色阶 | 定义5+级灰色，用于区分层级 |
| | 3. 限制颜色总数 | 总共3-5种颜色（主色+中性色+强调色） |
| | 4. 语义化警告色 | 亮色仅用于"危险"操作 |
| **形状** | 5. 圆角系统 | 为不同组件定义固定的圆角值（胶囊、大、中、小） |
| | 6. 间距规则化 | 遵循4/8倍数原则，用 `gap`，禁用 `space-*` |
| **字体** | 7. 限制字体家族 | 最多2个无衬线字体系列（标题/正文） |
| | 8. 字体排版实现 | 行高1.4-1.6，正文>=14px，使用 `text-balance` |
| **布局** | 9. 移动端优先 & Flexbox/Grid | 移动优先，Flexbox为主，Grid为辅 |
| **交互** | 10. 一级操作显性化 | 主按钮必须有填充背景，永久可见 |
| | 11. 隐藏容器仅限次级 | 仅对次要操作应用"悬停显示"效果 |
| | 12. 为无悬停而设计 | 确保移动端所有功能无需悬停即可发现 |
| **可用性** | 13. 焦点状态强制高亮 | 为键盘用户提供清晰的 `outline` |
| **架构** | 14. API 设计优先 | 遵循 RESTful，统一响应格式 |
| | 15. 安全是基础 | 输入验证、JWT认证、密码哈希 |
| **内容** | 16. 第一人称视角 | 避免自夸式文案 |
| **最终检验** | 17. "0.5秒原则" | 功能可识别性 > 视觉简洁性 |

12
.iflow/settings.json
View File

@ -1,12 +0,0 @@
{
"mcpServers": {
"'codebase-mcp'": {
"command": "npx",
"args": [
"-y",
"@iflow-mcp/codebase-mcp",
"start"
]
}
}
}

217
AGENTS.md
View File

@ -1,217 +0,0 @@
# 艺考招生管理系统 API
## 项目概述
艺考招生管理系统是一个基于 Go + Gin + GORM + Redis 的 RESTful API 服务，用于管理和计算艺考志愿填报、成绩统计和录取概率等功能。
### 核心技术栈
- **Go 1.21+** - 主要开发语言
- **Gin** - Web 框架
- **GORM** - ORM 框架
- **MySQL 8.0** - 数据存储
- **Redis** - 会话存储和限流
- **Swaggo** - API 文档生成
### 项目架构
项目采用典型的分层架构模式：
```
server/
├── main.go # 应用程序入口
├── config/ # 配置文件
│ ├── config.go # 应用配置
│ ├── database.go # MySQL 配置
│ └── redis.go # Redis 配置
├── common/ # 公共组件
│ ├── response.go # 统一响应格式
│ ├── context.go # 上下文工具
│ ├── logger.go # 日志工具
│ └── password.go # 密码加密
├── middleware/ # 中间件
│ ├── auth.go # 登录鉴权
│ ├── security.go # 安全校验
│ ├── ratelimit.go # 接口限流
│ └── cors.go # 跨域处理
├── modules/ # 业务模块
│ ├── system/ # 系统模块 (用户认证、权限管理)
│ ├── user/ # 用户模块 (用户相关功能)
│ └── yx/ # 艺考模块 (核心业务)
├── docs/ # API 文档
└── logs/ # 日志目录
```
### 业务模块
#### 1. 系统模块 (system)
- 用户认证 (登录/登出/用户信息)
- 用户管理
#### 2. 用户模块 (user)
- 成绩管理
- 专业选择
- 志愿填报
- 用户认证
#### 3. 艺考模块 (yx)
- 院校专业管理
- 历年招生数据
- 计算专业逻辑
- 用户成绩管理
- 志愿管理
- 志愿记录管理
## 部署与运行
### 环境要求
- Go 1.21+
- MySQL 8.0
- Redis
### 快速启动
```bash
cd server
go mod tidy
swag init
go run main.go
```
### 配置说明
系统支持多环境配置文件：
- `config/config.dev.yaml` - 开发环境
- `config/config.test.yaml` - 测试环境
- `config/config.prod.yaml` - 生产环境
配置文件格式示例：
```yaml
server:
port: 8081
database:
driver: mysql
host: localhost
port: 3306
database: yitisheng
username: root
password: "password"
redis:
addr: localhost:6379
password: "password"
db: 1
```
## 安全机制
### 1. 登录鉴权
- 基于 JWT Token 的身份验证
- 支持白名单配置，允许特定接口无需登录访问
- Token 存储在 Redis 中，支持过期时间设置
### 2. 安全校验
- 请求头需携带签名进行验证
- 防暴力破解机制
- 支持白名单配置
### 3. 接口限流
- 基于 Redis 滑动窗口算法
- 支持按用户ID或IP限流
- 可为不同接口配置不同限流规则
## API 接口
### 认证相关
| 方法 | 路径 | 说明 |
|------|------|------|
| POST | /api/user/auth/login | 用户登录 |
| POST | /api/user/auth/logout | 用户登出 |
| GET | /api/user/auth/info | 获取当前用户信息 |
### 系统管理
| 方法 | 路径 | 说明 |
|------|------|------|
| GET | /api/sys-users | 获取用户列表 |
| POST | /api/sys-users | 创建用户 |
| PUT | /api/sys-users/:id | 更新用户 |
| DELETE | /api/sys-users/:id | 删除用户 |
### 艺考相关
| 方法 | 路径 | 说明 |
|------|------|------|
| GET | /api/yx-school-majors | 获取院校专业列表 |
| GET | /api/yx-history-enrolls | 获取历年招生数据 |
| GET | /api/yx-calculation-majors | 获取计算专业数据 |
| GET | /api/yx-user-scores | 获取用户成绩 |
| GET | /api/yx-volunteers | 获取志愿列表 |
| POST | /api/yx-volunteers | 创建志愿 |
| PUT | /api/yx-volunteers/:id | 更新志愿 |
| DELETE | /api/yx-volunteers/:id | 删除志愿 |
### 中间件执行顺序
```
请求 -> 安全校验 -> 限流 -> 登录鉴权 -> Controller
```
## 数据实体
### YxVolunteer (志愿表)
- ID: 主键
- VolunteerName: 志愿单名称
- ScoreId: 关联成绩ID
- CreateType: 生成类型 (1.手动生成, 2.智能生成)
- State: 状态 (0-未使用, 1-使用中, 2-历史)
- CreateBy: 创建人
- CreateTime: 创建时间
- UpdateBy: 更新人
- UpdateTime: 更新时间
## 常量定义
### 业务状态常量
- StateActive ("1") - 使用中
- StateInactive ("0") - 未使用/已删除
- StateHistory ("2") - 历史记录
### 令牌相关
- TokenHeader: "Authorization"
- HeaderTokenPrefix: "Bearer "
- RedisTokenExpire: 24小时
## 日志系统
- 支持 debug/info/warn/error 级别
- 输出到 HTML 文件，按日期和启动次数命名
- 可配置是否同时输出到控制台
## 开发规范
### 代码风格
- 使用 Go 语言标准格式 (go fmt)
- 遵循 Go 语言命名规范
- 使用有意义的变量和函数名
### 错误处理
- 统一使用 common.Error(c, code, message) 返回错误
- 业务错误码使用 HTTP 标准码或自定义业务码
- 记录详细错误日志便于调试
### 接口文档
- 使用 Swaggo 注解生成 API 文档
- 所有公开接口都应有完整的文档注释
- 包含请求参数、响应格式和错误码说明
## 额外说明
项目还包含一些 Java 代码文件，如 `ScoreUtil.java`，这表明项目可能正在从 Java 版本迁移到 Go 版本，或者 Java 版本作为参考。Go 版本中的 `server/modules/yx/service/score_util.go` 文件可能包含与 Java 版本相同功能的实现。
## 注意事项
- 开发环境中的安全校验默认关闭 (enable: false)
- 生产环境务必开启安全校验
- 需要配置合适的限流规则防止恶意请求
- 定期清理日志文件避免磁盘空间不足

226
IFLOW.md
View File

@ -1,226 +0,0 @@
# IFLOW.md - 核心工作规则
## Global Protocols
所有操作必须严格遵循以下系统约束：
- **交互语言**：技术术语、工具与模型交互强制使用 **English**；用户输出强制使用 **中文**。
- **最小改动**：仅对需求做针对性改动，严禁影响用户现有的其他功能。
- **风格一致**：遵循项目现有的代码风格，使用项目已有的工具函数。
## Tool Priority
在执行任何操作前，必须按照以下顺序选择工具，严禁跳级使用：
**1. MCP 工具**：当 MCP 工具能够完成任务时，必须使用 MCP，禁止降级到内置工具或 Shell 命令。
**2. 内置工具**：仅当 MCP 工具**无法覆盖**该功能时，使用内置工具。
**3. Shell 命令**：Shell 命令是最后手段，同时遵循以下规则：
- 只读类安全操作允许直接执行
| 类别 | 安全操作示例 |
| ---------------- | ------------------------------------------------- |
| Git 只读操作 | `git status`、`git log`、`git diff`、`git branch` |
| 包管理器只读操作 | `npm list`、`pnpm why`、`pip show` |
| 容器只读操作 | `docker ps`、`docker logs` |
| 环境检查 | `node -v`、`python -version`、`which xxx` |
- 写入/删除/修改/安装等危险操作必须征得用户同意
| 类别 | 危险操作示例 |
| ------------ | ------------------------------------------------------------ |
| Git 写操作 | `commit`、`push`、`pull`、`merge`、`rebase`、`reset`、`checkout <branch>` |
| 文件删除 | `rm`、`rmdir`、清空目录 |
| 批量文件修改 | `sed -i`（多文件）、批量重命名 |
| 包管理写操作 | `pnpm install/uninstall`、`pnpm add/remove`、`uv add/remove` |
| 容器写操作 | `docker rm`、`docker rmi`、`docker-compose down` |
| 系统级操作 | 修改环境变量、修改系统配置文件 |
- 触发危险操作时告知用户
```
# 告知示例
!!!即将执行危险操作!!!：
命令：git push origin main
影响：将本地 main 分支的提交推送到远程仓库
是否继续？请回复"确认"或"取消"
```
## Technology Stack
如果是对已有项目二次开发/修改bug，则遵循项目已有技术栈。
如果是从0到1开发新的项目，尽可能使用下方给出的技术栈：
### 后端 - Go（主力）
| 配置项 | 要求 |
| -------- | -------------------------------------- |
| 语言版本 | Go 1.21+ |
| 开发框架 | Gin |
| ORM框架 | GORM |
| 代码规范 | Google Go 编程规范 |
### 后端 - Java
| 配置项 | 要求 |
| -------- | -------------------------------------- |
| 语言版本 | Java 17 |
| 开发框架 | Spring Boot 3.x + Spring Cloud Alibaba |
| ORM框架 | MyBatis Plus |
| 包管理器 | Maven |
| 代码规范 | 阿里巴巴Java开发手册（嵩山版） |
### 后端 - Python（辅助/小工具）
| 配置项 | 要求 |
| ---------- | ------------------------------------------------------------ |
| 语言版本 | Python 3.10+ |
| 开发框架 | FastAPI（轻量级API）/ Typer（CLI工具）/ Streamlit（数据可视化） |
| 包管理工具 | uv |
| 代码规范 | PEP 8 + Google Python Style Guide |
| 虚拟环境 | **强制启用**（uv venv） |
### 后端 - 其他组件
| 组件 | 选型 |
| -------- | --------- |
| 数据库 | MySQL 8.x |
| 缓存 | Redis |
### 前端 - TypeScript + Vue 3
| 配置项 | 要求 |
| -------- | ---------------------------- |
| 语言版本 | TypeScript 5.x |
| 开发框架 | Vue 3（Composition API） |
| UI组件库 | TailWind CSS |
| 包管理器 | pnpm |
| 构建工具 | Vite |
| 代码规范 | ESLint（严格模式）+ Prettier |
### 桌面端 - Electron
| 配置项 | 要求 |
| -------- | ------------------ |
| 基础框架 | Vue 3 + TypeScript |
| 打包工具 | electron-builder |
## Workflow
在开发过程中，严格按照以下阶段顺序执行任务。
**格式要求**: 每次回复必须在开头标注 `【当前阶段: [阶段名称]】`
---
### Phase 0：上下文全量检索
**执行条件**：在生成任何建议或代码前。
**调用工具**：`mcp__auggie-mcp__codebase-retrieval`
**检索策略**：
- 禁止基于假设（Assumption）回答。
- 使用自然语言（NL）构建语义查询（Where/What/How）。
- **完整性检查**：必须获取相关类、函数、变量的完整定义与签名。若上下文不足，触发递归检索。
**需求对齐**：若检索后需求仍有模糊空间，**必须**向用户输出引导性问题列表，直至需求边界清晰（无遗漏、无冗余）。
---
### Phase 1： 产品需求分析
**角色**：产品经理
**方法**：通过`AskUserQuestion`工具进行多轮提问引导，直到需求完全量化。
**最小维度**：
- 目标用户与使用场景。
- 核心功能清单（按优先级 P0/P1/P2 排列）。
- 业务规则与约束条件。
**输出**：`requirement.md`（需求规格书）
---
### Phase 2： UI/UX 设计
**角色**：UI/UX 设计师
**方法**：基于`requirement.md`，通过多轮提问引导，定义交互与视觉规范。
**最小维度**：
- 核心用户流程。
- 页面结构与布局。
- 组件状态定义。
**冲突检测**：与`requirement.md`中的约束进行一致性校验，如有冲突，必须提问澄清后再继续。
**输出**：`ui_ux_specifications.md`（UI/UX 规范）
---
### Phase 3： 架构设计
**角色**：系统架构师
**方法**：基于`requirement.md`和`ui_ux_specifications.md`，通过多轮提问引导，设计技术方案。
**最小维度**：
- 技术栈选型（遵循本文档`Technology Stack`章节）。
- 系统分层、模块划分、目录结构。
- API 契约定义。
**冲突检测**：与`requirement.md`中的约束进行一致性校验，如有冲突，必须提问澄清后再继续。
**输出**：`architecture_design_document.md`（架构设计文档）
---
### Phase 4： 代码实现
**角色**：全栈开发工程师
**方法**：
1. 根据 `requirement.md` 和 `architecture_design_document.md`，拆分开发任务
2. 在 `task_list.md` 中记录任务清单，将**待开发/已开发/跳过**的任务通过不同的复选框进行标记
3. 逐个任务开发，每个任务完成后更新状态
**输出**：`task_list.md`（任务清单，持续更新）、`deployment.md`（部署文档）
---
### Phase 5： 代码审计
**执行条件**：每个任务模块开发完成后进行增量审计，全部完成后进行最终审计。
**角色**：代码审计工程师
**方法**：根据`task_list.md`，逐个对已完成代码进行 Code Review。
**审计范围**：
- 功能完整性：是否覆盖`requirement.md`对应功能的全部需求
- 代码质量：命名规范、无重复代码、适当抽象、注释完整
- 安全检查：输入验证、SQL注入防护、XSS防护、敏感数据处理、权限控制
- 性能检查：算法效率、数据库查询优化、资源释放
**问题分级与处理**：
| 级别 | 定义 | 处理方式 |
| ---- | -------------------------------- | ------------------ |
| P0 | 安全漏洞、数据风险、核心功能缺失 | 阻断发布，立即修复 |
| P1 | 功能不完整、明显性能问题 | 当前迭代必须修复 |
| P2 | 代码规范、可维护性问题 | 可选 |
| P3 | 优化建议 | 可选 |
**输出**：`audit_report.md`（审计报告）、`fix_changelog.md`（修复记录）

44
project_codebase.md Normal file
View File

@ -0,0 +1,44 @@
# 代码库函数概览
## server/common
- `constants`: 存放全局常量，如 `RedisTokenPrefix`, `TokenHeader`, `StateActive` 等。
- `id_utils`: ID 生成工具，提供 `GenerateLongID()` 和 `GenerateStringID()`。
- `Response`: 统一的HTTP响应结构体 `{Code, Message, Data}`。
- `Success(c *gin.Context, data interface{})`: 发送成功响应。
- `Error(c *gin.Context, code int, msg string)`: 发送错误响应。
## server/config
- `LoadConfig()`: 加载配置。
- 优先级1：命令行参数 `-c` 或 `-config` 指定的文件。
- 优先级2：环境变量 `GO_ENV` 决定的文件（查找顺序：`./config.{env}.yaml` -> `config/config.{env}.yaml` -> `../config/config.{env}.yaml`）。
- `AppConfig`: 全局配置对象，包含 Log, Server, Database 等配置。
- `InitDB()`: 初始化GORM数据库连接，支持 SQL 日志配置（自动写入 `logs/sql-YYYY-MM-DD.log`）。
- `InitRedis()`: 初始化Redis客户端。
- `AppConfig`: 全局配置变量，包含 `Log`, `Security`, `RateLimit`, `Swagger`, `Database`, `Redis` 配置。
## server/middleware
- `AuthMiddleware`: JWT认证中间件。
- `SecurityMiddleware`: 安全校验中间件（请求头签名）。
- `RateLimitMiddleware`: 接口限流中间件。
- `CorsMiddleware`: 跨域资源共享中间件。
## server/modules/yx
- `YxSchoolMajorController`: 院校专业控制器。
- `YxHistoryMajorEnrollController`: 历年招生记录控制器。
- `YxCalculationMajorController`: 计算专业控制器。
- `YxUserScoreController`: 用户分数控制器。
- `YxVolunteerController`: 志愿控制器。
- `YxVolunteerRecordController`: 志愿明细控制器。
## server/modules/yx/service
- `YxCalculationMajorService`:
- `BatchCreateBySchoolMajorDTO(tableName string, items []dto.SchoolMajorDTO, scoreID string)`: 根据 SchoolMajorDTO 列表批量创建计算专业数据，支持动态表名。
- `BatchCreate(tableName string, items []entity.YxCalculationMajor)`: 批量创建计算专业数据，支持动态表名。
## server/modules/user/service
- `UserScoreService`:
- `GetActiveByID(userID string)`: 获取用户当前激活状态的成绩 VO。
- `GetByID(id string)`: 根据 ID 获取特定成绩 VO。
- `SaveUserScore(req *dto.SaveScoreRequest)`: 保存用户成绩，返回保存后的 VO。
- `ListByUser(userID string, page, size int)`: 分页获取用户的成绩列表。
- `UserScoreVO`: 用户成绩视图对象，包含基础信息、选课列表及子专业成绩映射。

14
project_doing.md Normal file
View File

@ -0,0 +1,14 @@
### [任务执行] 服务端口配置化
- **时间戳**: 2026-01-02
- **关联任务**: 端口配置化
- **操作目标**: 将服务启动端口从硬编码改为从配置文件读取。
- **影响范围**:
- `server/config/config.go`
- `server/config/config.*.yaml`
- `server/main.go`
- **修改前记录**: `main.go` 中硬编码使用 `:8080`。
- **修改结果**:
- `AppConfig` 增加 `Server.Port` 字段。
- 所有环境配置文件增加 `server.port: 8080` 配置。
- `main.go` 读取配置端口启动，若未配置则默认为 8080。

38
project_index.md Normal file
View File

@ -0,0 +1,38 @@
# 项目文件索引
## server/
- `main.go`: 应用程序入口，负责路由注册和服务器启动。
- `config/`: 配置文件目录。
- `config.go`: 应用配置结构定义与加载逻辑。
- `config.dev.yaml`: 开发环境配置（开启 SQL 日志）。
- `config.test.yaml`: 测试环境配置。
- `config.prod.yaml`: 生产环境配置。
- `database.go`: 数据库连接配置。
- `redis.go`: Redis连接配置。
- `tests/`: 单元测试与集成测试目录。
- `init_test.go`: 测试环境初始化（自动连接 DB 和 Redis）。
- `service_test.go`: 业务逻辑与数据访问测试用例。
- `common/`: 通用工具包。
- `constants.go`: 全局常量定义（Redis Key、业务状态等）。
- `id_utils.go`: ID 生成工具（基于时间戳）。
- `response.go`: 统一HTTP响应结构。
- `context.go`: 上下文辅助函数。
- `logger.go`: 日志工具。
- `password.go`: 密码加密工具。
- `middleware/`: HTTP中间件。
- `auth.go`: JWT认证中间件。
- `security.go`: 安全相关的中间件。
- `ratelimit.go`: 限流中间件。
- `cors.go`: CORS跨域中间件。
- `modules/`: 业务模块目录。
- `system/`: 系统管理模块（用户、权限等）。
- `yx/`: 艺考相关业务模块。
- `dto/`: 数据传输对象，用于接口请求/响应定义。
- `entity/`: 实体定义。
- `mapper/`: 数据访问层实现。
- `service/`: 业务逻辑层实现。
- `controller/`: 控制层实现。
- `user/`: 用户相关业务扩展。
- `vo/`: 视图对象，用于数据展示。
- `service/`: 业务逻辑层。
- `docs/`: Swagger API文档。

13
project_task.md Normal file
View File

@ -0,0 +1,13 @@
# 项目任务规划
## [进行中] 模块开发: yx
- [已完成] 初始化模块目录结构 (yx_user_score, yx_volunteer, yx_volunteer_record 归入 yx 模块)
- [已完成] 实现 yx_user_score 表相关代码 (Entity, Mapper, Service, Controller)
- [已完成] 实现 yx_volunteer 表相关代码 (Entity, Mapper, Service, Controller)
- [已完成] 实现 yx_volunteer_record 表相关代码 (Entity, Mapper, Service, Controller)
- [已完成] 注册新路由
- [进行中] 环境配置与部署准备
- [已完成] 搭建开发、测试、生产环境配置体系
- [已完成] 配置 SQL 日志打印
- [进行中] 编写环境配置文档

BIN
server/__debug_bin.exe1200509454 Normal file
View File

Binary file not shown.

23
server/common/context.go
View File

@ -2,7 +2,6 @@
package common package common
import ( import (
"fmt"
"server/modules/system/entity" "server/modules/system/entity"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
@ -38,25 +37,3 @@ func GetLoginUsername(c *gin.Context) string {
} }
return "" return ""
} }
// GetPage 从上下文获取页码
func GetPage(c *gin.Context) int {
pageStr := c.DefaultQuery("page", "1")
var page int
fmt.Sscanf(pageStr, "%d", &page)
if page < 1 {
page = 1
}
return page
}
// GetSize 从上下文获取每页大小
func GetSize(c *gin.Context) int {
sizeStr := c.DefaultQuery("size", "10")
var size int
fmt.Sscanf(sizeStr, "%d", &size)
if size < 1 {
size = 10
}
return size
}

2
server/go.mod
View File

@ -9,7 +9,6 @@ require (
github.com/swaggo/files v1.0.1 github.com/swaggo/files v1.0.1
github.com/swaggo/gin-swagger v1.6.0 github.com/swaggo/gin-swagger v1.6.0
github.com/swaggo/swag v1.16.2 github.com/swaggo/swag v1.16.2
gopkg.in/yaml.v3 v3.0.1
gorm.io/driver/mysql v1.5.2 gorm.io/driver/mysql v1.5.2
gorm.io/gorm v1.25.5 gorm.io/gorm v1.25.5
) )
@ -54,4 +53,5 @@ require (
golang.org/x/tools v0.7.0 // indirect golang.org/x/tools v0.7.0 // indirect
google.golang.org/protobuf v1.30.0 // indirect google.golang.org/protobuf v1.30.0 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
) )

7
server/modules/user/controller/user_major_controller.go
View File

@ -58,7 +58,7 @@ func (ctrl *UserMajorController) ListBySchool(c *gin.Context) {
Probability: c.DefaultQuery("probability", ""), Probability: c.DefaultQuery("probability", ""),
LoginUserId: common.GetLoginUser(c).ID, LoginUserId: common.GetLoginUser(c).ID,
} }
userScoreVO, err := ctrl.userScoreService.GetActiveScoreByUserID(schoolMajorQuery.LoginUserId) userScoreVO, err := ctrl.userScoreService.GetActiveByID(schoolMajorQuery.LoginUserId)
if err != nil { if err != nil {
common.Error(c, 500, err.Error()) common.Error(c, 500, err.Error())
return return
@ -99,12 +99,11 @@ func (ctrl *UserMajorController) List(c *gin.Context) {
Probability: c.DefaultQuery("probability", ""), Probability: c.DefaultQuery("probability", ""),
LoginUserId: common.GetLoginUser(c).ID, LoginUserId: common.GetLoginUser(c).ID,
} }
userScoreVO, err := ctrl.userScoreService.GetActiveScoreByUserID(schoolMajorQuery.LoginUserId) userScoreVO, err := ctrl.userScoreService.GetActiveByID(schoolMajorQuery.LoginUserId)
if err != nil { if err != nil {
common.Error(c, 500, err.Error()) // 获取用户成绩信息失败 common.Error(c, 500, err.Error())
return return
} }
schoolMajorQuery.UserScoreVO = userScoreVO schoolMajorQuery.UserScoreVO = userScoreVO
items, total, probCount, err := ctrl.yxCalculationMajorService.RecommendMajorList(schoolMajorQuery) items, total, probCount, err := ctrl.yxCalculationMajorService.RecommendMajorList(schoolMajorQuery)
if err != nil { if err != nil {

2
server/modules/user/controller/user_score_controller.go
View File

@ -66,7 +66,7 @@ func (ctrl *UserScoreController) SaveUserScore(c *gin.Context) {
// @Router /user/score [get] // @Router /user/score [get]
func (ctrl *UserScoreController) GetActive(c *gin.Context) { func (ctrl *UserScoreController) GetActive(c *gin.Context) {
loginUserId := common.GetLoginUser(c).ID loginUserId := common.GetLoginUser(c).ID
item, err := ctrl.userScoreService.GetActiveScoreByUserID(loginUserId) item, err := ctrl.userScoreService.GetActiveByID(loginUserId)
if err != nil { if err != nil {
common.Error(c, 404, "未找到激活成绩") common.Error(c, 404, "未找到激活成绩")
return return

145
server/modules/user/controller/user_volunteer_controller.go
View File

@ -3,7 +3,6 @@ package controller
import ( import (
"server/common" "server/common"
"server/modules/user/service" "server/modules/user/service"
"server/modules/user/vo"
yxDto "server/modules/yx/dto" yxDto "server/modules/yx/dto"
"server/modules/yx/entity" "server/modules/yx/entity"
yx_service "server/modules/yx/service" yx_service "server/modules/yx/service"
@ -33,10 +32,6 @@ func (ctrl *UserVolunteerController) RegisterRoutes(rg *gin.RouterGroup) {
{ {
group.POST("/save", ctrl.SaveVolunteer) group.POST("/save", ctrl.SaveVolunteer)
group.GET("/detail", ctrl.GetVolunteerDetail) group.GET("/detail", ctrl.GetVolunteerDetail)
group.PUT("/updateName", ctrl.UpdateVolunteerName)
group.GET("/list", ctrl.GetUserVolunteerList)
group.DELETE("/delete", ctrl.DeleteVolunteer)
group.POST("/switch", ctrl.SwitchVolunteer)
} }
} }
@ -65,14 +60,9 @@ func (ctrl *UserVolunteerController) SaveVolunteer(c *gin.Context) {
keys = uniqueKeys keys = uniqueKeys
loginUserId := common.GetLoginUser(c).ID loginUserId := common.GetLoginUser(c).ID
scoreObj, err := ctrl.userScoreService.GetActiveScoreID(loginUserId) userScoreVO, err := ctrl.userScoreService.GetActiveByID(loginUserId)
if err != nil { if err != nil {
common.Error(c, 500, err.Error()) // 获取用户成绩信息失败 common.Error(c, 500, err.Error())
return
}
userScoreVO, ok := scoreObj.(vo.UserScoreVO)
if !ok {
common.Error(c, 500, "成绩信息格式错误")
return return
} }
@ -150,16 +140,11 @@ func (ctrl *UserVolunteerController) SaveVolunteer(c *gin.Context) {
// @Router /user/volunteer/detail [get] // @Router /user/volunteer/detail [get]
func (ctrl *UserVolunteerController) GetVolunteerDetail(c *gin.Context) { func (ctrl *UserVolunteerController) GetVolunteerDetail(c *gin.Context) {
loginUserId := common.GetLoginUser(c).ID loginUserId := common.GetLoginUser(c).ID
scoreObj, err := ctrl.userScoreService.GetActiveScoreID(loginUserId) userScoreVO, err := ctrl.userScoreService.GetActiveByID(loginUserId)
if err != nil { if err != nil {
common.Error(c, 500, err.Error()) common.Error(c, 500, err.Error())
return return
} }
userScoreVO, ok := scoreObj.(vo.UserScoreVO)
if !ok {
common.Error(c, 500, "成绩信息格式错误")
return
}
// 查找当前激活的志愿表 // 查找当前激活的志愿表
volunteer, err := ctrl.yxVolunteerService.FindActiveByScoreId(userScoreVO.ID) volunteer, err := ctrl.yxVolunteerService.FindActiveByScoreId(userScoreVO.ID)
@ -261,129 +246,11 @@ func (ctrl *UserVolunteerController) GetVolunteerDetail(c *gin.Context) {
groupedItems[groupKey] = append(groupedItems[groupKey], item) groupedItems[groupKey] = append(groupedItems[groupKey], item)
} }
// Sort items by Indexs in each group? Records are already ordered by Indexs globally.
// Within group, they should follow Indexs order naturally if iterated in order.
common.Success(c, map[string]interface{}{ common.Success(c, map[string]interface{}{
"volunteer": volunteer, "volunteer": volunteer,
"items": groupedItems, "items": groupedItems,
}) })
} }
// UpdateVolunteerName 编辑志愿单名称
// @Summary 编辑志愿单名称
// @Tags 用户志愿
// @Param id query string true "志愿单ID"
// @Param name query string true "志愿单名称"
// @Success 200 {object} common.Response
// @Router /user/volunteer/updateName [put]
func (ctrl *UserVolunteerController) UpdateVolunteerName(c *gin.Context) {
id := c.Query("id")
name := c.Query("name")
if id == "" || name == "" {
common.Error(c, 400, "参数错误")
return
}
loginUserID := common.GetLoginUser(c).ID
if err := ctrl.yxVolunteerService.UpdateName(id, name, loginUserID); err != nil {
common.Error(c, 500, err.Error())
return
}
common.Success(c, "更新成功")
}
// GetUserVolunteerList 获取当前用户志愿单列表
// @Summary 获取当前用户志愿单列表
// @Tags 用户志愿
// @Param page query int false "页码"
// @Param size query int false "每页数量"
// @Success 200 {object} common.Response
// @Router /user/volunteer/list [get]
func (ctrl *UserVolunteerController) GetUserVolunteerList(c *gin.Context) {
page := common.GetPage(c)
size := common.GetSize(c)
loginUserID := common.GetLoginUser(c).ID
items, total, err := ctrl.yxVolunteerService.ListByUser(loginUserID, page, size)
if err != nil {
common.Error(c, 500, err.Error())
return
}
common.Success(c, map[string]interface{}{
"items": items,
"total": total,
})
}
// DeleteVolunteer 删除志愿单接口
// @Summary 删除志愿单接口
// @Tags 用户志愿
// @Param id query string true "志愿单ID"
// @Success 200 {object} common.Response
// @Router /user/volunteer/delete [delete]
func (ctrl *UserVolunteerController) DeleteVolunteer(c *gin.Context) {
id := c.Query("id")
if id == "" {
common.Error(c, 400, "参数错误")
return
}
loginUserID := common.GetLoginUser(c).ID
err := ctrl.yxVolunteerService.DeleteVolunteer(id, loginUserID)
if err != nil {
common.Error(c, 500, err.Error())
return
}
common.Success(c, "删除成功")
}
// SwitchVolunteer 切换当前志愿单
// @Summary 切换当前志愿单
// @Tags 用户志愿
// @Param id query string true "志愿单ID"
// @Success 200 {object} common.Response
// @Router /user/volunteer/switch [post]
func (ctrl *UserVolunteerController) SwitchVolunteer(c *gin.Context) {
id := c.Query("id")
if id == "" {
common.Error(c, 400, "参数错误")
return
}
loginUserID := common.GetLoginUser(c).ID
// 1. 先判断是否已是该志愿单 (从 cache 或 db 中查找激活的)
scoreObj, err := ctrl.userScoreService.GetActiveScoreID(loginUserID)
if err != nil {
common.Error(c, 500, "获取用户成绩信息失败: "+err.Error())
return
}
userScoreVO, ok := scoreObj.(vo.UserScoreVO)
if !ok {
common.Error(c, 500, "成绩信息格式错误")
return
}
if userScoreVO.ID != "" {
activeVolunteer, _ := ctrl.yxVolunteerService.FindActiveByScoreId(userScoreVO.ID)
if activeVolunteer != nil && activeVolunteer.ID == id {
common.Success(c, "已是当前志愿单，忽略切换")
return
}
}
// 2. 切换
if err := ctrl.yxVolunteerService.SwitchVolunteer(id, loginUserID, ctrl.userScoreService); err != nil {
common.Error(c, 500, err.Error())
return
}
// 3. Redis 缓存同步 (假设 common 中有清除缓存的方法逻辑，或者由 Service 处理)
// 这里按需求提到：切换志愿单切换后 写入到redis做缓存（查询志愿单接口也要从redis读本体数据），再清除之前的成绩单redis重新获取写到redis缓存。
// 实际项目中 common.GetLoginUser 已经包含了 ID，成绩单和志愿单通常由具体模块处理缓存。
// 如果这里只是标记，Service 层已做状态更新，查询接口读取时会感知变化。
// 为了彻底满足“写入/清除 redis 缓存”，通常会有相应的 RedisUtil 调用。
// 假设 service 层或 controller 有 Cache 清理逻辑。
common.Success(c, "切换成功")
}

51
server/modules/user/service/user_score_service.go
View File

@ -26,32 +26,12 @@ type UserScoreService struct {
mapper *mapper.YxUserScoreMapper mapper *mapper.YxUserScoreMapper
} }
// GetActiveScoreID 获取用户的激活成绩信息 func (s *UserScoreService) GetUserScoreByUserId(id string) {
func (s *UserScoreService) GetActiveScoreID(userID string) (interface{}, error) { panic("unimplemented")
vo, err := s.GetActiveScoreByUserID(userID)
if err != nil {
return nil, err
}
return vo, nil
} }
// GetActiveScoreByID 获取用户的激活成绩实体（实现 IScoreService 接口） // GetActiveByID 获取当前激活的成绩
func (s *UserScoreService) GetActiveScoreByID(userID string) (entity.YxUserScore, error) { func (s *UserScoreService) GetActiveByID(userID string) (vo.UserScoreVO, error) {
var score entity.YxUserScore
// 明确指定字段，提高可读性
err := config.DB.Model(&entity.YxUserScore{}).
Where("create_by = ? AND state = ?", userID, "1").
First(&score).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return entity.YxUserScore{}, fmt.Errorf("未找到激活的成绩记录")
}
return entity.YxUserScore{}, fmt.Errorf("查询成绩记录失败: %w", err)
}
return score, nil
}
func (s *UserScoreService) GetActiveScoreByUserID(userID string) (vo.UserScoreVO, error) {
var score entity.YxUserScore var score entity.YxUserScore
// 先从Redis获取是否存在 // 先从Redis获取是否存在
scoreRedisData, err := config.RDB.Get(context.Background(), common.RedisUserScorePrefix+userID).Result() scoreRedisData, err := config.RDB.Get(context.Background(), common.RedisUserScorePrefix+userID).Result()
@ -86,9 +66,19 @@ func (s *UserScoreService) GetActiveScoreByUserID(userID string) (vo.UserScoreVO
return s.convertEntityToVo(score), nil return s.convertEntityToVo(score), nil
} }
func (s *UserScoreService) GetByID(id string) (interface{}, error) { // GetByID 根据 ID 获取成绩
func (s *UserScoreService) GetByID(id string) (vo.UserScoreVO, error) {
var score entity.YxUserScore var score entity.YxUserScore
// ... (logic remains same) err := config.DB.Model(&entity.YxUserScore{}).
Where("id = ?", id).
First(&score).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return vo.UserScoreVO{}, fmt.Errorf("记录不存在")
}
return vo.UserScoreVO{}, fmt.Errorf("查询失败: %w", err)
}
return s.convertEntityToVo(score), nil return s.convertEntityToVo(score), nil
} }
@ -115,14 +105,6 @@ func (s *UserScoreService) ListByUser(userID string, page, size int) ([]vo.UserS
return vos, total, nil return vos, total, nil
} }
func (s *UserScoreService) Delete(id string) error {
return s.mapper.Delete(id)
}
func (s *UserScoreService) UpdateFields(id string, fields map[string]interface{}) error {
return s.mapper.UpdateFields(id, fields)
}
func NewUserScoreService() *UserScoreService { func NewUserScoreService() *UserScoreService {
return &UserScoreService{ return &UserScoreService{
yxUserScoreService: service.NewYxUserScoreService(), yxUserScoreService: service.NewYxUserScoreService(),
@ -168,6 +150,7 @@ func (s *UserScoreService) SaveUserScore(req *dto.SaveScoreRequest) (vo.UserScor
// 保存新的成绩记录 // 保存新的成绩记录
if err := tx.Create(entityItem).Error; err != nil { if err := tx.Create(entityItem).Error; err != nil {
fmt.Errorf("保存记录失败: %w", err)
tx.Rollback() tx.Rollback()
return vo.UserScoreVO{}, fmt.Errorf("保存记录失败: %w", err) return vo.UserScoreVO{}, fmt.Errorf("保存记录失败: %w", err)
} }

14
server/modules/yx/dto/yx_volunteer_vo.go
View File

@ -1,14 +0,0 @@
package dto
import (
"server/modules/yx/entity"
)
// UserVolunteerVO 志愿单视图对象，关联成绩信息
type UserVolunteerVO struct {
entity.YxVolunteer
ProfessionalCategory string `json:"professionalCategory"` // 专业类别
Province string `json:"province"` // 省份
CulturalScore float64 `json:"culturalScore"` // 文化分
ProfessionalScore float64 `json:"professionalScore"` // 专业成绩分
}

15
server/modules/yx/mapper/yx_calculation_major_mapper.go
View File

@ -194,7 +194,7 @@ func (m *YxCalculationMajorMapper) FindRecommendList(query dto.SchoolMajorQuery)
countErr = config.DB.Raw(countSQL, params...).Count(&total).Error countErr = config.DB.Raw(countSQL, params...).Count(&total).Error
// 计算该协程耗时，通过互斥锁安全写入共享变量 // 计算该协程耗时，通过互斥锁安全写入共享变量
mu.Lock() mu.Lock()
queryCost.CountCost = time.Since(start) queryCost.CountCost = time.Now().Sub(start)
mu.Unlock() mu.Unlock()
}() }()
@ -206,7 +206,7 @@ func (m *YxCalculationMajorMapper) FindRecommendList(query dto.SchoolMajorQuery)
probCountErr = config.DB.Raw(probCountSQL, params...).Scan(&probCount).Error probCountErr = config.DB.Raw(probCountSQL, params...).Scan(&probCount).Error
// 计算该协程耗时，通过互斥锁安全写入共享变量 // 计算该协程耗时，通过互斥锁安全写入共享变量
mu.Lock() mu.Lock()
queryCost.ProbCountCost = time.Since(start) queryCost.ProbCountCost = time.Now().Sub(start)
mu.Unlock() mu.Unlock()
}() }()
@ -218,14 +218,14 @@ func (m *YxCalculationMajorMapper) FindRecommendList(query dto.SchoolMajorQuery)
queryErr = config.DB.Raw(mainSQL, params...).Scan(&items).Error queryErr = config.DB.Raw(mainSQL, params...).Scan(&items).Error
// 计算该协程耗时，通过互斥锁安全写入共享变量 // 计算该协程耗时，通过互斥锁安全写入共享变量
mu.Lock() mu.Lock()
queryCost.QueryCost = time.Since(start) queryCost.QueryCost = time.Now().Sub(start)
mu.Unlock() mu.Unlock()
}() }()
wg.Wait() wg.Wait()
// 计算整体总耗时 // 计算整体总耗时
queryCost.TotalCost = time.Since(totalStartTime) queryCost.TotalCost = time.Now().Sub(totalStartTime)
// 打印各协程耗时和总耗时（按需输出，可注释或删除） // 打印各协程耗时和总耗时（按需输出，可注释或删除）
fmt.Printf("各查询耗时统计：\n") fmt.Printf("各查询耗时统计：\n")
@ -555,10 +555,3 @@ func (m *YxCalculationMajorMapper) BatchDelete(ids []string) error {
func (m *YxCalculationMajorMapper) DeleteByScoreID(scoreID string) error { func (m *YxCalculationMajorMapper) DeleteByScoreID(scoreID string) error {
return config.DB.Delete(&entity.YxCalculationMajor{}, "score_id = ?", scoreID).Error return config.DB.Delete(&entity.YxCalculationMajor{}, "score_id = ?", scoreID).Error
} }
func (m *YxCalculationMajorMapper) DeleteByScoreIDFromTable(tableName, scoreID string) error {
if tableName == "" {
return nil
}
return config.DB.Table(tableName).Where("score_id = ?", scoreID).Delete(map[string]interface{}{}).Error
}

15
server/modules/yx/mapper/yx_volunteer_mapper.go
View File

@ -3,7 +3,6 @@ package mapper
import ( import (
"server/config" "server/config"
"server/modules/yx/dto"
"server/modules/yx/entity" "server/modules/yx/entity"
"gorm.io/gorm/clause" "gorm.io/gorm/clause"
@ -80,17 +79,3 @@ func (m *YxVolunteerMapper) BatchUpsert(items []entity.YxVolunteer, updateColumn
func (m *YxVolunteerMapper) BatchDelete(ids []string) error { func (m *YxVolunteerMapper) BatchDelete(ids []string) error {
return config.DB.Delete(&entity.YxVolunteer{}, "id IN ?", ids).Error return config.DB.Delete(&entity.YxVolunteer{}, "id IN ?", ids).Error
} }
func (m *YxVolunteerMapper) ListByUser(userID string, page, size int) ([]dto.UserVolunteerVO, int64, error) {
var items []dto.UserVolunteerVO
var total int64
db := config.DB.Table("yx_volunteer v").
Select("v.*, s.professional_category, s.province, s.cultural_score, s.professional_score").
Joins("LEFT JOIN yx_user_score s ON v.score_id = s.id").
Where("v.create_by = ?", userID)
db.Count(&total)
err := db.Order("v.create_time DESC").Offset((page - 1) * size).Limit(size).Scan(&items).Error
return items, total, err
}

4
server/modules/yx/mapper/yx_volunteer_record_mapper.go
View File

@ -10,10 +10,6 @@ import (
type YxVolunteerRecordMapper struct{} type YxVolunteerRecordMapper struct{}
func (m *YxVolunteerRecordMapper) BatchDeleteByVolunteerId(id string) {
config.DB.Delete(&entity.YxVolunteerRecord{}, "volunteer_id = ?", id)
}
func NewYxVolunteerRecordMapper() *YxVolunteerRecordMapper { func NewYxVolunteerRecordMapper() *YxVolunteerRecordMapper {
return &YxVolunteerRecordMapper{} return &YxVolunteerRecordMapper{}
} }

4
server/modules/yx/service/yx_calculation_major_service.go
View File

@ -198,10 +198,6 @@ func (s *YxCalculationMajorService) DeleteByScoreID(scoreID string) error {
return s.mapper.DeleteByScoreID(scoreID) return s.mapper.DeleteByScoreID(scoreID)
} }
func (s *YxCalculationMajorService) DeleteByScoreIDFromTable(tableName, scoreID string) error {
return s.mapper.DeleteByScoreIDFromTable(tableName, scoreID)
}
// 函数名 根据用户查询类型获取专业列表 // 函数名 根据用户查询类型获取专业列表
// 详细描述（可选） // 详细描述（可选）
// //

93
server/modules/yx/service/yx_volunteer_service.go
View File

@ -4,28 +4,17 @@ package service
import ( import (
"fmt" "fmt"
"server/common" "server/common"
"server/modules/yx/dto"
"server/modules/yx/entity" "server/modules/yx/entity"
"server/modules/yx/mapper" "server/modules/yx/mapper"
"time" "time"
) )
// IScoreService 定义成绩服务的接口，用于解耦
type IScoreService interface {
GetByID(id string) (interface{}, error)
GetActiveScoreByID(userID string) (entity.YxUserScore, error)
GetActiveScoreID(userID string) (interface{}, error)
UpdateFields(id string, fields map[string]interface{}) error
Delete(id string) error
}
type YxVolunteerService struct { type YxVolunteerService struct {
mapper *mapper.YxVolunteerMapper mapper *mapper.YxVolunteerMapper
volunteerRecordMapper *mapper.YxVolunteerRecordMapper
} }
func NewYxVolunteerService() *YxVolunteerService { func NewYxVolunteerService() *YxVolunteerService {
return &YxVolunteerService{mapper: mapper.NewYxVolunteerMapper(), volunteerRecordMapper: mapper.NewYxVolunteerRecordMapper()} return &YxVolunteerService{mapper: mapper.NewYxVolunteerMapper()}
} }
func (s *YxVolunteerService) List(page, size int) ([]entity.YxVolunteer, int64, error) { func (s *YxVolunteerService) List(page, size int) ([]entity.YxVolunteer, int64, error) {
@ -102,81 +91,3 @@ func (s *YxVolunteerService) CreateByScoreId(scoreId string, userId string) erro
// 创建志愿表 // 创建志愿表
return s.mapper.Create(&volunteer) return s.mapper.Create(&volunteer)
} }
func (s *YxVolunteerService) UpdateName(id, name, userID string) error {
volunteer, err := s.mapper.FindByID(id)
if err != nil {
return err
}
if volunteer.CreateBy != userID {
return fmt.Errorf("无权修改该志愿单")
}
return s.mapper.UpdateFields(id, map[string]interface{}{"volunteer_name": name, "update_by": userID, "update_time": time.Now()})
}
func (s *YxVolunteerService) ListByUser(userID string, page, size int) ([]dto.UserVolunteerVO, int64, error) {
return s.mapper.ListByUser(userID, page, size)
}
func (s *YxVolunteerService) DeleteVolunteer(id, userID string) error {
volunteer, err := s.mapper.FindByID(id)
if err != nil {
return err
}
if volunteer.CreateBy != userID {
return fmt.Errorf("无权删除该志愿单")
}
if volunteer.State == "1" {
return fmt.Errorf("激活状态的志愿单不可删除")
}
s.volunteerRecordMapper.BatchDeleteByVolunteerId(id)
s.mapper.Delete(id)
// 1. 获取成绩单信息
//scoreObj, err := scoreService.GetByID(volunteer.ScoreId)
// if err != nil {
// return fmt.Errorf("获取成绩单失败: %w", err)
// }
// _ = scoreObj // temporarily ignore until cascade logic is refined
// 这里需要从 scoreObj 中获取 CalculationTableName 和 ID
// 由于是 interface{}，可以通过反射或简单断言（如果能在 yx 定义共用结构最好）
// 或者直接在 scoreService 中增加一个获取这些字段的方法
// 简化：这里我们假设 scoreObj 其实包含了这些信息。
// 为了真正的解耦，我们可以在 scoreService 中增加专门的方法。
return nil // 暂时回退复杂逻辑
}
func (s *YxVolunteerService) SwitchVolunteer(id, userID string, scoreService IScoreService) error {
if err := s.mapper.CloseOtherVolunteer(userID); err != nil {
return err
}
if err := s.mapper.UpdateFields(id, map[string]interface{}{"state": "1", "update_by": userID, "update_time": time.Now()}); err != nil {
return err
}
volunteer, err := s.mapper.FindByID(id)
if err != nil {
return err
}
// 获取之前的激活成绩并关闭
scoreObj, err := scoreService.GetActiveScoreID(userID)
if err != nil {
return fmt.Errorf("获取激活成绩失败: %w", err)
}
var activeScoreID string
if scoreObj != nil {
// 尝试从 VO 对象中提取 ID
if vo, ok := scoreObj.(map[string]interface{}); ok {
if id, ok := vo["id"].(string); ok {
activeScoreID = id
}
} else if vo, ok := scoreObj.(struct{ ID string }); ok {
activeScoreID = vo.ID
}
}
if activeScoreID != "" && activeScoreID != volunteer.ScoreId {
scoreService.UpdateFields(activeScoreID, map[string]interface{}{"state": "0"})
}
return scoreService.UpdateFields(volunteer.ScoreId, map[string]interface{}{"state": "1"})
}

8
task_detail.md Normal file
View File

@ -0,0 +1,8 @@
## 会话 ID: 20260102-03
- **执行原因**: 用户希望将服务端口号配置到配置文件中，避免硬编码。
- **执行过程**:
1. 修改 `server/config/config.go`，在 `AppConfig` 中添加 `ServerConfig` 结构体。
2. 更新 `config.dev.yaml`、`config.prod.yaml` 和 `config.test.yaml`，添加 `server: port: 8080` 配置。
3. 修改 `server/main.go`，使其从 `config.AppConfig.Server.Port` 读取端口号，并保留默认值 8080。
- **执行结果**: 服务现在会使用配置文件中指定的端口启动。