fix bugs

doc/schedule/README.md

@@ -0,0 +1,148 @@
+# 编排模块文档索引
+
+> 本目录包含编排模块的所有技术文档和历史版本
+
+## 📚 主文档
+
+### 当前版本
+
+- **[编排系统完整指南](./schedule-complete-guide.md)** - v1.0
+  - 最后更新：2025-12-10
+  - 状态：已发布
+  - 简介：编排系统的完整技术方案，包含架构设计、数据库设计、前后端实现、API文档等
+
+## 📁 文档结构
+
+```
+schedule/
+├── README.md                           # 本文件 - 编排模块文档索引
+├── schedule-complete-guide.md          # 主文档 - 编排系统完整指南（当前版本）
+├── versions/                           # 历史版本目录
+│   ├── CHANGELOG.md                    # 版本更新日志
+│   ├── v1.0/
+│   │   └── schedule-complete-guide-v1.0.md
+│   └── v1.1/ (未来版本)
+│       └── schedule-complete-guide-v1.1.md
+└── archive/                            # 已废弃的旧文档
+    ├── schedule-system-analysis.md     # 已废弃 - 系统分析文档
+    ├── schedule-system-design.md       # 已废弃 - 系统设计文档
+    ├── schedule-feature-implementation.md
+    ├── schedule-backend-implementation-summary.md
+    ├── schedule-backend-api-spec.md
+    ├── schedule-api-conflict-fix.md
+    ├── schedule-ui-test-guide.md
+    ├── schedule-ui-update-summary.md
+    └── schedule-performance-optimization.md
+```
+
+## 📖 文档说明
+
+### 主文档
+
+**schedule-complete-guide.md** 是编排模块的核心技术文档，包含以下内容：
+
+1. **系统概述** - 功能简介、技术栈
+2. **架构设计** - 系统架构图、模块划分
+3. **数据库设计** - 核心表设计、表关系图
+4. **后端实现** - Controller层、Service层、Mapper层
+5. **前端实现** - 页面结构、数据结构、核心方法
+6. **数据流转** - 完整流程图、数据库操作流程
+7. **核心功能** - 场地过滤、顺序调整、分组移动、异常标记等
+8. **API接口文档** - 详细的接口说明和示例
+9. **关键代码解析** - 重要代码段的详细说明
+10. **使用指南** - 操作流程、常见问题、调试方法
+
+### 历史版本
+
+所有发布的版本都会保存在 `versions/` 目录下，按版本号组织：
+
+- `versions/v1.0/` - 第一个正式版本
+- `versions/v1.1/` - 功能优化版本（未来）
+- `versions/CHANGELOG.md` - 记录所有版本的更新内容
+
+### 已废弃文档
+
+`archive/` 目录存放已不再维护的旧文档，这些文档可能包含过时的信息或已被主文档整合：
+
+- **schedule-system-analysis.md** - 早期的系统分析文档
+- **schedule-system-design.md** - 早期的设计文档
+- **schedule-feature-implementation.md** - 功能实现记录
+- **schedule-backend-implementation-summary.md** - 后端实现总结
+- **schedule-backend-api-spec.md** - API规范文档
+- **schedule-api-conflict-fix.md** - API冲突修复记录
+- **schedule-ui-test-guide.md** - UI测试指南
+- **schedule-ui-update-summary.md** - UI更新总结
+- **schedule-performance-optimization.md** - 性能优化方案
+
+> ⚠️ **注意**：archive 目录中的文档仅供参考，可能包含过时信息，请以主文档为准。
+
+## 🔄 版本管理
+
+### 版本号规则
+
+- **主版本号 (Major)**: 重大功能变更或架构调整 (v1.0 → v2.0)
+- **次版本号 (Minor)**: 功能新增或优化 (v1.0 → v1.1)
+- **修订号 (Patch)**: 文档修正、补充说明 (v1.0.1 → v1.0.2)
+
+### 更新流程
+
+1. **日常修改**：直接在主文档 `schedule-complete-guide.md` 中修改
+2. **发布新版本**：
+   - 将当前主文档复制到 `versions/vX.X/` 目录
+   - 更新 `versions/CHANGELOG.md` 记录变更
+   - 在主文档头部更新版本号和更新日期
+
+### 示例
+
+```bash
+# 当前主文档版本: v1.0
+doc/schedule/schedule-complete-guide.md
+
+# 发布 v1.1 版本的步骤:
+1. 复制主文档到历史版本目录
+   cp schedule-complete-guide.md versions/v1.0/schedule-complete-guide-v1.0.md
+
+2. 修改主文档内容，更新版本号为 v1.1
+
+3. 更新 versions/CHANGELOG.md，记录 v1.1 的变更内容
+
+4. 更新本 README.md，在主文档说明中更新版本号
+```
+
+## 📝 快速导航
+
+### 我想了解...
+
+- **整体架构** → [完整指南 - 架构设计](./schedule-complete-guide.md#架构设计)
+- **数据库表结构** → [完整指南 - 数据库设计](./schedule-complete-guide.md#数据库设计)
+- **API接口** → [完整指南 - API接口文档](./schedule-complete-guide.md#API接口文档)
+- **前端实现** → [完整指南 - 前端实现](./schedule-complete-guide.md#前端实现)
+- **后端实现** → [完整指南 - 后端实现](./schedule-complete-guide.md#后端实现)
+- **如何使用** → [完整指南 - 使用指南](./schedule-complete-guide.md#使用指南)
+- **数据流转** → [完整指南 - 数据流转](./schedule-complete-guide.md#数据流转)
+
+### 我遇到问题...
+
+- **编排数据为空** → [完整指南 - 常见问题](./schedule-complete-guide.md#为什么编排数据为空)
+- **无法编辑** → [完整指南 - 常见问题](./schedule-complete-guide.md#为什么无法编辑)
+- **保存失败** → [完整指南 - 常见问题](./schedule-complete-guide.md#保存草稿失败怎么办)
+- **调试方法** → [完整指南 - 开发调试](./schedule-complete-guide.md#开发调试)
+
+## 📅 版本历史
+
+| 版本 | 发布日期 | 主要更新 | 文档链接 |
+|------|----------|----------|----------|
+| v1.0 | 2025-12-10 | 初始版本，完整技术方案 | [查看文档](./versions/v1.0/schedule-complete-guide-v1.0.md) |
+
+详细的版本更新记录请查看 [CHANGELOG.md](./versions/CHANGELOG.md)
+
+## 🔗 相关文档
+
+- [项目文档中心](../README.md)
+- [报名模块文档](../registration/README.md)
+- [数据库设计文档](../database/schema.md)（待创建）
+- [开发规范](../development-standards.md)（待创建）
+
+---
+
+**最后更新**: 2025-12-10

doc/schedule/archive/schedule-api-conflict-fix.md

@@ -0,0 +1,201 @@
+# 赛程编排API冲突修复说明
+
+## 问题描述
+
+在实现赛程编排后端API时，发现项目中已经存在 `MartialScheduleArrangeController` 控制器，该控制器已经定义了相同的路径：
+- `GET /martial/schedule/result`
+- `POST /martial/schedule/save-and-lock`
+
+这导致Spring Boot启动时报错：
+```
+Ambiguous mapping. Cannot map 'martialScheduleController' method to {POST [/martial/schedule/save-and-lock]}:
+There is already 'martialScheduleArrangeController' bean method mapped.
+```
+
+## 解决方案
+
+### 1. 删除重复的控制器端点
+
+从新创建的 `MartialScheduleController` 中删除了冲突的3个端点：
+- `/result`
+- `/save-draft`
+- `/save-and-lock`
+
+保留原有的基础CRUD端点（detail, list, submit, remove）。
+
+### 2. 更新现有控制器
+
+修改 `MartialScheduleArrangeController`，使其使用新创建的Service和DTO：
+
+**文件**: [MartialScheduleArrangeController.java](d:\workspace\31.比赛项目\project\martial-master\src\main\java\org\springblade\modules\martial\controller\MartialScheduleArrangeController.java)
+
+#### 2.1 添加依赖注入
+
+```java
+private final IMartialScheduleArrangeService scheduleArrangeService;
+private final IMartialScheduleService scheduleService; // 新增
+```
+
+#### 2.2 更新 GET /result 端点
+
+**修改前**:
+```java
+public R<Map<String, Object>> getScheduleResult(@RequestParam Long competitionId) {
+    Map<String, Object> result = scheduleArrangeService.getScheduleResult(competitionId);
+    return R.data(result);
+}
+```
+
+**修改后**:
+```java
+public R<ScheduleResultDTO> getScheduleResult(@RequestParam Long competitionId) {
+    ScheduleResultDTO result = scheduleService.getScheduleResult(competitionId);
+    return R.data(result);
+}
+```
+
+**改进**:
+- 使用结构化的DTO替代Map
+- 返回类型更加明确
+- 符合前端API规范
+
+#### 2.3 新增 POST /save-draft 端点
+
+```java
+@PostMapping("/save-draft")
+@Operation(summary = "保存编排草稿", description = "传入编排草稿数据")
+public R saveDraftSchedule(@RequestBody SaveScheduleDraftDTO dto) {
+    try {
+        boolean success = scheduleService.saveDraftSchedule(dto);
+        return success ? R.success("草稿保存成功") : R.fail("草稿保存失败");
+    } catch (Exception e) {
+        log.error("保存编排草稿失败", e);
+        return R.fail("保存编排草稿失败: " + e.getMessage());
+    }
+}
+```
+
+#### 2.4 更新 POST /save-and-lock 端点
+
+**修改前**:
+```java
+public R saveAndLock(@RequestBody Map<String, Object> params) {
+    Long competitionId = Long.valueOf(String.valueOf(params.get("competitionId")));
+    scheduleArrangeService.saveAndLock(competitionId, userId);
+    return R.success("编排已保存并锁定");
+}
+```
+
+**修改后**:
+```java
+public R saveAndLock(@RequestBody SaveScheduleDraftDTO dto) {
+    BladeUser user = AuthUtil.getUser();
+    String userId = user != null ? user.getUserName() : "system";
+
+    boolean success = scheduleService.saveAndLockSchedule(dto.getCompetitionId());
+    if (success) {
+        // 调用原有的锁定逻辑
+        scheduleArrangeService.saveAndLock(dto.getCompetitionId(), userId);
+        return R.success("编排已完成并锁定");
+    } else {
+        return R.fail("编排锁定失败");
+    }
+}
+```
+
+**改进**:
+1. 使用DTO替代Map，类型安全
+2. 结合新旧两个Service的功能
+3. 先更新参赛者状态，再执行原有的锁定逻辑
+
+## 最终API结构
+
+### MartialScheduleArrangeController
+**基础路径**: `/martial/schedule`
+
+| 方法 | 路径 | 功能 | 请求类型 | 响应类型 |
+|------|------|------|----------|----------|
+| GET | `/result` | 获取编排结果 | competitionId | ScheduleResultDTO |
+| POST | `/save-draft` | 保存编排草稿 | SaveScheduleDraftDTO | R |
+| POST | `/save-and-lock` | 完成编排并锁定 | SaveScheduleDraftDTO | R |
+| POST | `/auto-arrange` | 手动触发自动编排 | Map | R |
+
+### MartialScheduleController
+**基础路径**: `/martial/schedule`
+
+| 方法 | 路径 | 功能 | 请求类型 | 响应类型 |
+|------|------|------|----------|----------|
+| GET | `/detail` | 获取详情 | id | MartialSchedule |
+| GET | `/list` | 分页列表 | MartialSchedule, Query | IPage |
+| POST | `/submit` | 新增或修改 | MartialSchedule | R |
+| POST | `/remove` | 删除 | ids | R |
+
+## 字段冲突修复
+
+### 问题
+实体类 `MartialScheduleParticipant` 的 `status` 字段与基础类 `TenantEntity` 冲突。
+
+### 解决方案
+将 `status` 字段重命名为 `checkInStatus`（签到状态）：
+
+**文件**: [MartialScheduleParticipant.java:86-90](d:\workspace\31.比赛项目\project\martial-master\src\main\java\org\springblade\modules\martial\pojo\entity\MartialScheduleParticipant.java#L86-L90)
+
+```java
+/**
+ * 签到状态：未签到/已签到/异常
+ */
+@Schema(description = "签到状态：未签到/已签到/异常")
+private String checkInStatus;
+```
+
+### 相应更新
+
+**Service层** ([MartialScheduleServiceImpl.java](d:\workspace\31.比赛项目\project\martial-master\src\main\java\org\springblade\modules\martial\service\impl\MartialScheduleServiceImpl.java)):
+
+1. **读取时**:
+```java
+dto.setStatus(p.getCheckInStatus() != null ? p.getCheckInStatus() : "未签到");
+```
+
+2. **保存时**:
+```java
+participant.setCheckInStatus(participantDTO.getStatus());
+```
+
+前端仍然使用 `status` 字段，在Service层进行映射转换。
+
+## 数据库字段名建议
+
+```sql
+ALTER TABLE martial_schedule_participant
+ADD COLUMN check_in_status VARCHAR(20) DEFAULT '未签到' COMMENT '签到状态：未签到/已签到/异常',
+ADD COLUMN schedule_status VARCHAR(20) DEFAULT 'draft' COMMENT '编排状态：draft/completed';
+```
+
+## 前后端对接
+
+前端API配置无需修改，仍然使用原有路径：
+```javascript
+// 获取赛程编排结果
+GET /api/martial/schedule/result
+
+// 保存编排草稿
+POST /api/martial/schedule/save-draft
+
+// 完成编排并锁定
+POST /api/martial/schedule/save-and-lock
+```
+
+所有端点都通过 `MartialScheduleArrangeController` 处理。
+
+## 总结
+
+通过以下措施解决了API冲突问题：
+
+1. ✅ 删除重复的控制器端点
+2. ✅ 更新现有控制器使用新的DTO和Service
+3. ✅ 修复字段名冲突
+4. ✅ 保持前端API路径不变
+5. ✅ 结合新旧Service功能，确保业务逻辑完整
+
+现在系统可以正常启动，API端点清晰明确，没有冲突。

doc/schedule/archive/schedule-backend-api-spec.md

@@ -0,0 +1,204 @@
+# 赛程编排后端API数据格式规范
+
+## 1. 获取赛程编排结果 - getScheduleResult
+
+**接口地址**: `GET /api/martial/schedule/result`
+
+**请求参数**:
+```javascript
+{
+  competitionId: Number  // 赛事ID
+}
+```
+
+**返回数据格式**:
+```javascript
+{
+  "code": 200,
+  "msg": "success",
+  "data": {
+    "isDraft": true,          // 是否为草稿状态
+    "isCompleted": false,     // 是否已完成编排
+    "competitionGroups": [    // 竞赛分组列表
+      {
+        "id": 1,                        // 分组ID
+        "title": "1. 小学组小组赛男女类",  // 分组标题
+        "type": "集体",                  // 类型：集体/单人/双人
+        "count": "2队",                  // 队伍数量
+        "code": "1101",                 // 分组编号
+        "venueId": 1,                   // 当前所属场地ID
+        "venueName": "一号场地",         // 场地名称
+        "timeSlot": "2025年11月6日 上午8:30",  // 时间段
+        "timeSlotIndex": 0,             // 时间段索引
+        "participants": [               // 参赛人员列表
+          {
+            "id": 101,                  // 参赛人员ID
+            "schoolUnit": "清河小学",    // 学校/单位
+            "status": "未签到",          // 状态：未签到/已签到/异常
+            "sortOrder": 1              // 排序
+          },
+          {
+            "id": 102,
+            "schoolUnit": "访河社区",
+            "status": "未签到",
+            "sortOrder": 2
+          }
+        ]
+      },
+      {
+        "id": 2,
+        "title": "1. 小学组小组赛男女类",
+        "type": "单人",
+        "count": "3队",
+        "code": "1组",
+        "venueId": 2,
+        "venueName": "二号场地",
+        "timeSlot": "2025年11月6日 上午8:30",
+        "timeSlotIndex": 0,
+        "participants": [
+          {
+            "id": 103,
+            "schoolUnit": "少林寺武校",
+            "status": "未签到",
+            "sortOrder": 1
+          },
+          {
+            "id": 104,
+            "schoolUnit": "访河社区",
+            "status": "已签到",
+            "sortOrder": 2
+          },
+          {
+            "id": 105,
+            "schoolUnit": "武当派",
+            "status": "异常",
+            "sortOrder": 3
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+**重要说明**:
+1. **首次分配规则**: 系统后台需要按照"先集体，后个人"的顺序进行第一次场地分配
+2. **状态字段**:
+   - `未签到`: 默认状态
+   - `已签到`: 参赛人员已签到
+   - `异常`: 被标记为异常的参赛人员
+3. **timeSlotIndex**: 对应前端动态生成的时间段数组索引，从0开始
+4. **sortOrder**: 参赛人员在分组内的排序，用于上移/下移功能
+
+## 2. 保存编排草稿 - saveDraftSchedule
+
+**接口地址**: `POST /api/martial/schedule/save-draft`
+
+**请求数据格式**:
+```javascript
+{
+  "competitionId": 1,           // 赛事ID
+  "isDraft": true,              // 是否为草稿
+  "competitionGroups": [        // 竞赛分组数据
+    {
+      "id": 1,                  // 分组ID（如果是新建则为null）
+      "title": "1. 小学组小组赛男女类",
+      "type": "集体",
+      "count": "2队",
+      "code": "1101",
+      "venueId": 1,             // 场地ID
+      "venueName": "一号场地",
+      "timeSlot": "2025年11月6日 上午8:30",
+      "timeSlotIndex": 0,
+      "participants": [
+        {
+          "id": 101,
+          "schoolUnit": "清河小学",
+          "status": "未签到",
+          "sortOrder": 1
+        },
+        {
+          "id": 102,
+          "schoolUnit": "访河社区",
+          "status": "异常",
+          "sortOrder": 2
+        }
+      ]
+    }
+  ]
+}
+```
+
+**返回数据格式**:
+```javascript
+{
+  "code": 200,
+  "msg": "草稿保存成功",
+  "data": null
+}
+```
+
+**重要说明**:
+1. 草稿可以被多次保存和更新
+2. 保存草稿不会锁定数据，用户可以继续编辑
+3. 下次打开页面时，如果`isCompleted`为false，则加载草稿数据
+
+## 3. 完成编排并锁定 - saveAndLockSchedule
+
+**接口地址**: `POST /api/martial/schedule/save-and-lock`
+
+**请求数据格式**:
+```javascript
+{
+  "competitionId": 1  // 赛事ID
+}
+```
+
+**返回数据格式**:
+```javascript
+{
+  "code": 200,
+  "msg": "编排已完成并锁定",
+  "data": null
+}
+```
+
+**重要说明**:
+1. 完成编排后，`isCompleted`标记为true
+2. 编排完成后，前端将禁用所有编辑功能（上移、下移、标记异常、移动分组等）
+3. 只有在`isCompleted`为true时，才显示"导出"按钮
+
+## 4. 前端页面功能说明
+
+### 4.1 移动分组功能
+- 用户可以将整个竞赛分组移动到不同的场地和时间段
+- 移动后需要更新分组的`venueId`、`venueName`、`timeSlot`、`timeSlotIndex`字段
+- 移动操作在保存草稿时提交到后端
+
+### 4.2 异常组功能
+- 只有状态为"未签到"的参赛人员才显示"异常"按钮
+- 点击"异常"按钮后，参赛人员状态变为"异常"
+- 异常参赛人员会在"异常组"弹窗中显示
+- 可以从异常组移除，状态恢复为"未签到"
+
+### 4.3 上移/下移功能
+- 调整参赛人员在分组内的顺序
+- 修改后会更新`sortOrder`字段
+- 在保存草稿时提交到后端
+
+### 4.4 保存草稿与完成编排
+- **保存草稿**: 保存当前编排状态，不锁定，可继续编辑
+- **完成编排**: 锁定编排，禁用所有编辑功能，显示导出按钮
+
+## 5. 字段映射说明
+
+| 前端字段 | 后端字段（可能的命名） | 说明 |
+|---------|---------------------|------|
+| schoolUnit | school_unit / schoolUnit | 学校/单位名称 |
+| venueName | venue_name / venueName | 场地名称 |
+| venueId | venue_id / venueId | 场地ID |
+| timeSlot | time_slot / timeSlot | 时间段文本 |
+| timeSlotIndex | time_slot_index / timeSlotIndex | 时间段索引 |
+| sortOrder | sort_order / sortOrder | 排序 |
+
+**提示**: 后端可以使用下划线命名（snake_case）或驼峰命名（camelCase），前端已做兼容处理。

doc/schedule/archive/schedule-backend-implementation-summary.md

@@ -0,0 +1,347 @@
+# 赛程编排后端实现总结
+
+## 实施概览
+
+本次实现了赛程编排系统的三个核心后端API接口，完全按照 `schedule-backend-api-spec.md` 文档的规范进行开发。
+
+## 实现的文件列表
+
+### 1. DTO类 (数据传输对象)
+
+#### 1.1 ScheduleResultDTO.java
+- **路径**: `martial-master/src/main/java/org/springblade/modules/martial/pojo/dto/ScheduleResultDTO.java`
+- **作用**: 赛程编排结果的响应数据结构
+- **字段**:
+  - `isDraft`: 是否为草稿状态
+  - `isCompleted`: 是否已完成编排
+  - `competitionGroups`: 竞赛分组列表
+
+#### 1.2 CompetitionGroupDTO.java
+- **路径**: `martial-master/src/main/java/org/springblade/modules/martial/pojo/dto/CompetitionGroupDTO.java`
+- **作用**: 竞赛分组数据结构
+- **字段**:
+  - `id`: 分组ID
+  - `title`: 分组标题
+  - `type`: 类型(集体/单人/双人)
+  - `count`: 队伍数量
+  - `code`: 分组编号
+  - `venueId`: 场地ID
+  - `venueName`: 场地名称
+  - `timeSlot`: 时间段
+  - `timeSlotIndex`: 时间段索引
+  - `participants`: 参赛人员列表
+
+#### 1.3 ParticipantDTO.java
+- **路径**: `martial-master/src/main/java/org/springblade/modules/martial/pojo/dto/ParticipantDTO.java`
+- **作用**: 参赛人员数据结构
+- **字段**:
+  - `id`: 参赛人员ID
+  - `schoolUnit`: 学校/单位
+  - `status`: 状态(未签到/已签到/异常)
+  - `sortOrder`: 排序
+
+#### 1.4 SaveScheduleDraftDTO.java
+- **路径**: `martial-master/src/main/java/org/springblade/modules/martial/pojo/dto/SaveScheduleDraftDTO.java`
+- **作用**: 保存编排草稿的请求数据结构
+- **字段**:
+  - `competitionId`: 赛事ID
+  - `isDraft`: 是否为草稿
+  - `competitionGroups`: 竞赛分组数据
+
+### 2. 实体类修改
+
+#### 2.1 MartialScheduleParticipant.java
+- **路径**: `martial-master/src/main/java/org/springblade/modules/martial/pojo/entity/MartialScheduleParticipant.java`
+- **修改内容**: 添加了两个新字段
+  - `status`: 参赛人员状态(未签到/已签到/异常)
+  - `scheduleStatus`: 编排状态(draft/completed)
+
+### 3. 服务接口
+
+#### 3.1 IMartialScheduleService.java
+- **路径**: `martial-master/src/main/java/org/springblade/modules/martial/service/IMartialScheduleService.java`
+- **新增方法**:
+  - `getScheduleResult(Long competitionId)`: 获取赛程编排结果
+  - `saveDraftSchedule(SaveScheduleDraftDTO dto)`: 保存编排草稿
+  - `saveAndLockSchedule(Long competitionId)`: 完成编排并锁定
+
+### 4. 服务实现
+
+#### 4.1 MartialScheduleServiceImpl.java
+- **路径**: `martial-master/src/main/java/org/springblade/modules/martial/service/impl/MartialScheduleServiceImpl.java`
+- **新增依赖注入**:
+  - `MartialScheduleGroupMapper`: 分组数据访问
+  - `MartialScheduleDetailMapper`: 编排明细数据访问
+  - `MartialScheduleParticipantMapper`: 参赛者数据访问
+
+- **实现的方法**:
+
+##### 4.1.1 getScheduleResult(Long competitionId)
+**功能**: 查询并返回赛事的编排结果
+
+**实现逻辑**:
+1. 查询所有竞赛分组(按display_order排序)
+2. 查询所有编排明细
+3. 查询所有参赛者(按performance_order排序)
+4. 根据scheduleStatus判断是否已完成编排
+5. 组装DTO数据返回
+
+**关键代码**:
+```java
+// 检查编排状态
+boolean isCompleted = participants.stream()
+    .anyMatch(p -> "completed".equals(p.getScheduleStatus()));
+boolean isDraft = !isCompleted;
+
+// 设置项目类型
+switch (group.getProjectType()) {
+    case 1: groupDTO.setType("单人"); break;
+    case 2: groupDTO.setType("集体"); break;
+    default: groupDTO.setType("其他"); break;
+}
+```
+
+##### 4.1.2 saveDraftSchedule(SaveScheduleDraftDTO dto)
+**功能**: 保存编排草稿数据
+
+**实现逻辑**:
+1. 遍历所有竞赛分组
+2. 更新或创建编排明细(MartialScheduleDetail)
+3. 更新参赛者的状态和排序
+4. 将scheduleStatus设置为"draft"
+5. 使用事务确保数据一致性
+
+**关键代码**:
+```java
+@Transactional(rollbackFor = Exception.class)
+public boolean saveDraftSchedule(SaveScheduleDraftDTO dto) {
+    // 更新编排明细
+    detail.setVenueId(groupDTO.getVenueId());
+    detail.setVenueName(groupDTO.getVenueName());
+    detail.setTimeSlot(groupDTO.getTimeSlot());
+
+    // 更新参赛者信息
+    participant.setStatus(participantDTO.getStatus());
+    participant.setPerformanceOrder(participantDTO.getSortOrder());
+    participant.setScheduleStatus("draft");
+}
+```
+
+##### 4.1.3 saveAndLockSchedule(Long competitionId)
+**功能**: 完成编排并锁定，不允许再次编辑
+
+**实现逻辑**:
+1. 查询赛事的所有分组
+2. 查询所有参赛者
+3. 将所有参赛者的scheduleStatus更新为"completed"
+4. 使用事务确保数据一致性
+
+**关键代码**:
+```java
+@Transactional(rollbackFor = Exception.class)
+public boolean saveAndLockSchedule(Long competitionId) {
+    for (MartialScheduleParticipant participant : participants) {
+        participant.setScheduleStatus("completed");
+        scheduleParticipantMapper.updateById(participant);
+    }
+}
+```
+
+### 5. 控制器
+
+#### 5.1 MartialScheduleController.java
+- **路径**: `martial-master/src/main/java/org/springblade/modules/martial/controller/MartialScheduleController.java`
+- **新增端点**:
+
+##### 5.1.1 GET /martial/schedule/result
+**功能**: 获取赛程编排结果
+
+**请求参数**:
+- `competitionId` (Long): 赛事ID
+
+**响应示例**:
+```json
+{
+  "code": 200,
+  "msg": "success",
+  "data": {
+    "isDraft": true,
+    "isCompleted": false,
+    "competitionGroups": [...]
+  }
+}
+```
+
+##### 5.1.2 POST /martial/schedule/save-draft
+**功能**: 保存编排草稿
+
+**请求体**: SaveScheduleDraftDTO
+
+**响应示例**:
+```json
+{
+  "code": 200,
+  "msg": "草稿保存成功"
+}
+```
+
+##### 5.1.3 POST /martial/schedule/save-and-lock
+**功能**: 完成编排并锁定
+
+**请求体**: 包含competitionId的SaveScheduleDraftDTO
+
+**响应示例**:
+```json
+{
+  "code": 200,
+  "msg": "编排已完成并锁定"
+}
+```
+
+## 数据库设计说明
+
+### 涉及的表
+
+1. **martial_schedule_group** (赛程编排分组)
+   - 存储竞赛分组信息
+   - 字段: competition_id, group_name, project_type, display_order等
+
+2. **martial_schedule_detail** (赛程编排明细)
+   - 存储场地和时间段分配信息
+   - 字段: schedule_group_id, venue_id, venue_name, schedule_date, time_slot等
+
+3. **martial_schedule_participant** (赛程编排参赛者关联)
+   - 存储参赛者信息
+   - **新增字段**:
+     - `status`: VARCHAR - 参赛人员状态(未签到/已签到/异常)
+     - `schedule_status`: VARCHAR - 编排状态(draft/completed)
+
+### 数据库迁移建议
+
+需要在 `martial_schedule_participant` 表中添加以下字段:
+
+```sql
+ALTER TABLE martial_schedule_participant
+ADD COLUMN status VARCHAR(20) DEFAULT '未签到' COMMENT '状态：未签到/已签到/异常',
+ADD COLUMN schedule_status VARCHAR(20) DEFAULT 'draft' COMMENT '编排状态：draft/completed';
+```
+
+## 业务逻辑说明
+
+### 编排状态管理
+
+1. **草稿状态** (draft):
+   - 用户可以多次保存和修改
+   - 不影响其他功能
+   - scheduleStatus = "draft"
+
+2. **完成状态** (completed):
+   - 编排锁定，前端禁用所有编辑功能
+   - 显示"导出"按钮
+   - scheduleStatus = "completed"
+
+### 首次分配规则
+
+根据API规范，后端需要按照"先集体，后个人"的顺序进行第一次场地分配:
+- 集体项目 (projectType = 2) 优先分配
+- 个人项目 (projectType = 1) 后分配
+- 使用 display_order 字段控制顺序
+
+### 状态字段说明
+
+参赛人员状态 (status):
+- **未签到**: 默认状态
+- **已签到**: 参赛人员已签到
+- **异常**: 被标记为异常的参赛人员
+
+## 前后端对接说明
+
+### API路径映射
+
+前端API配置 (`src/api/martial/activitySchedule.js`):
+```javascript
+// 获取赛程编排结果
+GET /api/martial/schedule/result
+
+// 保存编排草稿
+POST /api/martial/schedule/save-draft
+
+// 完成编排并锁定
+POST /api/martial/schedule/save-and-lock
+```
+
+后端Controller路径 (`MartialScheduleController.java`):
+```java
+@RequestMapping("/martial/schedule")
+
+@GetMapping("/result")
+@PostMapping("/save-draft")
+@PostMapping("/save-and-lock")
+```
+
+### 数据格式兼容性
+
+- 后端使用驼峰命名 (camelCase)
+- 前端已做兼容处理，同时支持驼峰和下划线命名
+- DTO中的字段名与前端API规范完全一致
+
+## 测试建议
+
+### 单元测试
+
+1. 测试getScheduleResult方法:
+   - 测试空数据情况
+   - 测试草稿状态
+   - 测试完成状态
+   - 测试数据组装正确性
+
+2. 测试saveDraftSchedule方法:
+   - 测试新建编排明细
+   - 测试更新编排明细
+   - 测试参赛者状态更新
+   - 测试事务回滚
+
+3. 测试saveAndLockSchedule方法:
+   - 测试状态更新
+   - 测试锁定后的查询结果
+
+### 集成测试
+
+1. 测试完整的编排流程:
+   - 首次获取编排结果
+   - 多次保存草稿
+   - 完成编排并锁定
+   - 再次查询验证状态
+
+2. 测试异常场景:
+   - 赛事不存在
+   - 分组不存在
+   - 参赛者不存在
+
+## 后续优化建议
+
+1. **性能优化**:
+   - 对于大量参赛者的情况，考虑使用批量更新
+   - 添加缓存机制减少数据库查询
+
+2. **功能增强**:
+   - 添加编排历史记录
+   - 实现编排版本管理
+   - 添加编排冲突检测
+
+3. **安全性**:
+   - 添加权限验证
+   - 添加操作日志
+   - 实现并发控制
+
+## 总结
+
+本次实现完全按照前端API规范进行开发，实现了:
+- ✅ 3个核心API接口
+- ✅ 4个DTO类
+- ✅ 实体类字段扩展
+- ✅ 完整的服务层逻辑
+- ✅ 事务管理
+- ✅ Swagger文档注解
+
+所有代码遵循项目现有的代码风格和架构规范，可以直接集成到现有系统中使用。

doc/schedule/archive/schedule-feature-implementation.md

@@ -0,0 +1,387 @@
+# 赛程编排功能实施完成文档
+
+## 📋 实施概述
+
+**实施日期**: 2025-12-08
+**版本**: v1.0
+**状态**: ✅ 核心功能已完成
+
+---
+
+## 1. 已完成的功能
+
+### ✅ 1.1 数据库表创建
+
+创建了两张核心数据库表:
+
+**文件位置**: `doc/create_schedule_tables.sql`
+
+#### martial_schedule (赛程安排表)
+- 存储分组的基本信息
+- 包含场地分配、时间段分配
+- 支持草稿和发布状态
+
+#### martial_schedule_detail (赛程明细表)
+- 存储每个分组中的参赛人员详情
+- 记录实际比赛时间
+- 支持比赛进度跟踪
+
+**执行方式**:
+```bash
+# 方式1: 通过数据库客户端导入并执行
+# 方式2: 命令行执行
+mysql -u root -p martial_competition < doc/create_schedule_tables.sql
+```
+
+### ✅ 1.2 前端赛程编排页面完善
+
+**文件位置**: `src/views/martial/schedule/index.vue`
+
+#### 核心算法实现:
+
+1. **时间段自动生成** (generateTimeSlots方法)
+   - 根据赛事开始/结束时间自动生成
+   - 上午场: 08:30-12:00
+   - 下午场: 13:30-17:30
+   - 支持多天赛程
+
+2. **智能自动分组** (autoGroupParticipants方法)
+   - ✅ 集体项目优先(type=2)
+   - ✅ 个人项目在后(type=1)
+   - ✅ 集体项目按"单位+项目"分组
+   - ✅ 个人项目按"项目+组别"分组,每组最多30人
+   - ✅ 自动生成分组名称和编号
+
+3. **场地自动分配** (autoAssignVenues方法)
+   - ✅ 负载均衡算法
+   - ✅ 优先分配时长长的分组
+   - ✅ 选择当前负载最小的场地
+   - ✅ 均匀分布,避免某个场地过载
+
+4. **分组名称编辑**
+   - ✅ 双击分组名称进入编辑模式
+   - ✅ Enter保存,失焦保存
+   - ✅ 实时更新显示
+
+5. **拖拽移动分组**
+   - ✅ 使用vuedraggable组件
+   - ✅ 支持在场地间拖拽移动
+   - ✅ 支持场地内排序
+
+---
+
+## 2. 功能使用流程
+
+### 2.1 基本操作流程
+
+```
+1. 进入赛事管理 → 选择赛事 → 点击"编排"按钮
+   ↓
+2. 系统自动加载:
+   - 赛事信息
+   - 时间段列表 (根据赛事时间自动生成)
+   - 场地列表
+   - 所有参赛者数据
+   ↓
+3. 点击"自动编排"按钮
+   ↓
+4. 系统自动完成:
+   - 按集体/个人分类参赛者
+   - 智能分组 (集体按单位+项目, 个人按项目+组别)
+   - 自动分配场地 (负载均衡)
+   ↓
+5. 手动调整 (可选):
+   - 双击分组名称修改
+   - 拖拽分组到其他场地
+   - 调整分组内选手顺序
+   - 选择场地下拉菜单移动分组
+   ↓
+6. 保存编排 / 完成编排
+```
+
+### 2.2 时间段切换
+
+- 点击页面顶部的时间段按钮
+- 可查看不同时间段的分组安排
+- 每个时间段独立管理分组
+
+### 2.3 场地视图
+
+- 切换到"场地"Tab
+- 查看每个场地的分组分布
+- 统计每个场地的预计时长
+
+---
+
+## 3. 核心算法说明
+
+### 3.1 自动分组算法
+
+```javascript
+autoGroupParticipants(participants) {
+  // 1. 分离集体(type=2)和个人(type=1)
+  const teamProjects = participants.filter(p => p.type === 2)
+  const individualProjects = participants.filter(p => p.type === 1)
+
+  // 2. 集体项目: 按"organization_projectId"分组
+  // 3. 个人项目: 按"projectId_category"分组,每组最多30人
+  // 4. 返回: [集体分组, 个人分组]
+}
+```
+
+**特点**:
+- 集体项目同单位同项目的选手分在一组
+- 个人项目同项目同组别的选手分在一组
+- 个人项目超过30人自动拆分为A组、B组、C组...
+
+### 3.2 场地分配算法 (贪心 + 负载均衡)
+
+```javascript
+autoAssignVenues(groups) {
+  // 1. 初始化场地负载为0
+  // 2. 分组按预计时长降序排序
+  // 3. 贪心策略:
+  //    - 找当前负载最小的场地
+  //    - 分配分组到该场地
+  //    - 更新场地负载
+}
+```
+
+**特点**:
+- 先分配时间长的分组,后分配时间短的
+- 总是选择负载最轻的场地
+- 确保各场地负载均衡
+
+---
+
+## 4. 测试用例
+
+### 4.1 使用1000个参赛者测试
+
+**前提条件**:
+1. 已执行 `test-data/batch_create_1000_participants.sql`
+2. 赛事ID=200: "郑州协会全国运动大赛"
+3. 包含10个项目、5个场地、1000个参赛者
+
+**测试步骤**:
+
+#### 测试1: 自动编排功能
+```
+1. 进入赛事编排页面 (competitionId=200)
+2. 点击"自动编排"按钮
+3. 预期结果:
+   - 自动生成分组 (集体项目在前,个人项目在后)
+   - 每个分组自动分配场地
+   - 场地负载均衡
+   - 显示成功提示
+```
+
+#### 测试2: 分组名称编辑
+```
+1. 双击某个分组名称
+2. 修改名称 (如: "少林寺武术学校 - 集体拳术表演" → "少林组")
+3. 按Enter保存
+4. 预期结果: 名称更新成功
+```
+
+#### 测试3: 场地切换
+```
+1. 点击某个分组的"选择场地"下拉菜单
+2. 选择其他场地
+3. 预期结果: 分组移动到新场地
+```
+
+#### 测试4: 时间段切换
+```
+1. 点击不同的时间段按钮
+2. 预期结果: 显示对应时间段的分组列表
+```
+
+#### 测试5: 场地视图
+```
+1. 切换到"场地"Tab
+2. 预期结果:
+   - 显示每个场地的分组列表
+   - 显示每个分组的预计时长
+   - 统计汇总正确
+```
+
+### 4.2 边界测试
+
+| 测试项 | 操作 | 预期结果 |
+|--------|------|---------|
+| 无参赛者 | 点击自动编排 | 提示"没有未分组的参赛者" |
+| 无场地 | 点击自动分配场地 | 提示"请先配置场地信息" |
+| 空分组名称 | 保存空名称 | 保持原名称 |
+| 大量参赛者 | 1000人自动编排 | 正常处理,性能良好 |
+
+---
+
+## 5. 性能优化
+
+### 5.1 已实现的优化
+
+1. **项目信息缓存**
+   - 使用Map缓存项目详情
+   - 避免重复查询相同项目
+
+2. **批量处理**
+   - 一次性加载所有参赛者
+   - 批量分组和分配
+
+3. **算法优化**
+   - 使用Map进行分组,时间复杂度O(n)
+   - 负载均衡算法,时间复杂度O(n*m), n=分组数, m=场地数
+
+### 5.2 未来可优化
+
+1. **虚拟滚动**: 分组数量>100时使用虚拟滚动
+2. **防抖保存**: 拖拽操作延迟保存
+3. **懒加载**: 只加载当前时间段数据
+
+---
+
+## 6. 数据流转
+
+```
+用户操作
+  ↓
+前端Vue页面 (src/views/martial/schedule/index.vue)
+  ↓
+调用API (src/api/martial/...)
+  ↓
+后端接口 (待开发)
+  ↓
+数据库表 (martial_schedule, martial_schedule_detail)
+```
+
+---
+
+## 7. 待开发功能
+
+### 7.1 后端API接口
+
+需要创建以下接口 (参考文档第5章):
+
+1. **GET /api/martial/schedule/time-slots**
+   - 获取时间段列表
+
+2. **POST /api/martial/schedule/auto-group**
+   - 自动生成分组
+
+3. **PUT /api/martial/schedule/group/{groupId}/name**
+   - 更新分组名称
+
+4. **POST /api/martial/schedule/save**
+   - 保存编排结果 (草稿)
+
+5. **POST /api/martial/schedule/publish**
+   - 发布编排 (status=1)
+
+6. **POST /api/martial/schedule/auto-assign-venues**
+   - 自动分配场地
+
+7. **GET /api/martial/schedule/list**
+   - 获取已保存的编排
+
+### 7.2 功能增强
+
+1. **保存草稿**: 将编排数据保存到数据库
+2. **加载已保存编排**: 恢复之前的编排状态
+3. **发布编排**: 确认完成后发布
+4. **导出功能**: 导出Excel/PDF格式的赛程表
+5. **打印功能**: 打印秩序册
+
+---
+
+## 8. 文件清单
+
+### 已创建/修改的文件
+
+```
+✅ doc/schedule-system-analysis.md            # 系统设计文档 (1200+行)
+✅ doc/create_schedule_tables.sql             # 数据库表创建SQL
+✅ doc/schedule-feature-implementation.md     # 本文档
+✅ src/views/martial/schedule/index.vue       # 前端编排页面 (已完善)
+✅ test-data/batch_create_1000_participants.sql  # 测试数据
+✅ doc/batch-create-participants-guide.md     # 测试数据使用指南
+```
+
+### 待创建的文件 (后端)
+
+```
+❌ backend/api/schedule.js         # 赛程编排API接口
+❌ backend/service/schedule.js     # 赛程编排业务逻辑
+❌ backend/mapper/schedule.xml     # 赛程数据访问SQL
+```
+
+---
+
+## 9. 技术栈
+
+| 技术 | 版本 | 用途 |
+|------|------|------|
+| Vue 3 | - | 前端框架 |
+| Element Plus | - | UI组件库 |
+| vuedraggable | - | 拖拽功能 |
+| MySQL | 5.7+ | 数据库 |
+| SpringBoot | 2.x | 后端框架(待开发) |
+
+---
+
+## 10. 常见问题
+
+### Q1: 如何确定参赛者的项目类型?
+**A**: 通过查询 `martial_project` 表的 `type` 字段:
+- `type=1`: 个人项目
+- `type=2`: 集体项目
+
+### Q2: 个人项目为什么每组最多30人?
+**A**: 这是为了避免单组人数过多,比赛时间过长。可以在代码中修改 `maxPerGroup` 变量。
+
+### Q3: 如何自定义场地分配策略?
+**A**: 修改 `autoAssignVenues` 方法中的分配逻辑,可以考虑:
+- 场地容量限制
+- 项目类型匹配 (如集体项目分配到大场地)
+- 时间段容量限制
+
+### Q4: 分组编号规则是什么?
+**A**: GROUP_001, GROUP_002, ... 按生成顺序递增,集体项目编号在前。
+
+---
+
+## 11. 下一步计划
+
+### 阶段1: 后端接口开发 (优先级: 高)
+- [ ] 创建赛程编排相关API接口
+- [ ] 实现数据持久化
+- [ ] 实现加载已保存编排
+
+### 阶段2: 功能完善 (优先级: 中)
+- [ ] 保存草稿功能
+- [ ] 发布编排功能
+- [ ] 撤销/重做功能
+
+### 阶段3: 导出功能 (优先级: 中)
+- [ ] 导出Excel格式赛程表
+- [ ] 导出PDF格式秩序册
+- [ ] 二维码生成(选手扫码查看)
+
+### 阶段4: 优化和扩展 (优先级: 低)
+- [ ] 性能优化(虚拟滚动、懒加载)
+- [ ] 冲突检测(同一选手多项目)
+- [ ] 可视化增强(甘特图、热力图)
+
+---
+
+## 12. 联系与反馈
+
+如有问题或建议,请记录在项目Issue中。
+
+---
+
+**文档维护**:
+- 创建人: Claude Code
+- 创建日期: 2025-12-08
+- 版本: v1.0
+- 最后更新: 2025-12-08

doc/schedule/archive/schedule-performance-optimization.md

@@ -0,0 +1,265 @@
+# 赛程编排页面加载性能优化
+
+## 问题描述
+
+用户反馈：点击打开编排页面（`http://localhost:2888/api/martial/project/detail?id=200`）时出现大批量数据库查询，导致页面加载缓慢。
+
+## 原问题分析
+
+### 原实现方式（MartialScheduleServiceImpl.java:149-258）
+
+```java
+public ScheduleResultDTO getScheduleResult(Long competitionId) {
+    // 1. 查询所有分组
+    List<MartialScheduleGroup> groups = scheduleGroupMapper.selectList(...);
+
+    // 2. 查询所有编排明细
+    List<MartialScheduleDetail> details = scheduleDetailMapper.selectList(...);
+
+    // 3. 查询所有参赛者（使用 IN 查询）
+    List<MartialScheduleParticipant> participants = scheduleParticipantMapper.selectList(...);
+
+    // 4. 在内存中进行数据组装
+    // ...
+}
+```
+
+**性能问题**：
+- 执行了 **3 次独立的数据库查询**
+- <20><><EFBFBD>然使用了 IN 查询避免了 N+1 问题，但仍需要多次网络往返
+- 数据库需要执行 3 次查询计划，查询优化器无法统一优化
+- 数据传输量大，需要多次网络 IO
+
+## 优化方案
+
+### 使用单次 JOIN 查询获取所有数据
+
+#### 1. 创建优化的 VO <20><>
+
+新建文件：`ScheduleGroupDetailVO.java`
+
+```java
+@Data
+public class ScheduleGroupDetailVO implements Serializable {
+    // 分组信息
+    private Long groupId;
+    private String groupName;
+    private String category;
+    private Integer projectType;
+    private Integer totalTeams;
+    private Integer totalParticipants;
+    private Integer displayOrder;
+
+    // 编排明细信息
+    private Long detailId;
+    private Long venueId;
+    private String venueName;
+    private String timeSlot;
+
+    // 参赛者信息
+    private Long participantId;
+    private String organization;
+    private String checkInStatus;
+    private String scheduleStatus;
+    private Integer performanceOrder;
+}
+```
+
+#### 2. 添加自定义 Mapper 方法
+
+在 `MartialScheduleGroupMapper.java` 中添加：
+
+```java
+public interface MartialScheduleGroupMapper extends BaseMapper<MartialScheduleGroup> {
+    /**
+     * 查询赛程编排的完整详情（一次性JOIN查询，优化性能）
+     */
+    List<ScheduleGroupDetailVO> selectScheduleGroupDetails(@Param("competitionId") Long competitionId);
+}
+```
+
+#### 3. 实现优化的 SQL 查询
+
+在 `MartialScheduleGroupMapper.xml` 中实现：
+
+```xml
+<select id="selectScheduleGroupDetails" resultType="org.springblade.modules.martial.pojo.vo.ScheduleGroupDetailVO">
+    SELECT
+        g.id AS groupId,
+        g.group_name AS groupName,
+        g.category AS category,
+        g.project_type AS projectType,
+        g.total_teams AS totalTeams,
+        g.total_participants AS totalParticipants,
+        g.display_order AS displayOrder,
+        d.id AS detailId,
+        d.venue_id AS venueId,
+        d.venue_name AS venueName,
+        d.time_slot AS timeSlot,
+        p.id AS participantId,
+        p.organization AS organization,
+        p.check_in_status AS checkInStatus,
+        p.schedule_status AS scheduleStatus,
+        p.performance_order AS performanceOrder
+    FROM
+        martial_schedule_group g
+    LEFT JOIN
+        martial_schedule_detail d ON g.id = d.schedule_group_id AND d.is_deleted = 0
+    LEFT JOIN
+        martial_schedule_participant p ON g.id = p.schedule_group_id AND p.is_deleted = 0
+    WHERE
+        g.competition_id = #{competitionId}
+        AND g.is_deleted = 0
+    ORDER BY
+        g.display_order ASC,
+        p.performance_order ASC
+</select>
+```
+
+#### 4. 重写 Service 层方法
+
+修改 `MartialScheduleServiceImpl.getScheduleResult()` 方法：
+
+```java
+@Override
+public ScheduleResultDTO getScheduleResult(Long competitionId) {
+    // 使用优化的一次性JOIN查询获取所有数据
+    List<ScheduleGroupDetailVO> details = scheduleGroupMapper.selectScheduleGroupDetails(competitionId);
+
+    if (details.isEmpty()) {
+        // 返回空结果
+    }
+
+    // 按分组ID分组数据（在内存中处理，速度很快）
+    Map<Long, List<ScheduleGroupDetailVO>> groupMap = details.stream()
+        .collect(Collectors.groupingBy(ScheduleGroupDetailVO::getGroupId));
+
+    // 组装 DTO 返回
+    // ...
+}
+```
+
+## 优化效果
+
+### 数据库查询次数对比
+
+| 指标 | 优化前 | 优化后 | 提升 |
+|------|--------|--------|------|
+| SQL 查询次数 | 3 次 | **1 次** | **减少 66.7%** |
+| 网络往返次数 | 3 次 | **1 次** | **减少 66.7%** |
+| 查询优化 | 分散优化 | **统一优化** | 数据库可进行整体优化 |
+
+### 性能提升分析
+
+1. **减少网络开销**
+   - 从 3 次<><E6ACA1>络往返减少到 1 次
+   - 减少了 TCP 连接的建立和等待时间
+   - 降低了网络延迟的累积效应
+
+2. **数据库查询优化**
+   - 数据库可以对整个 JOIN 查询进行统一的执行计划优化
+   - 可以利用索引加速 JOIN 操作
+   - 减少了查询解析和编译的次数
+
+3. **数据传输优化**
+   - 虽然单次传输数据量可能略大，但总体网络 IO 更少
+   - 减少了协议头、认证等额外开销
+
+4. **应用层优化**
+   - 使用 Java Stream API 在内存中快速分组
+   - 内存操作速度远快于网络 IO
+
+### 预估性能提升
+
+假设场景：
+- 一个比赛有 20 个分组
+- 平均每个分组有 30 个参赛者
+- 单次数据库查询平均耗时 50ms
+
+**优化前**：
+- 3 次查询 × 50ms = 150ms
+- 加上网络延迟和 Java 处理 ≈ **200ms**
+
+**优化后**：
+- 1 次查询 × 80ms = 80ms（JOIN 查询稍慢）
+- 加上 Java 内存分组 ≈ **100ms**
+
+**性能提升**：约 **50%** 的响应时间减少
+
+## 实际应用建议
+
+### 何时使用这种优化
+
+✅ **适用场景**：
+- 需要同时查询多个关联表的数据
+- 数据量不是特别大（几千到几万条）
+- 需要减少网络往返次数
+- 关联关系明确，JOIN 条件简单
+
+⚠️ **不适用场景**：
+- 单表数据量超过 10 万条
+- JOIN 会产生笛卡尔积爆炸
+- 某些关联数据可选加载（懒加载更合适）
+
+### 进一步优化建议
+
+如果数据量继续增大，可以考虑：
+
+1. **分页加载**
+   - 前端使用虚拟滚动或分页
+   - 后端添加 LIMIT/OFFSET
+
+2. **缓存优化**
+   - 将常用的编排结果缓存到 Redis
+   - 设置合理的过期时间
+
+3. **数据库索引**
+   - 确保 `competition_id`, `schedule_group_id` 有索引
+   - 考虑添加联合索引加速 JOIN
+
+4. **读写分离**
+   - 查询走从库，减轻主库压力
+   - 使用 MyBatis Plus 的多数据源配置
+
+## 相关文件
+
+### 新增文件
+- `src/main/java/org/springblade/modules/martial/pojo/vo/ScheduleGroupDetailVO.java`
+
+### 修改文件
+- `src/main/java/org/springblade/modules/martial/mapper/MartialScheduleGroupMapper.java`
+- `src/main/java/org/springblade/modules/martial/mapper/MartialScheduleGroupMapper.xml`
+- `src/main/java/org/springblade/modules/martial/service/impl/MartialScheduleServiceImpl.java`
+
+## 测试验证
+
+### 如何测试
+
+1. **启动后端服务**
+   ```bash
+   cd martial-master
+   mvn spring-boot:run
+   ```
+
+2. **访问编排页面**
+   ```
+   http://localhost:2888/api/martial/project/detail?id=200
+   ```
+
+3. **查看数据库日志**
+   - 在 `application.yml` 中开启 SQL 日志
+   - 观察只执行了 1 次 JOIN 查询
+
+4. **性能对比**
+   - 使用浏览器开发者工具查看网络请求时间
+   - 对比优化前后的响应时间
+
+### 预期结果
+
+- 后端日志中只看到 1 条 SQL 查询语句
+- 页面加载速度明显提升
+- 数据显示正确，功能无异常
+
+## 总结
+
+这次优化通过将 **3 次独立查询合并为 1 次 JOIN 查询**，显著减少了数据库往返次数和网络 IO，预计可将页面加载时间减少约 50%。这是一种常见且有效的性能优化手段，特别适合需要关联多个表的查询场景。

doc/schedule/archive/schedule-system-design.md

@@ -0,0 +1,819 @@
+# 赛程编排系统设计文档
+
+## 📋 文档说明
+
+**版本**: v2.0
+**创建日期**: 2025-12-08
+**最后更新**: 2025-12-08
+**状态**: 设计阶段
+
+---
+
+## 1. 业务需求概述
+
+### 1.1 核心需求
+
+武术赛事管理系统需要实现**自动赛程编排功能**，将参赛者智能分配到不同的场地和时间段，确保比赛有序进行。
+
+### 1.2 关键特性
+
+- ✅ **后端自动编排**：使用Java后端定时任务自动编排，前端只负责展示
+- ✅ **集体优先原则**：集体项目优先编排，个人项目随后
+- ✅ **负载均衡**：均匀分配到所有场地和时间段
+- ✅ **定时刷新**：每10分钟自动重新编排（未保存状态）
+- ✅ **手动调整**：支持用户手动调整编排结果
+- ✅ **锁定机制**：保存后锁定，不再自动编排
+
+---
+
+## 2. 业务规则
+
+### 2.1 项目类型
+
+#### 集体项目（type=2）
+- **定义**：多人一场表演
+- **时长**：约5分钟/场
+- **场地占用**：独占整个场地
+- **示例**：太极拳男组（泰州太极拳小学：张三、李四、王五、小红、小花）
+- **分组规则**：按"项目+组别"分组，同一分组内按单位列出
+
+#### 个人项目（type=1）
+- **定义**：单人表演
+- **时长**：约1分钟/人
+- **场地占用**：场地可同时容纳6人
+- **示例**：太极拳个人男组（台州太极拳馆：洪坚立；泰州太极拳小学：李四）
+- **分组规则**：按"项目+组别"分组，不限人数
+
+### 2.2 时间段划分
+
+```
+每天分为两个时间段：
+- 上午场：08:30 - 11:30（180分钟，预留30分钟机动）
+- 下午场：13:30 - 17:30（240分钟，预留30分钟机动）
+
+实际可用时间：
+- 上午：150分钟（扣除间隔时间）
+- 下午：210分钟（扣除间隔时间）
+
+间隔时间：每场比赛间隔1-2分钟（选手准备）
+```
+
+### 2.3 编排优先级
+
+```
+优先级排序：
+1. 集体项目（type=2）
+2. 个人项目（type=1）
+
+同类型内部排序：
+- 按项目ID升序
+- 按组别（category）排序
+- 按报名时间先后
+```
+
+### 2.4 分配策略
+
+#### 场地分配
+- **集体项目**：每个分组独占一个场地时间段
+- **个人项目**：每个场地时间段可容纳多个分组（按6人/批次计算）
+
+#### 时间段分配
+- **负载均衡**：优先填充负载较轻的时间段
+- **连续性**：同一项目的多个分组尽量安排在相邻时间段
+- **容量检查**：确保不超过时间段容量
+
+#### 计算公式
+```
+集体项目占用时长 = 队伍数 × 5分钟 + (队伍数-1) × 2分钟间隔
+个人项目占用时长 = ⌈人数/6⌉ × (6分钟 + 2分钟间隔)
+
+场地时间段容量：
+- 上午：150分钟
+- 下午：210分钟
+```
+
+---
+
+## 3. 数据库设计
+
+### 3.1 编排主表
+
+```sql
+CREATE TABLE `martial_schedule_group` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+  `competition_id` bigint(20) NOT NULL COMMENT '赛事ID',
+  `group_name` varchar(200) NOT NULL COMMENT '分组名称：太极拳男组',
+  `project_id` bigint(20) NOT NULL COMMENT '项目ID',
+  `project_name` varchar(100) DEFAULT NULL COMMENT '项目名称',
+  `category` varchar(50) DEFAULT NULL COMMENT '组别：成年组、少年组',
+  `project_type` tinyint(1) NOT NULL DEFAULT '1' COMMENT '1=个人 2=集体',
+  `display_order` int(11) NOT NULL DEFAULT '0' COMMENT '显示顺序（集体优先）',
+  `total_participants` int(11) DEFAULT '0' COMMENT '总参赛人数',
+  `total_teams` int(11) DEFAULT '0' COMMENT '总队伍数（集体项目）',
+  `created_time` datetime DEFAULT CURRENT_TIMESTAMP,
+  `updated_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  KEY `idx_competition` (`competition_id`),
+  KEY `idx_project` (`project_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='赛程编排分组表';
+```
+
+### 3.2 编排明细表（场地时间段分配）
+
+```sql
+CREATE TABLE `martial_schedule_detail` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+  `schedule_group_id` bigint(20) NOT NULL COMMENT '分组ID',
+  `competition_id` bigint(20) NOT NULL COMMENT '赛事ID',
+  `venue_id` bigint(20) NOT NULL COMMENT '场地ID',
+  `venue_name` varchar(100) DEFAULT NULL COMMENT '场地名称',
+  `schedule_date` date NOT NULL COMMENT '比赛日期',
+  `time_period` varchar(20) NOT NULL COMMENT '时间段：morning/afternoon',
+  `time_slot` varchar(20) NOT NULL COMMENT '时间点：08:30/13:30',
+  `estimated_start_time` datetime DEFAULT NULL COMMENT '预计开始时间',
+  `estimated_end_time` datetime DEFAULT NULL COMMENT '预计结束时间',
+  `estimated_duration` int(11) DEFAULT '0' COMMENT '预计时长（分钟）',
+  `participant_count` int(11) DEFAULT '0' COMMENT '参赛人数',
+  `sort_order` int(11) DEFAULT '0' COMMENT '场内顺序',
+  `created_time` datetime DEFAULT CURRENT_TIMESTAMP,
+  `updated_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  KEY `idx_group` (`schedule_group_id`),
+  KEY `idx_venue_time` (`venue_id`, `schedule_date`, `time_slot`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='赛程编排明细表';
+```
+
+### 3.3 参赛者关联表
+
+```sql
+CREATE TABLE `martial_schedule_participant` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+  `schedule_detail_id` bigint(20) NOT NULL COMMENT '编排明细ID',
+  `schedule_group_id` bigint(20) NOT NULL COMMENT '分组ID',
+  `participant_id` bigint(20) NOT NULL COMMENT '参赛者ID',
+  `organization` varchar(200) DEFAULT NULL COMMENT '单位名称',
+  `player_name` varchar(100) DEFAULT NULL COMMENT '选手姓名',
+  `project_name` varchar(100) DEFAULT NULL COMMENT '项目名称',
+  `category` varchar(50) DEFAULT NULL COMMENT '组别',
+  `performance_order` int(11) DEFAULT '0' COMMENT '出场顺序',
+  `created_time` datetime DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  KEY `idx_detail` (`schedule_detail_id`),
+  KEY `idx_participant` (`participant_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='赛程编排参赛者关联表';
+```
+
+### 3.4 编排状态表
+
+```sql
+CREATE TABLE `martial_schedule_status` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+  `competition_id` bigint(20) NOT NULL UNIQUE COMMENT '赛事ID',
+  `schedule_status` tinyint(1) NOT NULL DEFAULT '0' COMMENT '0=未编排 1=编排中 2=已保存锁定',
+  `last_auto_schedule_time` datetime DEFAULT NULL COMMENT '最后自动编排时间',
+  `locked_time` datetime DEFAULT NULL COMMENT '锁定时间',
+  `locked_by` varchar(100) DEFAULT NULL COMMENT '锁定人',
+  `total_groups` int(11) DEFAULT '0' COMMENT '总分组数',
+  `total_participants` int(11) DEFAULT '0' COMMENT '总参赛人数',
+  `created_time` datetime DEFAULT CURRENT_TIMESTAMP,
+  `updated_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_competition` (`competition_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='赛程编排状态表';
+```
+
+---
+
+## 4. 后端编排算法设计
+
+### 4.1 算法流程
+
+```
+┌─────────────────────────────────────────┐
+│  定时任务：每10分钟执行一次              │
+└─────────────────┬───────────────────────┘
+                  │
+                  ▼
+┌─────────────────────────────────────────┐
+│  1. 检查赛事状态                         │
+│     - 如果已锁定(status=2)，跳过         │
+│     - 如果未开始，继续                   │
+└─────────────────┬───────────────────────┘
+                  │
+                  ▼
+┌─────────────────────────────────────────┐
+│  2. 加载数据                             │
+│     - 赛事信息（开始/结束时间）          │
+│     - 场地列表                           │
+│     - 参赛者列表                         │
+└─────────────────┬───────────────────────┘
+                  │
+                  ▼
+┌─────────────────────────────────────────┐
+│  3. 生成时间段网格                       │
+│     - 计算比赛天数                       │
+│     - 生成所有时间段（上午/下午）        │
+└─────────────────┬───────────────────────┘
+                  │
+                  ▼
+┌─────────────────────────────────────────┐
+│  4. 自动分组                             │
+│     - 集体项目按"项目+组别"分组          │
+│     - 个人项目按"项目+组别"分组          │
+│     - 集体项目排在前面                   │
+└─────────────────┬───────────────────────┘
+                  │
+                  ▼
+┌─────────────────────────────────────────┐
+│  5. 分配场地和时间段（负载均衡）         │
+│     - 初始化所有场地×时间段的负载        │
+│     - 按时长降序处理分组                 │
+│     - 贪心算法：选择负载最小的位置       │
+└─────────────────┬───────────────────────┘
+                  │
+                  ▼
+┌─────────────────────────────────────────┐
+│  6. 保存到数据库                         │
+│     - 清空旧的编排数据                   │
+│     - 插入新的编排结果                   │
+│     - 更新编排状态                       │
+└─────────────────────────────────────────┘
+```
+
+### 4.2 核心算法伪代码
+
+#### 4.2.1 自动分组算法
+
+```java
+public List<ScheduleGroup> autoGroupParticipants(List<Participant> participants) {
+    List<ScheduleGroup> groups = new ArrayList<>();
+    int displayOrder = 1;
+
+    // 1. 分离集体和个人项目
+    List<Participant> teamParticipants = participants.stream()
+        .filter(p -> p.getProjectType() == 2)
+        .collect(Collectors.toList());
+
+    List<Participant> individualParticipants = participants.stream()
+        .filter(p -> p.getProjectType() == 1)
+        .collect(Collectors.toList());
+
+    // 2. 集体项目分组：按"项目ID_组别"分组
+    Map<String, List<Participant>> teamGroupMap = teamParticipants.stream()
+        .collect(Collectors.groupingBy(p ->
+            p.getProjectId() + "_" + p.getCategory()
+        ));
+
+    for (Map.Entry<String, List<Participant>> entry : teamGroupMap.entrySet()) {
+        List<Participant> members = entry.getValue();
+        Participant first = members.get(0);
+
+        // 统计队伍数（按单位分组）
+        long teamCount = members.stream()
+            .map(Participant::getOrganization)
+            .distinct()
+            .count();
+
+        ScheduleGroup group = new ScheduleGroup();
+        group.setGroupName(first.getProjectName() + " " + first.getCategory());
+        group.setProjectId(first.getProjectId());
+        group.setProjectType(2);
+        group.setDisplayOrder(displayOrder++);
+        group.setTotalParticipants(members.size());
+        group.setTotalTeams((int) teamCount);
+        group.setParticipants(members);
+
+        // 计算预计时长：队伍数 × 5分钟 + 间隔时间
+        int duration = (int) teamCount * 5 + ((int) teamCount - 1) * 2;
+        group.setEstimatedDuration(duration);
+
+        groups.add(group);
+    }
+
+    // 3. 个人项目分组：按"项目ID_组别"分组
+    Map<String, List<Participant>> individualGroupMap = individualParticipants.stream()
+        .collect(Collectors.groupingBy(p ->
+            p.getProjectId() + "_" + p.getCategory()
+        ));
+
+    for (Map.Entry<String, List<Participant>> entry : individualGroupMap.entrySet()) {
+        List<Participant> members = entry.getValue();
+        Participant first = members.get(0);
+
+        ScheduleGroup group = new ScheduleGroup();
+        group.setGroupName(first.getProjectName() + " " + first.getCategory());
+        group.setProjectId(first.getProjectId());
+        group.setProjectType(1);
+        group.setDisplayOrder(displayOrder++);
+        group.setTotalParticipants(members.size());
+        group.setParticipants(members);
+
+        // 计算预计时长：人数/6（向上取整）× (6分钟 + 2分钟间隔)
+        int batches = (int) Math.ceil(members.size() / 6.0);
+        int duration = batches * 8;
+        group.setEstimatedDuration(duration);
+
+        groups.add(group);
+    }
+
+    return groups;
+}
+```
+
+#### 4.2.2 场地时间段分配算法（负载均衡）
+
+```java
+public void assignVenueAndTimeSlot(List<ScheduleGroup> groups,
+                                    List<Venue> venues,
+                                    List<TimeSlot> timeSlots) {
+
+    // 1. 初始化负载表（场地 × 时间段）
+    Map<String, Integer> loadMap = new HashMap<>();
+    for (Venue venue : venues) {
+        for (TimeSlot timeSlot : timeSlots) {
+            String key = venue.getId() + "_" + timeSlot.getKey();
+            loadMap.put(key, 0);
+        }
+    }
+
+    // 2. 获取时间段容量
+    Map<String, Integer> capacityMap = new HashMap<>();
+    for (TimeSlot timeSlot : timeSlots) {
+        int capacity = timeSlot.getPeriod().equals("morning") ? 150 : 210;
+        capacityMap.put(timeSlot.getKey(), capacity);
+    }
+
+    // 3. 按预计时长降序排序（先安排时间长的）
+    groups.sort((a, b) -> b.getEstimatedDuration() - a.getEstimatedDuration());
+
+    // 4. 贪心算法分配
+    for (ScheduleGroup group : groups) {
+        String bestKey = null;
+        int minLoad = Integer.MAX_VALUE;
+
+        // 遍历所有场地×时间段组合
+        for (Venue venue : venues) {
+            for (TimeSlot timeSlot : timeSlots) {
+                String key = venue.getId() + "_" + timeSlot.getKey();
+                int currentLoad = loadMap.get(key);
+                int capacity = capacityMap.get(timeSlot.getKey());
+
+                // 检查容量是否足够
+                if (currentLoad + group.getEstimatedDuration() <= capacity) {
+                    if (currentLoad < minLoad) {
+                        minLoad = currentLoad;
+                        bestKey = key;
+                    }
+                }
+            }
+        }
+
+        // 分配到最佳位置
+        if (bestKey != null) {
+            String[] parts = bestKey.split("_");
+            long venueId = Long.parseLong(parts[0]);
+            String timeSlotKey = parts[1];
+
+            group.setVenueId(venueId);
+            group.setTimeSlotKey(timeSlotKey);
+
+            // 更新负载
+            loadMap.put(bestKey, loadMap.get(bestKey) + group.getEstimatedDuration());
+        }
+    }
+}
+```
+
+### 4.3 算法复杂度分析
+
+- **自动分组算法**: O(n)，n为参赛者数量
+- **场地分配算法**: O(g × v × t)，g为分组数，v为场地数，t为时间段数
+- **总体复杂度**: O(n + g×v×t)
+
+对于1000人，5个场地，10个时间段：
+- 分组: O(1000) ≈ 1ms
+- 分配: O(100×5×10) = O(5000) ≈ 5ms
+- **总耗时**: < 10ms
+
+---
+
+## 5. 前端展示设计
+
+### 5.1 页面布局
+
+```
+┌────────────────────────────────────────────────────────────┐
+│  编排 - 郑州协会全国运动大赛                [返回]           │
+└────────────────────────────────────────────────────────────┘
+┌────────────────────────────────────────────────────────────┐
+│  [竞赛分组] [场地]                                           │
+└────────────────────────────────────────────────────────────┘
+
+┌────────────────────────────────────────────────────────────┐
+│  竞赛分组内容区                                              │
+│                                                             │
+│  ┌─────────────────────────────────────────────────────┐   │
+│  │  1. 太极拳男组  集体  2队  2组  1101               │   │
+│  │  ┌─────────────────────────────────────────────┐   │   │
+│  │  │  1. 少林寺武校                              │   │   │
+│  │  │     [场A  2025-11-06 08:30] [场A  2025-11-06 13:30] ...│
+│  │  │  2. 洛阳武校                                │   │   │
+│  │  │     [场B  2025-11-06 08:30] [场B  2025-11-06 13:30] ...│
+│  │  └─────────────────────────────────────────────┘   │   │
+│  └─────────────────────────────────────────────────────┘   │
+│                                                             │
+│  ┌─────────────────────────────────────────────────────┐   │
+│  │  2. 长拳个人男组  个人  3人  1个A  1102            │   │
+│  │  ┌─────────────────────────────────────────────┐   │   │
+│  │  │  1. 少林寺武校  张三                        │   │   │
+│  │  │     [场A  2025-11-06 08:30]                │   │   │
+│  │  │  2. 洛阳武校  李四                          │   │   │
+│  │  │     [场A  2025-11-06 08:30]                │   │   │
+│  │  │  3. 少林寺武校  王五                        │   │   │
+│  │  │     [场B  2025-11-06 13:30]                │   │   │
+│  │  └─────────────────────────────────────────────┘   │   │
+│  └─────────────────────────────────────────────────────┘   │
+└────────────────────────────────────────────────────────────┘
+
+┌────────────────────────────────────────────────────────────┐
+│                          [保存编排]                          │
+└────────────────────────────────────────────────────────────┘
+```
+
+### 5.2 数据结构
+
+```javascript
+// 前端数据结构
+{
+  competitionInfo: {
+    competitionId: 200,
+    competitionName: "郑州协会全国运动大赛",
+    startDate: "2025-11-06",
+    endDate: "2025-11-10"
+  },
+
+  scheduleGroups: [
+    {
+      id: 1,
+      groupName: "太极拳男组",
+      projectType: 2, // 集体
+      displayOrder: 1,
+      totalParticipants: 10,
+      totalTeams: 2,
+
+      // 按单位组织的参赛者（集体项目）
+      organizationGroups: [
+        {
+          organization: "少林寺武校",
+          participants: [
+            { id: 1, playerName: "张三", ... },
+            { id: 2, playerName: "李四", ... }
+          ],
+          scheduleDetails: [
+            {
+              venueId: 1,
+              venueName: "场A",
+              scheduleDate: "2025-11-06",
+              timePeriod: "morning",
+              timeSlot: "08:30"
+            }
+          ]
+        },
+        {
+          organization: "洛阳武校",
+          participants: [...],
+          scheduleDetails: [...]
+        }
+      ]
+    },
+
+    {
+      id: 2,
+      groupName: "长拳个人男组",
+      projectType: 1, // 个人
+      displayOrder: 2,
+      totalParticipants: 3,
+
+      // 个人项目直接列出参赛者
+      participants: [
+        {
+          id: 10,
+          organization: "少林寺武校",
+          playerName: "张三",
+          scheduleDetail: {
+            venueId: 1,
+            venueName: "场A",
+            scheduleDate: "2025-11-06",
+            timePeriod: "morning",
+            timeSlot: "08:30"
+          }
+        },
+        {
+          id: 11,
+          organization: "洛阳武校",
+          playerName: "李四",
+          scheduleDetail: {...}
+        }
+      ]
+    }
+  ]
+}
+```
+
+### 5.3 场地按钮点击交互
+
+当用户点击某个场地时间段按钮时：
+
+```javascript
+handleVenueTimeClick(participant, scheduleDetail) {
+  // 弹出对话框显示该时间段该场地的详细信息
+  this.$alert(`
+    <h3>场地详情</h3>
+    <p>场地: ${scheduleDetail.venueName}</p>
+    <p>时间: ${scheduleDetail.scheduleDate} ${scheduleDetail.timeSlot}</p>
+    <p>参赛者: ${participant.organization} - ${participant.playerName}</p>
+    <p>项目: ${participant.projectName}</p>
+  `, '场地时间段详情', {
+    dangerouslyUseHTMLString: true
+  });
+}
+```
+
+---
+
+## 6. 后端定时任务设计
+
+### 6.1 定时任务配置
+
+```java
+@Component
+@EnableScheduling
+public class ScheduleAutoArrangeTask {
+
+    @Autowired
+    private IScheduleService scheduleService;
+
+    /**
+     * 每10分钟执行一次自动编排
+     * cron: 0 */10 * * * ?
+     */
+    @Scheduled(cron = "0 */10 * * * ?")
+    public void autoArrangeSchedule() {
+        log.info("开始执行自动编排任务...");
+
+        try {
+            // 查询所有未锁定的赛事
+            List<Long> competitionIds = scheduleService.getUnlockedCompetitions();
+
+            for (Long competitionId : competitionIds) {
+                try {
+                    // 执行自动编排
+                    scheduleService.autoArrange(competitionId);
+                    log.info("赛事[{}]自动编排完成", competitionId);
+                } catch (Exception e) {
+                    log.error("赛事[{}]自动编排失败", competitionId, e);
+                }
+            }
+
+        } catch (Exception e) {
+            log.error("自动编排任务执行失败", e);
+        }
+    }
+}
+```
+
+### 6.2 编排服务接口
+
+```java
+public interface IScheduleService {
+
+    /**
+     * 自动编排
+     * @param competitionId 赛事ID
+     */
+    void autoArrange(Long competitionId);
+
+    /**
+     * 获取未锁定的赛事列表
+     * @return 赛事ID列表
+     */
+    List<Long> getUnlockedCompetitions();
+
+    /**
+     * 保存编排（锁定）
+     * @param competitionId 赛事ID
+     * @param userId 用户ID
+     */
+    void saveAndLock(Long competitionId, String userId);
+
+    /**
+     * 获取编排结果
+     * @param competitionId 赛事ID
+     * @return 编排数据
+     */
+    ScheduleResult getScheduleResult(Long competitionId);
+
+    /**
+     * 手动调整编排
+     * @param adjustRequest 调整请求
+     */
+    void adjustSchedule(ScheduleAdjustRequest adjustRequest);
+}
+```
+
+---
+
+## 7. API接口设计
+
+### 7.1 获取编排结果
+
+```
+GET /api/martial/schedule/result/{competitionId}
+
+Response:
+{
+  "code": 200,
+  "msg": "success",
+  "data": {
+    "competitionId": 200,
+    "scheduleStatus": 1,  // 0=未编排 1=编排中 2=已锁定
+    "lastAutoScheduleTime": "2025-11-06 10:00:00",
+    "totalGroups": 45,
+    "totalParticipants": 1100,
+    "scheduleGroups": [
+      {
+        "id": 1,
+        "groupName": "太极拳男组",
+        "projectType": 2,
+        "displayOrder": 1,
+        "organizationGroups": [...]
+      },
+      ...
+    ]
+  }
+}
+```
+
+### 7.2 保存并锁定编排
+
+```
+POST /api/martial/schedule/save-and-lock
+
+Request:
+{
+  "competitionId": 200,
+  "userId": "admin"
+}
+
+Response:
+{
+  "code": 200,
+  "msg": "编排已保存并锁定"
+}
+```
+
+### 7.3 手动调整编排
+
+```
+POST /api/martial/schedule/adjust
+
+Request:
+{
+  "competitionId": 200,
+  "participantId": 123,
+  "targetVenueId": 2,
+  "targetDate": "2025-11-06",
+  "targetTimeSlot": "13:30"
+}
+
+Response:
+{
+  "code": 200,
+  "msg": "调整成功"
+}
+```
+
+---
+
+## 8. 测试数据设计
+
+### 8.1 集体项目测试数据
+
+需要生成100个集体项目的参赛队伍：
+
+```
+项目分布：
+- 太极拳（集体）：20个单位
+- 长拳（集体）：20个单位
+- 剑术（集体）：20个单位
+- 刀术（集体）：20个单位
+- 棍术（集体）：20个单位
+
+每个单位5人，共100个队伍，500人
+```
+
+### 8.2 测试数据总计
+
+```
+原有个人项目：1000人
+新增集体项目：500人（100个队伍）
+总计：1500人
+
+预计分组：
+- 集体项目分组：约20个（按项目+组别）
+- 个人项目分组：约25个
+- 总计：约45个分组
+```
+
+---
+
+## 9. 技术实现要点
+
+### 9.1 后端技术栈
+
+- **Spring Boot**: 2.x
+- **MyBatis-Plus**: 数据访问
+- **Quartz**: 定时任务调度
+- **Redis**: 编排结果缓存（可选）
+
+### 9.2 前端技术栈
+
+- **Vue 3**: 前端框架
+- **Element Plus**: UI组件
+- **Axios**: HTTP请求
+
+### 9.3 性能优化
+
+1. **批量查询**：一次性加载所有参赛者
+2. **结果缓存**：编排结果缓存10分钟
+3. **增量编排**：只对新增参赛者进行增量编排（可选）
+4. **索引优化**：场地、时间段联合索引
+
+---
+
+## 10. 实施计划
+
+### 阶段1：数据库和测试数据（第1天）
+- ✅ 创建数据库表
+- ✅ 生成集体项目测试数据
+- ✅ 验证数据完整性
+
+### 阶段2：后端编排算法（第2-3天）
+- ⏳ 实现自动分组算法
+- ⏳ 实现场地时间段分配算法
+- ⏳ 实现定时任务
+- ⏳ 单元测试
+
+### 阶段3：后端API接口（第4天）
+- ⏳ 获取编排结果接口
+- ⏳ 保存锁定接口
+- ⏳ 手动调整接口
+
+### 阶段4：前端展示页面（第5-6天）
+- ⏳ 修改页面布局
+- ⏳ 实现集体/个人不同展示
+- ⏳ 实现场地时间段按钮点击
+- ⏳ 集成后端API
+
+### 阶段5：测试和优化（第7天）
+- ⏳ 功能测试
+- ⏳ 性能测试
+- ⏳ 用户验收测试
+
+---
+
+## 11. 风险和注意事项
+
+### 11.1 容量不足风险
+
+**风险**：参赛人数过多，所有场地时间段容量不足
+
+**解决方案**：
+- 编排前进行容量校验
+- 提示用户增加比赛天数或场地
+- 自动建议最少需要的天数
+
+### 11.2 数据一致性
+
+**风险**：定时任务执行时用户正在查看页面
+
+**解决方案**：
+- 前端轮询检查编排时间戳
+- 如有更新，提示用户刷新
+- 锁定状态下不再自动编排
+
+### 11.3 并发冲突
+
+**风险**：多个定时任务同时执行
+
+**解决方案**：
+- 使用分布式锁（Redis）
+- 数据库乐观锁
+- 任务执行状态标记
+
+---
+
+**文档版本**: v2.0
+**创建人**: Claude Code
+**审核人**: 待定
+**状态**: 设计中

doc/schedule/archive/schedule-ui-test-guide.md

@@ -0,0 +1,194 @@
+# 赛程编排界面测试指南
+
+## 测试前准备
+
+### 1. 启动前端服务
+```bash
+cd D:\workspace\31.比赛项目\project\martial-web
+npm run dev
+```
+
+访问地址: http://localhost:5173 (或控制台显示的端口)
+
+### 2. 确认后端服务运行
+- 后端地址: http://localhost:8123
+- 确认赛事ID: 200 (或其他已有赛程数据的赛事)
+
+## 测试场景
+
+### 场景1: 竞赛分组Tab界面测试
+
+#### 测试步骤
+1. 进入赛程编排页面
+2. 确认默认显示"竞赛分组"Tab
+3. 检查时间段选择器显示是否正确
+4. 点击不同时间段按钮,观察分组数据是否正确切换
+
+#### 预期结果
+✅ 分组显示为紧凑列表格式
+✅ 每个分组标题格式: "序号. 项目名称 [类型标签] 队伍数 人数 编号"
+✅ 集体项目子项格式: "序号. 单位名称 [场地标签]"
+✅ 个人项目子项格式: "序号. 单位-姓名 [场地标签]"
+✅ 场地标签显示为小标签(如"场A场")
+✅ 时间段切换时数据正确过滤
+
+#### 对比参考图片
+- 参考图片: `doc/image/订单管理页面/微信图片_20251127165909_228_2.png`
+- 检查点:
+  - 布局是否紧凑
+  - 序号是否显示
+  - 场地标签是否内联显示
+  - 颜色样式是否协调
+
+### 场景2: 场地Tab界面测试
+
+#### 测试步骤
+1. 点击"场地"Tab切换
+2. 确认显示时间段选择器
+3. 观察场地分区是否正确显示
+4. 检查每个场地的标题样式
+5. 检查每个场地的表格内容
+6. 点击不同时间段,观察各场地表格数据变化
+
+#### 预期结果
+✅ 显示多个场地分区(一号场地、二号场地等)
+✅ 每个场地标题有蓝色背景
+✅ 每个场地显示独立的表格
+✅ 表格列包含: 序号、项目、单人/集体、队伍、组数、合并场、序号
+✅ "单人/集体"列显示带颜色的标签
+✅ 集体项目按单位展开为多行
+✅ 个人项目整个分组显示为一行
+✅ 时间段切换时表格数据正确过滤
+✅ 某场地无数据时显示空数据提示
+
+#### 对比参考图片
+- 参考图片: `doc/image/订单管理页面/微信图片_20251127165915_229_2.png`
+- 检查点:
+  - 场地分区是否清晰
+  - 场地标题样式是否匹配(蓝色背景)
+  - 表格列是否对齐
+  - 表格边框是否显示
+  - 数据是否正确填充
+
+### 场景3: 数据过滤测试
+
+#### 测试步骤
+1. 在"竞赛分组"Tab选择不同时间段
+2. 记录显示的分组数量
+3. 切换到"场地"Tab
+4. 确认相同时间段,各场地表格数据总和与竞赛分组数量一致
+5. 切换不同时间段,重复验证
+
+#### 预期结果
+✅ 两个Tab的时间段选择器状态保持同步
+✅ 同一时间段,两个Tab显示的数据应该对应
+✅ 数据过滤准确,无遗漏或重复
+
+### 场景4: 空数据测试
+
+#### 测试步骤
+1. 选择一个没有赛程的时间段
+2. 观察"竞赛分组"Tab显示
+3. 观察"场地"Tab显示
+
+#### 预期结果
+✅ "竞赛分组"Tab显示空数据提示
+✅ "场地"Tab各场地显示空数据提示
+✅ 空数据提示美观清晰
+
+### 场景5: 大数据量测试
+
+#### 测试步骤
+1. 使用有大量参赛者的赛事(如测试赛事ID: 200, 1000人)
+2. 检查页面加载速度
+3. 检查表格滚动是否流畅
+4. 检查数据显示是否完整
+
+#### 预期结果
+✅ 页面加载无明显卡顿
+✅ 表格滚动流畅
+✅ 所有数据正确显示
+✅ 序号连续无跳号
+
+### 场景6: 功能按钮测试
+
+#### 测试步骤
+1. 点击"刷新"按钮
+2. 点击"保存编排"按钮(如果状态允许)
+3. 观察状态标签变化
+
+#### 预期结果
+✅ 刷新按钮正常工作
+✅ 保存按钮正常工作
+✅ 状态标签正确显示(未编排/编排中/已锁定)
+
+## 兼容性测试
+
+### 浏览器测试
+- [ ] Chrome (最新版)
+- [ ] Edge (最新版)
+- [ ] Firefox (最新版)
+
+### 分辨率测试
+- [ ] 1920x1080
+- [ ] 1366x768
+- [ ] 1280x720
+
+## 问题记录
+
+### 界面问题
+| 序号 | 问题描述 | 严重程度 | 截图 | 状态 |
+|------|----------|----------|------|------|
+| 1 | | | | |
+
+### 数据问题
+| 序号 | 问题描述 | 严重程度 | 截图 | 状态 |
+|------|----------|----------|------|------|
+| 1 | | | | |
+
+### 功能问题
+| 序号 | 问题描述 | 严重程度 | 截图 | 状态 |
+|------|----------|----------|------|------|
+| 1 | | | | |
+
+## 性能指标
+
+### 页面加载
+- [ ] 初始加载时间 < 2秒
+- [ ] Tab切换响应 < 500毫秒
+- [ ] 时间段切换响应 < 500毫秒
+
+### 数据渲染
+- [ ] 100人以下: 即时渲染
+- [ ] 100-500人: < 1秒
+- [ ] 500-1000人: < 2秒
+- [ ] 1000人以上: < 3秒
+
+## 验收标准
+
+### 必须满足
+✅ 界面布局与参考图片一致
+✅ 所有功能正常工作
+✅ 数据显示准确无误
+✅ 无明显性能问题
+✅ 无控制台错误
+
+### 建议满足
+✅ 页面加载流畅
+✅ 动画过渡自然
+✅ 空数据提示友好
+✅ 多浏览器兼容
+
+## 测试完成确认
+
+- [ ] 所有测试场景已执行
+- [ ] 所有问题已记录
+- [ ] 严重问题已修复
+- [ ] 功能验收通过
+- [ ] 界面验收通过
+
+---
+
+**测试人员**: _____________
+**测试日期**: _____________
+**测试版本**: _____________

doc/schedule/archive/schedule-ui-update-summary.md

@@ -0,0 +1,230 @@
+# 赛程编排界面更新总结
+
+## 更新时间
+2025-12-09
+
+## 更新目标
+根据参考图片修改赛程编排页面的显示界面,使其更加简洁紧凑,同时保持所有现有业务逻辑不变。
+
+## 参考图片
+1. `doc/image/订单管理页面/微信图片_20251127165909_228_2.png` - 竞赛分组Tab界面
+2. `doc/image/订单管理页面/微信图片_20251127165915_229_2.png` - 场地Tab界面
+
+## 主要改动
+
+### 1. 竞赛分组Tab (Competition Grouping Tab)
+
+#### 改动前
+- 使用卡片式布局展示分组
+- 场地时间信息显示为按钮
+- 布局较为分散,占用空间较大
+
+#### 改动后
+- 采用紧凑列表布局
+- 分组标题显示为:"序号. 项目名称 类型标签 队伍数 人数 编号"
+- 集体项目:子项显示为"序号. 单位名称 场地标签..."
+- 个人项目:子项显示为"序号. 单位-姓名 场地标签"
+- 场地信息以小标签形式内联显示(如"场A场")
+
+#### 新增样式类
+- `.groups-list-compact` - 紧凑列表容器
+- `.group-item-compact` - 分组项
+- `.group-header-compact` - 分组标题区
+- `.group-number` - 序号样式
+- `.group-title-text` - 标题文本
+- `.group-type-badge` - 类型标签(集体/个人)
+- `.group-meta-text` - 元信息文本
+- `.team-list-compact` - 集体项目队伍列表
+- `.team-item-compact` - 队伍项
+- `.individual-list-compact` - 个人项目列表
+- `.individual-item-compact` - 个人项
+- `.venue-labels` - 场地标签容器
+- `.venue-label` - 单个场地标签
+
+### 2. 场地Tab (Venue Tab)
+
+#### 改动前
+- 按场地分区显示,每个场地一个大卡片
+- 每个场地内显示该场地的所有分组
+- 使用与竞赛分组Tab相同的卡片布局
+
+#### 改动后
+- **按场地分区显示**,保持场地分区结构
+- 添加时间段选择器(与竞赛分组Tab一致)
+- 每个场地显示一个**独立的表格**
+- 场地标题采用蓝色背景样式
+- 使用Element Plus的`el-table`组件
+- 表格列:
+  - 序号 (80px, 居中)
+  - 项目 (最小200px)
+  - 单人/集体 (100px, 居中, 带标签)
+  - 队伍 (80px, 居中)
+  - 组数 (80px, 居中)
+  - 合并场 (100px, 居中)
+  - 序号 (100px, 居中)
+
+#### 新增计算属性
+```javascript
+venueTableDataByVenue() {
+  // 按场地生成表格数据数组
+  // 每个场地一个对象: { venueId, venueName, tableData }
+  // 根据当前选中时间段过滤该场地的分组
+  // 集体项目:按单位(organizationGroups)生成行
+  // 个人项目:整个分组作为一行
+}
+```
+
+#### 新增样式类
+- `.venue-section-table` - 场地分区容器
+- `.venue-header` - 场地标题(蓝色背景)
+- `.empty-venue` - 场地无数据提示
+- `.venue-table-container` - 表格容器
+- Element Plus表格样式覆盖
+
+### 3. 公共改进
+
+#### 时间段选择器
+- 两个Tab都显示时间段选择器
+- 选中的时间段高亮显示
+- 根据选中时间段过滤显示的数据
+
+#### 样式优化
+- 统一使用更紧凑的间距
+- 调整颜色方案以匹配参考图片
+- 使用内联标签代替按钮显示场地信息
+- 优化字体大小和权重
+
+## 文件修改
+
+### 修改的文件
+- `src/views/martial/schedule/index.vue`
+
+### 具体修改内容
+
+#### Template部分
+1. **竞赛分组Tab** (行 38-113)
+   - 重写分组列表结构为紧凑布局
+   - 移除按钮,使用标签显示场地
+   - 简化嵌套结构
+
+2. **场地Tab** (行 115-172)
+   - 保持场地分区结构
+   - 每个场地显示独立表格
+   - 添加时间段选择器
+   - 使用`el-table`组件
+   - 添加场地标题和空数据提示
+
+#### Script部分
+1. **computed属性** (行 238-331)
+   - 保留`currentTimeSlotGroups`
+   - 保留`groupsByVenue`
+   - 新增`venueTableDataByVenue` - 按场地生成表格数据数组
+
+#### Style部分 (行 527-775)
+1. 完全重写样式
+2. 移除旧的`.groups-list`相关样式
+3. 新增`.groups-list-compact`相关样式
+4. 新增`.venue-section-table`相关样式(场地分区+表格)
+5. 保持页面整体布局样式不变
+
+## 保持不变的功能
+
+### 数据加载
+- `loadCompetitionInfo()` - 加载赛事信息
+- `loadVenues()` - 加载场地列表
+- `loadScheduleResult()` - 加载编排结果
+- `generateTimeSlots()` - 生成时间段
+
+### 业务逻辑
+- 自动编排逻辑(后端)
+- 数据结构(scheduleGroups)
+- API调用
+- 保存和锁定功能
+- 刷新功能
+
+### 删除的功能
+- 场地详情对话框相关代码(场地信息已直接在表格中显示)
+- `handleVenueDetailClick()` 方法(不再需要)
+- `handleParticipantDetailClick()` 方法(不再需要)
+- 相关的dialog组件(不再需要)
+
+## 兼容性说明
+
+### 数据结构兼容
+完全兼容现有后端API返回的数据结构:
+- `scheduleGroups` 数组
+- `organizationGroups` (集体项目)
+- `participants` (个人项目)
+- `scheduleDetails` 场地时间信息
+
+### 功能兼容
+- 所有后端API保持不变
+- 所有业务逻辑保持不变
+- 仅UI展示方式改变
+
+## 测试建议
+
+### 界面测试
+1. 检查竞赛分组Tab显示是否正确
+2. 检查场地Tab表格显示是否正确
+3. 测试时间段切换功能
+4. 测试Tab切换功能
+5. 检查在不同数据量下的显示效果
+
+### 数据测试
+1. 测试无数据情况
+2. 测试集体项目数据
+3. 测试个人项目数据
+4. 测试混合数据
+5. 测试大数据量(1000+参赛者)
+
+### 功能测试
+1. 测试刷新功能
+2. 测试保存编排功能
+3. 测试锁定状态显示
+4. 测试导出功能
+
+## 后续优化建议
+
+### 功能增强
+1. 添加表格排序功能
+2. 添加表格搜索/过滤功能
+3. 添加分页功能(数据量大时)
+4. 支持拖拽调整分组顺序
+
+### 交互优化
+1. 添加点击表格行显示详情
+2. 添加右键菜单快捷操作
+3. 添加批量编辑功能
+4. 添加场地冲突高亮提示
+
+### 导出功能
+1. 支持导出为Excel
+2. 支持导出为PDF
+3. 支持打印预览
+4. 支持自定义导出模板
+
+## 总结
+
+本次更新成功将赛程编排界面改造为更加紧凑清晰的布局,主要亮点:
+
+✅ 竞赛分组Tab采用紧凑列表,信息密度更高
+✅ 场地Tab保持场地分区结构,每个场地显示独立表格
+✅ 两个Tab都支持时间段筛选
+✅ 场地标题采用醒目的蓝色背景样式
+✅ 保持所有现有业务逻辑不变
+✅ 完全兼容现有后端API
+✅ 样式清晰,符合参考图片要求
+
+**关键改进点:**
+- 场地Tab按"一号场地"、"二号场地"等分区显示
+- 每个场地区域内显示该场地的赛程表格
+- 表格数据根据选中的时间段动态过滤
+- 集体项目按单位(队伍)展开为多行
+- 个人项目整个分组显示为一行
+
+---
+
+**修改人**: Claude Code
+**修改日期**: 2025-12-09
+**文件位置**: `src/views/martial/schedule/index.vue`

doc/schedule/implementation-summary.md

@@ -0,0 +1,442 @@
+# 编排功能实施总结
+
+> **完成日期**: 2025-12-11
+> **实施人员**: Claude Code
+> **项目**: 武术赛事管理系统 - 编排模块
+
+---
+
+## 📋 实施概述
+
+本次实施完成了武术赛事编排系统的前后端完整功能，包括数据查询、草稿保存、编排锁定等核心功能。
+
+## ✅ 已完成功能
+
+### 1. 后端实现
+
+#### 1.1 Controller层
+**文件**: [MartialScheduleArrangeController.java](d:\workspace\31.比赛项目\project\martial-master\src\main\java\org\springblade\modules\martial\controller\MartialScheduleArrangeController.java)
+
+已实现的接口：
+- ✅ `GET /api/martial/schedule/result` - 获取编排结果
+- ✅ `POST /api/martial/schedule/save-draft` - 保存编排草稿
+- ✅ `POST /api/martial/schedule/save-and-lock` - 完成编排并锁定
+- ✅ `POST /api/martial/schedule/auto-arrange` - 手动触发自动编排
+
+#### 1.2 Service层
+**文件**: [MartialScheduleServiceImpl.java](d:\workspace\31.比赛项目\project\martial-master\src\main\java\org\springblade\modules\martial\service\impl\MartialScheduleServiceImpl.java)
+
+已实现的方法：
+
+**getScheduleResult(Long competitionId)**
+- 功能：获取赛程编排结果
+- 优化：使用LEFT JOIN一次性查询所有数据，避免N+1问题
+- 返回：包含分组、场地、时间段、参赛者的完整数据
+
+```java
+@Override
+public ScheduleResultDTO getScheduleResult(Long competitionId) {
+    // 使用优化的一次性JOIN查询
+    List<ScheduleGroupDetailVO> details = scheduleGroupMapper
+        .selectScheduleGroupDetails(competitionId);
+
+    // 在内存中按分组ID分组
+    Map<Long, List<ScheduleGroupDetailVO>> groupMap = details.stream()
+        .collect(Collectors.groupingBy(ScheduleGroupDetailVO::getGroupId));
+
+    // 检查编排状态并组装数据
+    // ...
+}
+```
+
+**saveDraftSchedule(SaveScheduleDraftDTO dto)**
+- 功能：保存编排草稿
+- 事务：使用@Transactional确保数据一致性
+- 处理：更新分组、明细、参赛者信息
+
+```java
+@Override
+@Transactional(rollbackFor = Exception.class)
+public boolean saveDraftSchedule(SaveScheduleDraftDTO dto) {
+    // 遍历每个分组
+    for (CompetitionGroupDTO groupDTO : dto.getCompetitionGroups()) {
+        // 更新编排明细（场地、时间段）
+        // 更新参赛者信息（状态、出场顺序）
+    }
+    return true;
+}
+```
+
+**saveAndLockSchedule(Long competitionId)**
+- 功能：完成编排并锁定
+- 事务：使用@Transactional确保数据一致性
+- 处理：将所有参赛者状态改为"completed"
+
+```java
+@Override
+@Transactional(rollbackFor = Exception.class)
+public boolean saveAndLockSchedule(Long competitionId) {
+    // 查询所有分组
+    // 更新所有参赛者的编排状态为completed
+    for (MartialScheduleParticipant participant : participants) {
+        participant.setScheduleStatus("completed");
+        scheduleParticipantMapper.updateById(participant);
+    }
+    return true;
+}
+```
+
+#### 1.3 Mapper层
+**文件**: [MartialScheduleGroupMapper.xml](d:\workspace\31.比赛项目\project\martial-master\src\main\java\org\springblade\modules\martial\mapper\MartialScheduleGroupMapper.xml)
+
+核心SQL查询：
+
+```xml
+<select id="selectScheduleGroupDetails" resultType="ScheduleGroupDetailVO">
+    SELECT
+        g.id AS groupId,
+        g.group_name AS groupName,
+        g.category AS category,
+        g.project_type AS projectType,
+        g.total_teams AS totalTeams,
+        g.total_participants AS totalParticipants,
+        g.display_order AS displayOrder,
+        d.id AS detailId,
+        d.venue_id AS venueId,
+        d.venue_name AS venueName,
+        d.time_slot AS timeSlot,
+        p.id AS participantId,
+        p.organization AS organization,
+        p.check_in_status AS checkInStatus,
+        p.schedule_status AS scheduleStatus,
+        p.performance_order AS performanceOrder
+    FROM
+        martial_schedule_group g
+    LEFT JOIN
+        martial_schedule_detail d ON g.id = d.schedule_group_id AND d.is_deleted = 0
+    LEFT JOIN
+        martial_schedule_participant p ON g.id = p.schedule_group_id AND p.is_deleted = 0
+    WHERE
+        g.competition_id = #{competitionId}
+        AND g.is_deleted = 0
+    ORDER BY
+        g.display_order ASC,
+        p.performance_order ASC
+</select>
+```
+
+**优化说明**：
+- ✅ 使用LEFT JOIN避免N+1查询问题
+- ✅ 一次性获取所有关联数据
+- ✅ 在Service层进行内存分组，提高性能
+
+#### 1.4 DTO类
+已定义的DTO：
+
+**ScheduleResultDTO** - 编排结果DTO
+```java
+@Data
+public class ScheduleResultDTO {
+    private Boolean isDraft;              // 是否为草稿
+    private Boolean isCompleted;          // 是否已完成
+    private List<CompetitionGroupDTO> competitionGroups;  // 竞赛分组列表
+}
+```
+
+**CompetitionGroupDTO** - 竞赛分组DTO
+```java
+@Data
+public class CompetitionGroupDTO {
+    private Long id;                      // 分组ID
+    private String title;                 // 分组标题
+    private String type;                  // 类型：集体/单人/双人
+    private String count;                 // 队伍数量
+    private String code;                  // 分组编号
+    private Long venueId;                 // 场地ID
+    private String venueName;             // 场地名称
+    private String timeSlot;              // 时间段
+    private Integer timeSlotIndex;        // 时间段索引
+    private List<ParticipantDTO> participants;  // 参赛人员列表
+}
+```
+
+**ParticipantDTO** - 参赛人员DTO
+```java
+@Data
+public class ParticipantDTO {
+    private Long id;                      // 参赛人员ID
+    private String schoolUnit;            // 学校/单位
+    private String status;                // 状态：未签到/已签到/异常
+    private Integer sortOrder;            // 排序
+}
+```
+
+**SaveScheduleDraftDTO** - 保存草稿DTO
+```java
+@Data
+public class SaveScheduleDraftDTO {
+    private Long competitionId;           // 赛事ID
+    private Boolean isDraft;              // 是否为草稿
+    private List<CompetitionGroupDTO> competitionGroups;  // 竞赛分组数据
+}
+```
+
+### 2. 前端实现
+
+#### 2.1 页面组件
+**文件**: [index.vue](d:\workspace\31.比赛项目\project\martial-web\src\views\martial\schedule\index.vue)
+
+主要功能：
+- ✅ 场地选择和时间段选择
+- ✅ 竞赛分组列表展示（根据场地和时间段过滤）
+- ✅ 参赛者上移/下移功能
+- ✅ 异常标记功能
+- ✅ 分组移动功能
+- ✅ 草稿保存功能
+- ✅ 完成编排并锁定功能
+
+#### 2.2 核心方法
+
+**loadScheduleData()** - 加载编排数据
+```javascript
+async loadScheduleData() {
+  const res = await getScheduleResult(this.competitionId)
+  const data = res.data?.data
+
+  this.isScheduleCompleted = data.isCompleted || false
+  this.competitionGroups = data.competitionGroups.map(/* 数据映射 */)
+
+  // 加载异常组数据
+  this.loadExceptionList()
+}
+```
+
+**handleSaveDraft()** - 保存草稿
+```javascript
+async handleSaveDraft() {
+  const saveData = {
+    competitionId: this.competitionId,
+    isDraft: true,
+    competitionGroups: this.competitionGroups.map(group => ({
+      // 映射所有分组数据
+      participants: group.items.map((item, index) => ({
+        id: item.id,
+        schoolUnit: item.schoolUnit,
+        status: item.status,
+        sortOrder: index + 1  // 重新计算顺序
+      }))
+    }))
+  }
+
+  await saveDraftSchedule(saveData)
+  this.$message.success('草稿保存成功')
+}
+```
+
+**confirmComplete()** - 完成编排（已修复）
+```javascript
+async confirmComplete() {
+  // 1. 先保存草稿
+  const saveData = { /* 构建数据 */ }
+  await saveDraftSchedule(saveData)
+
+  // 2. 然后锁定
+  await saveAndLockSchedule(saveData)
+
+  // 3. 更新UI状态
+  this.isScheduleCompleted = true
+  this.$message.success('编排已完成并锁定')
+}
+```
+
+#### 2.3 计算属性
+
+**filteredCompetitionGroups** - 过滤竞赛分组
+```javascript
+computed: {
+  filteredCompetitionGroups() {
+    if (!this.selectedVenueId || this.selectedTime === null) {
+      return []
+    }
+
+    return this.competitionGroups.filter(group => {
+      return group.venueId === this.selectedVenueId &&
+             group.timeSlotIndex === this.selectedTime
+    })
+  }
+}
+```
+
+#### 2.4 API调用
+**文件**: [activitySchedule.js](d:\workspace\31.比赛项目\project\martial-web\src\api\martial\activitySchedule.js)
+
+```javascript
+// 获取赛程编排结果
+export const getScheduleResult = (competitionId) => {
+  return request({
+    url: '/api/martial/schedule/result',
+    method: 'get',
+    params: { competitionId }
+  })
+}
+
+// 保存编排草稿
+export const saveDraftSchedule = (data) => {
+  return request({
+    url: '/api/martial/schedule/save-draft',
+    method: 'post',
+    data
+  })
+}
+
+// 保存并锁定赛程编排
+export const saveAndLockSchedule = (data) => {
+  return request({
+    url: '/api/martial/schedule/save-and-lock',
+    method: 'post',
+    data
+  })
+}
+```
+
+## 🔧 修复的问题
+
+### 问题1: 前端页面不显示编排数据
+**原因**: 缺少场地和时间段过滤逻辑
+**解决方案**: 添加计算属性`filteredCompetitionGroups`实现动态过滤
+
+### 问题2: confirmComplete方法未调用保存接口
+**原因**: 直接修改状态，没有调用后端接口
+**解决方案**: 修改为先保存草稿，再调用锁定接口
+
+**修改前**:
+```javascript
+confirmComplete() {
+  this.isScheduleCompleted = true
+  this.confirmDialogVisible = false
+  this.$message.success('编排已完成，现在可以进行调度操作')
+}
+```
+
+**修改后**:
+```javascript
+async confirmComplete() {
+  try {
+    // 1. 保存草稿
+    await saveDraftSchedule(saveData)
+    // 2. 锁定
+    await saveAndLockSchedule(saveData)
+    // 3. 更新UI
+    this.isScheduleCompleted = true
+    this.$message.success('编排已完成并锁定')
+  } catch (err) {
+    this.$message.error('完成编排失败')
+  }
+}
+```
+
+## 📊 数据流转
+
+### 完整流程
+
+```
+1. 用户进入编排页面
+   ↓
+2. mounted钩子执行
+   - loadCompetitionInfo() - 加载赛事信息
+   - loadVenues() - 加载场地列表
+   - loadScheduleData() - 加载编排数据
+   ↓
+3. 后端查询编排数据
+   GET /api/martial/schedule/result?competitionId=1
+   - 执行优化的LEFT JOIN查询
+   - 在内存中分组和组装数据
+   - 返回ScheduleResultDTO
+   ↓
+4. 前端渲染
+   - 显示场地按钮列表
+   - 显示时间段按钮列表
+   - 根据选中的场地和时间段过滤分组
+   ↓
+5. 用户操作
+   - 选择场地/时间段
+   - 上移/下移参赛者
+   - 标记异常
+   - 移动分组
+   ↓
+6. 保存草稿
+   POST /api/martial/schedule/save-draft
+   - 更新编排明细（场地、时间段）
+   - 更新参赛者信息（状态、出场顺序）
+   ↓
+7. 完成编排
+   - 先调用保存草稿接口
+   - 再调用锁定接口
+   POST /api/martial/schedule/save-and-lock
+   - 更新所有参赛者状态为"completed"
+```
+
+## 🎯 核心技术点
+
+### 1. 性能优化
+- **后端**: 使用LEFT JOIN避免N+1查询
+- **前端**: 使用计算属性实现响应式过滤
+
+### 2. 数据一致性
+- 使用@Transactional确保事务性
+- 先保存草稿再锁定，确保数据完整
+
+### 3. 用户体验
+- 实时更新：修改后立即反馈
+- 错误处理：统一的错误提示
+- 状态管理：清晰的草稿/已完成状态
+
+## 📝 测试建议
+
+### 功能测试
+1. ✅ 测试加载编排数据
+2. ✅ 测试场地和时间段切换
+3. ✅ 测试参赛者上移/下移
+4. ✅ 测试异常标记和移除
+5. ✅ 测试分组移动
+6. ✅ 测试保存草稿
+7. ✅ 测试完成编排并锁定
+
+### 性能测试
+1. 测试大量数据（1000+参赛者）的加载速度
+2. 测试频繁切换场地和时间段的响应速度
+3. 测试保存草稿的并发性能
+
+### 边界测试
+1. 测试没有编排数据的情况
+2. 测试没有场地信息的情况
+3. 测试网络异常的情况
+4. 测试已锁定编排的操作限制
+
+## 🔗 相关文档
+
+- [编排系统完整指南](./schedule-complete-guide.md) - 完整技术方案
+- [项目文档中心](../README.md) - 文档索引
+- [版本更新日志](./versions/CHANGELOG.md) - 版本历史
+
+## 📅 后续优化建议
+
+### 短期优化（1-2周）
+1. **前端虚拟滚动** - 优化大数据量渲染
+2. **批量操作** - 支持批量上移/下移
+3. **撤销/重做** - 支持操作撤销
+
+### 中期优化（1-2月）
+1. **缓存策略** - 减少重复查询
+2. **实时推送** - WebSocket实时更新
+3. **导出功能** - 完善Excel导出
+
+### 长期优化（3-6月）
+1. **AI智能编排** - 自动优化编排顺序
+2. **协同编辑** - 多人同时编排
+3. **移动端适配** - 响应式设计
+
+---
+
+**实施完成日期**: 2025-12-11
+**文档最后更新**: 2025-12-11

doc/schedule/versions/CHANGELOG.md

@@ -0,0 +1,203 @@
+# 编排系统文档更新日志
+
+> 记录编排系统文档的所有版本更新历史
+
+## 版本规范
+
+- **主版本号 (Major)**: 重大功能变更或架构调整，如 v1.0 → v2.0
+- **次版本号 (Minor)**: 功能新增或优化，如 v1.0 → v1.1
+- **修订号 (Patch)**: 文档修正、补充说明，如 v1.0.1 → v1.0.2
+
+---
+
+## [v1.0] - 2025-12-10
+
+### 新增内容
+
+#### 系统概述
+- 功能简介：自动编排、手动调整、场地管理、草稿保存、锁定发布、数据导出
+- 技术栈：Vue 2.x + Element UI + Spring Boot + MyBatis Plus + MySQL 8.0
+
+#### 架构设计
+- 系统架构图（前端层、后端层、数据库层）
+- 模块划分（前端模块、后端模块）
+- 详细的文件结构说明
+
+#### 数据库设计
+- 核心表设计（4张表）
+  - `martial_schedule_group` - 赛程编排分组表
+  - `martial_schedule_detail` - 赛程编排明细表
+  - `martial_schedule_participant` - 赛程编排参赛者关联表
+  - `martial_schedule_status` - 赛程编排状态表
+- 关联表说明（`martial_athlete`, `martial_venue`）
+- 表关系图和关键字段说明
+- 完整的建表SQL和索引设计
+
+#### 后端实现
+- Controller层实现
+  - `MartialScheduleArrangeController` - 编排控制器
+  - 主要接口：获取编排结果、保存草稿、完成并锁定、手动触发编排
+- Service层实现
+  - 核心方法：`getScheduleResult()` - 获取编排结果
+  - 核心方法：`saveDraftSchedule()` - 保存编排草稿
+  - 数据流程和事务处理
+- Mapper层实现
+  - 关键SQL查询（LEFT JOIN优化）
+  - 避免N+1查询问题的最佳实践
+
+#### 前端实现
+- 页面结构（index.vue）
+  - 头部布局（返回按钮、标题、异常组按钮）
+  - Tab切换（竞赛分组、场地）
+  - 场地选择器、时间段选择器
+  - 竞赛分组列表和表格
+  - 底部操作按钮
+- 核心数据结构
+  - 基础信息字段
+  - UI状态字段
+  - 编排数据结构
+- 核心方法实现
+  - `loadScheduleData()` - 加载编排数据
+  - `handleSaveDraft()` - 保存草稿
+  - `handleMoveUp/Down()` - 上移/下移
+  - `markAsException()` - 标记异常
+- API调用（activitySchedule.js）
+  - `getScheduleResult()` - 获取编排结果
+  - `saveDraftSchedule()` - 保存草稿
+  - `saveAndLockSchedule()` - 保存并锁定
+
+#### 数据流转
+- 完整流程图（8个步骤）
+  - 用户进入页面 → 前端加载 → 后端查询 → 数据返回 → 前端渲染 → 用户操作 → 保存草稿 → 完成编排
+- 数据库操作流程
+  - 查询编排数据的SQL
+  - 保存草稿数据的事务处理
+
+#### 核心功能
+- 场地和时间段过滤（计算属性实现）
+- 参赛者顺序调整（上移、下移）
+- 分组移动（跨场地、跨时间段）
+- 异常标记（异常组管理）
+- 草稿保存（增量更新）
+- 完成编排（锁定机制）
+
+#### API接口文档
+- GET `/api/martial/schedule/result` - 获取编排结果
+- POST `/api/martial/schedule/save-draft` - 保存编排草稿
+- POST `/api/martial/schedule/save-and-lock` - 完成编排并锁定
+- GET `/api/martial/venue/list-by-competition` - 获取场地列表
+- GET `/api/martial/competition/detail` - 获取赛事详情
+- 包含请求参数、响应示例、错误码说明
+
+#### 关键代码解析
+- 计算属性 `filteredCompetitionGroups` 的实现原理
+- 生成时间段列表的算法
+- 保存草稿的数据转换逻辑
+- 后端数据组装的性能优化
+
+#### 使用指南
+- 管理员操作流程（进入页面、查看数据、调整编排、保存草稿、完成编排）
+- 常见问题解答
+  - 为什么编排数据为空？
+  - 为什么无法编辑？
+  - 保存草稿失败怎么办？
+- 开发调试方法
+  - 前端调试技巧
+  - 后端调试技巧
+  - 数据库调试SQL
+
+#### 附录
+- 数据字典（编排状态、项目类型、参赛者状态）
+- 相关文档链接
+- 更新日志
+
+### 文档特色
+
+- **完整性**：覆盖从前端到后端、从UI到数据库的完整技术栈
+- **实用性**：包含大量代码示例和实际操作流程
+- **可读性**：清晰的章节结构、流程图、表格说明
+- **可维护性**：详细的注释和说明，便于后续维护
+
+### 文件信息
+
+- **文件名**: `schedule-complete-guide.md`
+- **文件大小**: ~62 KB
+- **总行数**: 1857 行
+- **主要章节**: 11 个
+- **代码示例**: 50+ 个
+- **SQL语句**: 10+ 个
+- **流程图**: 5 个
+
+---
+
+## 版本对比
+
+| 版本 | 发布日期 | 主要内容 | 文件大小 | 行数 |
+|------|----------|----------|----------|------|
+| v1.0 | 2025-12-10 | 初始版本，完整技术方案 | ~62 KB | 1857 |
+
+---
+
+## 待规划版本
+
+### v1.1 (计划中)
+
+可能的更新方向：
+
+- **性能优化章节**
+  - 前端虚拟滚动优化
+  - 后端分页查询优化
+  - 缓存策略设计
+
+- **扩展功能**
+  - 批量操作功能
+  - 撤销/重做功能
+  - 编排历史记录
+
+- **集成测试**
+  - 单元测试用例
+  - 集成测试方案
+  - 性能测试报告
+
+### v2.0 (未来)
+
+可能的重大更新：
+
+- 微服务架构改造
+- 前端升级到 Vue 3
+- 实时协同编排功能
+- AI智能编排算法
+
+---
+
+## 文档维护说明
+
+### 更新规范
+
+1. **修改主文档**
+   - 所有修改都在 `schedule-complete-guide.md` 中进行
+   - 更新文档头部的版本信息和更新日期
+
+2. **发布新版本**
+   - 确定版本号（根据修改程度）
+   - 复制主文档到 `versions/vX.X/` 目录
+   - 更新本 CHANGELOG.md 文件
+   - 更新 README.md 中的版本信息
+
+3. **归档旧版本**
+   - 不再维护的文档移到 `archive/` 目录
+   - 在文档顶部添加 **已废弃** 标记
+
+### 版本命名示例
+
+```
+v1.0    - 初始版本
+v1.1    - 新增性能优化章节
+v1.1.1  - 修正API文档中的错误
+v1.2    - 新增集成测试章节
+v2.0    - 架构重构，升级到Vue 3
+```
+
+---
+
+**文档最后更新**: 2025-12-10