diff --git a/gym-manage-api/docs/V10-booking-test-data.md b/gym-manage-api/docs/V10-booking-test-data.md
new file mode 100644
index 0000000..16a938b
--- /dev/null
+++ b/gym-manage-api/docs/V10-booking-test-data.md
@@ -0,0 +1,272 @@
+# V10 团课预约业务场景测试数据
+
+## 概述
+
+本文档描述了 V10 版本新增的团课预约功能测试数据，覆盖了7种典型的预约业务场景，用于验证系统在不同会员卡状态下的正确处理逻辑。
+
+**当前日期**: 2026-06-02
+
+---
+
+## 一、测试场景总览
+
+| 场景 | 会员 | 会员卡状态 | 预约课程 | 预期结果 |
+|-----|------|----------|---------|---------|
+| 1 | 用户A | 无会员卡 | 次数卡团课 | 提示无可用会员卡 |
+| 2 | 用户B | 时长卡已过期 | 次数卡团课 | 提示会员卡已过期 |
+| 3 | 会员C | 时长卡有效 | 次数卡团课 | 预约成功 |
+| 4 | 会员D | 次数卡次数=0 | 次数卡团课 | 提示剩余次数不足 |
+| 5 | 会员E | 次数卡次数=5 | 次数卡团课 | 预约成功 |
+| 6 | 会员F | 储值卡余额=30元 | 储值卡团课(需50元) | 提示余额不足 |
+| 7 | 会员G | 储值卡余额=200元 | 储值卡团课(需50元) | 预约成功 |
+
+---
+
+## 二、测试会员数据
+
+### 2.1 会员列表
+
+| 会员编号 | 昵称 | 手机号 | 性别 | 创建时间 |
+|---------|------|--------|------|---------|
+| MEM_TEST_A | 用户A_无卡新用户 | 13800001001 | 男 | 2026-06-02 10:00:00 |
+| MEM_TEST_B | 用户B_过期时长卡 | 13800001002 | 男 | 2026-05-01 10:00:00 |
+| MEM_TEST_C | 会员C_有效时长卡 | 13800001003 | 女 | 2026-05-01 10:00:00 |
+| MEM_TEST_D | 会员D_次数用尽 | 13800001004 | 男 | 2026-05-01 10:00:00 |
+| MEM_TEST_E | 会员E_次数充足 | 13800001005 | 女 | 2026-05-01 10:00:00 |
+| MEM_TEST_F | 会员F_储值卡余额不足 | 13800001006 | 男 | 2026-05-01 10:00:00 |
+| MEM_TEST_G | 会员G_储值卡余额充足 | 13800001007 | 女 | 2026-05-01 10:00:00 |
+
+### 2.2 会员场景说明
+
+#### 场景1: 用户A - 无会员卡新用户
+- **会员编号**: MEM_TEST_A
+- **状态**: 2026-06-02 刚注册，尚未购买任何会员卡
+- **测试目标**: 验证无会员卡用户申请团课预约时的错误提示
+
+#### 场景2: 用户B - 时长卡已过期
+- **会员编号**: MEM_TEST_B
+- **状态**: 持有30天时长卡，于 2026-05-31 23:59:59 到期
+- **测试目标**: 验证会员卡过期后的预约行为
+
+#### 场景3: 会员C - 时长卡有效
+- **会员编号**: MEM_TEST_C
+- **状态**: 持有30天时长卡，到期时间 2026-07-02
+- **测试目标**: 验证有效期内的时长卡可以正常预约次数卡团课
+
+#### 场景4: 会员D - 次数卡耗尽
+- **会员编号**: MEM_TEST_D
+- **状态**: 持有10次卡，剩余次数 = 0
+- **测试目标**: 验证次数耗尽后无法预约团课
+
+#### 场景5: 会员E - 次数卡充足
+- **会员编号**: MEM_TEST_E
+- **状态**: 持有10次卡，剩余次数 = 5
+- **测试目标**: 验证次数充足时正常预约
+
+#### 场景6: 会员F - 储值卡余额不足
+- **会员编号**: MEM_TEST_F
+- **状态**: 持有储值卡，余额 = 30.00 元
+- **测试目标**: 验证预约储值卡团课（需50元）时提示余额不足
+
+#### 场景7: 会员G - 储值卡余额充足
+- **会员编号**: MEM_TEST_G
+- **状态**: 持有储值卡，余额 = 200.00 元
+- **测试目标**: 验证余额充足时正常预约储值卡团课
+
+---
+
+## 三、团课课程数据
+
+### 3.1 团课列表
+
+| 课程名称 | 教练ID | 课程类型 | 开始时间 | 结束时间 | 最大人数 | 当前人数 | 状态 | 点卡额度 | 储值额度 |
+|---------|-------|---------|---------|---------|---------|---------|------|---------|---------|
+| 燃脂搏击_次数卡课程 | 102 | 2 | 2026-06-10 19:30:00 | 2026-06-10 20:30:00 | 20 | 0 | 正常 | 1 | 0.00 |
+| 高端普拉提_储值卡课程 | 103 | 1 | 2026-06-11 19:00:00 | 2026-06-11 20:00:00 | 15 | 0 | 正常 | 0 | 50.00 |
+
+### 3.2 课程说明
+
+**燃脂搏击_次数卡课程**
+- **收费类型**: 次数卡
+- **消耗点数**: 1次
+- **适用会员**: 时长卡、次数卡用户
+- **课程描述**: 高强度间歇训练，配合音乐快速燃脂
+
+**高端普拉提_储值卡课程**
+- **收费类型**: 储值卡
+- **消耗金额**: 50.00 元
+- **适用会员**: 储值卡用户
+- **课程描述**: 精准训练核心肌群
+
+---
+
+## 四、会员卡类型数据
+
+| 卡名称 | 卡类型 | 价格 | 有效天数 | 总次数 | 面额 | 状态 |
+|-------|-------|------|---------|-------|------|------|
+| 30天时长卡 | TIME_CARD | 299.00 | 30 | - | - | 上架 |
+| 10次卡 | COUNT_CARD | 499.00 | - | 10 | - | 上架 |
+| 储值卡500 | STORED_VALUE_CARD | 500.00 | - | - | 500.00 | 上架 |
+
+---
+
+## 五、会员卡记录数据
+
+### 5.1 记录列表
+
+| 会员编号 | 卡名称 | 状态 | 剩余次数 | 剩余金额 | 过期时间 | 购买时间 |
+|---------|-------|------|---------|---------|---------|---------|
+| MEM_TEST_B | 30天时长卡 | EXPIRED | 0 | 0.00 | 2026-05-31 | 2026-05-01 |
+| MEM_TEST_C | 30天时长卡 | ACTIVE | 0 | 0.00 | 2026-07-02 | 2026-06-02 |
+| MEM_TEST_D | 10次卡 | ACTIVE | 0 | 0.00 | 2026-12-31 | 2026-05-01 |
+| MEM_TEST_E | 10次卡 | ACTIVE | 5 | 0.00 | 2026-12-31 | 2026-05-01 |
+| MEM_TEST_F | 储值卡500 | ACTIVE | 0 | 30.00 | 2027-06-02 | 2026-05-01 |
+| MEM_TEST_G | 储值卡500 | ACTIVE | 0 | 200.00 | 2027-06-02 | 2026-05-01 |
+
+### 5.2 详细说明
+
+**用户B - 时长卡已过期**
+```
+会员ID: MEM_TEST_B
+卡名称: 30天时长卡
+状态: EXPIRED (已过期)
+有效期: 2026-05-01 至 2026-05-31
+剩余次数: 0
+剩余金额: 0.00
+```
+
+**会员C - 时长卡有效**
+```
+会员ID: MEM_TEST_C
+卡名称: 30天时长卡
+状态: ACTIVE (有效)
+有效期: 2026-06-02 至 2026-07-02
+剩余次数: 0
+剩余金额: 0.00
+```
+
+**会员D - 次数卡耗尽**
+```
+会员ID: MEM_TEST_D
+卡名称: 10次卡
+状态: ACTIVE (有效)
+有效期: 2026-05-01 至 2026-12-31
+剩余次数: 0 (已用尽)
+剩余金额: 0.00
+```
+
+**会员E - 次数卡充足**
+```
+会员ID: MEM_TEST_E
+卡名称: 10次卡
+状态: ACTIVE (有效)
+有效期: 2026-05-01 至 2026-12-31
+剩余次数: 5
+剩余金额: 0.00
+```
+
+**会员F - 储值卡余额不足**
+```
+会员ID: MEM_TEST_F
+卡名称: 储值卡500
+状态: ACTIVE (有效)
+有效期: 2026-05-01 至 2027-06-02
+剩余次数: 0
+剩余金额: 30.00 (不足50.00)
+```
+
+**会员G - 储值卡余额充足**
+```
+会员ID: MEM_TEST_G
+卡名称: 储值卡500
+状态: ACTIVE (有效)
+有效期: 2026-05-01 至 2027-06-02
+剩余次数: 0
+剩余金额: 200.00 (充足)
+```
+
+---
+
+## 六、SQL数据插入顺序
+
+```sql
+-- 1. 先插入会员用户 (A-G)
+INSERT INTO member_user (member_no, nickname, phone, gender, is_deleted, created_at, updated_at) VALUES
+ ('MEM_TEST_A', '用户A_无卡新用户', '13800001001', 1, false, '2026-06-02 10:00:00', '2026-06-02 10:00:00'),
+ ('MEM_TEST_B', '用户B_过期时长卡', '13800001002', 1, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
+ ('MEM_TEST_C', '会员C_有效时长卡', '13800001003', 2, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
+ ('MEM_TEST_D', '会员D_次数用尽', '13800001004', 1, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
+ ('MEM_TEST_E', '会员E_次数充足', '13800001005', 2, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
+ ('MEM_TEST_F', '会员F_储值卡余额不足', '13800001006', 1, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
+ ('MEM_TEST_G', '会员G_储值卡余额充足', '13800001007', 2, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00');
+
+-- 2. 插入团课课程
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
+ ('燃脂搏击_次数卡课程', 102, 2, '2026-06-10 19:30:00', '2026-06-10 20:30:00', 20, 0, '0', '综合训练区', '高强度间歇训练，配合音乐快速燃脂，消耗1次', 1, 0.00, 'admin', '2026-06-01 10:00:00', '2026-06-01 10:00:00');
+
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
+ ('高端普拉提_储值卡课程', 103, 1, '2026-06-11 19:00:00', '2026-06-11 20:00:00', 15, 0, '0', '普拉提教室', '精准训练核心肌群，消耗储值50元', 0, 50.00, 'admin', '2026-06-01 10:00:00', '2026-06-01 10:00:00');
+
+-- 3. 插入会员卡类型
+INSERT INTO member_card (member_card_name, member_card_type, member_card_price, member_card_validity_days, member_card_total_times, member_card_amount, member_card_status, extra_config, created_at, updated_at) VALUES
+ ('30天时长卡', 'TIME_CARD', 299.00, 30, NULL, NULL, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'),
+ ('10次卡', 'COUNT_CARD', 499.00, NULL, 10, NULL, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'),
+ ('储值卡500', 'STORED_VALUE_CARD', 500.00, NULL, NULL, 500.00, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00');
+
+-- 4. 插入会员卡记录
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_B'), (SELECT member_card_id FROM member_card WHERE member_card_name = '30天时长卡'), 'EXPIRED', 0, 0.00, '2026-05-31 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_C'), (SELECT member_card_id FROM member_card WHERE member_card_name = '30天时长卡'), 'ACTIVE', 0, 0.00, '2026-07-02 23:59:59', '2026-06-02 10:00:00', 0, '{}', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
+
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_D'), (SELECT member_card_id FROM member_card WHERE member_card_name = '10次卡'), 'ACTIVE', 0, 0.00, '2026-12-31 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_E'), (SELECT member_card_id FROM member_card WHERE member_card_name = '10次卡'), 'ACTIVE', 5, 0.00, '2026-12-31 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_F'), (SELECT member_card_id FROM member_card WHERE member_card_name = '储值卡500'), 'ACTIVE', 0, 30.00, '2027-06-02 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_G'), (SELECT member_card_id FROM member_card WHERE member_card_name = '储值卡500'), 'ACTIVE', 0, 200.00, '2027-06-02 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+```
+
+---
+
+## 七、预期测试结果
+
+### 7.1 成功场景
+
+| 场景 | 会员 | 操作 | 预期结果 |
+|-----|------|-----|---------|
+| 3 | 会员C | 预约次数卡团课 | 预约成功，消耗时长卡1次 |
+| 5 | 会员E | 预约次数卡团课 | 预约成功，次数减1 (5→4) |
+| 7 | 会员G | 预约储值卡团课 | 预约成功，余额减50 (200→150) |
+
+### 7.2 失败场景
+
+| 场景 | 会员 | 操作 | 预期错误码 | 预期提示信息 |
+|-----|------|-----|----------|------------|
+| 1 | 用户A | 预约次数卡团课 | NO_CARD | 无可用会员卡 |
+| 2 | 用户B | 预约次数卡团课 | CARD_EXPIRED | 会员卡已过期 |
+| 4 | 会员D | 预约次数卡团课 | INSUFFICIENT_TIMES | 剩余次数不足 |
+| 6 | 会员F | 预约储值卡团课 | INSUFFICIENT_BALANCE | 余额不足，当前余额30.00元，需50.00元 |
+
+---
+
+## 八、数据清理
+
+测试完成后，可通过以下 SQL 清理测试数据：
+
+```sql
+-- 删除测试会员（会级联删除相关会员卡记录）
+DELETE FROM member_user WHERE member_no LIKE 'MEM_TEST_%';
+
+-- 删除测试团课
+DELETE FROM group_course WHERE course_name LIKE '%_次数卡课程' OR course_name LIKE '%_储值卡课程';
+
+-- 删除测试会员卡类型
+DELETE FROM member_card WHERE member_card_name IN ('30天时长卡', '10次卡', '储值卡500');
+```
diff --git a/gym-manage-api/docs/V11-cancel-booking-test-data.md b/gym-manage-api/docs/V11-cancel-booking-test-data.md
new file mode 100644
index 0000000..83fa698
--- /dev/null
+++ b/gym-manage-api/docs/V11-cancel-booking-test-data.md
@@ -0,0 +1,204 @@
+# V11 团课预约取消测试数据文档
+
+## 文档说明
+
+本文档描述了用于测试团课预约取消功能的测试数据，包含三种会员卡类型的取消预约场景。
+
+## 测试场景概览
+
+| 序号 | 场景描述 | 用户 | 会员卡类型 |
+| :--- | :--- | :--- | :--- |
+| 1 | 使用时长卡预约后取消 | 张三 | 时长卡（30天） |
+| 2 | 使用次数卡预约后取消 | 李四 | 次数卡（10次） |
+| 3 | 使用储值卡预约后取消 | 王五 | 储值卡（500元） |
+
+## 测试用户数据
+
+### 1. 张三（时长卡用户）
+
+| 字段 | 值 |
+| :--- | :--- |
+| 会员编号 | `MEM_TEST_ZHANG` |
+| 昵称 | 张三_时长卡用户 |
+| 手机号 | 13800002001 |
+| 性别 | 男（1） |
+
+#### 会员卡信息
+
+| 字段 | 值 |
+| :--- | :--- |
+| 卡类型 | 时长卡（TIME_CARD） |
+| 卡名称 | 30天时长卡 |
+| 状态 | ACTIVE（有效） |
+| 到期时间 | 2026-07-02 23:59:59 |
+| 购买时间 | 2026-06-02 10:00:00 |
+
+---
+
+### 2. 李四（次数卡用户）
+
+| 字段 | 值 |
+| :--- | :--- |
+| 会员编号 | `MEM_TEST_LI` |
+| 昵称 | 李四_次数卡用户 |
+| 手机号 | 13800002002 |
+| 性别 | 男（1） |
+
+#### 会员卡信息
+
+| 字段 | 值 |
+| :--- | :--- |
+| 卡类型 | 次数卡（COUNT_CARD） |
+| 卡名称 | 10次卡 |
+| 状态 | ACTIVE（有效） |
+| 剩余次数 | 5次 |
+| 到期时间 | 2026-12-31 23:59:59 |
+
+---
+
+### 3. 王五（储值卡用户）
+
+| 字段 | 值 |
+| :--- | :--- |
+| 会员编号 | `MEM_TEST_WANG` |
+| 昵称 | 王五_储值卡用户 |
+| 手机号 | 13800002003 |
+| 性别 | 女（2） |
+
+#### 会员卡信息
+
+| 字段 | 值 |
+| :--- | :--- |
+| 卡类型 | 储值卡（STORED_VALUE_CARD） |
+| 卡名称 | 储值卡500 |
+| 状态 | ACTIVE（有效） |
+| 剩余金额 | 200.00元 |
+| 到期时间 | 2027-06-02 23:59:59 |
+
+---
+
+## 测试课程数据
+
+### 晚间瑜伽_取消测试
+
+| 字段 | 值 |
+| :--- | :--- |
+| 课程名称 | 晚间瑜伽_取消测试 |
+| 教练ID | 101 |
+| 课程类型 | 1 |
+| 开始时间 | 2026-06-15 19:00:00 |
+| 结束时间 | 2026-06-15 20:00:00 |
+| 上课地点 | 瑜伽教室 |
+| 最大人数 | 20人 |
+| 当前人数 | 3人（三位测试用户） |
+| 状态 | 0（正常） |
+| 次数消耗 | 1次 |
+| 储值消耗 | 30.00元 |
+
+---
+
+## 预约记录数据
+
+### 预约状态说明
+
+| 状态码 | 含义 |
+| :--- | :--- |
+| `0` | 已预约（等待取消） |
+| `1` | 已取消 |
+| `2` | 已出席 |
+| `3` | 缺席 |
+
+### 预约记录详情
+
+| 用户 | 预约时间 | 状态 | 课程名称 |
+| :--- | :--- | :--- | :--- |
+| 张三 | 2026-06-02 11:00:00 | 0（已预约） | 晚间瑜伽_取消测试 |
+| 李四 | 2026-06-02 11:30:00 | 0（已预约） | 晚间瑜伽_取消测试 |
+| 王五 | 2026-06-02 12:00:00 | 0（已预约） | 晚间瑜伽_取消测试 |
+
+---
+
+## 测试用例设计
+
+### 场景1：时长卡用户取消预约
+
+**前置条件：**
+- 张三持有有效时长卡
+- 张三已成功预约课程
+- 当前时间 < 课程开始时间
+
+**测试步骤：**
+1. 调用取消预约接口，传入张三的预约记录ID
+2. 验证预约状态变为 `1`（已取消）
+3. 验证课程当前人数减1
+4. 验证时长卡状态保持不变（时长卡取消预约不影响卡状态）
+
+**预期结果：**
+- 预约记录状态更新为已取消
+- 课程剩余名额增加1
+- 时长卡有效期不受影响
+
+---
+
+### 场景2：次数卡用户取消预约
+
+**前置条件：**
+- 李四持有次数卡，剩余5次
+- 李四已成功预约课程（已扣除1次）
+- 当前时间 < 课程开始时间
+
+**测试步骤：**
+1. 调用取消预约接口，传入李四的预约记录ID
+2. 验证预约状态变为 `1`（已取消）
+3. 验证课程当前人数减1
+4. 验证次数卡剩余次数恢复为5次（返还1次）
+
+**预期结果：**
+- 预约记录状态更新为已取消
+- 课程剩余名额增加1
+- 次数卡返还1次，剩余次数恢复为5次
+
+---
+
+### 场景3：储值卡用户取消预约
+
+**前置条件：**
+- 王五持有储值卡，余额200元
+- 王五已成功预约课程（已扣除30元）
+- 当前时间 < 课程开始时间
+
+**测试步骤：**
+1. 调用取消预约接口，传入王五的预约记录ID
+2. 验证预约状态变为 `1`（已取消）
+3. 验证课程当前人数减1
+4. 验证储值卡余额恢复为200元（返还30元）
+
+**预期结果：**
+- 预约记录状态更新为已取消
+- 课程剩余名额增加1
+- 储值卡返还30元，余额恢复为200元
+
+---
+
+## 数据文件位置
+
+```
+manage-db/src/main/resources/db/migration/V11__Insert_Cancel_Booking_Test_Data.sql
+```
+
+## 数据依赖
+
+| 依赖文件 | 说明 |
+| :--- | :--- |
+| `V6__Create_GroupCourse_table.sql` | 团课相关表结构 |
+| `V8__Create_Member_And_MemberCard.sql` | 会员和会员卡表结构 |
+| `V9__Add_GroupCourse_Booking_Snapshot_Fields.sql` | 预约快照字段 |
+
+---
+
+## 注意事项
+
+1. 测试数据中使用的日期均为未来日期，确保测试时课程尚未开始
+2. 会员卡状态均为 ACTIVE，确保可以正常预约
+3. 取消预约功能应在课程开始前24小时内允许操作（具体时间限制由业务逻辑决定）
+4. 取消预约后应记录操作日志和交易流水
diff --git a/gym-manage-api/docs/booking-test-scenarios.md b/gym-manage-api/docs/booking-test-scenarios.md
new file mode 100644
index 0000000..cb7a087
--- /dev/null
+++ b/gym-manage-api/docs/booking-test-scenarios.md
@@ -0,0 +1,400 @@
+# 团课预约场景测试数据文档
+
+## 概述
+
+本文档描述了团课预约功能的测试数据，覆盖了各种预约场景，用于验证系统在不同业务条件下的正确性和健壮性。
+
+---
+
+## 一、测试数据概览
+
+| 数据类别 | 数量 | 说明 |
+|---------|------|------|
+| 测试会员 | 5个 | 覆盖不同会员卡状态 |
+| 会员卡类型 | 8种 | 次卡/时长卡/储值卡 |
+| 会员卡记录 | 5条 | 会员持有的实际卡 |
+| 团课预约记录 | 4条 | 不同状态的预约 |
+| 交易流水 | 27条 | 完整的消费记录 |
+
+---
+
+## 二、会员测试数据
+
+### 2.1 会员列表
+
+| 会员ID | 会员编号 | 昵称 | 手机号 | 性别 | 会员卡状态 |
+|--------|---------|------|--------|------|-----------|
+| 1001 | MEM202606001 | 新用户小张 | 13800138001 | 男 | 无会员卡 |
+| 1002 | MEM202606002 | 额度耗尽用户 | 13800138002 | 女 | 次卡已用完 |
+| 1003 | MEM202606003 | 额度充足用户 | 13800138003 | 男 | 次卡剩余8次 |
+| 1004 | MEM202606004 | 过期卡用户 | 13800138004 | 女 | 月卡已过期 |
+| 1005 | MEM202606005 | 多卡用户小李 | 13800138005 | 男 | 次卡+储值卡 |
+
+### 2.2 会员详情
+
+**会员1001 - 新用户小张**
+- 状态：新注册用户，尚未购买任何会员卡
+- 用途：测试无会员卡情况下的预约行为
+
+**会员1002 - 额度耗尽用户**
+- 状态：持有10次团课卡，已全部用完
+- 用途：测试会员卡额度耗尽时的预约行为
+
+**会员1003 - 额度充足用户**
+- 状态：持有20次团课卡，剩余8次
+- 用途：测试正常预约流程
+
+**会员1004 - 过期卡用户**
+- 状态：持有月卡，已于2026-05-31过期
+- 用途：测试过期会员卡的预约行为
+
+**会员1005 - 多卡用户小李**
+- 状态：持有50次团课卡(剩余45次) + 500元储值卡(剩余350元)
+- 用途：测试多会员卡用户选择支付方式的场景
+
+---
+
+## 三、会员卡类型数据
+
+### 3.1 次卡类型
+
+| 卡类型ID | 卡名称 | 类型 | 价格 | 有效天数 | 总次数 | 状态 |
+|---------|-------|------|------|---------|-------|------|
+| 101 | 10次团课卡 | COUNT_CARD | 299.00 | 90 | 10 | 上架 |
+| 102 | 20次团课卡 | COUNT_CARD | 499.00 | 180 | 20 | 上架 |
+| 103 | 50次团课卡 | COUNT_CARD | 999.00 | 365 | 50 | 上架 |
+
+### 3.2 时长卡类型
+
+| 卡类型ID | 卡名称 | 类型 | 价格 | 有效天数 | 状态 |
+|---------|-------|------|------|---------|------|
+| 201 | 月卡 | TIME_CARD | 399.00 | 30 | 上架 |
+| 202 | 季卡 | TIME_CARD | 899.00 | 90 | 上架 |
+| 203 | 年卡 | TIME_CARD | 2999.00 | 365 | 上架 |
+
+### 3.3 储值卡类型
+
+| 卡类型ID | 卡名称 | 类型 | 价格 | 面额 | 有效天数 | 状态 |
+|---------|-------|------|------|------|---------|------|
+| 301 | 500元储值卡 | STORED_VALUE_CARD | 500.00 | 500.00 | 365 | 上架 |
+| 302 | 1000元储值卡 | STORED_VALUE_CARD | 1000.00 | 1000.00 | 365 | 上架 |
+
+---
+
+## 四、会员卡记录数据（会员持有的卡）
+
+| 记录ID | 会员ID | 卡类型ID | 状态 | 剩余次数 | 剩余金额 | 到期时间 | 购买时间 |
+|-------|--------|---------|------|---------|---------|---------|---------|
+| 2001 | 1002 | 101 | USED_UP | 0 | 0.00 | 2026-09-01 | 2026-06-01 |
+| 2002 | 1003 | 102 | ACTIVE | 8 | 0.00 | 2026-12-01 | 2026-06-01 |
+| 2003 | 1004 | 201 | EXPIRED | 0 | 0.00 | 2026-05-31 | 2026-05-01 |
+| 2004 | 1005 | 103 | ACTIVE | 45 | 0.00 | 2027-06-01 | 2026-06-01 |
+| 2005 | 1005 | 301 | ACTIVE | 0 | 350.00 | 2027-06-01 | 2026-05-15 |
+
+---
+
+## 五、团课预约记录数据
+
+| 预约ID | 课程ID | 会员ID | 会员卡记录ID | 预约时间 | 状态 | 课程名称 |
+|-------|-------|--------|-------------|---------|------|---------|
+| 3001 | 1 | 1003 | 2002 | 2026-06-01 15:30 | 已预约(0) | 极速燃脂单车 |
+| 3002 | 2 | 1003 | 2002 | 2026-06-01 10:00 | 已取消(1) | 清晨流瑜伽 |
+| 3003 | 6 | 1003 | 2002 | 2026-05-28 19:00 | 已出席(2) | 蜜桃臀塑造 |
+| 3004 | 7 | 1002 | 2001 | 2026-05-30 10:00 | 缺席(3) | 午间冥想放松 |
+
+### 状态说明
+
+| 状态码 | 状态名称 | 说明 |
+|-------|---------|------|
+| 0 | 已预约 | 用户已成功预约，等待上课 |
+| 1 | 已取消 | 用户主动取消预约 |
+| 2 | 已出席 | 用户已按时参加课程 |
+| 3 | 缺席 | 用户预约后未出席 |
+
+---
+
+## 六、测试场景详解
+
+### 场景1：新注册用户无会员卡预约
+
+**测试目标**：验证系统对无会员卡用户的预约拦截
+
+**测试数据**：
+- 用户ID：1001（新用户小张）
+- 目标课程：任意课程
+
+**预期结果**：
+- 返回错误信息："未绑定会员卡，请先购买会员卡"
+- HTTP状态码：400 Bad Request
+
+---
+
+### 场景2：会员卡额度耗尽预约
+
+**测试目标**：验证系统对额度耗尽会员卡的预约拦截
+
+**测试数据**：
+- 用户ID：1002（额度耗尽用户）
+- 会员卡记录ID：2001
+- 剩余次数：0
+
+**预期结果**：
+- 返回错误信息："会员卡余额不足"
+- HTTP状态码：400 Bad Request
+
+---
+
+### 场景3：会员卡额度充足预约
+
+**测试目标**：验证正常预约流程
+
+**测试数据**：
+- 用户ID：1003（额度充足用户）
+- 会员卡记录ID：2002
+- 剩余次数：8
+- 目标课程：课程ID=1（极速燃脂单车）
+
+**预期结果**：
+- 预约成功
+- 会员卡剩余次数减1（变为7次）
+- 生成预约记录
+- HTTP状态码：200 OK
+
+---
+
+### 场景4：会员卡已过期预约
+
+**测试目标**：验证系统对过期会员卡的预约拦截
+
+**测试数据**：
+- 用户ID：1004（过期卡用户）
+- 会员卡记录ID：2003
+- 状态：EXPIRED
+- 到期时间：2026-05-31
+
+**预期结果**：
+- 返回错误信息："会员卡已过期"
+- HTTP状态码：400 Bad Request
+
+---
+
+### 场景5：课程已满员预约---------------
+
+**测试目标**：验证系统对满员课程的预约拦截
+
+**测试数据**：
+- 课程ID：3（燃脂搏击）
+- 当前人数：20/20
+
+**预期结果**：
+- 返回错误信息："课程已满员"
+- HTTP状态码：400 Bad Request
+
+---
+
+### 场景6：课程已取消预约
+
+**测试目标**：验证系统对已取消课程的预约拦截
+
+**测试数据**：
+- 课程ID：5（周末冥想修复）
+- 状态：1（已取消）
+
+**预期结果**：
+- 返回错误信息："课程已取消"
+- HTTP状态码：400 Bad Request
+
+---
+
+### 场景7：课程已结束预约
+
+**测试目标**：验证系统对已结束课程的预约拦截
+
+**测试数据**：
+- 课程ID：6（蜜桃臀塑造）或 7（午间冥想放松）
+- 状态：2（已结束）
+
+**预期结果**：
+- 返回错误信息："课程已结束"
+- HTTP状态码：400 Bad Request
+
+---
+
+### 场景8：超出预约时间预约
+
+**测试目标**：验证系统对预约时间窗口的控制
+
+**测试数据**：
+- 课程ID：4（哈他瑜伽）
+- 开始时间：2026-06-01 15:20:00
+- 测试时间：课程开始前30分钟内
+
+**预期结果**：
+- 返回错误信息："已过预约时间"
+- HTTP状态码：400 Bad Request
+
+---
+
+### 场景9：重复预约同一课程
+
+**测试目标**：验证系统对重复预约的拦截
+
+**测试数据**：
+- 用户ID：1003（额度充足用户）
+- 课程ID：1（极速燃脂单车）
+- 已有预约记录：booking_id=3001
+
+**预期结果**：
+- 返回错误信息："已预约该课程"
+- HTTP状态码：400 Bad Request
+
+---
+
+### 场景10：多会员卡用户选择支付方式
+
+**测试目标**：验证多卡用户的支付方式选择功能
+
+**测试数据**：
+- 用户ID：1005（多卡用户小李）
+- 可用卡1：次卡（记录ID=2004，剩余45次）
+- 可用卡2：储值卡（记录ID=2005，剩余350元）
+
+**预期结果**：
+- 系统列出用户所有可用会员卡
+- 用户可选择使用次卡或储值卡支付
+- 根据选择的卡类型扣减相应额度
+
+---
+
+## 七、交易流水说明
+
+### 7.1 会员1002（额度耗尽用户）消费记录
+
+| 操作顺序 | 操作类型 | 变动次数 | 剩余次数 | 备注 |
+|---------|---------|---------|---------|------|
+| 1 | PURCHASE | +10 | 10 | 购买10次团课卡 |
+| 2-11 | DEDUCT | -1×10 | 0 | 10次课程消费 |
+
+### 7.2 会员1003（额度充足用户）消费记录
+
+| 操作顺序 | 操作类型 | 变动次数 | 剩余次数 | 备注 |
+|---------|---------|---------|---------|------|
+| 1 | PURCHASE | +20 | 20 | 购买20次团课卡 |
+| 2-12 | DEDUCT | -12 | 8 | 12次课程消费 |
+
+### 7.3 会员1005（多卡用户）消费记录
+
+| 会员卡记录ID | 操作类型 | 变动次数 | 变动金额 | 备注 |
+|-------------|---------|---------|---------|------|
+| 2004 | PURCHASE | +50 | 0 | 购买50次团课卡 |
+| 2004 | DEDUCT | -5 | 0 | 预约5节课程 |
+| 2005 | PURCHASE | 0 | +500 | 购买500元储值卡 |
+| 2005 | DEDUCT | 0 | -150 | 私教课消费150元 |
+
+---
+
+## 八、API测试示例
+
+### 8.1 预约接口
+
+```http
+POST /api/group-course/bookings
+Content-Type: application/json
+
+{
+ "courseId": 1,
+ "memberCardRecordId": 2002
+}
+```
+
+### 8.2 取消预约接口
+
+```http
+PUT /api/group-course/bookings/{bookingId}/cancel
+Content-Type: application/json
+
+{
+ "reason": "临时有事无法参加"
+}
+```
+
+### 8.3 查询用户预约列表
+
+```http
+GET /api/group-course/bookings?memberId=1003
+```
+
+---
+
+## 九、测试数据对应关系图
+
+```
+会员表 (member_user)
+ │
+ ├── 1001 ──→ (无会员卡)
+ ├── 1002 ──→ 会员卡记录 2001 (USED_UP)
+ ├── 1003 ──→ 会员卡记录 2002 (ACTIVE, 8次)
+ ├── 1004 ──→ 会员卡记录 2003 (EXPIRED)
+ └── 1005 ──→ 会员卡记录 2004 (ACTIVE, 45次)
+ └── 会员卡记录 2005 (ACTIVE, 350元)
+ │
+ ↓
+ 预约记录表 (group_course_booking)
+ │
+ ├── 3001: 已预约
+ ├── 3002: 已取消
+ ├── 3003: 已出席
+ └── 3004: 缺席
+```
+
+---
+
+## 十、数据初始化
+
+测试数据通过 Flyway 迁移脚本 `V10__Insert_Booking_Test_Data.sql` 初始化，需在数据库初始化时执行。
+
+**执行顺序**：
+1. V1__Create_all_tables.sql - 创建基础表结构
+2. V2__Insert_initial_data.sql - 插入初始数据
+3. V6__Create_GroupCourse_table.sql - 创建团课表
+4. V7__Insert_GroupCourse_test_data.sql - 插入团课测试数据
+5. V8__Create_Member_And_MemberCard.sql - 创建会员和会员卡表
+6. V9__Add_GroupCourse_Booking_Snapshot_Fields.sql - 添加冗余字段
+7. V10__Insert_Booking_Test_Data.sql - 插入预约测试数据（本文件）
+
+---
+
+**文档版本**: v1.1
+**创建时间**: 2026-06-02
+**更新时间**: 2026-06-02
+**适用场景**: 团课预约功能测试
+
+---
+
+## 十一、重要说明
+
+### 11.1 字段说明
+
+`member_card_record` 表包含两个ID字段：
+- `id` - 数据库主键（BIGSERIAL PRIMARY KEY）
+- `member_card_record_id` - 业务ID（BIGSERIAL），代码中使用此字段作为查询和更新条件
+
+### 11.2 测试数据修复记录
+
+**v1.1 修复内容**：
+- 修复了 `member_card_record` 表测试数据缺失 `member_card_record_id` 字段的问题
+- 原问题：测试数据只插入了 `id` 字段，导致 `member_card_record_id` 为 NULL
+- 影响：代码使用 `member_card_record_id` 作为WHERE条件时无法匹配到记录，导致扣减权益失败
+- 解决：在INSERT语句中添加 `member_card_record_id` 字段，值与 `id` 相同
+
+**修复前**：
+```sql
+INSERT INTO member_card_record (id, member_id, member_card_id, ...) VALUES
+(2001, 1002, 101, ...);
+```
+
+**修复后**：
+```sql
+INSERT INTO member_card_record (id, member_card_record_id, member_id, member_card_id, ...) VALUES
+(2001, 2001, 1002, 101, ...);
+```
diff --git a/gym-manage-api/docs/groupcourse-api.md b/gym-manage-api/docs/groupcourse-api.md
new file mode 100644
index 0000000..17509e4
--- /dev/null
+++ b/gym-manage-api/docs/groupcourse-api.md
@@ -0,0 +1,728 @@
+# 团课管理模块 API 文档
+
+> **文档版本**: v1.0
+> **创建日期**: 2026-06-02
+> **作者**: 张翔
+> **状态**: 正式发布
+
+---
+
+## 📋 目录
+
+1. [概述](#概述)
+2. [基础路径](#基础路径)
+3. [团课管理接口](#团课管理接口)
+ - [获取所有团课](#获取所有团课)
+ - [分页获取团课](#分页获取团课)
+ - [根据ID获取团课详情](#根据ID获取团课详情)
+ - [创建团课](#创建团课)
+ - [更新团课](#更新团课)
+ - [取消团课](#取消团课)
+ - [团课签到](#团课签到)
+ - [删除团课](#删除团课)
+4. [团课预约接口](#团课预约接口)
+ - [预约团课](#预约团课)
+ - [取消预约](#取消预约)
+ - [查询会员预约记录](#查询会员预约记录)
+ - [查询预约详情](#查询预约详情)
+ - [查询课程预约记录](#查询课程预约记录)
+5. [数据模型](#数据模型)
+ - [GroupCourse（团课）](#GroupCourse团课)
+ - [GroupCourseBooking（团课预约）](#GroupCourseBooking团课预约)
+6. [状态码说明](#状态码说明)
+7. [业务规则](#业务规则)
+
+---
+
+## 概述
+
+团课管理模块提供团课的创建、编辑、查询、取消和签到功能，以及团课预约相关操作。采用 Spring WebFlux 响应式编程，支持高并发场景。
+
+## 基础路径
+
+所有接口的基础路径为: `http://{host}:{port}/api/groupCourse`
+
+---
+
+## 团课管理接口
+
+### 获取所有团课
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | GET |
+| **接口路径** | `/api/groupCourse/list` |
+| **所属文件** | `GroupCourseHandler.java` |
+
+**请求参数**:
+
+| 参数名 | 类型 | 必填 | 默认值 | 说明 |
+|--------|------|------|--------|------|
+| includeDeleted | boolean | 否 | false | 是否包含已删除的团课 |
+
+**成功响应** (200 OK):
+
+```json
+[
+ {
+ "id": 1,
+ "courseName": "瑜伽入门",
+ "coachId": 1,
+ "courseType": 1,
+ "startTime": "2026-06-02T09:00:00",
+ "endTime": "2026-06-02T10:00:00",
+ "maxMembers": 20,
+ "currentMembers": 15,
+ "status": 0,
+ "location": "健身房A区",
+ "coverImage": "https://example.com/yoga.jpg",
+ "description": "适合初学者的瑜伽课程",
+ "createdAt": "2026-06-01T10:00:00",
+ "updatedAt": "2026-06-01T10:00:00"
+ }
+]
+```
+
+---
+
+### 分页获取团课
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | POST |
+| **接口路径** | `/api/groupCourse/page` |
+| **所属文件** | `GroupCourseHandler.java` |
+
+**请求体**:
+
+```json
+{
+ "page": 0,
+ "size": 10,
+ "sort": "id",
+ "order": "asc",
+ "keyword": "瑜伽"
+}
+```
+
+| 参数名 | 类型 | 必填 | 默认值 | 说明 |
+|--------|------|------|--------|------|
+| page | int | 否 | 0 | 页码，从0开始 |
+| size | int | 否 | 10 | 每页数量，最大100 |
+| sort | string | 否 | id | 排序字段 |
+| order | string | 否 | asc | 排序方式（asc/desc） |
+| keyword | string | 否 | - | 搜索关键词 |
+
+**请求参数**:
+
+| 参数名 | 类型 | 必填 | 默认值 | 说明 |
+|--------|------|------|--------|------|
+| includeDeleted | boolean | 否 | false | 是否包含已删除的团课 |
+
+**成功响应** (200 OK):
+
+```json
+{
+ "data": [...],
+ "totalPages": 5,
+ "totalElements": 45,
+ "page": 0,
+ "size": 10
+}
+```
+
+---
+
+### 根据ID获取团课详情
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | GET |
+| **接口路径** | `/api/groupCourse/{id}` |
+| **所属文件** | `GroupCourseHandler.java` |
+
+**路径参数**:
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| id | Long | 是 | 团课ID |
+
+**成功响应** (200 OK):
+
+```json
+{
+ "id": 1,
+ "courseName": "瑜伽入门",
+ "coachId": 1,
+ "courseType": 1,
+ "startTime": "2026-06-02T09:00:00",
+ "endTime": "2026-06-02T10:00:00",
+ "maxMembers": 20,
+ "currentMembers": 15,
+ "status": 0,
+ "location": "健身房A区",
+ "coverImage": "https://example.com/yoga.jpg",
+ "description": "适合初学者的瑜伽课程",
+ "pointCardAmount": 1,
+ "storedValueAmount": 50.00,
+ "createdAt": "2026-06-01T10:00:00",
+ "updatedAt": "2026-06-01T10:00:00"
+}
+```
+
+**失败响应** (404 Not Found):
+
+```json
+{}
+```
+
+---
+
+### 创建团课
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | POST |
+| **接口路径** | `/api/groupCourse` |
+| **所属文件** | `GroupCourseHandler.java` |
+
+**请求体**:
+
+```json
+{
+ "courseName": "动感单车",
+ "coachId": 2,
+ "courseType": 2,
+ "startTime": "2026-06-05T18:00:00",
+ "endTime": "2026-06-05T19:00:00",
+ "maxMembers": 25,
+ "location": "健身房B区",
+ "coverImage": "https://example.com/spinning.jpg",
+ "description": "高强度有氧运动课程",
+ "pointCardAmount": 1,
+ "storedValueAmount": 50.00
+}
+```
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| courseName | String | **是** | 课程名称 |
+| coachId | Long | 否 | 教练ID |
+| courseType | Long | 否 | 课程类型 |
+| startTime | LocalDateTime | 否 | 开始时间 |
+| endTime | LocalDateTime | 否 | 结束时间 |
+| maxMembers | Integer | 否 | 最大参与人数，默认20 |
+| location | String | 否 | 上课地点 |
+| coverImage | String | 否 | 封面图URL |
+| description | String | 否 | 课程描述 |
+| pointCardAmount | Integer | 否 | 点卡额度（消耗次数），默认1 |
+| storedValueAmount | BigDecimal | 否 | 储值卡额度（消耗金额），默认0 |
+
+**成功响应** (200 OK):
+
+```json
+{
+ "success": true,
+ "message": "团课创建成功",
+ "data": {
+ "id": 2,
+ "courseName": "动感单车",
+ "coachId": 2,
+ "courseType": 2,
+ "startTime": "2026-06-05T18:00:00",
+ "endTime": "2026-06-05T19:00:00",
+ "maxMembers": 25,
+ "currentMembers": 0,
+ "status": 0,
+ "location": "健身房B区",
+ "coverImage": "https://example.com/spinning.jpg",
+ "description": "高强度有氧运动课程",
+ "pointCardAmount": 1,
+ "storedValueAmount": 50.00
+ }
+}
+```
+
+**失败响应** (400 Bad Request):
+
+```json
+{
+ "success": false,
+ "message": "课程名称不能为空"
+}
+```
+
+---
+
+### 更新团课
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | PUT |
+| **接口路径** | `/api/groupCourse/{id}` |
+| **所属文件** | `GroupCourseHandler.java` |
+
+**路径参数**:
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| id | Long | 是 | 团课ID |
+
+**请求体**:
+
+```json
+{
+ "courseName": "动感单车升级版",
+ "coachId": 2,
+ "maxMembers": 30,
+ "description": "升级版高强度有氧运动课程",
+ "pointCardAmount": 2,
+ "storedValueAmount": 80.00
+}
+```
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| courseName | String | 否 | 课程名称 |
+| coachId | Long | 否 | 教练ID |
+| courseType | Long | 否 | 课程类型 |
+| startTime | LocalDateTime | 否 | 开始时间 |
+| endTime | LocalDateTime | 否 | 结束时间 |
+| maxMembers | Integer | 否 | 最大参与人数 |
+| location | String | 否 | 上课地点 |
+| coverImage | String | 否 | 封面图URL |
+| description | String | 否 | 课程描述 |
+| pointCardAmount | Integer | 否 | 点卡额度（消耗次数） |
+| storedValueAmount | BigDecimal | 否 | 储值卡额度（消耗金额） |
+
+**成功响应** (200 OK):
+
+```json
+{
+ "success": true,
+ "message": "团课更新成功",
+ "data": {
+ "id": 2,
+ "courseName": "动感单车升级版",
+ "coachId": 2,
+ "maxMembers": 30,
+ "description": "升级版高强度有氧运动课程",
+ "pointCardAmount": 2,
+ "storedValueAmount": 80.00
+ }
+}
+```
+
+**失败响应** (400 Bad Request):
+
+```json
+{
+ "success": false,
+ "message": "团课不存在"
+}
+```
+
+---
+
+### 取消团课
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | POST |
+| **接口路径** | `/api/groupCourse/{id}/cancel` |
+| **所属文件** | `GroupCourseHandler.java` |
+
+**路径参数**:
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| id | Long | 是 | 团课ID |
+
+**成功响应** (200 OK):
+
+```json
+{
+ "success": true,
+ "message": "团课取消成功",
+ "data": {
+ "id": 2,
+ "status": 1
+ }
+}
+```
+
+**失败响应** (400 Bad Request):
+
+```json
+{
+ "success": false,
+ "message": "课程取消需提前24小时"
+}
+```
+
+---
+
+### 团课签到
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | POST |
+| **接口路径** | `/api/groupCourse/{courseId}/signin` |
+| **所属文件** | `GroupCourseHandler.java` |
+
+**路径参数**:
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| courseId | Long | 是 | 团课ID |
+
+**请求体**:
+
+```json
+{
+ "memberId": 1001
+}
+```
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| memberId | Long | **是** | 会员ID |
+
+**成功响应** (200 OK):
+
+```json
+{
+ "success": true,
+ "message": "签到成功",
+ "data": {
+ "id": 2,
+ "currentMembers": 16
+ }
+}
+```
+
+**失败响应** (400 Bad Request):
+
+```json
+{
+ "success": false,
+ "message": "课程已满员"
+}
+```
+
+---
+
+### 删除团课
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | DELETE |
+| **接口路径** | `/api/groupCourse/{id}` |
+| **所属文件** | `GroupCourseHandler.java` |
+
+**路径参数**:
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| id | Long | 是 | 团课ID |
+
+**成功响应** (200 OK):
+
+```json
+{
+ "success": true,
+ "message": "团课删除成功"
+}
+```
+
+---
+
+## 团课预约接口
+
+### 预约团课
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | POST |
+| **接口路径** | `/api/groupCourse/book` |
+| **所属文件** | `GroupCourseBookingHandler.java` |
+
+**请求体**:
+
+```json
+{
+ "courseId": 1,
+ "memberId": 1001,
+ "memberCardRecordId": 5001
+}
+```
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| courseId | Long | **是** | 团课ID |
+| memberId | Long | **是** | 会员ID |
+| memberCardRecordId | Long | **是** | 会员卡记录ID |
+
+**成功响应** (200 OK):
+
+```json
+{
+ "success": true,
+ "message": "预约成功",
+ "data": {
+ "id": 100,
+ "courseId": 1,
+ "memberId": 1001,
+ "memberCardRecordId": 5001,
+ "bookingTime": "2026-06-02T08:00:00",
+ "status": "0"
+ }
+}
+```
+
+---
+
+### 取消预约
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | POST |
+| **接口路径** | `/api/groupCourse/booking/{bookingId}/cancel` |
+| **所属文件** | `GroupCourseBookingHandler.java` |
+
+**路径参数**:
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| bookingId | Long | 是 | 预约ID |
+
+**请求体**:
+
+```json
+{
+ "memberId": 1001
+}
+```
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| memberId | Long | **是** | 会员ID |
+
+**成功响应** (200 OK):
+
+```json
+{
+ "success": true,
+ "message": "取消成功",
+ "data": {
+ "id": 100,
+ "status": "1",
+ "cancelTime": "2026-06-02T09:00:00"
+ }
+}
+```
+
+---
+
+### 查询会员预约记录
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | GET |
+| **接口路径** | `/api/groupCourse/bookings/member/{memberId}` |
+| **所属文件** | `GroupCourseBookingHandler.java` |
+
+**路径参数**:
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| memberId | Long | 是 | 会员ID |
+
+**成功响应** (200 OK):
+
+```json
+[
+ {
+ "id": 100,
+ "courseId": 1,
+ "courseName": "瑜伽入门",
+ "memberId": 1001,
+ "memberCardRecordId": 5001,
+ "bookingTime": "2026-06-02T08:00:00",
+ "status": "0",
+ "courseStartTime": "2026-06-02T09:00:00",
+ "location": "健身房A区"
+ }
+]
+```
+
+---
+
+### 查询预约详情
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | GET |
+| **接口路径** | `/api/groupCourse/bookings/{bookingId}` |
+| **所属文件** | `GroupCourseBookingHandler.java` |
+
+**路径参数**:
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| bookingId | Long | 是 | 预约ID |
+
+**成功响应** (200 OK):
+
+```json
+{
+ "id": 100,
+ "courseId": 1,
+ "courseName": "瑜伽入门",
+ "memberId": 1001,
+ "memberCardRecordId": 5001,
+ "bookingTime": "2026-06-02T08:00:00",
+ "status": "0",
+ "courseStartTime": "2026-06-02T09:00:00",
+ "courseEndTime": "2026-06-02T10:00:00",
+ "location": "健身房A区"
+}
+```
+
+**失败响应** (404 Not Found):
+
+```json
+{}
+```
+
+---
+
+### 查询课程预约记录
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | GET |
+| **接口路径** | `/api/groupCourse/bookings/course/{courseId}` |
+| **所属文件** | `GroupCourseBookingHandler.java` |
+
+**路径参数**:
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| courseId | Long | 是 | 团课ID |
+
+**成功响应** (200 OK):
+
+```json
+[
+ {
+ "id": 100,
+ "courseId": 1,
+ "courseName": "瑜伽入门",
+ "memberId": 1001,
+ "bookingTime": "2026-06-02T08:00:00",
+ "status": "0"
+ }
+]
+```
+
+---
+
+## 数据模型
+
+### GroupCourse（团课）
+
+| 字段名 | 类型 | 说明 |
+|--------|------|------|
+| id | Long | 主键ID |
+| courseName | String | 课程名称 |
+| coachId | Long | 教练ID |
+| courseType | Long | 课程类型 |
+| startTime | LocalDateTime | 开始时间 |
+| endTime | LocalDateTime | 结束时间 |
+| maxMembers | Integer | 最大参与人数 |
+| currentMembers | Integer | 当前参与人数 |
+| status | Long | 状态（0-正常，1-已取消，2-已结束） |
+| location | String | 上课地点 |
+| coverImage | String | 封面图URL |
+| description | String | 课程描述 |
+| pointCardAmount | Integer | 点卡额度（消耗次数），默认1 |
+| storedValueAmount | BigDecimal | 储值卡额度（消耗金额），默认0 |
+| createdBy | String | 创建人 |
+| updatedBy | String | 更新人 |
+| createdAt | LocalDateTime | 创建时间 |
+| updatedAt | LocalDateTime | 更新时间 |
+| deletedAt | LocalDateTime | 删除时间（软删除） |
+
+### GroupCourseBooking（团课预约）
+
+| 字段名 | 类型 | 说明 |
+|--------|------|------|
+| id | Long | 主键ID |
+| courseId | Long | 团课ID |
+| courseName | String | 团课名称 |
+| memberId | Long | 会员ID |
+| memberCardRecordId | Long | 会员卡记录ID |
+| bookingTime | LocalDateTime | 预约时间 |
+| status | String | 状态（0-已预约，1-已取消，2-已出席，3-缺席） |
+| cancelTime | LocalDateTime | 取消时间 |
+| courseStartTime | LocalDateTime | 课程开始时间 |
+| courseEndTime | LocalDateTime | 课程结束时间 |
+| location | String | 上课地点 |
+| createdBy | String | 创建人 |
+| updatedBy | String | 更新人 |
+| createdAt | LocalDateTime | 创建时间 |
+| updatedAt | LocalDateTime | 更新时间 |
+| deletedAt | LocalDateTime | 删除时间（软删除） |
+
+---
+
+## 状态码说明
+
+### 团课状态
+
+| 状态码 | 含义 |
+|--------|------|
+| 0 | 正常 |
+| 1 | 已取消 |
+| 2 | 已结束 |
+
+### 预约状态
+
+| 状态码 | 含义 |
+|--------|------|
+| 0 | 已预约 |
+| 1 | 已取消 |
+| 2 | 已出席 |
+| 3 | 缺席 |
+
+---
+
+## 业务规则
+
+### 团课管理
+1. **创建团课**：课程名称为必填项
+2. **取消团课**：需提前24小时通知，否则拒绝操作
+3. **团课签到**：验证课程状态必须为正常，且未达最大人数限制
+4. **删除团课**：采用软删除机制，数据保留可恢复
+
+### 团课预约
+1. **预约团课**：需验证会员卡有效性和课程名额
+2. **取消预约**：需在课程开始前至少2小时取消
+
+---
+
+## 附录：错误响应格式
+
+所有接口的错误响应统一格式：
+
+```json
+{
+ "success": false,
+ "message": "错误描述信息"
+}
+```
+
+---
+
+*文档结束*
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/.mvn/wrapper/maven-wrapper.properties b/gym-manage-api/gym-groupCourse/.mvn/wrapper/maven-wrapper.properties
new file mode 100644
index 0000000..5291372
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/.mvn/wrapper/maven-wrapper.properties
@@ -0,0 +1,3 @@
+wrapperVersion=3.3.4
+distributionType=only-script
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.15/apache-maven-3.9.15-bin.zip
diff --git a/gym-manage-api/gym-groupCourse/pom.xml b/gym-manage-api/gym-groupCourse/pom.xml
new file mode 100644
index 0000000..2b8ae6b
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/pom.xml
@@ -0,0 +1,95 @@
+
+
+ 4.0.0
+
+ cn.novalon.gym.manage
+ gym-manage-api
+ 1.0.0
+ ../pom.xml
+
+ cn.novalon.gym.manage
+ gym-groupCourse
+ 1.0.0
+ gym-groupCourse
+ Group Course Management Module
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 21
+
+
+
+ cn.novalon.gym.manage
+ manage-common
+ ${project.version}
+
+
+ cn.novalon.gym.manage
+ manage-db
+ ${project.version}
+
+
+ org.springframework.boot
+ spring-boot-starter-webflux
+
+
+ org.springframework.boot
+ spring-boot-starter-data-r2dbc
+
+
+ org.springframework.boot
+ spring-boot-starter-validation
+
+
+ org.springdoc
+ springdoc-openapi-starter-webflux-ui
+
+
+ org.springframework.boot
+ spring-boot-starter-test
+ test
+
+
+ io.swagger.core.v3
+ swagger-annotations-jakarta
+ 2.2.43
+ compile
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-data-redis
+
+
+
+
+ cn.novalon.gym.manage
+ gym-member
+ ${project.version}
+
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+
+
+
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/converter/GroupCourseConverter.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/converter/GroupCourseConverter.java
new file mode 100644
index 0000000..e8bcf07
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/converter/GroupCourseConverter.java
@@ -0,0 +1,127 @@
+
+package cn.novalon.gym.manage.groupcourse.converter;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseBookingEntity;
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * 团课相关转换器
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+@Component
+@Slf4j
+public class GroupCourseConverter {
+
+ /**
+ * 将团课实体转换为领域模型
+ */
+ public GroupCourse toDomain(GroupCourseEntity entity){
+ if(entity == null){
+ return null;
+ }
+ GroupCourse groupCourse = new GroupCourse();
+ BeanUtil.copyProperties(entity,groupCourse);
+ log.info("转换bean，entity-domain：",groupCourse);
+ return groupCourse;
+ }
+
+ /**
+ * 将团课领域模型转换为实体
+ */
+ public GroupCourseEntity toEntity(GroupCourse domain){
+ if(domain == null){
+ return null;
+ }
+ GroupCourseEntity entity = new GroupCourseEntity();
+ BeanUtil.copyProperties(domain,entity);
+ log.info("转换bean，domain-entity：",entity);
+ return entity;
+ }
+
+ /**
+ * 将团课实体列表转换为领域模型列表
+ */
+ public List toDomainList(List entities){
+ if (entities == null) {
+ return null;
+ }
+ return entities.stream()
+ .map(this::toDomain)
+ .collect(Collectors.toList());
+ }
+
+ /**
+ * 将团课领域模型列表转换为实体列表
+ */
+ public List toEntityList(List domains){
+ if (domains == null) {
+ return null;
+ }
+ return domains.stream()
+ .map(this::toEntity)
+ .collect(Collectors.toList());
+ }
+
+ /**
+ * 将团课预约实体转换为领域模型
+ */
+ public GroupCourseBooking toBookingDomain(GroupCourseBookingEntity entity){
+ if(entity == null){
+ return null;
+ }
+ GroupCourseBooking booking = new GroupCourseBooking();
+ BeanUtil.copyProperties(entity, booking);
+ log.debug("转换预约记录实体到领域模型：bookingId={}", entity.getId());
+ return booking;
+ }
+
+ /**
+ * 将团课预约领域模型转换为实体
+ */
+ public GroupCourseBookingEntity toBookingEntity(GroupCourseBooking domain){
+ if(domain == null){
+ return null;
+ }
+ GroupCourseBookingEntity entity = new GroupCourseBookingEntity();
+ BeanUtil.copyProperties(domain, entity);
+ if (domain.getId() != null) {
+ entity.markNotNew();
+ }
+ log.debug("转换预约记录领域模型到实体：bookingId={}", domain.getId());
+ return entity;
+ }
+
+ /**
+ * 将团课预约实体列表转换为领域模型列表
+ */
+ public List toBookingDomainList(List entities){
+ if (entities == null) {
+ return null;
+ }
+ return entities.stream()
+ .map(this::toBookingDomain)
+ .collect(Collectors.toList());
+ }
+
+ /**
+ * 将团课预约领域模型列表转换为实体列表
+ */
+ public List toBookingEntityList(List domains){
+ if (domains == null) {
+ return null;
+ }
+ return domains.stream()
+ .map(this::toBookingEntity)
+ .collect(Collectors.toList());
+ }
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/dao/GroupCourseBookingDao.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/dao/GroupCourseBookingDao.java
new file mode 100644
index 0000000..766c617
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/dao/GroupCourseBookingDao.java
@@ -0,0 +1,111 @@
+package cn.novalon.gym.manage.groupcourse.dao;
+
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseBookingEntity;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.repository.R2dbcRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * 团课预约记录DAO接口
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+@Repository
+public interface GroupCourseBookingDao extends R2dbcRepository {
+
+ /**
+ * 根据ID查询未删除的预约记录
+ */
+ Mono findByIdIsAndDeletedAtIsNull(Long id);
+
+ /**
+ * 根据会员ID查询所有预约记录
+ */
+ Flux findByMemberIdAndDeletedAtIsNull(Long memberId);
+
+ /**
+ * 根据会员ID查询所有预约记录（带排序）
+ */
+ Flux findByMemberIdAndDeletedAtIsNull(Long memberId, Sort sort);
+
+ /**
+ * 根据团课ID查询所有预约记录
+ */
+ Flux findByCourseIdAndDeletedAtIsNull(Long courseId);
+
+ /**
+ * 根据团课ID和会员ID查询预约记录
+ */
+ Mono findByCourseIdAndMemberIdAndDeletedAtIsNull(Long courseId, Long memberId);
+
+ /**
+ * 根据团课ID和状态查询预约记录
+ */
+ Flux findByCourseIdAndStatusAndDeletedAtIsNull(Long courseId, String status);
+
+ /**
+ * 查询会员在指定课程的有效预约（状态为已预约且未取消）
+ */
+ Mono findByCourseIdAndMemberIdAndStatusAndDeletedAtIsNull(Long courseId, Long memberId, String status);
+
+ /**
+ * 根据会员卡记录ID查询预约记录
+ */
+ Flux findByMemberCardRecordIdAndDeletedAtIsNull(Long memberCardRecordId);
+
+ /**
+ * 统计团课已预约人数
+ */
+ Mono countByCourseIdAndStatusAndDeletedAtIsNull(Long courseId, String status);
+
+ /**
+ * 查询会员是否有时间冲突的预约（状态为已预约且未取消）
+ * 时间冲突条件：新课程的开始时间 < 已预约课程的结束时间 且 新课程的结束时间 > 已预约课程的开始时间
+ */
+ @org.springframework.data.r2dbc.repository.Query("SELECT * FROM group_course_booking b " +
+ "JOIN group_course c ON b.course_id = c.id " +
+ "WHERE b.member_id = :memberId " +
+ "AND b.status = '0' " +
+ "AND b.deleted_at IS NULL " +
+ "AND c.deleted_at IS NULL " +
+ "AND :newStartTime < c.end_time " +
+ "AND :newEndTime > c.start_time")
+ Flux findConflictingBookings(Long memberId, java.time.LocalDateTime newStartTime, java.time.LocalDateTime newEndTime);
+
+ /**
+ * 更新预约状态
+ */
+ @org.springframework.data.r2dbc.repository.Modifying
+ @org.springframework.data.r2dbc.repository.Query("UPDATE group_course_booking SET status = :status, cancel_time = :cancelTime, updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
+ Mono updateStatus(Long id, String status, java.time.LocalDateTime cancelTime, java.time.LocalDateTime updatedAt);
+
+ /**
+ * 软删除预约记录
+ */
+ @org.springframework.data.r2dbc.repository.Modifying
+ @org.springframework.data.r2dbc.repository.Query("UPDATE group_course_booking SET deleted_at = :deletedAt WHERE id = :id")
+ Mono softDelete(Long id, java.time.LocalDateTime deletedAt);
+
+ /**
+ * 查询已开始课程但未到场会员的预约记录
+ * 条件：课程开始时间早于当前时间，预约状态为已预约(0)
+ */
+ @org.springframework.data.r2dbc.repository.Query("SELECT b.* FROM group_course_booking b " +
+ "JOIN group_course c ON b.course_id = c.id " +
+ "WHERE b.status = '0' " +
+ "AND b.deleted_at IS NULL " +
+ "AND c.deleted_at IS NULL " +
+ "AND c.status = '0' " +
+ "AND c.start_time < CURRENT_TIMESTAMP")
+ Flux findAbsentMembers();
+
+ /**
+ * 批量更新预约状态为缺席
+ */
+ @org.springframework.data.r2dbc.repository.Modifying
+ @org.springframework.data.r2dbc.repository.Query("UPDATE group_course_booking SET status = '3', updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
+ Mono updateToAbsent(Long id, java.time.LocalDateTime updatedAt);
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/dao/GroupCourseDao.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/dao/GroupCourseDao.java
new file mode 100644
index 0000000..9a0000b
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/dao/GroupCourseDao.java
@@ -0,0 +1,39 @@
+
+package cn.novalon.gym.manage.groupcourse.dao;
+
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.repository.Modifying;
+import org.springframework.data.r2dbc.repository.Query;
+import org.springframework.data.r2dbc.repository.R2dbcRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+@Repository
+public interface GroupCourseDao extends R2dbcRepository {
+
+ Mono findByIdIsAndDeletedAtIsNull(Long id);
+
+ Flux findAll();
+
+ Flux findAll(Sort sort);
+
+ Flux findAllByDeletedAtIsNull();
+
+ Flux findAllByDeletedAtIsNull(Sort sort);
+
+ @Modifying
+ @Query("UPDATE group_course SET status = '1', updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
+ Mono cancelCourse(Long id, LocalDateTime updatedAt);
+
+ @Modifying
+ @Query("UPDATE group_course SET current_members = current_members + :delta, updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
+ Mono updateCurrentMembers(Long id, Integer delta, LocalDateTime updatedAt);
+
+ @Modifying
+ @Query("UPDATE group_course SET deleted_at = :deletedAt WHERE id = :id")
+ Mono softDelete(Long id, LocalDateTime deletedAt);
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/domain/GroupCourse.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/domain/GroupCourse.java
new file mode 100644
index 0000000..b3100e7
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/domain/GroupCourse.java
@@ -0,0 +1,166 @@
+
+package cn.novalon.gym.manage.groupcourse.domain;
+
+import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.time.LocalDateTime;
+
+public class GroupCourse extends BaseDomain{
+
+ //课程名称
+ @Schema(description = "团课名", example = "Push-up")
+ private String courseName;
+
+ //教练id
+ @Schema(description = "教练id", example = "1")
+ private Long coachId;
+
+ //课程类型
+ @Schema(description = "课程类型", example = "1")
+ private Long courseType;
+
+ //开始时间
+ @Schema(description = "开始时间", example = "2026-01-01")
+ private LocalDateTime startTime;
+
+ //结束时间
+ @Schema(description = "结束时间", example = "2026-01-02")
+ private LocalDateTime endTime;
+
+ //最大参与人数
+ @Schema(description = "最大参与人数", example = "20")
+ private Integer maxMembers;
+
+ //当前参与人数
+ @Schema(description = "当前参与人数", example = "2")
+ private Integer currentMembers;
+
+ //课程状态：0-正常，1-已取消，2-已结束
+ @Schema(description = "课程状态", example = "0")
+ private Long status;
+
+ //上课地点
+ @Schema(description = "上课地点", example = "龙泉驿区幸福路")
+ private String location;
+
+ //封面图URL
+ @Schema(description = "封面图URL", example = "https://12345.com")
+ private String coverImage;
+
+ //课程描述
+ @Schema(description = "课程描述", example = "从入门到入土")
+ private String description;
+
+ //点卡额度（消耗次数）
+ @Schema(description = "点卡额度（消耗次数）", example = "1")
+ private Integer pointCardAmount;
+
+ //储值卡额度（消耗金额）
+ @Schema(description = "储值卡额度（消耗金额）", example = "50.00")
+ private java.math.BigDecimal storedValueAmount;
+
+ public String getCourseName() {
+ return courseName;
+ }
+
+ public void setCourseName(String courseName) {
+ this.courseName = courseName;
+ }
+
+ public Long getCoachId() {
+ return coachId;
+ }
+
+ public void setCoachId(Long coachId) {
+ this.coachId = coachId;
+ }
+
+ public Long getCourseType() {
+ return courseType;
+ }
+
+ public void setCourseType(Long courseType) {
+ this.courseType = courseType;
+ }
+
+ public LocalDateTime getStartTime() {
+ return startTime;
+ }
+
+ public void setStartTime(LocalDateTime startTime) {
+ this.startTime = startTime;
+ }
+
+ public LocalDateTime getEndTime() {
+ return endTime;
+ }
+
+ public void setEndTime(LocalDateTime endTime) {
+ this.endTime = endTime;
+ }
+
+ public Integer getMaxMembers() {
+ return maxMembers;
+ }
+
+ public void setMaxMembers(Integer maxMembers) {
+ this.maxMembers = maxMembers;
+ }
+
+ public Integer getCurrentMembers() {
+ return currentMembers;
+ }
+
+ public void setCurrentMembers(Integer currentMembers) {
+ this.currentMembers = currentMembers;
+ }
+
+ public Long getStatus() {
+ return status;
+ }
+
+ public void setStatus(Long status) {
+ this.status = status;
+ }
+
+ public String getLocation() {
+ return location;
+ }
+
+ public void setLocation(String location) {
+ this.location = location;
+ }
+
+ public String getCoverImage() {
+ return coverImage;
+ }
+
+ public void setCoverImage(String coverImage) {
+ this.coverImage = coverImage;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public Integer getPointCardAmount() {
+ return pointCardAmount;
+ }
+
+ public void setPointCardAmount(Integer pointCardAmount) {
+ this.pointCardAmount = pointCardAmount;
+ }
+
+ public java.math.BigDecimal getStoredValueAmount() {
+ return storedValueAmount;
+ }
+
+ public void setStoredValueAmount(java.math.BigDecimal storedValueAmount) {
+ this.storedValueAmount = storedValueAmount;
+ }
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/domain/GroupCourseBooking.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/domain/GroupCourseBooking.java
new file mode 100644
index 0000000..cea5e74
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/domain/GroupCourseBooking.java
@@ -0,0 +1,135 @@
+package cn.novalon.gym.manage.groupcourse.domain;
+
+import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.time.LocalDateTime;
+
+/**
+ * 团课预约记录领域模型
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+public class GroupCourseBooking extends BaseDomain {
+
+ //团课ID
+ @Schema(description = "团课ID", example = "1")
+ private Long courseId;
+
+ //团课名称（关联查询）
+ @Schema(description = "团课名称", example = "瑜伽入门")
+ private String courseName;
+
+ //会员ID
+ @Schema(description = "会员ID", example = "1")
+ private Long memberId;
+
+ //会员卡记录ID
+ @Schema(description = "会员卡记录ID", example = "1")
+ private Long memberCardRecordId;
+
+ //预约时间
+ @Schema(description = "预约时间", example = "2026-06-01 10:00:00")
+ private LocalDateTime bookingTime;
+
+ //状态：0-已预约，1-已取消，2-已出席，3-缺席
+ @Schema(description = "状态：0-已预约，1-已取消，2-已出席，3-缺席", example = "0")
+ private String status;
+
+ //取消时间
+ @Schema(description = "取消时间", example = "2026-06-01 11:00:00")
+ private LocalDateTime cancelTime;
+
+ //课程开始时间
+ @Schema(description = "课程开始时间", example = "2026-06-02 09:00:00")
+ private LocalDateTime courseStartTime;
+
+ //课程结束时间
+ @Schema(description = "课程结束时间", example = "2026-06-02 10:00:00")
+ private LocalDateTime courseEndTime;
+
+ //上课地点
+ @Schema(description = "上课地点", example = "健身房A区")
+ private String location;
+
+ public Long getCourseId() {
+ return courseId;
+ }
+
+ public void setCourseId(Long courseId) {
+ this.courseId = courseId;
+ }
+
+ public String getCourseName() {
+ return courseName;
+ }
+
+ public void setCourseName(String courseName) {
+ this.courseName = courseName;
+ }
+
+ public Long getMemberId() {
+ return memberId;
+ }
+
+ public void setMemberId(Long memberId) {
+ this.memberId = memberId;
+ }
+
+ public Long getMemberCardRecordId() {
+ return memberCardRecordId;
+ }
+
+ public void setMemberCardRecordId(Long memberCardRecordId) {
+ this.memberCardRecordId = memberCardRecordId;
+ }
+
+ public LocalDateTime getBookingTime() {
+ return bookingTime;
+ }
+
+ public void setBookingTime(LocalDateTime bookingTime) {
+ this.bookingTime = bookingTime;
+ }
+
+ public String getStatus() {
+ return status;
+ }
+
+ public void setStatus(String status) {
+ this.status = status;
+ }
+
+ public LocalDateTime getCancelTime() {
+ return cancelTime;
+ }
+
+ public void setCancelTime(LocalDateTime cancelTime) {
+ this.cancelTime = cancelTime;
+ }
+
+ public LocalDateTime getCourseStartTime() {
+ return courseStartTime;
+ }
+
+ public void setCourseStartTime(LocalDateTime courseStartTime) {
+ this.courseStartTime = courseStartTime;
+ }
+
+ public LocalDateTime getCourseEndTime() {
+ return courseEndTime;
+ }
+
+ public void setCourseEndTime(LocalDateTime courseEndTime) {
+ this.courseEndTime = courseEndTime;
+ }
+
+ public String getLocation() {
+ return location;
+ }
+
+ public void setLocation(String location) {
+ this.location = location;
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/entity/GroupCourseBookingEntity.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/entity/GroupCourseBookingEntity.java
new file mode 100644
index 0000000..093699e
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/entity/GroupCourseBookingEntity.java
@@ -0,0 +1,137 @@
+package cn.novalon.gym.manage.groupcourse.entity;
+
+import cn.novalon.gym.manage.db.entity.BaseEntity;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.LocalDateTime;
+
+/**
+ * 团课预约记录实体类 - 对应 group_course_booking 表
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+@Table("group_course_booking")
+public class GroupCourseBookingEntity extends BaseEntity {
+
+ //团课ID
+ @Column("course_id")
+ private Long courseId;
+
+ //会员ID
+ @Column("member_id")
+ private Long memberId;
+
+ //会员卡记录ID
+ @Column("member_card_id")
+ private Long memberCardRecordId;
+
+ //预约时间
+ @Column("booking_time")
+ private LocalDateTime bookingTime;
+
+ //状态：0-已预约，1-已取消，2-已出席，3-缺席
+ @Column("status")
+ private String status;
+
+ //取消时间
+ @Column("cancel_time")
+ private LocalDateTime cancelTime;
+
+ //课程名称（冗余字段，保存预约时的课程快照）
+ @Column("course_name")
+ private String courseName;
+
+ //课程开始时间（冗余字段，保存预约时的课程快照）
+ @Column("course_start_time")
+ private LocalDateTime courseStartTime;
+
+ //课程结束时间（冗余字段，保存预约时的课程快照）
+ @Column("course_end_time")
+ private LocalDateTime courseEndTime;
+
+ //上课地点（冗余字段，保存预约时的课程快照）
+ @Column("location")
+ private String location;
+
+ public Long getCourseId() {
+ return courseId;
+ }
+
+ public void setCourseId(Long courseId) {
+ this.courseId = courseId;
+ }
+
+ public Long getMemberId() {
+ return memberId;
+ }
+
+ public void setMemberId(Long memberId) {
+ this.memberId = memberId;
+ }
+
+ public Long getMemberCardRecordId() {
+ return memberCardRecordId;
+ }
+
+ public void setMemberCardRecordId(Long memberCardRecordId) {
+ this.memberCardRecordId = memberCardRecordId;
+ }
+
+ public LocalDateTime getBookingTime() {
+ return bookingTime;
+ }
+
+ public void setBookingTime(LocalDateTime bookingTime) {
+ this.bookingTime = bookingTime;
+ }
+
+ public String getStatus() {
+ return status;
+ }
+
+ public void setStatus(String status) {
+ this.status = status;
+ }
+
+ public LocalDateTime getCancelTime() {
+ return cancelTime;
+ }
+
+ public void setCancelTime(LocalDateTime cancelTime) {
+ this.cancelTime = cancelTime;
+ }
+
+ public String getCourseName() {
+ return courseName;
+ }
+
+ public void setCourseName(String courseName) {
+ this.courseName = courseName;
+ }
+
+ public LocalDateTime getCourseStartTime() {
+ return courseStartTime;
+ }
+
+ public void setCourseStartTime(LocalDateTime courseStartTime) {
+ this.courseStartTime = courseStartTime;
+ }
+
+ public LocalDateTime getCourseEndTime() {
+ return courseEndTime;
+ }
+
+ public void setCourseEndTime(LocalDateTime courseEndTime) {
+ this.courseEndTime = courseEndTime;
+ }
+
+ public String getLocation() {
+ return location;
+ }
+
+ public void setLocation(String location) {
+ this.location = location;
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/entity/GroupCourseEntity.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/entity/GroupCourseEntity.java
new file mode 100644
index 0000000..1b16c78
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/entity/GroupCourseEntity.java
@@ -0,0 +1,168 @@
+
+package cn.novalon.gym.manage.groupcourse.entity;
+
+import cn.novalon.gym.manage.db.entity.BaseEntity;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.LocalDateTime;
+
+@Table("group_course")
+public class GroupCourseEntity extends BaseEntity {
+
+ //课程名称
+ @Column("course_name")
+ private String courseName;
+
+ //教练id
+ @Column("coach_id")
+ private Long coachId;
+
+ //课程类型
+ @Column("course_type")
+ private Long courseType;
+
+ //开始时间
+ @Column("start_time")
+ private LocalDateTime startTime;
+
+ //结束时间
+ @Column("end_time")
+ private LocalDateTime endTime;
+
+ //最大参与人数
+ @Column("max_members")
+ private Integer maxMembers;
+
+ //当前参与人数
+ @Column("current_members")
+ private Integer currentMembers;
+
+ //课程状态：0-正常，1-已取消，2-已结束
+ @Column("status")
+ private Long status;
+
+ //上课地点
+ @Column("location")
+ private String location;
+
+ //封面图URL
+ @Column("cover_image")
+ private String coverImage;
+
+ //课程描述
+ @Column("description")
+ private String description;
+
+ //点卡额度（消耗次数）
+ @Column("point_card_amount")
+ private Integer pointCardAmount;
+
+ //储值卡额度（消耗金额）
+ @Column("stored_value_amount")
+ private java.math.BigDecimal storedValueAmount;
+
+ public String getCourseName() {
+ return courseName;
+ }
+
+ public void setCourseName(String courseName) {
+ this.courseName = courseName;
+ }
+
+ public Long getCoachId() {
+ return coachId;
+ }
+
+ public void setCoachId(Long coachId) {
+ this.coachId = coachId;
+ }
+
+ public Long getCourseType() {
+ return courseType;
+ }
+
+ public void setCourseType(Long courseType) {
+ this.courseType = courseType;
+ }
+
+ public LocalDateTime getStartTime() {
+ return startTime;
+ }
+
+ public void setStartTime(LocalDateTime startTime) {
+ this.startTime = startTime;
+ }
+
+ public LocalDateTime getEndTime() {
+ return endTime;
+ }
+
+ public void setEndTime(LocalDateTime endTime) {
+ this.endTime = endTime;
+ }
+
+ public Integer getMaxMembers() {
+ return maxMembers;
+ }
+
+ public void setMaxMembers(Integer maxMembers) {
+ this.maxMembers = maxMembers;
+ }
+
+ public Integer getCurrentMembers() {
+ return currentMembers;
+ }
+
+ public void setCurrentMembers(Integer currentMembers) {
+ this.currentMembers = currentMembers;
+ }
+
+ public Long getStatus() {
+ return status;
+ }
+
+ public void setStatus(Long status) {
+ this.status = status;
+ }
+
+ public String getLocation() {
+ return location;
+ }
+
+ public void setLocation(String location) {
+ this.location = location;
+ }
+
+ public String getCoverImage() {
+ return coverImage;
+ }
+
+ public void setCoverImage(String coverImage) {
+ this.coverImage = coverImage;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public Integer getPointCardAmount() {
+ return pointCardAmount;
+ }
+
+ public void setPointCardAmount(Integer pointCardAmount) {
+ this.pointCardAmount = pointCardAmount;
+ }
+
+ public java.math.BigDecimal getStoredValueAmount() {
+ return storedValueAmount;
+ }
+
+ public void setStoredValueAmount(java.math.BigDecimal storedValueAmount) {
+ this.storedValueAmount = storedValueAmount;
+ }
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/enums/CourseEvent.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/enums/CourseEvent.java
new file mode 100644
index 0000000..94ce597
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/enums/CourseEvent.java
@@ -0,0 +1,24 @@
+package cn.novalon.gym.manage.groupcourse.enums;
+
+/**
+ * 团课状态机事件枚举
+ *
+ * @author 张翔
+ * @date 2026-06-02
+ */
+public enum CourseEvent {
+
+ CANCEL("取消课程"),
+ END("结束课程"),
+ START("开始课程");
+
+ private final String desc;
+
+ CourseEvent(String desc) {
+ this.desc = desc;
+ }
+
+ public String getDesc() {
+ return desc;
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/enums/CourseStatus.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/enums/CourseStatus.java
new file mode 100644
index 0000000..ed198e6
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/enums/CourseStatus.java
@@ -0,0 +1,43 @@
+package cn.novalon.gym.manage.groupcourse.enums;
+
+/**
+ * 团课状态枚举
+ *
+ * @author 张翔
+ * @date 2026-06-02
+ */
+public enum CourseStatus {
+
+ NORMAL(0L, "正常"),
+ CANCELLED(1L, "已取消"),
+ ENDED(2L, "已结束"),
+ IN_PROGRESS(3L, "进行中");
+
+ private final Long value;
+ private final String desc;
+
+ CourseStatus(Long value, String desc) {
+ this.value = value;
+ this.desc = desc;
+ }
+
+ public Long getValue() {
+ return value;
+ }
+
+ public String getDesc() {
+ return desc;
+ }
+
+ /**
+ * 根据值获取枚举
+ */
+ public static CourseStatus fromValue(Long value) {
+ for (CourseStatus status : values()) {
+ if (status.value.equals(value)) {
+ return status;
+ }
+ }
+ return NORMAL;
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/event/BookingReminderEvent.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/event/BookingReminderEvent.java
new file mode 100644
index 0000000..0933035
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/event/BookingReminderEvent.java
@@ -0,0 +1,57 @@
+package cn.novalon.gym.manage.groupcourse.event;
+
+import org.springframework.context.ApplicationEvent;
+
+/**
+ * 预约提醒事件
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+public class BookingReminderEvent extends ApplicationEvent {
+
+ /**
+ * 消息类型枚举
+ */
+ public enum ReminderType {
+ BOOKING_SUCCESS, // 预约成功
+ COURSE_REMINDER, // 课程即将开始提醒
+ BOOKING_CANCEL // 预约取消
+ }
+
+ private final Long bookingId;
+ private final Long memberId;
+ private final String courseName;
+ private final String courseTime;
+ private final ReminderType type;
+
+ public BookingReminderEvent(Object source, Long bookingId, Long memberId,
+ String courseName, String courseTime, ReminderType type) {
+ super(source);
+ this.bookingId = bookingId;
+ this.memberId = memberId;
+ this.courseName = courseName;
+ this.courseTime = courseTime;
+ this.type = type;
+ }
+
+ public Long getBookingId() {
+ return bookingId;
+ }
+
+ public Long getMemberId() {
+ return memberId;
+ }
+
+ public String getCourseName() {
+ return courseName;
+ }
+
+ public String getCourseTime() {
+ return courseTime;
+ }
+
+ public ReminderType getType() {
+ return type;
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/event/BookingReminderEventListener.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/event/BookingReminderEventListener.java
new file mode 100644
index 0000000..9ffa621
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/event/BookingReminderEventListener.java
@@ -0,0 +1,98 @@
+package cn.novalon.gym.manage.groupcourse.event;
+
+import cn.novalon.gym.manage.groupcourse.event.BookingReminderEvent.ReminderType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+
+/**
+ * 预约提醒事件监听器
+ *
+ * 监听预约相关事件，处理提醒业务
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+@Component
+public class BookingReminderEventListener {
+
+ private static final Logger logger = LoggerFactory.getLogger(BookingReminderEventListener.class);
+
+ /**
+ * 处理预约提醒事件
+ *
+ * @param event 预约提醒事件
+ */
+ @EventListener
+ public void handleBookingReminderEvent(BookingReminderEvent event) {
+ logger.info("收到预约提醒事件：type={}, bookingId={}, memberId={}",
+ event.getType(), event.getBookingId(), event.getMemberId());
+
+ try {
+ processReminderEvent(event);
+ } catch (Exception e) {
+ logger.error("处理预约提醒事件失败：bookingId={}, error={}",
+ event.getBookingId(), e.getMessage(), e);
+ }
+ }
+
+ /**
+ * 处理提醒事件
+ *
+ * 根据事件类型执行不同的提醒逻辑
+ */
+ private void processReminderEvent(BookingReminderEvent event) {
+ switch (event.getType()) {
+ case BOOKING_SUCCESS:
+ handleBookingSuccess(event);
+ break;
+ case COURSE_REMINDER:
+ handleCourseReminder(event);
+ break;
+ case BOOKING_CANCEL:
+ handleBookingCancel(event);
+ break;
+ default:
+ logger.warn("未知的提醒事件类型：{}", event.getType());
+ }
+
+ logger.info("预约提醒事件处理完成：bookingId={}", event.getBookingId());
+ }
+
+ /**
+ * 处理预约成功事件
+ */
+ private void handleBookingSuccess(BookingReminderEvent event) {
+ logger.info("处理预约成功提醒：会员ID={}, 课程={}, 时间={}",
+ event.getMemberId(), event.getCourseName(), event.getCourseTime());
+
+ // 实际业务中会调用通知服务发送短信、APP推送等
+ // sendNotification(event.getMemberId(), "预约成功",
+ // "您已成功预约课程：" + event.getCourseName() + "，时间：" + event.getCourseTime());
+ }
+
+ /**
+ * 处理课程即将开始提醒事件
+ */
+ private void handleCourseReminder(BookingReminderEvent event) {
+ logger.info("处理课程提醒：会员ID={}, 课程={}, 时间={}",
+ event.getMemberId(), event.getCourseName(), event.getCourseTime());
+
+ // 实际业务中会调用通知服务发送课程开始前提醒
+ // sendNotification(event.getMemberId(), "课程提醒",
+ // "您预约的课程" + event.getCourseName() + "即将开始，时间：" + event.getCourseTime());
+ }
+
+ /**
+ * 处理预约取消事件
+ */
+ private void handleBookingCancel(BookingReminderEvent event) {
+ logger.info("处理预约取消提醒：会员ID={}, 课程={}",
+ event.getMemberId(), event.getCourseName());
+
+ // 实际业务中会调用通知服务发送预约取消通知
+ // sendNotification(event.getMemberId(), "预约取消",
+ // "您已取消课程：" + event.getCourseName() + "的预约");
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/event/BookingReminderEventPublisher.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/event/BookingReminderEventPublisher.java
new file mode 100644
index 0000000..5c50bd6
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/event/BookingReminderEventPublisher.java
@@ -0,0 +1,74 @@
+package cn.novalon.gym.manage.groupcourse.event;
+
+import cn.novalon.gym.manage.groupcourse.event.BookingReminderEvent.ReminderType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.stereotype.Component;
+
+/**
+ * 预约提醒事件发布器
+ *
+ * 使用Spring事件机制发布预约相关事件
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+@Component
+public class BookingReminderEventPublisher {
+
+ private static final Logger logger = LoggerFactory.getLogger(BookingReminderEventPublisher.class);
+
+ private final ApplicationEventPublisher eventPublisher;
+
+ public BookingReminderEventPublisher(ApplicationEventPublisher eventPublisher) {
+ this.eventPublisher = eventPublisher;
+ }
+
+ /**
+ * 发布预约成功事件
+ *
+ * @param bookingId 预约ID
+ * @param memberId 会员ID
+ * @param courseName 课程名称
+ * @param courseTime 课程时间
+ */
+ public void publishBookingSuccessEvent(Long bookingId, Long memberId, String courseName, String courseTime) {
+ BookingReminderEvent event = new BookingReminderEvent(
+ this, bookingId, memberId, courseName, courseTime, ReminderType.BOOKING_SUCCESS);
+
+ logger.info("发布预约成功事件：bookingId={}, memberId={}", bookingId, memberId);
+ eventPublisher.publishEvent(event);
+ }
+
+ /**
+ * 发布课程即将开始提醒事件
+ *
+ * @param bookingId 预约ID
+ * @param memberId 会员ID
+ * @param courseName 课程名称
+ * @param courseTime 课程时间
+ */
+ public void publishCourseReminderEvent(Long bookingId, Long memberId, String courseName, String courseTime) {
+ BookingReminderEvent event = new BookingReminderEvent(
+ this, bookingId, memberId, courseName, courseTime, ReminderType.COURSE_REMINDER);
+
+ logger.info("发布课程提醒事件：bookingId={}, memberId={}", bookingId, memberId);
+ eventPublisher.publishEvent(event);
+ }
+
+ /**
+ * 发布预约取消事件
+ *
+ * @param bookingId 预约ID
+ * @param memberId 会员ID
+ * @param courseName 课程名称
+ */
+ public void publishBookingCancelEvent(Long bookingId, Long memberId, String courseName) {
+ BookingReminderEvent event = new BookingReminderEvent(
+ this, bookingId, memberId, courseName, null, ReminderType.BOOKING_CANCEL);
+
+ logger.info("发布预约取消事件：bookingId={}, memberId={}", bookingId, memberId);
+ eventPublisher.publishEvent(event);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/BookingSagaHandler.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/BookingSagaHandler.java
new file mode 100644
index 0000000..b62032d
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/BookingSagaHandler.java
@@ -0,0 +1,369 @@
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import cn.novalon.gym.manage.groupcourse.service.impl.GroupCourseRedisService;
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.enums.MemberCardType;
+import cn.novalon.gym.manage.member.repository.MemberCardRepository;
+import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * 预约 Saga 处理器
+ *
+ * 实现预约和取消预约的分布式事务处理
+ *
+ * @author 张翔
+ * @date 2026-06-02
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class BookingSagaHandler {
+
+ private final IGroupCourseBookingRepository bookingRepository;
+ private final IGroupCourseRepository courseRepository;
+ private final IMemberCardRecordService memberCardRecordService;
+ private final MemberCardRepository memberCardRepository;
+ private final GroupCourseRedisService redisService;
+
+ private static final double DEFAULT_GROUP_COURSE_PRICE = 50.0;
+
+ /**
+ * 执行预约事务
+ *
+ * 步骤：
+ * 1. 保存预约记录
+ * 2. 扣减会员卡权益
+ * 3. 更新课程当前人数
+ */
+ public Mono executeBooking(GroupCourseBooking booking, Long recordId) {
+ List steps = new ArrayList<>();
+ List rollbackSteps = new ArrayList<>();
+
+ // 步骤1：保存预约记录
+ SagaStep step1 = new SagaStep(
+ "保存预约记录",
+ saveBooking(booking),
+ Mono.defer(() -> deleteBooking(booking.getId()))
+ );
+ steps.add(step1);
+ rollbackSteps.add(0, step1);
+
+ // 步骤2：扣减会员卡权益（根据卡类型决定扣除次数还是金额）
+ SagaStep step2 = new SagaStep(
+ "扣减会员卡权益",
+ deductCardUsageByCardType(booking.getMemberId(), recordId),
+ Mono.defer(() -> restoreCardUsageByCardType(booking.getMemberId(), recordId))
+ );
+ steps.add(step2);
+ rollbackSteps.add(0, step2);
+
+ // 步骤3：更新课程当前人数
+ SagaStep step3 = new SagaStep(
+ "更新课程当前人数",
+ incrementCourseCurrentMembers(booking.getCourseId()),
+ Mono.defer(() -> decrementCourseCurrentMembers(booking.getCourseId()))
+ );
+ steps.add(step3);
+ rollbackSteps.add(0, step3);
+
+ // 步骤4：更新Redis预约计数
+ SagaStep step4 = new SagaStep(
+ "更新Redis预约计数",
+ incrementRedisBookingCount(booking.getCourseId()),
+ Mono.defer(() -> decrementRedisBookingCount(booking.getCourseId()))
+ );
+ steps.add(step4);
+ rollbackSteps.add(0, step4);
+
+ return executeSaga(steps, rollbackSteps)
+ .then(Mono.just(booking));
+ }
+
+ /**
+ * 根据会员卡类型扣减权益
+ */
+ private Mono deductCardUsageByCardType(Long memberId, Long recordId) {
+ return memberCardRecordService.findById(recordId)
+ .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
+ .flatMap(record -> {
+ // 验证会员卡归属
+ if (!record.getMemberId().equals(memberId)) {
+ return Mono.error(new RuntimeException("会员卡不归属当前用户"));
+ }
+
+ return memberCardRepository.findById(record.getMemberCardId())
+ .flatMap(card -> {
+ MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+
+ switch (cardType) {
+ case COUNT_CARD:
+ // 次卡扣除次数
+ return deductCardUsage(recordId, 1, 0.0);
+ case STORED_VALUE_CARD:
+ // 储值卡扣除金额
+ return deductCardUsage(recordId, 0, DEFAULT_GROUP_COURSE_PRICE);
+ case TIME_CARD:
+ // 时长卡不扣除，但需验证有效期
+ return validateTimeCard(record);
+ default:
+ return Mono.error(new RuntimeException("不支持的会员卡类型: " + cardType));
+ }
+ });
+ });
+ }
+
+ /**
+ * 验证时长卡有效期
+ *
+ * @param record 会员卡记录
+ * @return 验证通过返回Mono.empty()，否则返回Mono.error()
+ */
+ private Mono validateTimeCard(MemberCardRecord record) {
+ // 验证会员卡状态
+ cn.novalon.gym.manage.member.enums.MemberCardRecordStatus status = record.getStatus();
+ if (status != cn.novalon.gym.manage.member.enums.MemberCardRecordStatus.ACTIVE) {
+ return Mono.error(new RuntimeException("会员卡状态无效，当前状态: " + (status != null ? status.getDesc() : "未知")));
+ }
+
+ // 验证有效期
+ java.time.LocalDateTime expireTime = record.getExpireTime();
+ if (expireTime == null) {
+ return Mono.error(new RuntimeException("会员卡有效期未设置"));
+ }
+ if (expireTime.isBefore(java.time.LocalDateTime.now())) {
+ return Mono.error(new RuntimeException("会员卡已过期，有效期至: " + expireTime));
+ }
+
+ log.debug("时长卡验证通过: recordId={}, expireTime={}", record.getId(), expireTime);
+ return Mono.empty();
+ }
+
+ /**
+ * 根据会员卡类型恢复权益
+ */
+ private Mono restoreCardUsageByCardType(Long memberId, Long recordId) {
+ return memberCardRecordService.findById(recordId)
+ .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在，无法恢复权益")))
+ .flatMap(record -> {
+ // 验证会员卡归属（memberId为null时跳过验证）
+ if (memberId != null && !record.getMemberId().equals(memberId)) {
+ return Mono.error(new RuntimeException("会员卡不归属当前用户"));
+ }
+
+ return memberCardRepository.findById(record.getMemberCardId())
+ .flatMap(card -> {
+ MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+
+ switch (cardType) {
+ case COUNT_CARD:
+ return restoreCardUsage(recordId, 1, 0.0);
+ case STORED_VALUE_CARD:
+ return restoreCardUsage(recordId, 0, DEFAULT_GROUP_COURSE_PRICE);
+ case TIME_CARD:
+ return Mono.empty();
+ default:
+ return Mono.error(new RuntimeException("不支持的会员卡类型: " + cardType));
+ }
+ });
+ });
+ }
+
+ /**
+ * 执行取消预约事务
+ */
+ public Mono executeCancelBooking(Long bookingId, Long courseId, Long recordId, Long memberId) {
+ List steps = new ArrayList<>();
+ List rollbackSteps = new ArrayList<>();
+
+ // 步骤1：更新预约状态为已取消
+ SagaStep step1 = new SagaStep(
+ "更新预约状态为已取消",
+ updateBookingStatus(bookingId, "1"),
+ Mono.defer(() -> updateBookingStatus(bookingId, "0"))
+ );
+ steps.add(step1);
+ rollbackSteps.add(0, step1);
+
+ // 步骤2：恢复会员卡权益
+ SagaStep step2 = new SagaStep(
+ "恢复会员卡权益",
+ restoreCardUsageByCardType(memberId, recordId),
+ Mono.defer(() -> deductCardUsageByCardType(memberId, recordId))
+ );
+ steps.add(step2);
+ rollbackSteps.add(0, step2);
+
+ // 步骤3：减少课程当前人数
+ SagaStep step3 = new SagaStep(
+ "减少课程当前人数",
+ decrementCourseCurrentMembers(courseId),
+ Mono.defer(() -> incrementCourseCurrentMembers(courseId))
+ );
+ steps.add(step3);
+ rollbackSteps.add(0, step3);
+
+ // 步骤4：更新Redis预约计数
+ SagaStep step4 = new SagaStep(
+ "更新Redis预约计数",
+ decrementRedisBookingCount(courseId),
+ Mono.defer(() -> incrementRedisBookingCount(courseId))
+ );
+ steps.add(step4);
+ rollbackSteps.add(0, step4);
+
+ return executeSaga(steps, rollbackSteps)
+ .then(bookingRepository.findById(bookingId));
+ }
+
+ private Mono updateBookingStatus(Long bookingId, String status) {
+ return bookingRepository.updateStatus(bookingId, status)
+ .flatMap(rows -> {
+ if (rows == 0) {
+ return Mono.error(new RuntimeException("更新预约状态失败"));
+ }
+ return Mono.empty();
+ });
+ }
+
+ private Mono saveBooking(GroupCourseBooking booking) {
+ return bookingRepository.save(booking)
+ .flatMap(saved -> {
+ if (saved.getId() == null) {
+ return Mono.error(new RuntimeException("保存预约记录失败"));
+ }
+ booking.setId(saved.getId());
+ return Mono.empty();
+ });
+ }
+
+ private Mono deleteBooking(Long bookingId) {
+ return bookingRepository.deleteById(bookingId);
+ }
+
+ private Mono deductCardUsage(Long recordId, Integer deductTimes, Double deductAmount) {
+ if (deductTimes == 0 && deductAmount == 0.0) {
+ return Mono.empty();
+ }
+
+ return memberCardRecordService.findById(recordId)
+ .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
+ .flatMap(record -> {
+ cn.novalon.gym.manage.member.enums.MemberCardRecordStatus status = record.getStatus();
+ if (status != cn.novalon.gym.manage.member.enums.MemberCardRecordStatus.ACTIVE) {
+ return Mono.error(new RuntimeException("会员卡状态无效，当前状态: " + (status != null ? status.getDesc() : "未知")));
+ }
+ java.time.LocalDateTime expireTime = record.getExpireTime();
+ if (expireTime != null && expireTime.isBefore(java.time.LocalDateTime.now())) {
+ return Mono.error(new RuntimeException("会员卡已过期"));
+ }
+ if (record.getRemainingTimes() != null && deductTimes > 0 && record.getRemainingTimes() < deductTimes) {
+ return Mono.error(new RuntimeException("会员卡剩余次数不足，当前剩余: " + record.getRemainingTimes() + "次"));
+ }
+ if (record.getRemainingAmount() != null && deductAmount > 0 && record.getRemainingAmount() < deductAmount) {
+ return Mono.error(new RuntimeException("会员卡余额不足，当前剩余: " + record.getRemainingAmount()));
+ }
+ return memberCardRecordService.deductUsage(recordId, deductTimes, deductAmount)
+ .flatMap(rows -> {
+ if (rows == 0) {
+ return Mono.error(new RuntimeException("扣减会员卡权益失败，请重试"));
+ }
+ return Mono.empty();
+ });
+ });
+ }
+
+ private Mono restoreCardUsage(Long recordId, Integer addTimes, Double addAmount) {
+ if (addTimes == 0 && addAmount == 0.0) {
+ return Mono.empty();
+ }
+
+ return memberCardRecordService.findById(recordId)
+ .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在，无法恢复权益")))
+ .flatMap(record -> {
+ // 使用当前记录的过期时间，避免清空过期时间
+ return memberCardRecordService.renewCard(recordId, addTimes, addAmount, record.getExpireTime())
+ .flatMap(rows -> {
+ if (rows == 0) {
+ return Mono.error(new RuntimeException("恢复会员卡权益失败，请重试"));
+ }
+ return Mono.empty();
+ });
+ });
+ }
+
+ private Mono incrementCourseCurrentMembers(Long courseId) {
+ return courseRepository.updateCurrentMembers(courseId, 1).then();
+ }
+
+ private Mono decrementCourseCurrentMembers(Long courseId) {
+ return courseRepository.updateCurrentMembers(courseId, -1).then();
+ }
+
+ private Mono incrementRedisBookingCount(Long courseId) {
+ return redisService.incrementBookingCount(courseId).then();
+ }
+
+ private Mono decrementRedisBookingCount(Long courseId) {
+ return redisService.decrementBookingCount(courseId).then();
+ }
+
+ private Mono executeSaga(List steps, List rollbackSteps) {
+ List completedSteps = new ArrayList<>();
+ return executeStep(steps, 0, completedSteps);
+ }
+
+ private Mono executeStep(List steps, int index, List completedSteps) {
+ if (index >= steps.size()) {
+ return Mono.empty();
+ }
+
+ SagaStep currentStep = steps.get(index);
+
+ return currentStep.operation()
+ .doOnSuccess(unused -> completedSteps.add(currentStep))
+ .then(Mono.defer(() -> executeStep(steps, index + 1, completedSteps)))
+ .onErrorResume(error -> {
+ log.error("Saga步骤执行失败: step={}, error={}", currentStep.description(), error.getMessage());
+ return rollbackCompletedSteps(completedSteps).then(Mono.error(error));
+ });
+ }
+
+ private Mono rollbackCompletedSteps(List completedSteps) {
+ if (completedSteps.isEmpty()) {
+ return Mono.empty();
+ }
+
+ // 反转已完成的步骤，按逆序回滚
+ List reversed = new ArrayList<>(completedSteps);
+ Collections.reverse(reversed);
+
+ return rollbackSteps(reversed, 0);
+ }
+
+ private Mono rollbackSteps(List rollbackSteps, int index) {
+ if (index >= rollbackSteps.size()) {
+ return Mono.empty();
+ }
+
+ SagaStep currentStep = rollbackSteps.get(index);
+
+ return currentStep.rollbackOperation()
+ .then(Mono.defer(() -> rollbackSteps(rollbackSteps, index + 1)))
+ .doOnError(error -> log.error("Saga回滚失败: step={}, error={}", currentStep.description(), error.getMessage()))
+ .onErrorResume(e -> Mono.empty());
+ }
+
+ private record SagaStep(String description, Mono operation, Mono rollbackOperation) {}
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseBookingHandler.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseBookingHandler.java
new file mode 100644
index 0000000..e879c5c
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseBookingHandler.java
@@ -0,0 +1,141 @@
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseBookingService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import reactor.core.publisher.Mono;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 团课预约Handler
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+@Component
+@Tag(name = "团课预约", description = "团课预约相关操作")
+public class GroupCourseBookingHandler {
+
+ private final IGroupCourseBookingService bookingService;
+
+ public GroupCourseBookingHandler(IGroupCourseBookingService bookingService) {
+ this.bookingService = bookingService;
+ }
+
+ /**
+ * 预约团课
+ */
+ @Operation(summary = "预约团课", description = "会员预约指定团课")
+ public Mono bookCourse(ServerRequest request) {
+ return request.bodyToMono(Map.class)
+ .flatMap(body -> {
+ // 验证必填参数
+ if (body.get("courseId") == null) {
+ return buildErrorResponse("请提供课程ID");
+ }
+ if (body.get("memberId") == null) {
+ return buildErrorResponse("请提供会员ID");
+ }
+ if (body.get("memberCardRecordId") == null) {
+ return buildErrorResponse("请提供会员卡记录ID");
+ }
+
+ Long courseId = ((Number) body.get("courseId")).longValue();
+ Long memberId = ((Number) body.get("memberId")).longValue();
+ Long memberCardRecordId = ((Number) body.get("memberCardRecordId")).longValue();
+
+ return bookingService.bookCourse(courseId, memberId, memberCardRecordId)
+ .flatMap(booking -> {
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "预约成功");
+ response.put("data", booking);
+ return ServerResponse.ok().bodyValue(response);
+ })
+ .onErrorResume(error -> {
+ Map response = new HashMap<>();
+ response.put("success", false);
+ response.put("message", error.getMessage());
+ return ServerResponse.badRequest().bodyValue(response);
+ });
+ });
+ }
+
+ /**
+ * 取消预约
+ */
+ @Operation(summary = "取消预约", description = "会员取消已预约的团课")
+ public Mono cancelBooking(ServerRequest request) {
+ Long bookingId = Long.valueOf(request.pathVariable("bookingId"));
+
+ return request.bodyToMono(Map.class)
+ .flatMap(body -> {
+ Long memberId = ((Number) body.get("memberId")).longValue();
+
+ return bookingService.cancelBooking(bookingId, memberId)
+ .flatMap(booking -> {
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "取消成功");
+ response.put("data", booking);
+ return ServerResponse.ok().bodyValue(response);
+ })
+ .onErrorResume(error -> {
+ Map response = new HashMap<>();
+ response.put("success", false);
+ response.put("message", error.getMessage());
+ return ServerResponse.badRequest().bodyValue(response);
+ });
+ });
+ }
+
+ /**
+ * 查询会员预约记录
+ */
+ @Operation(summary = "查询会员预约记录", description = "根据会员ID查询所有预约记录")
+ public Mono getBookingsByMemberId(ServerRequest request) {
+ Long memberId = Long.valueOf(request.pathVariable("memberId"));
+
+ return ServerResponse.ok()
+ .body(bookingService.getBookingsByMemberId(memberId), GroupCourseBooking.class);
+ }
+
+ /**
+ * 查询预约详情
+ */
+ @Operation(summary = "查询预约详情", description = "根据预约ID查询预约详情")
+ public Mono getBookingById(ServerRequest request) {
+ Long bookingId = Long.valueOf(request.pathVariable("bookingId"));
+
+ return bookingService.getBookingById(bookingId)
+ .flatMap(booking -> ServerResponse.ok().bodyValue(booking))
+ .switchIfEmpty(ServerResponse.notFound().build());
+ }
+
+ /**
+ * 查询课程预约记录
+ */
+ @Operation(summary = "查询课程预约记录", description = "根据团课ID查询所有预约记录")
+ public Mono getBookingsByCourseId(ServerRequest request) {
+ Long courseId = Long.valueOf(request.pathVariable("courseId"));
+
+ return ServerResponse.ok()
+ .body(bookingService.getBookingsByCourseId(courseId), GroupCourseBooking.class);
+ }
+
+ /**
+ * 构建错误响应
+ */
+ private Mono buildErrorResponse(String message) {
+ Map response = new HashMap<>();
+ response.put("success", false);
+ response.put("message", message);
+ return ServerResponse.badRequest().bodyValue(response);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandler.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandler.java
new file mode 100644
index 0000000..0b4d38b
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandler.java
@@ -0,0 +1,261 @@
+
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseService;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Validator;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import reactor.core.publisher.Mono;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Component
+@Tag(name="团课管理",description = "团课相关操作")
+public class GroupCourseHandler {
+ private final IGroupCourseService groupCourseService;
+ private final Validator validator;
+ private final RedisUtil redisUtil;
+ private final ObjectMapper objectMapper;
+
+ public GroupCourseHandler(IGroupCourseService groupCourseService,
+ Validator validator,
+ RedisUtil redisUtil,
+ ObjectMapper objectMapper){
+ this.groupCourseService = groupCourseService;
+ this.validator = validator;
+ this.redisUtil = redisUtil;
+ this.objectMapper = objectMapper;
+ }
+
+ @Operation(summary = "获取所有团课", description = "获取系统中所有团课列表")
+ public Mono getAllGroupCourse(ServerRequest request){
+ boolean includeDeleted = Boolean.valueOf(request.queryParam("includeDeleted").orElse("false"));
+ return ServerResponse.ok()
+ .body(groupCourseService.findAll(includeDeleted), GroupCourse.class);
+ }
+
+ @Operation(summary = "分页获取团课", description = "根据分页参数获取团课列表")
+ public Mono getGroupCoursesByPage(ServerRequest request) {
+ return request.bodyToMono(PageRequest.class)
+ .flatMap(pageRequest -> {
+ boolean includeDeleted = request.queryParam("includeDeleted")
+ .map(Boolean::parseBoolean)
+ .orElse(false);
+
+ if (pageRequest.getPage() < 0) {
+ pageRequest.setPage(0);
+ }
+ if (pageRequest.getSize() <= 0 || pageRequest.getSize() > 100) {
+ pageRequest.setSize(10);
+ }
+ if (pageRequest.getSort() == null || pageRequest.getSort().isEmpty()) {
+ pageRequest.setSort("id");
+ }
+ if (pageRequest.getOrder() == null || pageRequest.getOrder().isEmpty()) {
+ pageRequest.setOrder("asc");
+ }
+
+ return groupCourseService.findByPage(pageRequest, includeDeleted)
+ .flatMap(response -> ServerResponse.ok().bodyValue(response));
+ });
+ }
+
+ @Operation(summary = "根据ID获取团课", description = "根据ID获取团课详情")
+ public Mono getGroupCourseById(ServerRequest request){
+ Long id = Long.valueOf(request.pathVariable("id"));
+ return groupCourseService.findById(id)
+ .flatMap(course -> ServerResponse.ok().bodyValue(course))
+ .switchIfEmpty(ServerResponse.notFound().build());
+ }
+
+ @Operation(summary = "创建团课", description = "创建新的团课")
+ public Mono createGroupCourse(ServerRequest request) {
+ return request.bodyToMono(GroupCourse.class)
+ .flatMap(groupCourse -> {
+ if (groupCourse.getCourseName() == null || groupCourse.getCourseName().isEmpty()) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("message", "课程名称不能为空");
+ return ServerResponse.badRequest().bodyValue(error);
+ }
+
+ return groupCourseService.create(groupCourse)
+ .flatMap(course -> {
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "团课创建成功");
+ response.put("data", course);
+ return ServerResponse.ok().bodyValue(response);
+ })
+ .onErrorResume(error -> {
+ Map response = new HashMap<>();
+ response.put("success", false);
+ response.put("message", error.getMessage());
+ return ServerResponse.badRequest().bodyValue(response);
+ });
+ });
+ }
+
+ @Operation(summary = "更新团课", description = "更新指定团课信息")
+ public Mono updateGroupCourse(ServerRequest request) {
+ Long id = Long.valueOf(request.pathVariable("id"));
+
+ return request.bodyToMono(GroupCourse.class)
+ .flatMap(groupCourse -> {
+ return groupCourseService.update(id, groupCourse)
+ .flatMap(course -> {
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "团课更新成功");
+ response.put("data", course);
+ return ServerResponse.ok().bodyValue(response);
+ })
+ .onErrorResume(error -> {
+ Map response = new HashMap<>();
+ response.put("success", false);
+ response.put("message", error.getMessage());
+ return ServerResponse.badRequest().bodyValue(response);
+ });
+ });
+ }
+
+ @Operation(summary = "取消团课", description = "取消指定团课（需提前24小时）")
+ public Mono cancelGroupCourse(ServerRequest request) {
+ Long id = Long.valueOf(request.pathVariable("id"));
+
+ return groupCourseService.cancel(id)
+ .flatMap(course -> {
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "团课取消成功");
+ response.put("data", course);
+ return ServerResponse.ok().bodyValue(response);
+ })
+ .onErrorResume(error -> {
+ Map response = new HashMap<>();
+ response.put("success", false);
+ response.put("message", error.getMessage());
+ return ServerResponse.badRequest().bodyValue(response);
+ });
+ }
+
+ @Operation(summary = "团课签到", description = "会员签到参加团课")
+ public Mono signIn(ServerRequest request) {
+ Long courseId = Long.valueOf(request.pathVariable("courseId"));
+
+ return request.bodyToMono(Map.class)
+ .flatMap(body -> {
+ if (body == null || body.isEmpty()) {
+ Map response = new HashMap<>();
+ response.put("success", false);
+ response.put("message", "请求体不能为空");
+ return ServerResponse.badRequest().bodyValue(response);
+ }
+
+ Object memberIdObj = body.get("memberId");
+ if (memberIdObj == null) {
+ Map response = new HashMap<>();
+ response.put("success", false);
+ response.put("message", "memberId不能为空");
+ return ServerResponse.badRequest().bodyValue(response);
+ }
+
+ Long memberId = ((Number) memberIdObj).longValue();
+
+ return groupCourseService.signIn(courseId, memberId)
+ .flatMap(course -> {
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "签到成功");
+ response.put("data", course);
+ return ServerResponse.ok().bodyValue(response);
+ })
+ .onErrorResume(error -> {
+ Map response = new HashMap<>();
+ response.put("success", false);
+ response.put("message", error.getMessage());
+ return ServerResponse.badRequest().bodyValue(response);
+ });
+ });
+ }
+
+ @Operation(summary = "删除团课", description = "删除指定团课（软删除）")
+ public Mono deleteGroupCourse(ServerRequest request) {
+ Long id = Long.valueOf(request.pathVariable("id"));
+
+ return groupCourseService.delete(id)
+ .then(Mono.defer(() -> {
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "团课删除成功");
+ return ServerResponse.ok().bodyValue(response);
+ }))
+ .onErrorResume(error -> {
+ Map response = new HashMap<>();
+ response.put("success", false);
+ response.put("message", error.getMessage());
+ return ServerResponse.badRequest().bodyValue(response);
+ });
+ }
+
+ @Operation(summary = "测试-根据Key获取Redis缓存", description = "测试接口：根据传入的key值获取Redis中缓存的数据")
+ public Mono getCacheByKey(ServerRequest request) {
+ return request.bodyToMono(Map.class)
+ .flatMap(body -> {
+ String key = (String) body.get("key");
+
+ if (key == null || key.isEmpty()) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("message", "key参数不能为空");
+ return ServerResponse.badRequest().bodyValue(error);
+ }
+
+ return redisUtil.get(key)
+ .map(cachedValue -> {
+ Map result = new HashMap<>();
+ if (cachedValue != null) {
+ result.put("success", true);
+ result.put("key", key);
+ result.put("value", cachedValue);
+ result.put("message", "缓存命中");
+
+ try {
+ if (cachedValue instanceof String) {
+ Object jsonObject = objectMapper.readValue((String) cachedValue, Object.class);
+ result.put("parsedValue", jsonObject);
+ result.put("valueType", "JSON字符串");
+ } else {
+ result.put("valueType", cachedValue.getClass().getSimpleName());
+ }
+ } catch (Exception e) {
+ result.put("parsedValue", null);
+ result.put("valueType", "无法解析");
+ }
+ } else {
+ result.put("success", false);
+ result.put("key", key);
+ result.put("value", null);
+ result.put("message", "缓存未命中");
+ }
+
+ return result;
+ })
+ .flatMap(result -> ServerResponse.ok().bodyValue(result))
+ .onErrorResume(error -> {
+ Map errorResponse = new HashMap<>();
+ errorResponse.put("success", false);
+ errorResponse.put("message", "请求处理失败: " + error.getMessage());
+ return ServerResponse.status(500).bodyValue(errorResponse);
+ });
+ });
+ }
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseStateMachine.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseStateMachine.java
new file mode 100644
index 0000000..79fb78b
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseStateMachine.java
@@ -0,0 +1,139 @@
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.enums.CourseEvent;
+import cn.novalon.gym.manage.groupcourse.enums.CourseStatus;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 团课状态机处理器
+ *
+ * 管理团课的状态转换逻辑
+ *
+ * @author 张翔
+ * @date 2026-06-02
+ */
+@Slf4j
+@Component
+public class GroupCourseStateMachine {
+
+ private final Map> stateTransitionMap;
+
+ public GroupCourseStateMachine() {
+ this.stateTransitionMap = buildStateTransitionMap();
+ }
+
+ private Map> buildStateTransitionMap() {
+ Map> map = new HashMap<>();
+
+ // NORMAL 状态可以转换的事件
+ Map normalTransitions = new HashMap<>();
+ normalTransitions.put(CourseEvent.CANCEL, CourseStatus.CANCELLED);
+ normalTransitions.put(CourseEvent.END, CourseStatus.ENDED);
+ normalTransitions.put(CourseEvent.START, CourseStatus.IN_PROGRESS);
+ map.put(CourseStatus.NORMAL, normalTransitions);
+
+ // IN_PROGRESS 状态可以转换的事件
+ Map inProgressTransitions = new HashMap<>();
+ inProgressTransitions.put(CourseEvent.END, CourseStatus.ENDED);
+ map.put(CourseStatus.IN_PROGRESS, inProgressTransitions);
+
+ // CANCELLED 状态是终态，不允许任何转换
+
+ // ENDED 状态是终态，不允许任何转换
+
+ return map;
+ }
+
+ /**
+ * 检查是否可以转换状态
+ */
+ public Mono canTransition(CourseStatus currentState, CourseEvent event) {
+ return Mono.fromSupplier(() -> {
+ Map transitions = stateTransitionMap.get(currentState);
+ if (transitions == null) {
+ return false;
+ }
+ return transitions.containsKey(event);
+ });
+ }
+
+ /**
+ * 执行状态转换
+ */
+ public Mono transition(CourseStatus currentState, CourseEvent event) {
+ return Mono.fromSupplier(() -> {
+ Map transitions = stateTransitionMap.get(currentState);
+ if (transitions == null || !transitions.containsKey(event)) {
+ log.error("Invalid state transition: currentState={}, event={}", currentState, event);
+ throw new IllegalStateException(
+ String.format("不允许的状态转换: 当前状态=%s, 事件=%s", currentState, event));
+ }
+ CourseStatus newState = transitions.get(event);
+ log.info("State transition: {} --({})--> {}", currentState, event, newState);
+ return newState;
+ });
+ }
+
+ /**
+ * 验证状态转换是否允许
+ */
+ public Mono validateTransition(GroupCourse course, CourseEvent event) {
+ Long statusValue = course.getStatus();
+ CourseStatus currentState = CourseStatus.fromValue(statusValue != null ? statusValue : 0L);
+
+ return canTransition(currentState, event)
+ .flatMap(canTransition -> {
+ if (!canTransition) {
+ String errorMessage = buildErrorMessage(course.getId(), currentState, event);
+ return Mono.error(new IllegalStateException(errorMessage));
+ }
+ return Mono.empty();
+ });
+ }
+
+ /**
+ * 构建状态转换错误信息
+ */
+ private String buildErrorMessage(Long courseId, CourseStatus currentState, CourseEvent event) {
+ String currentStateDesc = currentState.getDesc();
+ String eventDesc = event.getDesc();
+
+ String advice = "";
+ switch (currentState) {
+ case CANCELLED:
+ advice = "（课程已取消，无法进行此操作）";
+ break;
+ case ENDED:
+ advice = "（课程已结束，无法进行此操作）";
+ break;
+ case IN_PROGRESS:
+ if (event == CourseEvent.CANCEL) {
+ advice = "（课程正在进行中，无法取消）";
+ }
+ break;
+ default:
+ break;
+ }
+
+ return String.format("团课ID=%d 不允许的状态转换: 当前状态=%s(%s), 操作=%s%s",
+ courseId, currentState, currentStateDesc, eventDesc, advice);
+ }
+
+ /**
+ * 执行状态转换并更新课程对象
+ */
+ public Mono applyTransition(GroupCourse course, CourseEvent event) {
+ return validateTransition(course, event)
+ .then(transition(CourseStatus.fromValue(course.getStatus()), event))
+ .map(newStatus -> {
+ course.setStatus(newStatus.getValue());
+ return course;
+ });
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/IGroupCourseBookingRepository.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/IGroupCourseBookingRepository.java
new file mode 100644
index 0000000..99d832e
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/IGroupCourseBookingRepository.java
@@ -0,0 +1,92 @@
+package cn.novalon.gym.manage.groupcourse.repository;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * 团课预约记录Repository接口
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+public interface IGroupCourseBookingRepository {
+
+ /**
+ * 根据ID查询预约记录
+ */
+ Mono findById(Long id);
+
+ /**
+ * 根据会员ID查询预约记录列表
+ */
+ Flux findByMemberId(Long memberId);
+
+ /**
+ * 根据团课ID查询预约记录列表
+ */
+ Flux findByCourseId(Long courseId);
+
+ /**
+ * 查询会员是否已预约某课程
+ */
+ Mono findByCourseIdAndMemberId(Long courseId, Long memberId);
+
+ /**
+ * 查询会员在指定课程的有效预约
+ */
+ Mono findValidBooking(Long courseId, Long memberId);
+
+ /**
+ * 统计课程有效预约人数
+ */
+ Mono countValidBookings(Long courseId);
+
+ /**
+ * 保存预约记录
+ */
+ Mono save(GroupCourseBooking booking);
+
+ /**
+ * 更新预约记录
+ */
+ Mono update(GroupCourseBooking booking);
+
+ /**
+ * 更新预约状态
+ */
+ Mono updateStatus(Long bookingId, String status);
+
+ /**
+ * 删除预约记录
+ */
+ Mono deleteById(Long bookingId);
+
+ /**
+ * 根据会员卡记录ID查询预约记录
+ */
+ Flux findByMemberCardRecordId(Long memberCardRecordId);
+
+ /**
+ * 查询会员是否有时间冲突的预约
+ *
+ * @param memberId 会员ID
+ * @param newStartTime 新课程开始时间
+ * @param newEndTime 新课程结束时间
+ * @return 冲突的预约记录列表
+ */
+ Flux findConflictingBookings(Long memberId, java.time.LocalDateTime newStartTime, java.time.LocalDateTime newEndTime);
+
+ /**
+ * 查询已开始课程但未到场会员的预约记录
+ * @return 缺席会员的预约记录列表
+ */
+ Flux findAbsentMembers();
+
+ /**
+ * 更新预约状态为缺席(3)
+ * @param bookingId 预约ID
+ * @return 更新记录数
+ */
+ Mono updateToAbsent(Long bookingId);
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/IGroupCourseRepository.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/IGroupCourseRepository.java
new file mode 100644
index 0000000..cee768e
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/IGroupCourseRepository.java
@@ -0,0 +1,30 @@
+
+package cn.novalon.gym.manage.groupcourse.repository;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import org.springframework.data.domain.Sort;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+public interface IGroupCourseRepository {
+ Mono findByIdAndDeletedAtIsNull(Long id);
+ Flux findAll();
+ Flux findAll(Sort sort);
+ Flux findByDeletedAtIsNull();
+ Flux findByDeletedAtIsNull(Sort sort);
+
+ Mono> findByPage(PageRequest pageRequest);
+ Mono> findByPageAndNotDeleted(PageRequest pageRequest);
+
+ Mono save(GroupCourse groupCourse);
+
+ Mono update(GroupCourse groupCourse);
+
+ Mono cancel(Long id);
+
+ Mono deleteById(Long id);
+
+ Mono updateCurrentMembers(Long id, Integer delta);
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/GroupCourseBookingRepository.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/GroupCourseBookingRepository.java
new file mode 100644
index 0000000..c95b0bb
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/GroupCourseBookingRepository.java
@@ -0,0 +1,115 @@
+package cn.novalon.gym.manage.groupcourse.repository.impl;
+
+import cn.novalon.gym.manage.groupcourse.converter.GroupCourseConverter;
+import cn.novalon.gym.manage.groupcourse.dao.GroupCourseBookingDao;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseBookingEntity;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepository;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * 团课预约记录Repository实现类
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+@Repository
+public class GroupCourseBookingRepository implements IGroupCourseBookingRepository {
+
+ private final GroupCourseBookingDao groupCourseBookingDao;
+ private final GroupCourseConverter groupCourseConverter;
+
+ public GroupCourseBookingRepository(GroupCourseBookingDao groupCourseBookingDao,
+ GroupCourseConverter groupCourseConverter) {
+ this.groupCourseBookingDao = groupCourseBookingDao;
+ this.groupCourseConverter = groupCourseConverter;
+ }
+
+ @Override
+ public Mono findById(Long id) {
+ return groupCourseBookingDao.findByIdIsAndDeletedAtIsNull(id)
+ .map(groupCourseConverter::toBookingDomain);
+ }
+
+ @Override
+ public Flux findByMemberId(Long memberId) {
+ return groupCourseBookingDao.findByMemberIdAndDeletedAtIsNull(memberId, Sort.by(Sort.Direction.DESC, "bookingTime"))
+ .map(groupCourseConverter::toBookingDomain);
+ }
+
+ @Override
+ public Flux findByCourseId(Long courseId) {
+ return groupCourseBookingDao.findByCourseIdAndDeletedAtIsNull(courseId)
+ .map(groupCourseConverter::toBookingDomain);
+ }
+
+ @Override
+ public Mono findByCourseIdAndMemberId(Long courseId, Long memberId) {
+ return groupCourseBookingDao.findByCourseIdAndMemberIdAndDeletedAtIsNull(courseId, memberId)
+ .map(groupCourseConverter::toBookingDomain);
+ }
+
+ @Override
+ public Mono findValidBooking(Long courseId, Long memberId) {
+ return groupCourseBookingDao.findByCourseIdAndMemberIdAndStatusAndDeletedAtIsNull(courseId, memberId, "0")
+ .map(groupCourseConverter::toBookingDomain);
+ }
+
+ @Override
+ public Mono countValidBookings(Long courseId) {
+ return groupCourseBookingDao.countByCourseIdAndStatusAndDeletedAtIsNull(courseId, "0");
+ }
+
+ @Override
+ public Mono save(GroupCourseBooking booking) {
+ GroupCourseBookingEntity entity = groupCourseConverter.toBookingEntity(booking);
+ return groupCourseBookingDao.save(entity)
+ .map(groupCourseConverter::toBookingDomain);
+ }
+
+ @Override
+ public Mono update(GroupCourseBooking booking) {
+ GroupCourseBookingEntity entity = groupCourseConverter.toBookingEntity(booking);
+ return groupCourseBookingDao.save(entity)
+ .map(groupCourseConverter::toBookingDomain);
+ }
+
+ @Override
+ public Mono updateStatus(Long bookingId, String status) {
+ java.time.LocalDateTime now = java.time.LocalDateTime.now();
+ java.time.LocalDateTime cancelTime = "1".equals(status) ? now : null;
+ return groupCourseBookingDao.updateStatus(bookingId, status, cancelTime, now);
+ }
+
+ @Override
+ public Mono deleteById(Long bookingId) {
+ return groupCourseBookingDao.softDelete(bookingId, java.time.LocalDateTime.now()).then();
+ }
+
+ @Override
+ public Flux findByMemberCardRecordId(Long memberCardRecordId) {
+ return groupCourseBookingDao.findByMemberCardRecordIdAndDeletedAtIsNull(memberCardRecordId)
+ .map(groupCourseConverter::toBookingDomain);
+ }
+
+ @Override
+ public Flux findConflictingBookings(Long memberId, java.time.LocalDateTime newStartTime, java.time.LocalDateTime newEndTime) {
+ return groupCourseBookingDao.findConflictingBookings(memberId, newStartTime, newEndTime)
+ .map(groupCourseConverter::toBookingDomain);
+ }
+
+ @Override
+ public Flux findAbsentMembers() {
+ return groupCourseBookingDao.findAbsentMembers()
+ .map(groupCourseConverter::toBookingDomain);
+ }
+
+ @Override
+ public Mono updateToAbsent(Long bookingId) {
+ java.time.LocalDateTime now = java.time.LocalDateTime.now();
+ return groupCourseBookingDao.updateToAbsent(bookingId, now);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/GroupCourseRepository.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/GroupCourseRepository.java
new file mode 100644
index 0000000..ef344d0
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/GroupCourseRepository.java
@@ -0,0 +1,181 @@
+
+package cn.novalon.gym.manage.groupcourse.repository.impl;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.groupcourse.converter.GroupCourseConverter;
+import cn.novalon.gym.manage.groupcourse.dao.GroupCourseDao;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Repository
+public class GroupCourseRepository implements IGroupCourseRepository {
+ private final GroupCourseDao groupCourseDao;
+ private final GroupCourseConverter groupCourseConverter;
+ private final R2dbcEntityTemplate r2dbcEntityTemplate;
+
+ public GroupCourseRepository(GroupCourseDao groupCourseDao, GroupCourseConverter groupCourseConverter,
+ R2dbcEntityTemplate r2dbcEntityTemplate){
+ this.groupCourseDao = groupCourseDao;
+ this.groupCourseConverter = groupCourseConverter;
+ this.r2dbcEntityTemplate = r2dbcEntityTemplate;
+ }
+
+ @Override
+ public Mono findByIdAndDeletedAtIsNull(Long id) {
+ return groupCourseDao.findByIdIsAndDeletedAtIsNull(id)
+ .map(groupCourseConverter::toDomain);
+ }
+
+ @Override
+ public Flux findAll() {
+ return groupCourseDao.findAll()
+ .map(groupCourseConverter::toDomain);
+ }
+
+ @Override
+ public Flux findAll(Sort sort) {
+ return groupCourseDao.findAll(sort)
+ .map(groupCourseConverter::toDomain);
+ }
+
+ @Override
+ public Flux findByDeletedAtIsNull() {
+ return groupCourseDao.findAllByDeletedAtIsNull()
+ .map(groupCourseConverter::toDomain);
+ }
+
+ @Override
+ public Flux findByDeletedAtIsNull(Sort sort) {
+ return groupCourseDao.findAllByDeletedAtIsNull(sort)
+ .map(groupCourseConverter::toDomain);
+ }
+
+ @Override
+ public Mono> findByPage(PageRequest pageRequest) {
+ int page = pageRequest.getPage();
+ int size = pageRequest.getSize();
+ String sort = pageRequest.getSort();
+ String order = pageRequest.getOrder();
+
+ Sort sortObj = Sort.unsorted();
+ if (sort != null && !sort.isEmpty()) {
+ sortObj = Sort.by(Sort.Direction.fromString(order), sort);
+ }
+
+ org.springframework.data.domain.PageRequest pageable = org.springframework.data.domain.PageRequest.of(page, size, sortObj);
+
+ Query query = Query.empty();
+
+ return r2dbcEntityTemplate.select(GroupCourseEntity.class)
+ .matching(query.with(pageable))
+ .all()
+ .collectList()
+ .zipWith(r2dbcEntityTemplate.count(query, GroupCourseEntity.class))
+ .map(tuple -> {
+ long total = tuple.getT2();
+ int totalPages = (int) Math.ceil((double) total / size);
+ List courseList = tuple.getT1().stream()
+ .map(groupCourseConverter::toDomain)
+ .toList();
+ return new PageResponse<>(courseList, totalPages, total, page, size);
+ });
+ }
+
+ @Override
+ public Mono> findByPageAndNotDeleted(PageRequest pageRequest) {
+ int page = pageRequest.getPage();
+ int size = pageRequest.getSize();
+ String sort = pageRequest.getSort();
+ String order = pageRequest.getOrder();
+
+ Sort sortObj = Sort.unsorted();
+ if (sort != null && !sort.isEmpty()) {
+ sortObj = Sort.by(Sort.Direction.fromString(order), sort);
+ }
+
+ org.springframework.data.domain.PageRequest pageable = org.springframework.data.domain.PageRequest.of(page, size, sortObj);
+
+ return groupCourseDao.findAllByDeletedAtIsNull(sortObj)
+ .collectList()
+ .zipWith(groupCourseDao.findAllByDeletedAtIsNull().count())
+ .map(tuple -> {
+ List allEntities = tuple.getT1();
+ long total = tuple.getT2();
+
+ int fromIndex = page * size;
+ int toIndex = Math.min(fromIndex + size, allEntities.size());
+
+ List courseList;
+ if (fromIndex < allEntities.size()) {
+ courseList = allEntities.subList(fromIndex, toIndex).stream()
+ .map(groupCourseConverter::toDomain)
+ .toList();
+ } else {
+ courseList = List.of();
+ }
+
+ int totalPages = (int) Math.ceil((double) total / size);
+ return new PageResponse<>(courseList, totalPages, total, page, size);
+ });
+ }
+
+ @Override
+ public Mono save(GroupCourse groupCourse) {
+ GroupCourseEntity entity = groupCourseConverter.toEntity(groupCourse);
+ entity.setCreatedAt(LocalDateTime.now());
+ entity.setUpdatedAt(LocalDateTime.now());
+ entity.setStatus(0L);
+ entity.setCurrentMembers(0);
+
+ return groupCourseDao.save(entity)
+ .map(groupCourseConverter::toDomain);
+ }
+
+ @Override
+ public Mono update(GroupCourse groupCourse) {
+ GroupCourseEntity entity = groupCourseConverter.toEntity(groupCourse);
+ entity.setUpdatedAt(LocalDateTime.now());
+
+ return r2dbcEntityTemplate.update(entity)
+ .then(findByIdAndDeletedAtIsNull(groupCourse.getId()));
+ }
+
+ @Override
+ public Mono cancel(Long id) {
+ return groupCourseDao.cancelCourse(id, LocalDateTime.now())
+ .flatMap(updated -> {
+ if (updated > 0) {
+ return findByIdAndDeletedAtIsNull(id);
+ }
+ return Mono.empty();
+ });
+ }
+
+ @Override
+ public Mono deleteById(Long id) {
+ return groupCourseDao.softDelete(id, LocalDateTime.now())
+ .then();
+ }
+
+ @Override
+ public Mono updateCurrentMembers(Long id, Integer delta) {
+ return groupCourseDao.updateCurrentMembers(id, delta, LocalDateTime.now())
+ .flatMap(updated -> {
+ if (updated > 0) {
+ return findByIdAndDeletedAtIsNull(id);
+ }
+ return Mono.empty();
+ });
+ }
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/scheduler/GroupCourseAbsentScheduler.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/scheduler/GroupCourseAbsentScheduler.java
new file mode 100644
index 0000000..c1a23d5
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/scheduler/GroupCourseAbsentScheduler.java
@@ -0,0 +1,42 @@
+package cn.novalon.gym.manage.groupcourse.scheduler;
+
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseBookingService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+/**
+ * 团课缺席会员定时任务
+ *
+ * 功能：定期检查已开始但会员未到场的课程，自动更新预约记录状态为缺席
+ *
+ * @author 张翔
+ * @date 2026-06-02
+ */
+@Component
+public class GroupCourseAbsentScheduler {
+
+ private static final Logger logger = LoggerFactory.getLogger(GroupCourseAbsentScheduler.class);
+
+ private final IGroupCourseBookingService bookingService;
+
+ public GroupCourseAbsentScheduler(IGroupCourseBookingService bookingService) {
+ this.bookingService = bookingService;
+ }
+
+ /**
+ * 每分钟检查一次已开始课程但未到场会员的预约记录
+ * 使用fixedRate保证任务间隔稳定执行
+ */
+ @Scheduled(fixedRate = 60000)
+ public void checkAndUpdateAbsentMembers() {
+ logger.debug("定时任务开始检查已开始课程但未到场会员的预约记录");
+
+ bookingService.processAbsentMembers()
+ .subscribe(
+ count -> logger.debug("定时任务完成，更新了 {} 条缺席记录", count),
+ error -> logger.error("定时任务执行失败：{}", error.getMessage(), error)
+ );
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/IGroupCourseBookingService.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/IGroupCourseBookingService.java
new file mode 100644
index 0000000..ce1d068
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/IGroupCourseBookingService.java
@@ -0,0 +1,65 @@
+package cn.novalon.gym.manage.groupcourse.service;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * 团课预约服务接口
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+public interface IGroupCourseBookingService {
+
+ /**
+ * 预约团课
+ *
+ * @param courseId 团课ID
+ * @param memberId 会员ID
+ * @param memberCardRecordId 会员卡记录ID
+ * @return 预约记录
+ */
+ Mono bookCourse(Long courseId, Long memberId, Long memberCardRecordId);
+
+ /**
+ * 取消预约
+ *
+ * @param bookingId 预约ID
+ * @param memberId 会员ID
+ * @return 取消后的预约记录
+ */
+ Mono cancelBooking(Long bookingId, Long memberId);
+
+ /**
+ * 根据会员ID查询预约记录列表
+ *
+ * @param memberId 会员ID
+ * @return 预约记录列表
+ */
+ Flux getBookingsByMemberId(Long memberId);
+
+ /**
+ * 根据预约ID查询预约详情
+ *
+ * @param bookingId 预约ID
+ * @return 预约记录
+ */
+ Mono getBookingById(Long bookingId);
+
+ /**
+ * 根据团课ID查询预约记录列表
+ *
+ * @param courseId 团课ID
+ * @return 预约记录列表
+ */
+ Flux getBookingsByCourseId(Long courseId);
+
+ /**
+ * 处理已开始课程但未到场会员的预约记录
+ * 将状态更新为缺席(3)
+ *
+ * @return 处理的记录数
+ */
+ Mono processAbsentMembers();
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/IGroupCourseService.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/IGroupCourseService.java
new file mode 100644
index 0000000..7db154d
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/IGroupCourseService.java
@@ -0,0 +1,26 @@
+
+package cn.novalon.gym.manage.groupcourse.service;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+public interface IGroupCourseService {
+ Mono findById(Long id);
+ Flux findAll();
+ Flux findAll(boolean includeDeleted);
+
+ Mono> findByPage(PageRequest pageRequest, boolean includeDeleted);
+
+ Mono create(GroupCourse groupCourse);
+
+ Mono update(Long id, GroupCourse groupCourse);
+
+ Mono cancel(Long id);
+
+ Mono signIn(Long courseId, Long memberId);
+
+ Mono delete(Long id);
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseBookingService.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseBookingService.java
new file mode 100644
index 0000000..1159f71
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseBookingService.java
@@ -0,0 +1,372 @@
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import cn.novalon.gym.manage.groupcourse.event.BookingReminderEventPublisher;
+import cn.novalon.gym.manage.groupcourse.handler.BookingSagaHandler;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseBookingService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.UUID;
+
+/**
+ * 团课预约服务实现类
+ *
+ * 业务规则：
+ * - 预约需在课程开始前至少30分钟
+ * - 取消预约需在课程开始前至少2小时
+ * - 每节课最多20人
+ * - 预约成功后发送提醒
+ * - 预约成功后扣减权益
+ *
+ * 技术要点：
+ * - 使用Redis缓存团课信息
+ * - 使用分布式锁防止预约冲突
+ * - 使用响应式编程实现高并发预约
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+@Service
+public class GroupCourseBookingService implements IGroupCourseBookingService {
+
+ private static final Logger logger = LoggerFactory.getLogger(GroupCourseBookingService.class);
+
+ private final IGroupCourseBookingRepository bookingRepository;
+ private final IGroupCourseRepository courseRepository;
+ private final GroupCourseRedisService redisService;
+ private final BookingReminderEventPublisher bookingReminderEventPublisher;
+ private final BookingSagaHandler bookingSagaHandler;
+
+ // 预约提前时间限制（分钟）
+ private static final long BOOKING_MIN_ADVANCE_MINUTES = 30;
+ // 取消预约提前时间限制（小时）
+ private static final long CANCEL_MIN_ADVANCE_HOURS = 2;
+
+ public GroupCourseBookingService(IGroupCourseBookingRepository bookingRepository,
+ IGroupCourseRepository courseRepository,
+ GroupCourseRedisService redisService,
+ BookingReminderEventPublisher bookingReminderEventPublisher,
+ BookingSagaHandler bookingSagaHandler) {
+ this.bookingRepository = bookingRepository;
+ this.courseRepository = courseRepository;
+ this.redisService = redisService;
+ this.bookingReminderEventPublisher = bookingReminderEventPublisher;
+ this.bookingSagaHandler = bookingSagaHandler;
+ }
+
+ @Override
+ public Mono bookCourse(Long courseId, Long memberId, Long memberCardRecordId) {
+ logger.info("开始预约团课：courseId={}, memberId={}, memberCardRecordId={}", courseId, memberId, memberCardRecordId);
+
+ // 生成唯一请求ID用于分布式锁
+ String requestId = UUID.randomUUID().toString();
+
+ // 1. 获取分布式锁
+ return redisService.acquireLock(courseId, requestId)
+ .flatMap(lockAcquired -> {
+ if (!lockAcquired) {
+ return Mono.error(new RuntimeException("系统繁忙，请稍后重试"));
+ }
+
+ // 2. 尝试从缓存获取课程信息，如果缓存不存在则从数据库获取
+ return getCourseWithCache(courseId)
+ .flatMap(course -> {
+ // 3. 验证课程状态
+ Long status = course.getStatus();
+ if (status == null || status != 0L) {
+ String errorMessage;
+ if (status == null) {
+ errorMessage = "课程状态异常";
+ } else if (status == 1L) {
+ errorMessage = "课程已取消，无法预约";
+ } else if (status == 2L) {
+ errorMessage = "课程已结束，无法预约";
+ } else {
+ errorMessage = "课程状态不可预约";
+ }
+ return releaseLockAndError(courseId, requestId, errorMessage);
+ }
+
+ // 4. 验证预约时间
+ LocalDateTime now = LocalDateTime.now();
+ LocalDateTime startTime = course.getStartTime();
+ long minutesUntilStart = ChronoUnit.MINUTES.between(now, startTime);
+ if (minutesUntilStart < BOOKING_MIN_ADVANCE_MINUTES) {
+ return releaseLockAndError(courseId, requestId,
+ "需在课程开始前" + BOOKING_MIN_ADVANCE_MINUTES + "分钟预约");
+ }
+
+ // 5. 验证课程人数是否已满（使用数据库中的current_members字段）
+ if (course.getCurrentMembers() != null &&
+ course.getMaxMembers() != null &&
+ course.getCurrentMembers() >= course.getMaxMembers()) {
+ return releaseLockAndError(courseId, requestId, "课程已满");
+ }
+
+ // 6. 验证时间冲突（会员是否已预约时间重叠的课程）
+ return bookingRepository.findConflictingBookings(memberId, course.getStartTime(), course.getEndTime())
+ .collectList()
+ .flatMap(conflictingBookings -> {
+ if (!conflictingBookings.isEmpty()) {
+ StringBuilder errorMsg = new StringBuilder("您已预约的课程与当前课程时间冲突：");
+ for (GroupCourseBooking conflict : conflictingBookings) {
+ errorMsg.append(conflict.getCourseName())
+ .append("(")
+ .append(conflict.getCourseStartTime())
+ .append(" - ")
+ .append(conflict.getCourseEndTime())
+ .append(") ");
+ }
+ return releaseLockAndError(courseId, requestId, errorMsg.toString());
+ }
+
+ // 7. 验证是否已预约
+ return bookingRepository.findValidBooking(courseId, memberId)
+ .flatMap(existingBooking -> {
+ return releaseLockAndError(courseId, requestId, "您已预约该课程");
+ })
+ .switchIfEmpty(
+ // 8. 使用Redis原子操作验证课程人数是否已满
+ validateAndIncrementBookingCount(courseId, course.getMaxMembers())
+ .flatMap(countValid -> {
+ if (countValid > course.getMaxMembers()) {
+ return releaseLockAndError(courseId, requestId, "课程已满");
+ }
+
+ // 9. 创建预约记录
+ GroupCourseBooking booking = new GroupCourseBooking();
+ booking.setCourseId(courseId);
+ booking.setMemberId(memberId);
+ booking.setMemberCardRecordId(memberCardRecordId);
+ booking.setBookingTime(LocalDateTime.now());
+ booking.setStatus("0"); // 0-已预约
+
+ // 添加课程信息到预约记录
+ booking.setCourseName(course.getCourseName());
+ booking.setCourseStartTime(course.getStartTime());
+ booking.setCourseEndTime(course.getEndTime());
+ booking.setLocation(course.getLocation());
+
+ // 10. 使用Saga事务执行预约（包含权益扣减）
+ return bookingSagaHandler.executeBooking(booking, memberCardRecordId)
+ .flatMap(savedBooking -> {
+ // 11. 释放锁
+ return redisService.releaseLock(courseId, requestId)
+ .then(Mono.just(savedBooking));
+ })
+ .doOnSuccess(savedBooking -> {
+ logger.info("预约成功：bookingId={}, courseId={}, memberId={}",
+ savedBooking.getId(), courseId, memberId);
+ // 发布预约成功事件
+ bookingReminderEventPublisher.publishBookingSuccessEvent(
+ savedBooking.getId(),
+ savedBooking.getMemberId(),
+ savedBooking.getCourseName(),
+ savedBooking.getCourseStartTime().toString()
+ );
+ })
+ .doOnError(error -> {
+ // 回滚Redis计数
+ redisService.decrementBookingCount(courseId).subscribe();
+ logger.error("预约失败：courseId={}, memberId={}, error={}",
+ courseId, memberId, error.getMessage());
+ });
+ })
+ );
+ });
+ })
+ .onErrorResume(error -> {
+ // 发生错误时释放锁
+ redisService.releaseLock(courseId, requestId).subscribe();
+ return Mono.error(error);
+ });
+ });
+ }
+
+ /**
+ * 从缓存或数据库获取课程信息
+ */
+ private Mono getCourseWithCache(Long courseId) {
+ return redisService.getCachedCourse(courseId)
+ .switchIfEmpty(
+ // 缓存未命中，从数据库查询
+ courseRepository.findByIdAndDeletedAtIsNull(courseId)
+ .switchIfEmpty(Mono.error(new RuntimeException("团课不存在")))
+ .flatMap(course -> {
+ // 将课程信息存入缓存
+ return redisService.cacheCourse(course).then(Mono.just(course));
+ })
+ );
+ }
+
+ /**
+ * 验证并增加预约人数（使用Redis原子操作）
+ */
+ private Mono validateAndIncrementBookingCount(Long courseId, Integer maxMembers) {
+ // 先获取当前Redis中的预约计数
+ return redisService.getBookingCount(courseId)
+ .flatMap(currentCount -> {
+ // 如果Redis中计数为0，可能是首次访问，需要从数据库同步
+ if (currentCount == 0) {
+ // 从数据库查询实际预约人数
+ return bookingRepository.countValidBookings(courseId)
+ .flatMap(dbCount -> {
+ // 将数据库中的实际预约人数同步到Redis
+ return redisService.setBookingCount(courseId, dbCount.intValue())
+ .then(Mono.just(dbCount.intValue()));
+ });
+ }
+ return Mono.just(currentCount);
+ })
+ // 递增预约计数
+ .flatMap(count -> redisService.incrementBookingCount(courseId).map(Long::intValue));
+ }
+
+ /**
+ * 释放锁并返回错误
+ */
+ private Mono releaseLockAndError(Long courseId, String requestId, String errorMessage) {
+ return redisService.releaseLock(courseId, requestId)
+ .then(Mono.error(new RuntimeException(errorMessage)));
+ }
+
+ @Override
+ public Mono cancelBooking(Long bookingId, Long memberId) {
+ logger.info("开始取消预约：bookingId={}, memberId={}", bookingId, memberId);
+
+ // 生成唯一请求ID用于分布式锁
+ String requestId = UUID.randomUUID().toString();
+
+ // 获取锁防止并发取消
+ return redisService.acquireLock(bookingId, requestId)
+ .flatMap(lockAcquired -> {
+ if (!lockAcquired) {
+ return Mono.error(new RuntimeException("系统繁忙，请稍后重试"));
+ }
+
+ // 1. 查询预约记录
+ return bookingRepository.findById(bookingId)
+ .switchIfEmpty(Mono.error(new RuntimeException("预约记录不存在")))
+ .flatMap(booking -> {
+ // 2. 验证预约归属
+ if (!booking.getMemberId().equals(memberId)) {
+ return releaseLockAndError(bookingId, requestId, "无权取消他人预约");
+ }
+
+ // 3. 验证预约状态
+ String status = booking.getStatus();
+ if (!"0".equals(status)) {
+ String errorMessage;
+ if ("1".equals(status)) {
+ errorMessage = "预约已取消，无需重复取消";
+ } else if ("2".equals(status)) {
+ errorMessage = "课程已出席，无法取消";
+ } else if ("3".equals(status)) {
+ errorMessage = "已缺席课程，无法取消";
+ } else {
+ errorMessage = "预约状态不允许取消";
+ }
+ return releaseLockAndError(bookingId, requestId, errorMessage);
+ }
+
+ // 4. 验证取消时间
+ LocalDateTime now = LocalDateTime.now();
+ LocalDateTime startTime = booking.getCourseStartTime();
+ if (startTime == null) {
+ return releaseLockAndError(bookingId, requestId, "课程开始时间为空，无法取消预约");
+ }
+ long hoursUntilStart = ChronoUnit.HOURS.between(now, startTime);
+ if (hoursUntilStart < CANCEL_MIN_ADVANCE_HOURS) {
+ return releaseLockAndError(bookingId, requestId,
+ "需在课程开始前" + CANCEL_MIN_ADVANCE_HOURS + "小时取消");
+ }
+
+ // 5. 使用Saga事务执行取消预约（包含权益恢复）
+ return bookingSagaHandler.executeCancelBooking(bookingId, booking.getCourseId(), booking.getMemberCardRecordId(), memberId)
+ .flatMap(updatedBooking -> {
+ // 6. 释放锁
+ return redisService.releaseLock(bookingId, requestId)
+ .then(Mono.just(updatedBooking));
+ })
+ .doOnSuccess(updatedBooking -> {
+ logger.info("取消预约成功：bookingId={}, memberId={}", bookingId, memberId);
+ // 发布预约取消事件
+ bookingReminderEventPublisher.publishBookingCancelEvent(
+ updatedBooking.getId(),
+ updatedBooking.getMemberId(),
+ updatedBooking.getCourseName()
+ );
+ })
+ .doOnError(error -> {
+ logger.error("取消预约失败：bookingId={}, memberId={}, error={}",
+ bookingId, memberId, error.getMessage());
+ });
+ })
+ .onErrorResume(error -> {
+ redisService.releaseLock(bookingId, requestId).subscribe();
+ return Mono.error(error);
+ });
+ });
+ }
+
+ @Override
+ public Flux getBookingsByMemberId(Long memberId) {
+ logger.debug("查询会员预约记录：memberId={}", memberId);
+ return bookingRepository.findByMemberId(memberId)
+ .doOnComplete(() -> logger.debug("查询完成：memberId={}", memberId));
+ }
+
+ @Override
+ public Mono getBookingById(Long bookingId) {
+ logger.debug("查询预约详情：bookingId={}", bookingId);
+ return bookingRepository.findById(bookingId);
+ }
+
+ @Override
+ public Flux getBookingsByCourseId(Long courseId) {
+ logger.debug("查询课程预约记录：courseId={}", courseId);
+ return bookingRepository.findByCourseId(courseId)
+ .doOnComplete(() -> logger.debug("查询完成：courseId={}", courseId));
+ }
+
+ @Override
+ public Mono processAbsentMembers() {
+ logger.info("开始处理已开始课程但未到场会员的预约记录");
+
+ return bookingRepository.findAbsentMembers()
+ .collectList()
+ .flatMap(absentBookings -> {
+ if (absentBookings.isEmpty()) {
+ logger.info("没有需要处理的缺席会员记录");
+ return Mono.just(0);
+ }
+
+ logger.info("发现 {} 条需要更新为缺席状态的预约记录", absentBookings.size());
+
+ // 批量更新状态为缺席
+ return Flux.fromIterable(absentBookings)
+ .flatMap(booking -> {
+ logger.debug("更新预约记录为缺席状态：bookingId={}, memberId={}, courseId={}",
+ booking.getId(), booking.getMemberId(), booking.getCourseId());
+ return bookingRepository.updateToAbsent(booking.getId());
+ })
+ .reduce(Integer::sum)
+ .defaultIfEmpty(0)
+ .doOnSuccess(count -> {
+ logger.info("成功更新 {} 条预约记录为缺席状态", count);
+ })
+ .doOnError(error -> {
+ logger.error("处理缺席会员记录时发生错误：{}", error.getMessage(), error);
+ });
+ });
+ }
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseRedisService.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseRedisService.java
new file mode 100644
index 0000000..f8110e4
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseRedisService.java
@@ -0,0 +1,194 @@
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.redis.core.ReactiveRedisTemplate;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+import java.time.Duration;
+
+/**
+ * 团课Redis缓存服务
+ *
+ * 负责团课信息的缓存管理和分布式锁实现
+ *
+ * @author 张翔
+ * @date 2026-06-01
+ */
+@Service
+public class GroupCourseRedisService {
+
+ private static final Logger logger = LoggerFactory.getLogger(GroupCourseRedisService.class);
+
+ // 团课信息缓存Key前缀
+ private static final String GROUP_COURSE_CACHE_PREFIX = "group_course:";
+ // 团课预约锁Key前缀
+ private static final String BOOKING_LOCK_PREFIX = "booking_lock:";
+ // 缓存过期时间（5分钟）
+ private static final Duration CACHE_EXPIRE_TIME = Duration.ofMinutes(5);
+ // 锁过期时间（30秒）
+ private static final Duration LOCK_EXPIRE_TIME = Duration.ofSeconds(30);
+
+ private final ReactiveRedisTemplate reactiveRedisTemplate;
+ private final ObjectMapper objectMapper;
+
+ public GroupCourseRedisService(ReactiveRedisTemplate reactiveRedisTemplate,
+ ObjectMapper objectMapper) {
+ this.reactiveRedisTemplate = reactiveRedisTemplate;
+ this.objectMapper = objectMapper;
+ }
+
+ /**
+ * 获取团课缓存Key
+ */
+ private String getCourseCacheKey(Long courseId) {
+ return GROUP_COURSE_CACHE_PREFIX + courseId;
+ }
+
+ /**
+ * 获取预约锁Key
+ */
+ private String getBookingLockKey(Long courseId) {
+ return BOOKING_LOCK_PREFIX + courseId;
+ }
+
+ /**
+ * 缓存团课信息
+ */
+ public Mono cacheCourse(GroupCourse course) {
+ String key = getCourseCacheKey(course.getId());
+ try {
+ String value = objectMapper.writeValueAsString(course);
+ return reactiveRedisTemplate.opsForValue()
+ .set(key, value, CACHE_EXPIRE_TIME)
+ .doOnSuccess(result -> logger.debug("团课信息已缓存：courseId={}", course.getId()))
+ .then();
+ } catch (JsonProcessingException e) {
+ logger.error("序列化团课信息失败：courseId={}", course.getId(), e);
+ return Mono.error(e);
+ }
+ }
+
+ /**
+ * 获取缓存的团课信息
+ */
+ public Mono getCachedCourse(Long courseId) {
+ String key = getCourseCacheKey(courseId);
+ return reactiveRedisTemplate.opsForValue()
+ .get(key)
+ .cast(String.class)
+ .flatMap(value -> {
+ try {
+ GroupCourse course = objectMapper.readValue(value, GroupCourse.class);
+ logger.debug("从缓存获取团课信息：courseId={}", courseId);
+ return Mono.just(course);
+ } catch (JsonProcessingException e) {
+ logger.error("反序列化团课信息失败：courseId={}", courseId, e);
+ return Mono.empty();
+ }
+ })
+ .switchIfEmpty(Mono.fromRunnable(() -> logger.debug("缓存中未找到团课信息：courseId={}", courseId)));
+ }
+
+ /**
+ * 删除团课缓存
+ */
+ public Mono invalidateCourseCache(Long courseId) {
+ String key = getCourseCacheKey(courseId);
+ return reactiveRedisTemplate.delete(key)
+ .doOnSuccess(result -> logger.debug("团课缓存已删除：courseId={}", courseId))
+ .then();
+ }
+
+ /**
+ * 获取分布式锁
+ *
+ * @param courseId 课程ID
+ * @param requestId 请求ID（用于锁的唯一性校验）
+ * @return 是否获取成功
+ */
+ public Mono acquireLock(Long courseId, String requestId) {
+ String key = getBookingLockKey(courseId);
+ return reactiveRedisTemplate.opsForValue()
+ .setIfAbsent(key, requestId, LOCK_EXPIRE_TIME)
+ .doOnSuccess(acquired -> {
+ if (acquired) {
+ logger.debug("获取预约锁成功：courseId={}, requestId={}", courseId, requestId);
+ } else {
+ logger.debug("获取预约锁失败：courseId={}", courseId);
+ }
+ });
+ }
+
+ /**
+ * 释放分布式锁
+ *
+ * @param courseId 课程ID
+ * @param requestId 请求ID（用于锁的唯一性校验）
+ * @return 是否释放成功
+ */
+ public Mono releaseLock(Long courseId, String requestId) {
+ String key = getBookingLockKey(courseId);
+ return reactiveRedisTemplate.opsForValue()
+ .get(key)
+ .cast(String.class)
+ .flatMap(storedRequestId -> {
+ if (requestId.equals(storedRequestId)) {
+ return reactiveRedisTemplate.delete(key)
+ .map(deleted -> deleted > 0)
+ .doOnSuccess(result -> logger.debug("释放预约锁成功：courseId={}, requestId={}", courseId, requestId));
+ } else {
+ logger.warn("锁归属校验失败：courseId={}, expectedRequestId={}, actualRequestId={}",
+ courseId, requestId, storedRequestId);
+ return Mono.just(false);
+ }
+ })
+ .defaultIfEmpty(false);
+ }
+
+ /**
+ * 获取课程预约人数（缓存）
+ */
+ public Mono getBookingCount(Long courseId) {
+ String key = "booking_count:" + courseId;
+ return reactiveRedisTemplate.opsForValue()
+ .get(key)
+ .map(obj -> (Integer) obj)
+ .defaultIfEmpty(0);
+ }
+
+ /**
+ * 增加课程预约人数
+ */
+ public Mono incrementBookingCount(Long courseId) {
+ String key = "booking_count:" + courseId;
+ return reactiveRedisTemplate.opsForValue()
+ .increment(key)
+ .doOnSuccess(count -> logger.debug("预约人数增加：courseId={}, count={}", courseId, count));
+ }
+
+ /**
+ * 减少课程预约人数
+ */
+ public Mono decrementBookingCount(Long courseId) {
+ String key = "booking_count:" + courseId;
+ return reactiveRedisTemplate.opsForValue()
+ .decrement(key)
+ .doOnSuccess(count -> logger.debug("预约人数减少：courseId={}, count={}", courseId, count));
+ }
+
+ /**
+ * 设置课程预约人数（用于从数据库同步）
+ */
+ public Mono setBookingCount(Long courseId, Integer count) {
+ String key = "booking_count:" + courseId;
+ return reactiveRedisTemplate.opsForValue()
+ .set(key, count)
+ .doOnSuccess(result -> logger.debug("预约人数已设置：courseId={}, count={}", courseId, count))
+ .then();
+ }
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseService.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseService.java
new file mode 100644
index 0000000..7847c9a
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseService.java
@@ -0,0 +1,396 @@
+
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import cn.novalon.gym.manage.groupcourse.enums.CourseEvent;
+import cn.novalon.gym.manage.groupcourse.enums.CourseStatus;
+import cn.novalon.gym.manage.groupcourse.handler.GroupCourseStateMachine;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseService;
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.enums.MemberCardType;
+import cn.novalon.gym.manage.member.repository.MemberCardRepository;
+import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+@Service
+public class GroupCourseService implements IGroupCourseService {
+ private static final Logger logger = LoggerFactory.getLogger(GroupCourseService.class);
+
+ private final IGroupCourseRepository groupCourseRepository;
+ private final IGroupCourseBookingRepository bookingRepository;
+ private final IMemberCardRecordService memberCardRecordService;
+ private final MemberCardRepository memberCardRepository;
+ private final RedisUtil redisUtil;
+ private final ObjectMapper objectMapper;
+ private final GroupCourseStateMachine stateMachine;
+
+ private static final String CACHE_KEY_PREFIX = "group_course:page:";
+ private static final String CACHE_KEY_ID_PREFIX = "group_course:id:";
+ private static final long CACHE_EXPIRE_SECONDS = 300;
+
+ private static final double DEFAULT_GROUP_COURSE_PRICE = 50.0;
+
+ public GroupCourseService(IGroupCourseRepository groupCourseRepository,
+ IGroupCourseBookingRepository bookingRepository,
+ IMemberCardRecordService memberCardRecordService,
+ MemberCardRepository memberCardRepository,
+ RedisUtil redisUtil,
+ ObjectMapper objectMapper,
+ GroupCourseStateMachine stateMachine){
+ this.groupCourseRepository = groupCourseRepository;
+ this.bookingRepository = bookingRepository;
+ this.memberCardRecordService = memberCardRecordService;
+ this.memberCardRepository = memberCardRepository;
+ this.redisUtil = redisUtil;
+ this.objectMapper = objectMapper;
+ this.stateMachine = stateMachine;
+ }
+
+ @Override
+ public Mono findById(Long id) {
+ String cacheKey = CACHE_KEY_ID_PREFIX + id;
+
+ return redisUtil.get(cacheKey, String.class)
+ .flatMap(cachedJson -> {
+ if (cachedJson != null) {
+ try {
+ GroupCourse groupCourse = objectMapper.readValue(cachedJson, GroupCourse.class);
+ logger.info("缓存命中 - findById: id={}", id);
+ return Mono.just(groupCourse);
+ } catch (JsonProcessingException e) {
+ logger.warn("缓存解析失败，删除缓存 - id: {}, error: {}", id, e.getMessage());
+ return redisUtil.delete(cacheKey).then(Mono.empty());
+ }
+ }
+ return Mono.empty();
+ })
+ .switchIfEmpty(
+ groupCourseRepository.findByIdAndDeletedAtIsNull(id)
+ .flatMap(groupCourse -> {
+ try {
+ String jsonData = objectMapper.writeValueAsString(groupCourse);
+ return redisUtil.setWithExpire(cacheKey, jsonData, CACHE_EXPIRE_SECONDS)
+ .thenReturn(groupCourse)
+ .doOnSuccess(gc -> logger.debug("缓存已设置 - findById: id={}", id));
+ } catch (JsonProcessingException e) {
+ logger.error("缓存设置失败 - id: {}, error: {}", id, e.getMessage());
+ return Mono.just(groupCourse);
+ }
+ })
+ .doOnSubscribe(sub -> logger.debug("缓存未命中，查询数据库 - findById: id={}", id))
+ );
+ }
+
+ @Override
+ public Flux findAll() {
+ return groupCourseRepository.findAll();
+ }
+
+ @Override
+ public Flux findAll(boolean includeDeleted) {
+ if(includeDeleted){
+ return groupCourseRepository.findAll();
+ }else{
+ return groupCourseRepository.findByDeletedAtIsNull();
+ }
+ }
+
+ @Override
+ public Mono> findByPage(PageRequest pageRequest, boolean includeDeleted) {
+ int page = pageRequest.getPage();
+ int size = pageRequest.getSize();
+ String sort = pageRequest.getSort();
+ String order = pageRequest.getOrder();
+ String keyword = pageRequest.getKeyword() != null ? pageRequest.getKeyword() : "";
+
+ String cacheKey = CACHE_KEY_PREFIX + page + ":" + size + ":" + includeDeleted + ":" + sort + ":" + order + ":" + keyword;
+
+ return redisUtil.get(cacheKey, String.class)
+ .flatMap(cachedJson -> {
+ if (cachedJson != null) {
+ try {
+ PageResponse pageResponse = objectMapper.readValue(cachedJson,
+ objectMapper.getTypeFactory().constructParametricType(PageResponse.class, GroupCourse.class));
+ logger.info("缓存命中 - findByPage: key={}", cacheKey);
+ return Mono.just(pageResponse);
+ } catch (JsonProcessingException e) {
+ logger.warn("缓存解析失败，删除缓存 - key: {}, error: {}", cacheKey, e.getMessage());
+ return redisUtil.delete(cacheKey).then(Mono.empty());
+ }
+ }
+ return Mono.empty();
+ })
+ .switchIfEmpty(
+ Mono.defer(() -> {
+ logger.debug("缓存未命中，查询数据库 - findByPage: key={}", cacheKey);
+ Mono> resultMono;
+ if (includeDeleted) {
+ resultMono = groupCourseRepository.findByPage(pageRequest);
+ } else {
+ resultMono = groupCourseRepository.findByPageAndNotDeleted(pageRequest);
+ }
+
+ return resultMono.flatMap(pageResponse -> {
+ try {
+ String jsonData = objectMapper.writeValueAsString(pageResponse);
+ return redisUtil.setWithExpire(cacheKey, jsonData, CACHE_EXPIRE_SECONDS)
+ .thenReturn(pageResponse)
+ .doOnSuccess(pr -> logger.debug("缓存已设置 - findByPage: key={}", cacheKey));
+ } catch (JsonProcessingException e) {
+ logger.error("缓存设置失败 - key: {}, error: {}", cacheKey, e.getMessage());
+ return Mono.just(pageResponse);
+ }
+ });
+ })
+ );
+ }
+
+ @Override
+ public Mono create(GroupCourse groupCourse) {
+ return groupCourseRepository.save(groupCourse)
+ .doOnSuccess(course -> logger.info("团课创建成功 - id={}, name={}", course.getId(), course.getCourseName()))
+ .flatMap(course -> clearCache().thenReturn(course))
+ .doOnError(error -> logger.error("团课创建失败 - error: {}", error.getMessage()));
+ }
+
+ @Override
+ public Mono update(Long id, GroupCourse groupCourse) {
+ return groupCourseRepository.findByIdAndDeletedAtIsNull(id)
+ .switchIfEmpty(Mono.error(new RuntimeException("团课不存在")))
+ .flatMap(existing -> {
+ if (groupCourse.getCourseName() != null) {
+ existing.setCourseName(groupCourse.getCourseName());
+ }
+ if (groupCourse.getCoachId() != null) {
+ existing.setCoachId(groupCourse.getCoachId());
+ }
+ if (groupCourse.getCourseType() != null) {
+ existing.setCourseType(groupCourse.getCourseType());
+ }
+ if (groupCourse.getStartTime() != null) {
+ existing.setStartTime(groupCourse.getStartTime());
+ }
+ if (groupCourse.getEndTime() != null) {
+ existing.setEndTime(groupCourse.getEndTime());
+ }
+ if (groupCourse.getMaxMembers() != null) {
+ existing.setMaxMembers(groupCourse.getMaxMembers());
+ }
+ if (groupCourse.getStatus() != null) {
+ existing.setStatus(groupCourse.getStatus());
+ }
+ if (groupCourse.getLocation() != null) {
+ existing.setLocation(groupCourse.getLocation());
+ }
+ if (groupCourse.getCoverImage() != null) {
+ existing.setCoverImage(groupCourse.getCoverImage());
+ }
+ if (groupCourse.getDescription() != null) {
+ existing.setDescription(groupCourse.getDescription());
+ }
+ if (groupCourse.getPointCardAmount() != null) {
+ existing.setPointCardAmount(groupCourse.getPointCardAmount());
+ }
+ if (groupCourse.getStoredValueAmount() != null) {
+ existing.setStoredValueAmount(groupCourse.getStoredValueAmount());
+ }
+ return groupCourseRepository.update(existing);
+ })
+ .doOnSuccess(course -> logger.info("团课更新成功 - id={}", id))
+ .flatMap(course -> clearCache().thenReturn(course))
+ .doOnError(error -> logger.error("团课更新失败 - id={}, error: {}", id, error.getMessage()));
+ }
+
+ @Override
+ public Mono cancel(Long id) {
+ return groupCourseRepository.findByIdAndDeletedAtIsNull(id)
+ .switchIfEmpty(Mono.error(new RuntimeException("团课不存在")))
+ .flatMap(course -> {
+ // 使用状态机验证状态转换
+ return stateMachine.validateTransition(course, CourseEvent.CANCEL)
+ .then(Mono.just(course));
+ })
+ .flatMap(course -> {
+ LocalDateTime now = LocalDateTime.now();
+ // 检查当前时间是否超过课程开始前24小时
+ // 如果当前时间 > (课程开始时间 - 24小时)，则不允许取消
+ if (now.isAfter(course.getStartTime().minusHours(24))) {
+ return Mono.error(new RuntimeException("课程取消需提前24小时"));
+ }
+
+ // 取消课程并返还权益
+ return groupCourseRepository.cancel(id)
+ .flatMap(canceledCourse -> {
+ // 为所有预约该课程的会员返还权益
+ return refundBookingMembers(canceledCourse.getId())
+ .then(Mono.just(canceledCourse));
+ });
+ })
+ .doOnSuccess(course -> logger.info("团课取消成功 - id={}", id))
+ .flatMap(course -> clearCache().thenReturn(course))
+ .doOnError(error -> logger.error("团课取消失败 - id={}, error: {}", id, error.getMessage()));
+ }
+
+ /**
+ * 为预约课程的所有会员返还权益
+ *
+ * @param courseId 课程ID
+ * @return 空Mono
+ */
+ private Mono refundBookingMembers(Long courseId) {
+ logger.info("开始为课程预约会员返还权益: courseId={}", courseId);
+
+ return groupCourseRepository.findByIdAndDeletedAtIsNull(courseId)
+ .switchIfEmpty(Mono.error(new RuntimeException("课程不存在")))
+ .flatMap(course -> {
+ Integer pointCardAmount = course.getPointCardAmount() != null ? course.getPointCardAmount() : 1;
+ Double storedValueAmount = course.getStoredValueAmount() != null ?
+ course.getStoredValueAmount().doubleValue() : DEFAULT_GROUP_COURSE_PRICE;
+
+ logger.info("课程权益信息: courseId={}, pointCardAmount={}, storedValueAmount={}",
+ courseId, pointCardAmount, storedValueAmount);
+
+ return bookingRepository.findByCourseId(courseId)
+ .filter(booking -> "0".equals(booking.getStatus())) // 只处理已预约状态的记录
+ .flatMap(booking -> {
+ Long memberCardRecordId = booking.getMemberCardRecordId();
+ if (memberCardRecordId == null) {
+ logger.warn("预约记录没有会员卡记录ID: bookingId={}", booking.getId());
+ return Mono.empty();
+ }
+
+ // 根据会员卡类型返还权益
+ return refundCardUsage(booking.getId(), memberCardRecordId, pointCardAmount, storedValueAmount)
+ .doOnSuccess(unused -> logger.info("会员权益返还成功: bookingId={}, memberId={}",
+ booking.getId(), booking.getMemberId()))
+ .doOnError(error -> logger.error("会员权益返还失败: bookingId={}, memberId={}, error={}",
+ booking.getId(), booking.getMemberId(), error.getMessage()))
+ .onErrorResume(e -> Mono.empty()); // 单个会员返还失败不影响其他会员
+ })
+ .then();
+ });
+ }
+
+ /**
+ * 根据会员卡类型返还权益
+ *
+ * @param bookingId 预约ID
+ * @param recordId 会员卡记录ID
+ * @param pointCardAmount 次卡返还次数
+ * @param storedValueAmount 储值卡返还金额
+ * @return 空Mono
+ */
+ private Mono refundCardUsage(Long bookingId, Long recordId, Integer pointCardAmount, Double storedValueAmount) {
+ return memberCardRecordService.findById(recordId)
+ .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
+ .flatMap(record -> {
+ return memberCardRepository.findById(record.getMemberCardId())
+ .flatMap(card -> {
+ MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+
+ Mono refundOperation;
+ switch (cardType) {
+ case COUNT_CARD:
+ // 次卡返还次数（基于课程设置的pointCardAmount）
+ logger.debug("返还次卡次数: recordId={}, amount={}", recordId, pointCardAmount);
+ refundOperation = memberCardRecordService.renewCard(recordId, pointCardAmount, 0.0, record.getExpireTime())
+ .then(Mono.empty());
+ break;
+ case STORED_VALUE_CARD:
+ // 储值卡返还金额（基于课程设置的storedValueAmount）
+ logger.debug("返还储值卡金额: recordId={}, amount={}", recordId, storedValueAmount);
+ refundOperation = memberCardRecordService.renewCard(recordId, 0, storedValueAmount, record.getExpireTime())
+ .then(Mono.empty());
+ break;
+ case TIME_CARD:
+ // 时长卡不返还，仅修改预约记录状态
+ logger.debug("时长卡不返还权益，仅更新预约状态: bookingId={}", bookingId);
+ refundOperation = Mono.empty();
+ break;
+ default:
+ return Mono.error(new RuntimeException("不支持的会员卡类型: " + cardType));
+ }
+
+ // 无论哪种卡类型，都需要更新预约记录状态为已取消
+ return refundOperation.then(bookingRepository.updateStatus(bookingId, "1"))
+ .flatMap(rows -> {
+ if (rows == 0) {
+ logger.warn("更新预约状态失败: bookingId={}", bookingId);
+ }
+ return Mono.empty();
+ });
+ });
+ });
+ }
+
+ @Override
+ public Mono signIn(Long courseId, Long memberId) {
+ return groupCourseRepository.findByIdAndDeletedAtIsNull(courseId)
+ .switchIfEmpty(Mono.error(new RuntimeException("团课不存在")))
+ .flatMap(course -> {
+ if (course.getStatus() != 0L) {
+ return Mono.error(new RuntimeException("课程状态不允许签到"));
+ }
+
+ if (course.getCurrentMembers() >= course.getMaxMembers()) {
+ return Mono.error(new RuntimeException("课程已满员"));
+ }
+
+ // 检查会员是否已预约此课程
+ return bookingRepository.findValidBooking(courseId, memberId)
+ .switchIfEmpty(Mono.error(new RuntimeException("会员未预约此课程")))
+ .flatMap(booking -> {
+ // 更新课程当前人数
+ return groupCourseRepository.updateCurrentMembers(courseId, 1)
+ .flatMap(updatedCourse -> {
+ // 更新预约状态为已出席
+ return bookingRepository.updateStatus(booking.getId(), "2")
+ .thenReturn(updatedCourse);
+ });
+ });
+ })
+ .doOnSuccess(course -> logger.info("团课签到成功 - courseId={}, memberId={}", courseId, memberId))
+ .flatMap(course -> clearCache().thenReturn(course))
+ .doOnError(error -> logger.error("团课签到失败 - courseId={}, memberId={}, error: {}", courseId, memberId, error.getMessage()));
+ }
+
+ @Override
+ public Mono delete(Long id) {
+ // 先查询课程状态，只有已取消的课程才能删除
+ return groupCourseRepository.findByIdAndDeletedAtIsNull(id)
+ .switchIfEmpty(Mono.error(new RuntimeException("团课不存在")))
+ .flatMap(course -> {
+ // 检查课程状态是否为已取消（状态码1）
+ if (course.getStatus() == null || !course.getStatus().equals(CourseStatus.CANCELLED.getValue())) {
+ return Mono.error(new RuntimeException("只有已取消的课程才能删除，当前状态: " +
+ (course.getStatus() != null ? course.getStatus() : "未知")));
+ }
+
+ // 删除课程
+ return groupCourseRepository.deleteById(id)
+ .doOnSuccess(v -> logger.info("团课删除成功 - id={}", id))
+ .then(clearCache())
+ .doOnError(error -> logger.error("团课删除失败 - id={}, error: {}", id, error.getMessage()));
+ });
+ }
+
+ private Mono clearCache() {
+ return redisUtil.deleteByPattern(CACHE_KEY_PREFIX + "*")
+ .then(redisUtil.deleteByPattern(CACHE_KEY_ID_PREFIX + "*")).then();
+ }
+}
diff --git a/gym-manage-api/gym-groupCourse/src/main/resources/application.yaml b/gym-manage-api/gym-groupCourse/src/main/resources/application.yaml
new file mode 100644
index 0000000..2d60330
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/main/resources/application.yaml
@@ -0,0 +1,3 @@
+spring:
+ application:
+ name: gym-groupCourse
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/GymGroupCourseApplicationTests.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/GymGroupCourseApplicationTests.java
new file mode 100644
index 0000000..b0d48f8
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/GymGroupCourseApplicationTests.java
@@ -0,0 +1,13 @@
+package cn.novalon.gym.manage.groupcourse;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class GymGroupCourseApplicationTests {
+
+ @Test
+ void contextLoads() {
+ }
+
+}
diff --git a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardRecordServiceImpl.java b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardRecordServiceImpl.java
index 0cbbd76..ae20bd4 100644
--- a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardRecordServiceImpl.java
+++ b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardRecordServiceImpl.java
@@ -3,7 +3,7 @@ package cn.novalon.gym.manage.member.service.impl;
import cn.novalon.gym.manage.member.entity.MemberCardRecord;
import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
-import cn.novalon.gym.manage.member.util.RedisUtil;
+import cn.novalon.gym.manage.common.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
diff --git a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImpl.java b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImpl.java
index 87e345b..070a938 100644
--- a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImpl.java
+++ b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImpl.java
@@ -15,7 +15,7 @@ import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
import cn.novalon.gym.manage.member.repository.MemberCardRepository;
import cn.novalon.gym.manage.member.service.IMemberCardService;
import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
-import cn.novalon.gym.manage.member.util.RedisUtil;
+import cn.novalon.gym.manage.common.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
diff --git a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberServiceImpl.java b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberServiceImpl.java
index cecdaed..e40ff5f 100644
--- a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberServiceImpl.java
+++ b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberServiceImpl.java
@@ -17,30 +17,21 @@ import cn.novalon.gym.manage.member.service.MemberService;
import cn.novalon.gym.manage.member.util.AesUtil;
import cn.novalon.gym.manage.member.util.BeanConvertUtil;
import cn.novalon.gym.manage.member.util.EsSyncUtils;
-import cn.novalon.gym.manage.member.util.RedisUtil;
+import cn.novalon.gym.manage.common.util.RedisUtil;
import cn.novalon.gym.manage.member.vo.MemberCardInfoVO;
import cn.novalon.gym.manage.member.vo.MemberDetailVO;
import cn.novalon.gym.manage.member.vo.MemberInfoVO;
-import co.elastic.clients.elasticsearch.ElasticsearchClient;
-import co.elastic.clients.elasticsearch.core.IndexResponse;
-import co.elastic.clients.json.jackson.JacksonJsonpMapper;
-import co.elastic.clients.transport.rest_client.RestClientTransport;
import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
-import org.apache.http.HttpHost;
-import org.elasticsearch.client.RestClient;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
-import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
import java.util.stream.Collectors;
/**
diff --git a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/RefundApplicationServiceImpl.java b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/RefundApplicationServiceImpl.java
index 0e9da72..e505ef7 100644
--- a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/RefundApplicationServiceImpl.java
+++ b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/RefundApplicationServiceImpl.java
@@ -5,7 +5,7 @@ import cn.novalon.gym.manage.member.entity.RefundApplication;
import cn.novalon.gym.manage.member.enums.RefundStatus;
import cn.novalon.gym.manage.member.repository.RefundApplicationRepository;
import cn.novalon.gym.manage.member.service.IRefundApplicationService;
-import cn.novalon.gym.manage.member.util.RedisUtil;
+import cn.novalon.gym.manage.common.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;
diff --git a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatApiServiceImpl.java b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatApiServiceImpl.java
index aac7753..99238ec 100644
--- a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatApiServiceImpl.java
+++ b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatApiServiceImpl.java
@@ -4,7 +4,7 @@ import cn.novalon.gym.manage.common.exception.ErrorCode;
import cn.novalon.gym.manage.common.exception.SystemException;
import cn.novalon.gym.manage.member.config.WechatProperties;
import cn.novalon.gym.manage.member.service.WechatApiService;
-import cn.novalon.gym.manage.member.util.RedisUtil;
+import cn.novalon.gym.manage.common.util.RedisUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
diff --git a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatAuthServiceImpl.java b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatAuthServiceImpl.java
index a462a14..af116b4 100644
--- a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatAuthServiceImpl.java
+++ b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatAuthServiceImpl.java
@@ -4,8 +4,6 @@ import cn.novalon.gym.manage.common.exception.ConflictException;
import cn.novalon.gym.manage.common.exception.ErrorCode;
import cn.novalon.gym.manage.common.exception.NotFoundException;
import cn.novalon.gym.manage.common.exception.SystemException;
-import cn.novalon.gym.manage.common.util.HtmlEscapeUtil;
-import cn.novalon.gym.manage.member.config.WechatProperties;
import cn.novalon.gym.manage.member.dto.WechatLoginDto;
import cn.novalon.gym.manage.member.entity.Member;
import cn.novalon.gym.manage.member.es.entity.MemberES;
@@ -16,7 +14,7 @@ import cn.novalon.gym.manage.member.service.WechatAuthService;
import cn.novalon.gym.manage.member.util.AesUtil;
import cn.novalon.gym.manage.member.util.EsSyncUtils;
import cn.novalon.gym.manage.member.util.MemberNoGenerator;
-import cn.novalon.gym.manage.member.util.RedisUtil;
+import cn.novalon.gym.manage.common.util.RedisUtil;
import cn.novalon.gym.manage.member.util.WechatPhoneUtil;
import cn.novalon.gym.manage.member.vo.WechatLoginVO;
import cn.novalon.gym.manage.sys.security.JwtTokenProvider;
diff --git a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatOfficialServiceImpl.java b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatOfficialServiceImpl.java
index 22a2d56..41aca11 100644
--- a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatOfficialServiceImpl.java
+++ b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatOfficialServiceImpl.java
@@ -8,7 +8,7 @@ import cn.novalon.gym.manage.member.es.repository.MemberESRepository;
import cn.novalon.gym.manage.member.repository.IMemberRepository;
import cn.novalon.gym.manage.member.service.WechatOfficialService;
import cn.novalon.gym.manage.member.util.EsSyncUtils;
-import cn.novalon.gym.manage.member.util.RedisUtil;
+import cn.novalon.gym.manage.common.util.RedisUtil;
import cn.novalon.gym.manage.member.vo.WechatUserInfoVO;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
diff --git a/gym-manage-api/log.text b/gym-manage-api/log.text
new file mode 100644
index 0000000..c2deea4
--- /dev/null
+++ b/gym-manage-api/log.text
@@ -0,0 +1,200 @@
+2026-06-02T14:56:05.966+08:00 TRACE 22380 --- [gym-manage-api] [ctor-http-nio-7] o.s.w.s.adapter.HttpWebHandlerAdapter : [7ce54381-10] HTTP POST "/api/groupCourse/11/cancel", headers={masked}
+2026-06-02T14:56:05.967+08:00 DEBUG 22380 --- [gym-manage-api] [ parallel-11] o.s.w.s.s.DefaultWebSessionManager : Created new WebSession.
+2026-06-02T14:56:05.967+08:00 INFO 22380 --- [gym-manage-api] [ parallel-11] c.n.g.m.sys.audit.OperationLogWebFilter : WebFilter 拦截请求: POST /api/groupCourse/11/cancel
+2026-06-02T14:56:05.967+08:00 INFO 22380 --- [gym-manage-api] [ parallel-11] c.n.g.m.sys.audit.OperationLogWebFilter : 未匹配到操作日志配置，跳过: POST /api/groupCourse/11/cancel
+2026-06-02T14:56:05.967+08:00 INFO 22380 --- [gym-manage-api] [ parallel-11] c.n.g.m.sys.audit.OperationLogWebFilter : WebFilter 拦截请求: POST /api/groupCourse/11/cancel
+2026-06-02T14:56:05.967+08:00 INFO 22380 --- [gym-manage-api] [ parallel-11] c.n.g.m.sys.audit.OperationLogWebFilter : 未匹配到操作日志配置，跳过: POST /api/groupCourse/11/cancel
+2026-06-02T14:56:05.967+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.967+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.967+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/dictionaries" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/users" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/users/{id}/action/change-password" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/users/{id}/action/logical-delete" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/users/logical-delete" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/users/action/restore" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/users/{id}/action/restore" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/users/{id}/roles" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/menus" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/roles" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/roles/{id}/restore" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/roles/{id}/permissions" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/config" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/logs/login" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/logs/exception" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/logs/operation" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/auth/login" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/auth/register" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/auth/logout" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/dict/types" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/dict/data" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/notices" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/messages" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/files/upload" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/permissions" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/member/auth/miniapp/login" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/member/auth/mp/callback" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/member/phone/bind" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/admin/member/{id}/phone" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/member-cards" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/member-card-records/purchase" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/member-card-records/{recordId}/renew" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/member-card-records/{recordId}/use" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/member-card-records/{recordId}/refund" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/member-card-records/process-expired" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/member-card-transactions" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/groupCourse/page" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "GET" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/groupCourse" does not match against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "PUT" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "DELETE" does not match against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Method "POST" matches against value "POST"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.server.RequestPredicates : Pattern "/api/groupCourse/{id}/cancel" matches against value "/api/groupCourse/11/cancel"
+2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.function.server.RouterFunctions : [7ce54381-10] Matched (POST && /api/groupCourse/{id}/cancel)
+2026-06-02T14:56:05.970+08:00 DEBUG 22380 --- [gym-manage-api] [ parallel-11] o.s.w.r.f.s.s.RouterFunctionMapping : [7ce54381-10] Mapped to cn.novalon.gym.manage.app.config.SystemRouter$$Lambda/0x00000198019592d8@6903bec9
+2026-06-02T14:56:05.972+08:00 DEBUG 22380 --- [gym-manage-api] [ parallel-11] o.s.r2dbc.core.DefaultDatabaseClient : Executing SQL statement [SELECT group_course.course_name, group_course.coach_id, group_course.course_type, group_course.start_time, group_course.end_time, group_course.max_members, group_course.current_members, group_course.status, group_course.location, group_course.cover_image, group_course.description, group_course.point_card_amount, group_course.stored_value_amount, group_course.id, group_course.create_by, group_course.update_by, group_course.created_at, group_course.updated_at, group_course.deleted_at FROM group_course WHERE group_course.id = $1 AND (group_course.deleted_at IS NULL)]
+2026-06-02T14:56:05.976+08:00 INFO 22380 --- [gym-manage-api] [actor-tcp-nio-5] c.n.g.m.g.c.GroupCourseConverter : 转换bean，entity-domain：
+2026-06-02T14:56:05.976+08:00 ERROR 22380 --- [gym-manage-api] [actor-tcp-nio-5] c.n.g.m.g.s.impl.GroupCourseService : 团课取消失败 - id=11, error: 课程取消需提前24小时
+2026-06-02T14:56:05.976+08:00 TRACE 22380 --- [gym-manage-api] [actor-tcp-nio-5] org.springframework.web.HttpLogging : [7ce54381-10] Encoding [{success=false, message=课程取消需提前24小时}]
+2026-06-02T14:56:05.976+08:00 TRACE 22380 --- [gym-manage-api] [actor-tcp-nio-5] o.s.w.s.adapter.HttpWebHandlerAdapter : [7ce54381-10] Completed 400 BAD_REQUEST, headers={masked}
+2026-06-02T14:56:05.976+08:00 TRACE 22380 --- [gym-manage-api] [actor-tcp-nio-5] org.springframework.web.HttpLogging : [7ce54381-1, L:/[0:0:0:0:0:0:0:1]:8084 - R:/[0:0:0:0:0:0:0:1]:57674] Handling completed
diff --git a/gym-manage-api/manage-app/pom.xml b/gym-manage-api/manage-app/pom.xml
index 2644308..11b6479 100644
--- a/gym-manage-api/manage-app/pom.xml
+++ b/gym-manage-api/manage-app/pom.xml
@@ -143,6 +143,12 @@
org.springframework.boot
spring-boot-starter-data-redis
+
+ cn.novalon.gym.manage
+ gym-groupCourse
+ 1.0.0
+ compile
+
diff --git a/gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/ManageApplication.java b/gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/ManageApplication.java
index a87aaef..b190bfd 100644
--- a/gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/ManageApplication.java
+++ b/gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/ManageApplication.java
@@ -13,17 +13,20 @@ import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
import org.springframework.data.elasticsearch.repository.config.EnableReactiveElasticsearchRepositories;
import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
+import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.web.server.WebFilter;
import java.util.List;
@SpringBootApplication(scanBasePackages = "cn.novalon.gym.manage", exclude = {
ReactiveUserDetailsServiceAutoConfiguration.class })
+@EnableScheduling
@EnableR2dbcRepositories(basePackages = {
"cn.novalon.gym.manage.db.dao",
"cn.novalon.gym.manage.sys.audit.repository" ,
"cn.novalon.gym.manage.gymmembercard.dao",
- "cn.novalon.gym.manage.member.repository"
+ "cn.novalon.gym.manage.member.repository",
+ "cn.novalon.gym.manage.groupcourse.dao"
})
@EnableReactiveElasticsearchRepositories(basePackages = "cn.novalon.gym.manage.member.es.repository")
public class ManageApplication {
diff --git a/gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/config/SystemRouter.java b/gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/config/SystemRouter.java
index 996c1d1..76e0b56 100644
--- a/gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/config/SystemRouter.java
+++ b/gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/config/SystemRouter.java
@@ -2,6 +2,8 @@ package cn.novalon.gym.manage.app.config;
import cn.novalon.gym.manage.file.handler.SysFileHandler;
+import cn.novalon.gym.manage.groupcourse.handler.GroupCourseBookingHandler;
+import cn.novalon.gym.manage.groupcourse.handler.GroupCourseHandler;
import cn.novalon.gym.manage.member.handler.MemberCardHandler;
import cn.novalon.gym.manage.member.handler.MemberCardRecordHandler;
import cn.novalon.gym.manage.member.handler.MemberCardTransactionHandler;
@@ -62,7 +64,9 @@ public class SystemRouter {
PasswordDiagnosticHandler passwordDiagnosticHandler,
MemberCardHandler memberCardHandler,
MemberCardRecordHandler memberCardRecordHandler,
- MemberCardTransactionHandler memberCardTransactionHandler) {
+ MemberCardTransactionHandler memberCardTransactionHandler,
+ GroupCourseHandler groupCourseHandler,
+ GroupCourseBookingHandler groupCourseBookingHandler) {
return route()
// ========== 诊断路由 ==========
@@ -249,6 +253,27 @@ public class SystemRouter {
.GET("/api/member-card-transactions/statistics/deduct/{cardId}", memberCardTransactionHandler::getDeductCountByCardId)
.GET("/api/member-card-transactions/statistics/renew", memberCardTransactionHandler::getRenewAmountByTimeRange)
.GET("/api/member-card-transactions/statistics/purchase/{memberId}", memberCardTransactionHandler::getPurchaseAmountByMember)
+
+ // ========================================
+ // ========== 团课管理路由 =================
+ // ========================================
+
+ // ===== 团课课程管理 =====
+ .GET("/api/groupCourse/list", groupCourseHandler::getAllGroupCourse)
+ .POST("/api/groupCourse/page", groupCourseHandler::getGroupCoursesByPage)
+ .GET("/api/groupCourse/{id}", groupCourseHandler::getGroupCourseById)
+ .POST("/api/groupCourse", groupCourseHandler::createGroupCourse)
+ .PUT("/api/groupCourse/{id}", groupCourseHandler::updateGroupCourse)
+ .DELETE("/api/groupCourse/{id}", groupCourseHandler::deleteGroupCourse)
+ .POST("/api/groupCourse/{id}/cancel", groupCourseHandler::cancelGroupCourse)
+ .POST("/api/groupCourse/{courseId}/signin", groupCourseHandler::signIn)
+
+ // ===== 团课预约管理 =====
+ .POST("/api/groupCourse/book", groupCourseBookingHandler::bookCourse)
+ .POST("/api/groupCourse/booking/{bookingId}/cancel", groupCourseBookingHandler::cancelBooking)
+ .GET("/api/groupCourse/bookings/member/{memberId}", groupCourseBookingHandler::getBookingsByMemberId)
+ .GET("/api/groupCourse/bookings/{bookingId}", groupCourseBookingHandler::getBookingById)
+ .GET("/api/groupCourse/bookings/course/{courseId}", groupCourseBookingHandler::getBookingsByCourseId)
.build();
}
diff --git a/gym-manage-api/manage-app/src/main/resources/application-dev.yml b/gym-manage-api/manage-app/src/main/resources/application-dev.yml
index 443a17e..33e428e 100644
--- a/gym-manage-api/manage-app/src/main/resources/application-dev.yml
+++ b/gym-manage-api/manage-app/src/main/resources/application-dev.yml
@@ -15,7 +15,7 @@ spring:
url: jdbc:postgresql://localhost:55432/manage_system
user: novalon
password: novalon123
- enabled: false
+ enabled: true
locations: classpath:db/migration
baseline-on-migrate: true
validate-on-migrate: true
diff --git a/gym-manage-api/manage-app/src/main/resources/application.yml b/gym-manage-api/manage-app/src/main/resources/application.yml
index 708973f..824ca7b 100644
--- a/gym-manage-api/manage-app/src/main/resources/application.yml
+++ b/gym-manage-api/manage-app/src/main/resources/application.yml
@@ -29,7 +29,7 @@ spring:
password: ${DB_PASSWORD:novalon123}
driver-class-name: org.postgresql.Driver
flyway:
- enabled: false
+ enabled: true
locations: classpath:db/migration
baseline-on-migrate: true
baseline-version: 0
@@ -38,11 +38,25 @@ spring:
user:
name: disabled
password: disabled
+ data:
+ redis:
+ host: ${REDIS_HOST:localhost}
+ port: ${REDIS_PORT:6379}
+ password: ${REDIS_PASSWORD:novalon123}
+ timeout: 5000
+ lettuce:
+ pool:
+ max-active: 8 # 最大连接数
+ max-idle: 8 # 最大空闲连接
+ min-idle: 0 # 最小空闲连接
+ max-wait: -1ms # 连接等待时间
profiles:
active: dev
config:
import: classpath:member-config.yml
+
+
management:
endpoints:
web:
diff --git a/gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/config/RedisConfig.java b/gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/config/RedisConfig.java
index 7321879..6b9f23c 100644
--- a/gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/config/RedisConfig.java
+++ b/gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/config/RedisConfig.java
@@ -1,4 +1,4 @@
-package cn.novalon.gym.manage.member.config;
+package cn.novalon.gym.manage.common.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
diff --git a/gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/util/RedisUtil.java b/gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/util/RedisUtil.java
index ea49f50..e880dee 100644
--- a/gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/util/RedisUtil.java
+++ b/gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/util/RedisUtil.java
@@ -1,4 +1,4 @@
-package cn.novalon.gym.manage.member.util;
+package cn.novalon.gym.manage.common.util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ReactiveRedisTemplate;
@@ -69,4 +69,12 @@ public class RedisUtil {
public Mono expire(String key, long timeoutSeconds) {
return reactiveRedisTemplate.expire(key, Duration.ofSeconds(timeoutSeconds));
}
+
+ /**
+ * 根据通配符模式删除key
+ */
+ public Mono deleteByPattern(String pattern) {
+ return reactiveRedisTemplate.keys(pattern)
+ .flatMap(keys -> reactiveRedisTemplate.delete(keys)).count();
+ }
}
\ No newline at end of file
diff --git a/gym-manage-api/manage-db/pom.xml b/gym-manage-api/manage-db/pom.xml
index 392f5e3..2c54f5b 100644
--- a/gym-manage-api/manage-db/pom.xml
+++ b/gym-manage-api/manage-db/pom.xml
@@ -99,6 +99,8 @@
spring-boot-starter-test
test
+
+
diff --git a/gym-manage-api/manage-db/src/main/java/cn/novalon/gym/manage/db/repository/SysUserRepository.java b/gym-manage-api/manage-db/src/main/java/cn/novalon/gym/manage/db/repository/SysUserRepository.java
index c0feccc..2fb85ee 100644
--- a/gym-manage-api/manage-db/src/main/java/cn/novalon/gym/manage/db/repository/SysUserRepository.java
+++ b/gym-manage-api/manage-db/src/main/java/cn/novalon/gym/manage/db/repository/SysUserRepository.java
@@ -10,6 +10,7 @@ import cn.novalon.gym.manage.sys.core.query.SysUserQuery;
import cn.novalon.gym.manage.sys.core.repository.ISysUserRepository;
import cn.novalon.gym.manage.common.dto.PageRequest;
import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.sys.dto.response.UserResponse;
import org.springframework.data.domain.Sort;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.data.relational.core.query.Query;
diff --git a/gym-manage-api/manage-db/src/main/resources/db/migration/V10__Insert_Booking_Test_Data.sql b/gym-manage-api/manage-db/src/main/resources/db/migration/V10__Insert_Booking_Test_Data.sql
new file mode 100644
index 0000000..c6c4452
--- /dev/null
+++ b/gym-manage-api/manage-db/src/main/resources/db/migration/V10__Insert_Booking_Test_Data.sql
@@ -0,0 +1,86 @@
+-- V10: 团课预约业务场景测试数据
+-- 测试场景：
+-- 1. 用户A刚刚注册，在没有任何会员卡的情况下申请团课预约
+-- 2. 用户B已有时长卡，但已经过期
+-- 3. 会员C有时长卡，未过期
+-- 4. 会员D有次数卡，但次数卡耗尽次数
+-- 5. 会员E有次数卡，且次数充足
+-- 6. 会员F有储值卡，但余额不足以支付其预约的团课
+-- 7. 会员G有储值卡，余额充足
+
+-- ============================================
+-- 1. 创建测试会员用户 (A-G)
+-- ============================================
+
+INSERT INTO member_user (member_no, nickname, phone, gender, is_deleted, created_at, updated_at) VALUES
+ ('MEM_TEST_A', '用户A_无卡新用户', '13800001001', 1, false, '2026-06-02 10:00:00', '2026-06-02 10:00:00'),
+ ('MEM_TEST_B', '用户B_过期时长卡', '13800001002', 1, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
+ ('MEM_TEST_C', '会员C_有效时长卡', '13800001003', 2, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
+ ('MEM_TEST_D', '会员D_次数用尽', '13800001004', 1, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
+ ('MEM_TEST_E', '会员E_次数充足', '13800001005', 2, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
+ ('MEM_TEST_F', '会员F_储值卡余额不足', '13800001006', 1, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
+ ('MEM_TEST_G', '会员G_储值卡余额充足', '13800001007', 2, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00');
+
+-- ============================================
+-- 2. 团课课程测试数据（用于预约测试）
+-- ============================================
+
+-- 团课A: 收费类型为次数卡(点卡额度=1)
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
+ ('燃脂搏击_次数卡课程', 102, 2, '2026-06-10 19:30:00', '2026-06-10 20:30:00', 20, 0, '0', '综合训练区', '高强度间歇训练，配合音乐快速燃脂，消耗1次', 1, 0.00, 'admin', '2026-06-01 10:00:00', '2026-06-01 10:00:00');
+
+-- 团课B: 收费类型为储值卡(储值额度=50.00)
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
+ ('高端普拉提_储值卡课程', 103, 1, '2026-06-11 19:00:00', '2026-06-11 20:00:00', 15, 0, '0', '普拉提教室', '精准训练核心肌群，消耗储值50元', 0, 20.00, 'admin', '2026-06-01 10:00:00', '2026-06-01 10:00:00');
+
+-- ============================================
+-- 3. 会员卡类型定义
+-- ============================================
+
+INSERT INTO member_card (member_card_name, member_card_type, member_card_price, member_card_validity_days, member_card_total_times, member_card_amount, member_card_status, extra_config, created_at, updated_at) VALUES
+ ('30天时长卡', 'TIME_CARD', 299.00, 30, NULL, NULL, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'),
+ ('10次卡', 'COUNT_CARD', 499.00, NULL, 10, NULL, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'),
+ ('储值卡500', 'STORED_VALUE_CARD', 500.00, NULL, NULL, 500.00, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00');
+
+-- ============================================
+-- 4. 会员卡记录测试数据
+-- ============================================
+
+-- 场景2: 用户B - 时长卡已过期 (expire_time < 当前时间)
+-- 购买于30天前，有效期30天，现已过期
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_B'), (SELECT member_card_id FROM member_card WHERE member_card_name = '30天时长卡'), 'EXPIRED', 0, 0.00, '2026-05-31 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+
+-- 场景3: 会员C - 时长卡未过期 (expire_time > 当前时间)
+-- 购买于今天，有效期30天，还有30天有效期
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_C'), (SELECT member_card_id FROM member_card WHERE member_card_name = '30天时长卡'), 'ACTIVE', 0, 0.00, '2026-07-02 23:59:59', '2026-06-02 10:00:00', 0, '{}', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
+
+-- 场景4: 会员D - 次数卡耗尽 (remaining_times = 0)
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_D'), (SELECT member_card_id FROM member_card WHERE member_card_name = '10次卡'), 'ACTIVE', 0, 0.00, '2026-12-31 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+
+-- 场景5: 会员E - 次数卡充足 (remaining_times >= point_card_amount)
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_E'), (SELECT member_card_id FROM member_card WHERE member_card_name = '10次卡'), 'ACTIVE', 5, 0.00, '2026-12-31 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+
+-- 场景6: 会员F - 储值卡余额不足 (remaining_amount < stored_value_amount of course)
+-- 团课B收费50元，但会员F储值卡只有30元
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_F'), (SELECT member_card_id FROM member_card WHERE member_card_name = '储值卡500'), 'ACTIVE', 0, 30.00, '2027-06-02 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+
+-- 场景7: 会员G - 储值卡余额充足 (remaining_amount >= stored_value_amount of course)
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_G'), (SELECT member_card_id FROM member_card WHERE member_card_name = '储值卡500'), 'ACTIVE', 0, 200.00, '2027-06-02 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+
+-- ============================================
+-- 5. 测试场景说明
+-- ============================================
+
+-- 场景1: 用户A无会员卡 -> 预约团课时应提示"无可用会员卡"
+-- 场景2: 用户B时长卡已过期 -> 预约团课时应提示"会员卡已过期"
+-- 场景3: 会员C时长卡有效 -> 可以正常预约次数卡团课
+-- 场景4: 会员D次数为0 -> 预约团课时应提示"剩余次数不足"
+-- 场景5: 会员E次数充足 -> 可以正常预约次数卡团课
+-- 场景6: 会员F储值卡余额30元，团课需50元 -> 预约时应提示"余额不足"
+-- 场景7: 会员G储值卡余额200元，团课需50元 -> 可以正常预约储值卡团课
diff --git a/gym-manage-api/manage-db/src/main/resources/db/migration/V11__Insert_Cancel_Booking_Test_Data.sql b/gym-manage-api/manage-db/src/main/resources/db/migration/V11__Insert_Cancel_Booking_Test_Data.sql
new file mode 100644
index 0000000..a6d94c8
--- /dev/null
+++ b/gym-manage-api/manage-db/src/main/resources/db/migration/V11__Insert_Cancel_Booking_Test_Data.sql
@@ -0,0 +1,116 @@
+-- V11: 团课预约取消业务场景测试数据
+-- 测试场景：
+-- 1. 用户张三使用时长卡预约了团课，需要取消预约
+-- 2. 用户李四使用次数卡预约了团课，需要取消预约
+-- 3. 用户王五使用储值卡预约了团课，需要取消预约
+
+-- ============================================
+-- 1. 创建测试会员用户 (张三、李四、王五)
+-- ============================================
+
+INSERT INTO member_user (member_no, nickname, phone, gender, is_deleted, created_at, updated_at) VALUES
+ ('MEM_TEST_ZHANG', '张三_时长卡用户', '13800002001', 1, false, '2026-06-02 10:00:00', '2026-06-02 10:00:00'),
+ ('MEM_TEST_LI', '李四_次数卡用户', '13800002002', 1, false, '2026-06-02 10:00:00', '2026-06-02 10:00:00'),
+ ('MEM_TEST_WANG', '王五_储值卡用户', '13800002003', 2, false, '2026-06-02 10:00:00', '2026-06-02 10:00:00');
+
+-- ============================================
+-- 2. 确保会员卡类型已存在（如果不存在则创建）
+-- ============================================
+
+-- 时长卡类型（30天）
+INSERT INTO member_card (member_card_name, member_card_type, member_card_price, member_card_validity_days, member_card_total_times, member_card_amount, member_card_status, extra_config, created_at, updated_at)
+SELECT '30天时长卡', 'TIME_CARD', 299.00, 30, NULL, NULL, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'
+WHERE NOT EXISTS (SELECT 1 FROM member_card WHERE member_card_name = '30天时长卡');
+
+-- 次数卡类型（10次）
+INSERT INTO member_card (member_card_name, member_card_type, member_card_price, member_card_validity_days, member_card_total_times, member_card_amount, member_card_status, extra_config, created_at, updated_at)
+SELECT '10次卡', 'COUNT_CARD', 499.00, NULL, 10, NULL, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'
+WHERE NOT EXISTS (SELECT 1 FROM member_card WHERE member_card_name = '10次卡');
+
+-- 储值卡类型（500元）
+INSERT INTO member_card (member_card_name, member_card_type, member_card_price, member_card_validity_days, member_card_total_times, member_card_amount, member_card_status, extra_config, created_at, updated_at)
+SELECT '储值卡500', 'STORED_VALUE_CARD', 500.00, NULL, NULL, 500.00, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'
+WHERE NOT EXISTS (SELECT 1 FROM member_card WHERE member_card_name = '储值卡500');
+
+-- ============================================
+-- 3. 为测试用户分配会员卡
+-- ============================================
+
+-- 张三：时长卡（有效期内）
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_ZHANG'),
+ (SELECT member_card_id FROM member_card WHERE member_card_name = '30天时长卡'),
+ 'ACTIVE', 0, 0.00, '2026-07-02 23:59:59', '2026-06-02 10:00:00', 0, '{}', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
+
+-- 李四：次数卡（剩余5次）
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_LI'),
+ (SELECT member_card_id FROM member_card WHERE member_card_name = '10次卡'),
+ 'ACTIVE', 5, 0.00, '2026-12-31 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+
+-- 王五：储值卡（余额200元）
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_WANG'),
+ (SELECT member_card_id FROM member_card WHERE member_card_name = '储值卡500'),
+ 'ACTIVE', 0, 200.00, '2027-06-02 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
+
+-- ============================================
+-- 4. 创建用于取消预约测试的团课
+-- ============================================
+
+-- 团课X: 时长卡可用课程（使用次数卡支付，时长卡会员可预约）
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
+ ('晚间瑜伽_取消测试', 101, 1, '2026-06-15 19:00:00', '2026-06-15 20:00:00', 20, 0, '0', '瑜伽教室', '适合所有级别的瑜伽课程，用于测试取消预约功能', 1, 30.00, 'admin', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
+
+-- ============================================
+-- 5. 创建已预约的记录（状态为0-已预约）
+-- ============================================
+
+-- 张三使用时长卡预约团课（状态：已预约）
+INSERT INTO group_course_booking (course_id, member_id, member_card_id, booking_time, status, course_name, course_start_time, course_end_time, location, created_at, updated_at) VALUES
+ ((SELECT id FROM group_course WHERE course_name = '晚间瑜伽_取消测试'),
+ (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_ZHANG'),
+ (SELECT id FROM member_card_record WHERE member_id = (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_ZHANG')),
+ '2026-06-02 11:00:00', '0', '晚间瑜伽_取消测试', '2026-06-15 19:00:00', '2026-06-15 20:00:00', '瑜伽教室',
+ '2026-06-02 11:00:00', '2026-06-02 11:00:00');
+
+-- 李四使用次数卡预约团课（状态：已预约）
+INSERT INTO group_course_booking (course_id, member_id, member_card_id, booking_time, status, course_name, course_start_time, course_end_time, location, created_at, updated_at) VALUES
+ ((SELECT id FROM group_course WHERE course_name = '晚间瑜伽_取消测试'),
+ (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_LI'),
+ (SELECT id FROM member_card_record WHERE member_id = (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_LI')),
+ '2026-06-02 11:30:00', '0', '晚间瑜伽_取消测试', '2026-06-15 19:00:00', '2026-06-15 20:00:00', '瑜伽教室',
+ '2026-06-02 11:30:00', '2026-06-02 11:30:00');
+
+-- 王五使用储值卡预约团课（状态：已预约）
+INSERT INTO group_course_booking (course_id, member_id, member_card_id, booking_time, status, course_name, course_start_time, course_end_time, location, created_at, updated_at) VALUES
+ ((SELECT id FROM group_course WHERE course_name = '晚间瑜伽_取消测试'),
+ (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_WANG'),
+ (SELECT id FROM member_card_record WHERE member_id = (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_WANG')),
+ '2026-06-02 12:00:00', '0', '晚间瑜伽_取消测试', '2026-06-15 19:00:00', '2026-06-15 20:00:00', '瑜伽教室',
+ '2026-06-02 12:00:00', '2026-06-02 12:00:00');
+
+-- ============================================
+-- 6. 更新团课当前预约人数
+-- ============================================
+
+UPDATE group_course
+SET current_members = current_members + 3
+WHERE course_name = '晚间瑜伽_取消测试';
+
+-- ============================================
+-- 测试数据说明
+-- ============================================
+-- 用户信息：
+-- 张三 (MEM_TEST_ZHANG): 13800002001 - 持有有效期内的时长卡
+-- 李四 (MEM_TEST_LI): 13800002002 - 持有次数卡（剩余5次）
+-- 王五 (MEM_TEST_WANG): 13800002003 - 持有储值卡（余额200元）
+
+-- 测试场景：
+-- 1. 张三使用时长卡预约了团课 -> 取消预约 -> 应恢复时长卡状态，释放课程名额
+-- 2. 李四使用次数卡预约了团课 -> 取消预约 -> 应返还扣除的次数，释放课程名额
+-- 3. 王五使用储值卡预约了团课 -> 取消预约 -> 应返还扣除的金额，释放课程名额
+
+-- 预约记录状态说明：
+-- status = '0' 表示已预约
+-- status = '1' 表示已取消（取消后应更新为此状态）
diff --git a/gym-manage-api/manage-db/src/main/resources/db/migration/V12__Insert_Time_Conflict_Test_Data.sql b/gym-manage-api/manage-db/src/main/resources/db/migration/V12__Insert_Time_Conflict_Test_Data.sql
new file mode 100644
index 0000000..7189cce
--- /dev/null
+++ b/gym-manage-api/manage-db/src/main/resources/db/migration/V12__Insert_Time_Conflict_Test_Data.sql
@@ -0,0 +1,58 @@
+-- V12: 团课预约时间冲突测试数据
+-- 测试场景：会员预约两个时间重叠的团课时，系统应检测到时间冲突并拒绝预约
+
+-- ============================================
+-- 1. 创建测试会员
+-- ============================================
+
+INSERT INTO member_user (member_no, nickname, phone, gender, is_deleted, created_at, updated_at) VALUES
+ ('MEM_TIME_CONFLICT', '时间冲突测试会员', '13800009999', 1, false, '2026-06-02 10:00:00', '2026-06-02 10:00:00');
+
+-- ============================================
+-- 2. 创建时间冲突的团课
+-- ============================================
+
+-- 团课A: 6月15日 13:00 - 15:00
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
+ ('时间冲突测试_A_13点-15点', 102, 2, '2026-06-15 13:00:00', '2026-06-15 15:00:00', 20, 0, '0', '综合训练区', '测试用团课A，用于验证时间冲突检测', 1, 0.00, 'admin', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
+
+-- 团课B: 6月15日 14:00 - 16:00 (与团课A时间重叠)
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
+ ('时间冲突测试_B_14点-16点', 103, 1, '2026-06-15 14:00:00', '2026-06-15 16:00:00', 15, 0, '0', '普拉提教室', '测试用团课B，与团课A时间重叠（14:00-15:00）', 1, 0.00, 'admin', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
+
+-- 团课C: 6月15日 10:00 - 12:00 (不冲突，作为对照)
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
+ ('时间冲突测试_C_10点-12点', 101, 1, '2026-06-15 10:00:00', '2026-06-15 12:00:00', 15, 0, '0', '瑜伽教室', '测试用团课C，与团课A/B不冲突', 1, 0.00, 'admin', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
+
+-- ============================================
+-- 3. 会员卡记录（用于预约）
+-- ============================================
+
+-- 为时间冲突测试会员创建有效次数卡
+INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
+ ((SELECT id FROM member_user WHERE member_no = 'MEM_TIME_CONFLICT'), (SELECT member_card_id FROM member_card WHERE member_card_name = '10次卡'), 'ACTIVE', 10, 0.00, '2026-12-31 23:59:59', '2026-06-02 10:00:00', 0, '{}', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
+
+-- ============================================
+-- 4. 测试场景说明
+-- ============================================
+--
+-- 测试步骤：
+-- 1. 使用会员 MEM_TIME_CONFLICT 预约团课A (course_name='时间冲突测试_A_13点-15点')
+-- → 预期：预约成功
+--
+-- 2. 使用会员 MEM_TIME_CONFLICT 预约团课B (course_name='时间冲突测试_B_14点-16点')
+-- → 预期：预约失败，提示时间冲突（14:00-15:00与已预约的团课A重叠）
+--
+-- 3. 使用会员 MEM_TIME_CONFLICT 预约团课C (course_name='时间冲突测试_C_10点-12点')
+-- → 预期：预约成功（与团课A时间不冲突）
+--
+-- 时间冲突判断逻辑：
+-- 新课程开始时间 < 已预约课程结束时间 AND 新课程结束时间 > 已预约课程开始时间
+-- 即：newStartTime < existingEndTime AND newEndTime > existingStartTime
+--
+-- 本测试数据中的时间关系：
+-- - 团课A: 13:00 - 15:00
+-- - 团课B: 14:00 - 16:00
+-- → 14:00 < 15:00 AND 16:00 > 13:00 → 冲突
+-- - 团课C: 10:00 - 12:00
+-- → 10:00 < 15:00 AND 12:00 > 13:00 → 12:00 > 13:00 不成立 → 不冲突
\ No newline at end of file
diff --git a/gym-manage-api/manage-db/src/main/resources/db/migration/V6__Create_GroupCourse_table.sql b/gym-manage-api/manage-db/src/main/resources/db/migration/V6__Create_GroupCourse_table.sql
new file mode 100644
index 0000000..0e26497
--- /dev/null
+++ b/gym-manage-api/manage-db/src/main/resources/db/migration/V6__Create_GroupCourse_table.sql
@@ -0,0 +1,77 @@
+-- ============================================
+-- 团课相关表
+-- ============================================
+
+-- 团课课程表
+CREATE TABLE IF NOT EXISTS group_course (
+ id BIGSERIAL PRIMARY KEY,
+ course_name VARCHAR(100) NOT NULL,
+ coach_id BIGINT,
+ course_type BIGINT,
+ start_time TIMESTAMP NOT NULL,
+ end_time TIMESTAMP NOT NULL,
+ max_members INTEGER DEFAULT 20,
+ current_members INTEGER DEFAULT 0,
+ status VARCHAR(1) DEFAULT '0',
+ location VARCHAR(255),
+ cover_image VARCHAR(500),
+ description TEXT,
+ point_card_amount INTEGER DEFAULT 1,
+ stored_value_amount DECIMAL(10,2) DEFAULT 0,
+ create_by VARCHAR(50),
+ update_by VARCHAR(50),
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ deleted_at TIMESTAMP
+);
+
+-- 团课预约记录表
+CREATE TABLE IF NOT EXISTS group_course_booking (
+ id BIGSERIAL PRIMARY KEY,
+ course_id BIGINT NOT NULL,
+ member_id BIGINT NOT NULL,
+ member_card_id BIGINT NOT NULL,
+ booking_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ status VARCHAR(1) DEFAULT '0',
+ cancel_time TIMESTAMP,
+ create_by VARCHAR(50),
+ update_by VARCHAR(50),
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ deleted_at TIMESTAMP
+);
+
+COMMENT ON TABLE group_course IS '团课课程表';
+COMMENT ON COLUMN group_course.id IS '主键ID';
+COMMENT ON COLUMN group_course.course_name IS '课程名称';
+COMMENT ON COLUMN group_course.coach_id IS '教练ID（关联sys_user）';
+COMMENT ON COLUMN group_course.course_type IS '课程类型（如瑜伽/普拉提/动感单车）';
+COMMENT ON COLUMN group_course.start_time IS '开始时间';
+COMMENT ON COLUMN group_course.end_time IS '结束时间';
+COMMENT ON COLUMN group_course.max_members IS '最大参与人数';
+COMMENT ON COLUMN group_course.current_members IS '当前参与人数';
+COMMENT ON COLUMN group_course.status IS '状态（0正常 1已取消 2已结束）';
+COMMENT ON COLUMN group_course.location IS '上课地点';
+COMMENT ON COLUMN group_course.cover_image IS '封面图URL';
+COMMENT ON COLUMN group_course.description IS '课程描述';
+COMMENT ON COLUMN group_course.point_card_amount IS '点卡额度（消耗次数）';
+COMMENT ON COLUMN group_course.stored_value_amount IS '储值卡额度（消耗金额）';
+COMMENT ON COLUMN group_course.create_by IS '创建人';
+COMMENT ON COLUMN group_course.update_by IS '更新人';
+COMMENT ON COLUMN group_course.created_at IS '创建时间';
+COMMENT ON COLUMN group_course.updated_at IS '更新时间';
+COMMENT ON COLUMN group_course.deleted_at IS '删除时间（软删除）';
+
+COMMENT ON TABLE group_course_booking IS '团课预约记录表';
+COMMENT ON COLUMN group_course_booking.id IS '主键ID';
+COMMENT ON COLUMN group_course_booking.course_id IS '团课ID';
+COMMENT ON COLUMN group_course_booking.member_id IS '用户ID';
+COMMENT ON COLUMN group_course_booking.member_card_id IS '会员卡ID';
+COMMENT ON COLUMN group_course_booking.booking_time IS '预约时间';
+COMMENT ON COLUMN group_course_booking.status IS '状态（0已预约 1已取消 2已出席 3缺席）';
+COMMENT ON COLUMN group_course_booking.cancel_time IS '取消时间';
+COMMENT ON COLUMN group_course_booking.create_by IS '创建人';
+COMMENT ON COLUMN group_course_booking.update_by IS '更新人';
+COMMENT ON COLUMN group_course_booking.created_at IS '创建时间';
+COMMENT ON COLUMN group_course_booking.updated_at IS '更新时间';
+COMMENT ON COLUMN group_course_booking.deleted_at IS '删除时间（软删除）';
\ No newline at end of file
diff --git a/gym-manage-api/manage-db/src/main/resources/db/migration/V7__Insert_GroupCourse_test_data.sql b/gym-manage-api/manage-db/src/main/resources/db/migration/V7__Insert_GroupCourse_test_data.sql
new file mode 100644
index 0000000..ee7adaa
--- /dev/null
+++ b/gym-manage-api/manage-db/src/main/resources/db/migration/V7__Insert_GroupCourse_test_data.sql
@@ -0,0 +1,28 @@
+-- 场景1: 0人预约，可预约（正常状态，6月15日，距开始还有14天）
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
+ ('极速燃脂单车', 104, 2, '2026-06-02 16:45:00', '2026-06-15 20:20:00', 25, 0, 0, '单车房', '/images/spinning.jpg', '跟随音乐节奏变换阻力和速度，体验爬坡与冲刺的快感，一节课消耗800大卡。', 'admin', '2026-06-01 11:00:00', '2026-06-01 11:00:00');
+
+-- 场景2: 已有人预约，可预约（正常状态，6月12日，5/15人）
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
+ ('清晨流瑜伽', 101, 1, '2026-06-12 09:00:00', '2026-06-12 10:30:00', 15, 5, 0, 'A座3楼瑜伽教室', '/images/yoga_flow.jpg', '适合有一定基础的学员，通过流畅的体式连接呼吸，唤醒身体能量。', 'admin', '2026-06-01 10:00:00', '2026-06-01 10:00:00');
+
+-- 场景3: 满员，不可预约（正常状态但已满员，6月10日，20/20人）
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
+ ('燃脂搏击', 102, 2, '2026-06-10 18:30:00', '2026-06-10 19:30:00', 20, 20, 0, '综合训练区', '/images/kickboxing.jpg', '高强度间歇训练，配合音乐快速燃脂，释放压力。名额已满，无法预约。', 'coach_zhang', '2026-06-01 14:30:00', '2026-06-01 14:30:00');
+
+-- 场景4: 超出可预约时间，不可预约（正常状态但距开始不足30分钟）
+-- 当前时间: 2026-06-01 15:00，课程开始: 2026-06-01 15:20
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
+ ('哈他瑜伽', 101, 1, '2026-06-01 15:20:00', '2026-06-01 16:50:00', 12, 3, 0, '瑜伽教室B', '/images/hatha_yoga.jpg', '基础哈他瑜伽，适合所有级别。距开始不足30分钟，已停止预约。', 'coach_li', '2026-06-01 08:00:00', '2026-06-01 08:00:00');
+
+-- 场景5: 课程已取消，不可预约（status=1）
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
+ ('周末冥想修复', 101, 1, '2026-06-20 15:00:00', '2026-06-20 16:00:00', 12, 3, 1, '冥想室', '/images/meditation.jpg', '通过呼吸和正念冥想，深度放松身心。该课程已被取消。', 'coach_wang', '2026-05-28 08:00:00', '2026-05-28 08:00:00');
+
+-- 场景6: 课程已结束，不可预约（status=2）
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
+ ('蜜桃臀塑造', 103, 3, '2026-05-30 19:00:00', '2026-05-30 20:00:00', 10, 8, 2, '私教专区', '/images/glute.jpg', '针对性训练臀部肌肉群，课程已于5月30日结束，无法预约。', 'coach_li', '2026-05-20 09:15:00', '2026-05-20 09:15:00');
+
+-- 场景7（可选）: 已结束但未满员的课程（status=2，即使有空位也不可预约）
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
+ ('午间冥想放松', 101, 1, '2026-05-31 12:00:00', '2026-05-31 13:00:00', 15, 6, 2, '冥想室', '/images/meditation_noon.jpg', '午间冥想课程，已于5月31日结束。', 'admin', '2026-05-25 09:00:00', '2026-05-25 09:00:00');
\ No newline at end of file
diff --git a/gym-manage-api/manage-db/src/main/resources/db/migration/V8__Create_Member_And_MemberCard.sql b/gym-manage-api/manage-db/src/main/resources/db/migration/V8__Create_Member_And_MemberCard.sql
new file mode 100644
index 0000000..d9c3954
--- /dev/null
+++ b/gym-manage-api/manage-db/src/main/resources/db/migration/V8__Create_Member_And_MemberCard.sql
@@ -0,0 +1,281 @@
+-- ============================================
+-- 1. member_user 表（会员表）
+-- ============================================
+
+-- Step 1: 删除已存在的表（如果需要重建）
+-- DROP TABLE IF EXISTS member_user CASCADE;
+
+-- Step 2: 创建 member_user 表
+CREATE TABLE IF NOT EXISTS member_user (
+ -- ========== 主键和基础字段（来自BaseEntity）==========
+ id BIGSERIAL PRIMARY KEY, -- 主键ID，自增
+ created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
+ updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 更新时间
+
+ -- ========== 会员核心字段 ==========
+ member_no VARCHAR(50) NOT NULL UNIQUE, -- 会员编号（唯一）
+ nickname VARCHAR(100), -- 昵称
+ phone VARCHAR(255), -- 手机号（AES加密存储）
+ gender INTEGER DEFAULT 0, -- 性别：0-未知，1-男，2-女
+ birthday DATE, -- 生日
+ address VARCHAR(500), -- 地址
+ avatar VARCHAR(500), -- 头像URL
+ subscribed BOOLEAN DEFAULT FALSE, -- 是否关注服务号
+ last_login_at TIMESTAMP, -- 最后登录时间
+
+-- ========== 微信相关字段 ==========
+ union_id VARCHAR(100), -- 微信UnionID（跨应用唯一标识）
+ miniapp_open_id VARCHAR(100), -- 小程序OpenID
+ official_open_id VARCHAR(100), -- 服务号OpenID
+
+-- ========== 软删除字段 ==========
+ is_deleted BOOLEAN DEFAULT FALSE -- 是否删除（软删除标记）
+ );
+
+-- Step 3: 创建索引
+-- 会员编号索引（唯一索引，加速查询）
+CREATE UNIQUE INDEX IF NOT EXISTS idx_member_user_member_no ON member_user(member_no);
+
+-- UnionID索引（加速跨平台用户查找）
+CREATE INDEX IF NOT EXISTS idx_member_user_union_id ON member_user(union_id);
+
+-- 小程序OpenID索引（加速小程序登录查询）
+CREATE INDEX IF NOT EXISTS idx_member_user_miniapp_openid ON member_user(miniapp_open_id);
+
+-- 服务号OpenID索引（加速服务号事件处理）
+CREATE INDEX IF NOT EXISTS idx_member_user_official_openid ON member_user(official_open_id);
+
+-- 手机号索引（加速手机号查询和去重）
+CREATE INDEX IF NOT EXISTS idx_member_user_phone ON member_user(phone);
+
+-- 软删除索引（加速查询未删除的记录）
+CREATE INDEX IF NOT EXISTS idx_member_user_is_deleted ON member_user(is_deleted);
+
+-- Step 4: 添加注释
+COMMENT ON TABLE member_user IS '会员表';
+
+COMMENT ON COLUMN member_user.id IS '主键ID';
+COMMENT ON COLUMN member_user.created_at IS '创建时间';
+COMMENT ON COLUMN member_user.updated_at IS '更新时间';
+
+COMMENT ON COLUMN member_user.member_no IS '会员编号（唯一，格式：MEM + 8位随机字符）';
+COMMENT ON COLUMN member_user.nickname IS '昵称';
+COMMENT ON COLUMN member_user.phone IS '手机号（AES-128-CBC加密存储）';
+COMMENT ON COLUMN member_user.gender IS '性别：0-未知，1-男，2-女';
+COMMENT ON COLUMN member_user.birthday IS '生日';
+COMMENT ON COLUMN member_user.address IS '地址';
+COMMENT ON COLUMN member_user.avatar IS '头像URL';
+COMMENT ON COLUMN member_user.subscribed IS '是否关注服务号：true-已关注，false-未关注';
+COMMENT ON COLUMN member_user.last_login_at IS '最后登录时间';
+
+COMMENT ON COLUMN member_user.union_id IS '微信UnionID（用户在开放平台的唯一标识，跨应用相同）';
+COMMENT ON COLUMN member_user.miniapp_open_id IS '小程序OpenID（用户在当前小程序的唯一标识）';
+COMMENT ON COLUMN member_user.official_open_id IS '服务号OpenID（用户在当前服务号的唯一标识）';
+
+COMMENT ON COLUMN member_user.is_deleted IS '是否删除（软删除标记）：false-正常，true-已删除';
+
+
+-- ============================================
+-- 2. wechat_user 表（微信用户表）
+-- ============================================
+
+-- Step 1: 删除已存在的表（如果需要重建）
+-- DROP TABLE IF EXISTS wechat_user CASCADE;
+
+-- Step 2: 创建 wechat_user 表
+CREATE TABLE IF NOT EXISTS wechat_user (
+ -- ========== 主键和基础字段（来自BaseEntity）==========
+ id BIGSERIAL PRIMARY KEY, -- 主键ID，自增
+ created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
+ updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 更新时间
+
+ -- ========== 关联字段 ==========
+ member_id BIGINT NOT NULL, -- 会员ID（外键）
+
+ -- ========== 微信标识字段 ==========
+ union_id VARCHAR(100), -- 微信UnionID
+ miniapp_openid VARCHAR(100), -- 小程序OpenID
+ mp_openid VARCHAR(100), -- 服务号OpenID
+
+-- ========== 关注状态字段 ==========
+ is_subscribed BOOLEAN DEFAULT FALSE, -- 是否关注服务号
+ subscribe_time TIMESTAMP, -- 首次关注时间
+ unsubscribe_time TIMESTAMP -- 最后一次取消关注时间
+ );
+
+-- Step 3: 创建外键约束
+ALTER TABLE wechat_user
+ ADD CONSTRAINT fk_wechat_user_member
+ FOREIGN KEY (member_id) REFERENCES member_user(id) ON DELETE CASCADE;
+
+-- Step 4: 创建索引
+-- UnionID索引（加速跨平台用户查找）
+CREATE INDEX IF NOT EXISTS idx_wechat_user_union_id ON wechat_user(union_id);
+
+-- 小程序OpenID索引（加速小程序登录查询）
+CREATE INDEX IF NOT EXISTS idx_wechat_user_miniapp_openid ON wechat_user(miniapp_openid);
+
+-- 服务号OpenID索引（加速服务号事件处理）
+CREATE INDEX IF NOT EXISTS idx_wechat_user_mp_openid ON wechat_user(mp_openid);
+
+-- 会员ID索引（加速关联查询）
+CREATE INDEX IF NOT EXISTS idx_wechat_user_member_id ON wechat_user(member_id);
+
+-- Step 5: 添加注释
+COMMENT ON TABLE wechat_user IS '微信用户表';
+
+COMMENT ON COLUMN wechat_user.id IS '主键ID';
+COMMENT ON COLUMN wechat_user.created_at IS '创建时间';
+COMMENT ON COLUMN wechat_user.updated_at IS '更新时间';
+
+COMMENT ON COLUMN wechat_user.member_id IS '会员ID（关联 member_user 表的 id 字段）';
+COMMENT ON COLUMN wechat_user.union_id IS '微信UnionID（用户在开放平台的唯一标识）';
+COMMENT ON COLUMN wechat_user.miniapp_openid IS '小程序OpenID（用户在当前小程序的唯一标识）';
+COMMENT ON COLUMN wechat_user.mp_openid IS '服务号OpenID（用户在当前服务号的唯一标识）';
+
+COMMENT ON COLUMN wechat_user.is_subscribed IS '是否关注服务号：true-已关注，false-未关注';
+COMMENT ON COLUMN wechat_user.subscribe_time IS '首次关注时间';
+COMMENT ON COLUMN wechat_user.unsubscribe_time IS '最后一次取消关注时间';
+
+
+-- ============================================
+-- 3. member_card 表（会员卡类型表）
+-- ============================================
+CREATE TABLE IF NOT EXISTS member_card (
+ id BIGSERIAL PRIMARY KEY,
+ created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ deleted_at TIMESTAMP,
+
+ member_card_id BIGSERIAL,
+ member_card_name VARCHAR(100) NOT NULL,
+ member_card_type VARCHAR(20) NOT NULL,
+ member_card_price DECIMAL(10, 2) NOT NULL,
+ member_card_validity_days INTEGER,
+ member_card_total_times INTEGER,
+ member_card_amount DECIMAL(10, 2),
+ member_card_status INTEGER DEFAULT 1 NOT NULL,
+ extra_config TEXT DEFAULT '{}'
+ );
+
+COMMENT ON TABLE member_card IS '会员卡类型表';
+COMMENT ON COLUMN member_card.member_card_id IS '会员卡ID';
+COMMENT ON COLUMN member_card.member_card_name IS '会员卡名称';
+COMMENT ON COLUMN member_card.member_card_type IS '会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡';
+COMMENT ON COLUMN member_card.member_card_price IS '会员卡价格';
+COMMENT ON COLUMN member_card.member_card_validity_days IS '有效天数（时长卡用）';
+COMMENT ON COLUMN member_card.member_card_total_times IS '总次数（次卡用）';
+COMMENT ON COLUMN member_card.member_card_amount IS '面额（储值卡用）';
+COMMENT ON COLUMN member_card.member_card_status IS '状态：0-下架, 1-上架';
+COMMENT ON COLUMN member_card.extra_config IS '扩展配置（JSON格式）';
+
+
+-- ============================================
+-- 4. member_card_record 表（会员卡记录表）
+-- ============================================
+CREATE TABLE IF NOT EXISTS member_card_record (
+ id BIGSERIAL PRIMARY KEY,
+ created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ deleted_at TIMESTAMP,
+
+ member_card_record_id BIGSERIAL,
+ member_id BIGINT NOT NULL,
+ member_card_id BIGINT NOT NULL,
+ status VARCHAR(20) NOT NULL DEFAULT 'ACTIVE',
+ remaining_times INTEGER DEFAULT 0,
+ remaining_amount DECIMAL(10, 2) DEFAULT 0.00,
+ expire_time TIMESTAMP,
+ source_order_id BIGINT,
+ purchase_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ version INTEGER DEFAULT 0 NOT NULL,
+ card_composition TEXT
+ );
+
+-- 索引优化
+CREATE INDEX IF NOT EXISTS idx_member_card_record_member_id ON member_card_record(member_id);
+CREATE INDEX IF NOT EXISTS idx_member_card_record_status ON member_card_record(status);
+CREATE INDEX IF NOT EXISTS idx_member_card_record_expire_time ON member_card_record(expire_time);
+CREATE INDEX IF NOT EXISTS idx_member_card_record_member_status ON member_card_record(member_id, status);
+CREATE INDEX IF NOT EXISTS idx_member_card_record_status_expire ON member_card_record(status, expire_time)
+ WHERE status = 'ACTIVE';
+
+COMMENT ON TABLE member_card_record IS '会员卡记录表（会员持有的卡）';
+COMMENT ON COLUMN member_card_record.member_card_record_id IS '会员卡记录ID';
+COMMENT ON COLUMN member_card_record.member_id IS '会员ID';
+COMMENT ON COLUMN member_card_record.member_card_id IS '会员卡类型ID';
+COMMENT ON COLUMN member_card_record.status IS '状态：ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款';
+COMMENT ON COLUMN member_card_record.remaining_times IS '剩余次数';
+COMMENT ON COLUMN member_card_record.remaining_amount IS '剩余金额';
+COMMENT ON COLUMN member_card_record.expire_time IS '到期时间';
+COMMENT ON COLUMN member_card_record.source_order_id IS '来源订单ID';
+COMMENT ON COLUMN member_card_record.purchase_time IS '购买时间';
+COMMENT ON COLUMN member_card_record.version IS '乐观锁版本号';
+COMMENT ON COLUMN member_card_record.card_composition IS '卡片组成（JSON格式，用于组合卡）';
+
+
+-- ============================================
+-- 5. member_card_transactions 表（会员卡交易流水表）
+-- ============================================
+CREATE TABLE IF NOT EXISTS member_card_transactions (
+ id BIGSERIAL PRIMARY KEY,
+ created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+ member_card_record_id BIGINT NOT NULL,
+ member_id BIGINT NOT NULL,
+ member_card_id BIGINT NOT NULL,
+ operation_type VARCHAR(20) NOT NULL,
+ change_amount INTEGER DEFAULT 0,
+ change_balance DECIMAL(10, 2) DEFAULT 0.00,
+ after_remaining_count INTEGER DEFAULT 0,
+ after_remaining_balance DECIMAL(10, 2) DEFAULT 0.00,
+ related_biz_type VARCHAR(20),
+ source_order_id BIGINT,
+ remark VARCHAR(500),
+ is_archived BOOLEAN DEFAULT FALSE,
+ archived_at TIMESTAMP
+ );
+
+-- 索引优化
+CREATE INDEX IF NOT EXISTS idx_member_card_transactions_member_id ON member_card_transactions(member_id);
+CREATE INDEX IF NOT EXISTS idx_member_card_transactions_record_id ON member_card_transactions(member_card_record_id);
+CREATE INDEX IF NOT EXISTS idx_member_card_transactions_created_at ON member_card_transactions(created_at);
+CREATE INDEX IF NOT EXISTS idx_member_card_transactions_member_type_time
+ ON member_card_transactions(member_id, operation_type, created_at);
+
+COMMENT ON TABLE member_card_transactions IS '会员卡交易流水表';
+COMMENT ON COLUMN member_card_transactions.operation_type IS '操作类型：PURCHASE-购买, DEDUCT-扣次/扣费, RENEW-续费, REFUND-退款, EXPIRE-过期';
+COMMENT ON COLUMN member_card_transactions.change_amount IS '变动次数';
+COMMENT ON COLUMN member_card_transactions.change_balance IS '变动金额';
+COMMENT ON COLUMN member_card_transactions.after_remaining_count IS '变动后剩余次数';
+COMMENT ON COLUMN member_card_transactions.after_remaining_balance IS '变动后剩余金额';
+COMMENT ON COLUMN member_card_transactions.related_biz_type IS '关联业务类型：GROUP_CLASS-团课, PT_CLASS-私教, CHECK_IN-签到';
+COMMENT ON COLUMN member_card_transactions.is_archived IS '是否已归档';
+COMMENT ON COLUMN member_card_transactions.archived_at IS '归档时间';
+
+
+-- ============================================
+-- 6. refund_application 表（退款申请表）
+-- ============================================
+CREATE TABLE IF NOT EXISTS refund_application (
+ id BIGSERIAL PRIMARY KEY,
+ created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ deleted_at TIMESTAMP,
+
+ record_id BIGINT NOT NULL,
+ member_id BIGINT NOT NULL,
+ status VARCHAR(20) NOT NULL DEFAULT 'PENDING',
+ reason VARCHAR(500),
+ apply_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ audit_time TIMESTAMP,
+ auditor_id BIGINT,
+ audit_remark VARCHAR(500),
+ refund_amount DECIMAL(10, 2)
+ );
+
+CREATE INDEX IF NOT EXISTS idx_refund_application_record_id ON refund_application(record_id);
+CREATE INDEX IF NOT EXISTS idx_refund_application_status ON refund_application(status);
+
+COMMENT ON TABLE refund_application IS '退款申请表';
+COMMENT ON COLUMN refund_application.status IS '状态：PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败';
diff --git a/gym-manage-api/manage-db/src/main/resources/db/migration/V9__Add_GroupCourse_Booking_Snapshot_Fields.sql b/gym-manage-api/manage-db/src/main/resources/db/migration/V9__Add_GroupCourse_Booking_Snapshot_Fields.sql
new file mode 100644
index 0000000..8a07dc7
--- /dev/null
+++ b/gym-manage-api/manage-db/src/main/resources/db/migration/V9__Add_GroupCourse_Booking_Snapshot_Fields.sql
@@ -0,0 +1,15 @@
+-- ============================================
+-- 为团课预约记录表添加课程冗余字段
+-- 用于保存预约时的课程快照信息
+-- ============================================
+
+ALTER TABLE group_course_booking
+ ADD COLUMN IF NOT EXISTS course_name VARCHAR(100),
+ ADD COLUMN IF NOT EXISTS course_start_time TIMESTAMP,
+ ADD COLUMN IF NOT EXISTS course_end_time TIMESTAMP,
+ ADD COLUMN IF NOT EXISTS location VARCHAR(255);
+
+COMMENT ON COLUMN group_course_booking.course_name IS '课程名称（冗余字段，保存预约时的课程快照）';
+COMMENT ON COLUMN group_course_booking.course_start_time IS '课程开始时间（冗余字段，保存预约时的课程快照）';
+COMMENT ON COLUMN group_course_booking.course_end_time IS '课程结束时间（冗余字段，保存预约时的课程快照）';
+COMMENT ON COLUMN group_course_booking.location IS '上课地点（冗余字段，保存预约时的课程快照）';
\ No newline at end of file
diff --git a/gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/config/SecurityConfig.java b/gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/config/SecurityConfig.java
index 4df2a4b..b83f541 100644
--- a/gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/config/SecurityConfig.java
+++ b/gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/config/SecurityConfig.java
@@ -50,7 +50,14 @@ public class SecurityConfig {
spec.pathMatchers("/api/auth/**").permitAll()
.pathMatchers("/api/public/**").permitAll()
.pathMatchers("/ws/**").permitAll()
- .pathMatchers("/actuator/**").permitAll();
+ .pathMatchers("/actuator/**").permitAll()
+ .pathMatchers("/api/groupCourse/**").permitAll()
+ .pathMatchers("/api/member/**").permitAll()
+ .pathMatchers("/api/admin/member/**").permitAll()
+ .pathMatchers("/api/member-cards/**").permitAll()
+ .pathMatchers("/api/member-card-records/**").permitAll()
+ .pathMatchers("/api/member-card-transactions/**").permitAll();
+
if (isDevOrTest) {
spec.pathMatchers("/swagger-ui.html").permitAll()
diff --git a/gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/core/service/impl/SysUserService.java b/gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/core/service/impl/SysUserService.java
index 3d7bf64..ee1da91 100644
--- a/gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/core/service/impl/SysUserService.java
+++ b/gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/core/service/impl/SysUserService.java
@@ -15,6 +15,7 @@ import cn.novalon.gym.manage.sys.core.repository.IUserRoleRepository;
import cn.novalon.gym.manage.sys.core.service.ISysUserService;
import cn.novalon.gym.manage.sys.core.command.CreateUserCommand;
import cn.novalon.gym.manage.sys.core.command.UpdateUserCommand;
+import cn.novalon.gym.manage.sys.dto.response.UserResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
diff --git a/gym-manage-api/pom.xml b/gym-manage-api/pom.xml
index 489ae2c..e84ef9d 100644
--- a/gym-manage-api/pom.xml
+++ b/gym-manage-api/pom.xml
@@ -43,6 +43,7 @@
manage-notify
manage-file
gym-member
+ gym-groupCourse
@@ -223,12 +224,18 @@
true
-
+
- org.springframework.boot
- spring-boot-starter-data-redis-reactive
+ cn.hutool
+ hutool-all
+ 5.8.38
-
+
+
+ org.springframework.boot
+ spring-boot-starter-data-redis-reactive
+
+