修改主题色

# Conflicts:
#	gym-manage-uniapp/pages.json

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');
+```

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. 取消预约后应记录操作日志和交易流水

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, ...);
+```

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": "错误描述信息"
+}
+```
+
+---
+
+*文档结束*

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

gym-manage-api/gym-groupCourse/pom.xml

@@ -0,0 +1,95 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>cn.novalon.gym.manage</groupId>
+        <artifactId>gym-manage-api</artifactId>
+        <version>1.0.0</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <groupId>cn.novalon.gym.manage</groupId>
+    <artifactId>gym-groupCourse</artifactId>
+    <version>1.0.0</version>
+    <name>gym-groupCourse</name>
+    <description>Group Course Management Module</description>
+    <url/>
+    <licenses>
+        <license/>
+    </licenses>
+    <developers>
+        <developer/>
+    </developers>
+    <scm>
+        <connection/>
+        <developerConnection/>
+        <tag/>
+        <url/>
+    </scm>
+    <properties>
+        <java.version>21</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-db</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webflux</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-r2dbc</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springdoc</groupId>
+            <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.swagger.core.v3</groupId>
+            <artifactId>swagger-annotations-jakarta</artifactId>
+            <version>2.2.43</version>
+            <scope>compile</scope>
+        </dependency>
+
+
+<!--        Redis依赖-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+        
+        <!-- 会员模块依赖 -->
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>gym-member</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

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<GroupCourse> toDomainList(List<GroupCourseEntity> entities){
+        if (entities == null) {
+            return null;
+        }
+        return entities.stream()
+                .map(this::toDomain)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * 将团课领域模型列表转换为实体列表
+     */
+    public List<GroupCourseEntity> toEntityList(List<GroupCourse> 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<GroupCourseBooking> toBookingDomainList(List<GroupCourseBookingEntity> entities){
+        if (entities == null) {
+            return null;
+        }
+        return entities.stream()
+                .map(this::toBookingDomain)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * 将团课预约领域模型列表转换为实体列表
+     */
+    public List<GroupCourseBookingEntity> toBookingEntityList(List<GroupCourseBooking> domains){
+        if (domains == null) {
+            return null;
+        }
+        return domains.stream()
+                .map(this::toBookingEntity)
+                .collect(Collectors.toList());
+    }
+}

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<GroupCourseBookingEntity, Long> {
+
+    /**
+     * 根据ID查询未删除的预约记录
+     */
+    Mono<GroupCourseBookingEntity> findByIdIsAndDeletedAtIsNull(Long id);
+
+    /**
+     * 根据会员ID查询所有预约记录
+     */
+    Flux<GroupCourseBookingEntity> findByMemberIdAndDeletedAtIsNull(Long memberId);
+
+    /**
+     * 根据会员ID查询所有预约记录（带排序）
+     */
+    Flux<GroupCourseBookingEntity> findByMemberIdAndDeletedAtIsNull(Long memberId, Sort sort);
+
+    /**
+     * 根据团课ID查询所有预约记录
+     */
+    Flux<GroupCourseBookingEntity> findByCourseIdAndDeletedAtIsNull(Long courseId);
+
+    /**
+     * 根据团课ID和会员ID查询预约记录
+     */
+    Mono<GroupCourseBookingEntity> findByCourseIdAndMemberIdAndDeletedAtIsNull(Long courseId, Long memberId);
+
+    /**
+     * 根据团课ID和状态查询预约记录
+     */
+    Flux<GroupCourseBookingEntity> findByCourseIdAndStatusAndDeletedAtIsNull(Long courseId, String status);
+
+    /**
+     * 查询会员在指定课程的有效预约（状态为已预约且未取消）
+     */
+    Mono<GroupCourseBookingEntity> findByCourseIdAndMemberIdAndStatusAndDeletedAtIsNull(Long courseId, Long memberId, String status);
+
+    /**
+     * 根据会员卡记录ID查询预约记录
+     */
+    Flux<GroupCourseBookingEntity> findByMemberCardRecordIdAndDeletedAtIsNull(Long memberCardRecordId);
+
+    /**
+     * 统计团课已预约人数
+     */
+    Mono<Long> 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<GroupCourseBookingEntity> 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<Integer> 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<Integer> 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<GroupCourseBookingEntity> 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<Integer> updateToAbsent(Long id, java.time.LocalDateTime updatedAt);
+}

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<GroupCourseEntity, Long> {
+
+    Mono<GroupCourseEntity> findByIdIsAndDeletedAtIsNull(Long id);
+
+    Flux<GroupCourseEntity> findAll();
+
+    Flux<GroupCourseEntity> findAll(Sort sort);
+
+    Flux<GroupCourseEntity> findAllByDeletedAtIsNull();
+
+    Flux<GroupCourseEntity> findAllByDeletedAtIsNull(Sort sort);
+
+    @Modifying
+    @Query("UPDATE group_course SET status = '1', updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
+    Mono<Integer> 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<Integer> updateCurrentMembers(Long id, Integer delta, LocalDateTime updatedAt);
+
+    @Modifying
+    @Query("UPDATE group_course SET deleted_at = :deletedAt WHERE id = :id")
+    Mono<Integer> softDelete(Long id, LocalDateTime deletedAt);
+}

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;
+    }
+}

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;
+    }
+}

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;
+    }
+}

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;
+    }
+}

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;
+    }
+}

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;
+    }
+}

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;
+    }
+}

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() + "的预约");
+    }
+}

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);
+    }
+}

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<GroupCourseBooking> executeBooking(GroupCourseBooking booking, Long recordId) {
+        List<SagaStep> steps = new ArrayList<>();
+        List<SagaStep> 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<Void> 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<Void> 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<Void> 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<GroupCourseBooking> executeCancelBooking(Long bookingId, Long courseId, Long recordId, Long memberId) {
+        List<SagaStep> steps = new ArrayList<>();
+        List<SagaStep> 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<Void> 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<Void> 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<Void> deleteBooking(Long bookingId) {
+        return bookingRepository.deleteById(bookingId);
+    }
+
+    private Mono<Void> 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<Void> 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<Void> incrementCourseCurrentMembers(Long courseId) {
+        return courseRepository.updateCurrentMembers(courseId, 1).then();
+    }
+
+    private Mono<Void> decrementCourseCurrentMembers(Long courseId) {
+        return courseRepository.updateCurrentMembers(courseId, -1).then();
+    }
+
+    private Mono<Void> incrementRedisBookingCount(Long courseId) {
+        return redisService.incrementBookingCount(courseId).then();
+    }
+
+    private Mono<Void> decrementRedisBookingCount(Long courseId) {
+        return redisService.decrementBookingCount(courseId).then();
+    }
+
+    private Mono<Void> executeSaga(List<SagaStep> steps, List<SagaStep> rollbackSteps) {
+        List<SagaStep> completedSteps = new ArrayList<>();
+        return executeStep(steps, 0, completedSteps);
+    }
+
+    private Mono<Void> executeStep(List<SagaStep> steps, int index, List<SagaStep> 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<Void> rollbackCompletedSteps(List<SagaStep> completedSteps) {
+        if (completedSteps.isEmpty()) {
+            return Mono.empty();
+        }
+        
+        // 反转已完成的步骤，按逆序回滚
+        List<SagaStep> reversed = new ArrayList<>(completedSteps);
+        Collections.reverse(reversed);
+        
+        return rollbackSteps(reversed, 0);
+    }
+
+    private Mono<Void> rollbackSteps(List<SagaStep> 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<Void> operation, Mono<Void> rollbackOperation) {}
+}

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<ServerResponse> 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<String, Object> response = new HashMap<>();
+                                response.put("success", true);
+                                response.put("message", "预约成功");
+                                response.put("data", booking);
+                                return ServerResponse.ok().bodyValue(response);
+                            })
+                            .onErrorResume(error -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", false);
+                                response.put("message", error.getMessage());
+                                return ServerResponse.badRequest().bodyValue(response);
+                            });
+                });
+    }
+
+    /**
+     * 取消预约
+     */
+    @Operation(summary = "取消预约", description = "会员取消已预约的团课")
+    public Mono<ServerResponse> 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<String, Object> response = new HashMap<>();
+                                response.put("success", true);
+                                response.put("message", "取消成功");
+                                response.put("data", booking);
+                                return ServerResponse.ok().bodyValue(response);
+                            })
+                            .onErrorResume(error -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", false);
+                                response.put("message", error.getMessage());
+                                return ServerResponse.badRequest().bodyValue(response);
+                            });
+                });
+    }
+
+    /**
+     * 查询会员预约记录
+     */
+    @Operation(summary = "查询会员预约记录", description = "根据会员ID查询所有预约记录")
+    public Mono<ServerResponse> 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<ServerResponse> 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<ServerResponse> getBookingsByCourseId(ServerRequest request) {
+        Long courseId = Long.valueOf(request.pathVariable("courseId"));
+
+        return ServerResponse.ok()
+                .body(bookingService.getBookingsByCourseId(courseId), GroupCourseBooking.class);
+    }
+
+    /**
+     * 构建错误响应
+     */
+    private Mono<ServerResponse> buildErrorResponse(String message) {
+        Map<String, Object> response = new HashMap<>();
+        response.put("success", false);
+        response.put("message", message);
+        return ServerResponse.badRequest().bodyValue(response);
+    }
+}

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<ServerResponse> 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<ServerResponse> 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<ServerResponse> 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<ServerResponse> createGroupCourse(ServerRequest request) {
+        return request.bodyToMono(GroupCourse.class)
+                .flatMap(groupCourse -> {
+                    if (groupCourse.getCourseName() == null || groupCourse.getCourseName().isEmpty()) {
+                        Map<String, Object> error = new HashMap<>();
+                        error.put("success", false);
+                        error.put("message", "课程名称不能为空");
+                        return ServerResponse.badRequest().bodyValue(error);
+                    }
+                    
+                    return groupCourseService.create(groupCourse)
+                            .flatMap(course -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", true);
+                                response.put("message", "团课创建成功");
+                                response.put("data", course);
+                                return ServerResponse.ok().bodyValue(response);
+                            })
+                            .onErrorResume(error -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", false);
+                                response.put("message", error.getMessage());
+                                return ServerResponse.badRequest().bodyValue(response);
+                            });
+                });
+    }
+
+    @Operation(summary = "更新团课", description = "更新指定团课信息")
+    public Mono<ServerResponse> 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<String, Object> response = new HashMap<>();
+                                response.put("success", true);
+                                response.put("message", "团课更新成功");
+                                response.put("data", course);
+                                return ServerResponse.ok().bodyValue(response);
+                            })
+                            .onErrorResume(error -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", false);
+                                response.put("message", error.getMessage());
+                                return ServerResponse.badRequest().bodyValue(response);
+                            });
+                });
+    }
+
+    @Operation(summary = "取消团课", description = "取消指定团课（需提前24小时）")
+    public Mono<ServerResponse> cancelGroupCourse(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+        
+        return groupCourseService.cancel(id)
+                .flatMap(course -> {
+                    Map<String, Object> response = new HashMap<>();
+                    response.put("success", true);
+                    response.put("message", "团课取消成功");
+                    response.put("data", course);
+                    return ServerResponse.ok().bodyValue(response);
+                })
+                .onErrorResume(error -> {
+                    Map<String, Object> response = new HashMap<>();
+                    response.put("success", false);
+                    response.put("message", error.getMessage());
+                    return ServerResponse.badRequest().bodyValue(response);
+                });
+    }
+
+    @Operation(summary = "团课签到", description = "会员签到参加团课")
+    public Mono<ServerResponse> signIn(ServerRequest request) {
+        Long courseId = Long.valueOf(request.pathVariable("courseId"));
+        
+        return request.bodyToMono(Map.class)
+                .flatMap(body -> {
+                    if (body == null || body.isEmpty()) {
+                        Map<String, Object> response = new HashMap<>();
+                        response.put("success", false);
+                        response.put("message", "请求体不能为空");
+                        return ServerResponse.badRequest().bodyValue(response);
+                    }
+                    
+                    Object memberIdObj = body.get("memberId");
+                    if (memberIdObj == null) {
+                        Map<String, Object> 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<String, Object> response = new HashMap<>();
+                                response.put("success", true);
+                                response.put("message", "签到成功");
+                                response.put("data", course);
+                                return ServerResponse.ok().bodyValue(response);
+                            })
+                            .onErrorResume(error -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", false);
+                                response.put("message", error.getMessage());
+                                return ServerResponse.badRequest().bodyValue(response);
+                            });
+                });
+    }
+
+    @Operation(summary = "删除团课", description = "删除指定团课（软删除）")
+    public Mono<ServerResponse> deleteGroupCourse(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+        
+        return groupCourseService.delete(id)
+                .then(Mono.defer(() -> {
+                    Map<String, Object> response = new HashMap<>();
+                    response.put("success", true);
+                    response.put("message", "团课删除成功");
+                    return ServerResponse.ok().bodyValue(response);
+                }))
+                .onErrorResume(error -> {
+                    Map<String, Object> 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<ServerResponse> getCacheByKey(ServerRequest request) {
+        return request.bodyToMono(Map.class)
+                .flatMap(body -> {
+                    String key = (String) body.get("key");
+                    
+                    if (key == null || key.isEmpty()) {
+                        Map<String, Object> error = new HashMap<>();
+                        error.put("success", false);
+                        error.put("message", "key参数不能为空");
+                        return ServerResponse.badRequest().bodyValue(error);
+                    }
+                    
+                    return redisUtil.get(key)
+                            .map(cachedValue -> {
+                                Map<String, Object> 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<String, Object> errorResponse = new HashMap<>();
+                                errorResponse.put("success", false);
+                                errorResponse.put("message", "请求处理失败: " + error.getMessage());
+                                return ServerResponse.status(500).bodyValue(errorResponse);
+                            });
+                });
+    }
+}

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<CourseStatus, Map<CourseEvent, CourseStatus>> stateTransitionMap;
+
+    public GroupCourseStateMachine() {
+        this.stateTransitionMap = buildStateTransitionMap();
+    }
+
+    private Map<CourseStatus, Map<CourseEvent, CourseStatus>> buildStateTransitionMap() {
+        Map<CourseStatus, Map<CourseEvent, CourseStatus>> map = new HashMap<>();
+
+        // NORMAL 状态可以转换的事件
+        Map<CourseEvent, CourseStatus> 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<CourseEvent, CourseStatus> inProgressTransitions = new HashMap<>();
+        inProgressTransitions.put(CourseEvent.END, CourseStatus.ENDED);
+        map.put(CourseStatus.IN_PROGRESS, inProgressTransitions);
+
+        // CANCELLED 状态是终态，不允许任何转换
+
+        // ENDED 状态是终态，不允许任何转换
+
+        return map;
+    }
+
+    /**
+     * 检查是否可以转换状态
+     */
+    public Mono<Boolean> canTransition(CourseStatus currentState, CourseEvent event) {
+        return Mono.fromSupplier(() -> {
+            Map<CourseEvent, CourseStatus> transitions = stateTransitionMap.get(currentState);
+            if (transitions == null) {
+                return false;
+            }
+            return transitions.containsKey(event);
+        });
+    }
+
+    /**
+     * 执行状态转换
+     */
+    public Mono<CourseStatus> transition(CourseStatus currentState, CourseEvent event) {
+        return Mono.fromSupplier(() -> {
+            Map<CourseEvent, CourseStatus> 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<Void> 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<GroupCourse> applyTransition(GroupCourse course, CourseEvent event) {
+        return validateTransition(course, event)
+                .then(transition(CourseStatus.fromValue(course.getStatus()), event))
+                .map(newStatus -> {
+                    course.setStatus(newStatus.getValue());
+                    return course;
+                });
+    }
+}

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<GroupCourseBooking> findById(Long id);
+
+    /**
+     * 根据会员ID查询预约记录列表
+     */
+    Flux<GroupCourseBooking> findByMemberId(Long memberId);
+
+    /**
+     * 根据团课ID查询预约记录列表
+     */
+    Flux<GroupCourseBooking> findByCourseId(Long courseId);
+
+    /**
+     * 查询会员是否已预约某课程
+     */
+    Mono<GroupCourseBooking> findByCourseIdAndMemberId(Long courseId, Long memberId);
+
+    /**
+     * 查询会员在指定课程的有效预约
+     */
+    Mono<GroupCourseBooking> findValidBooking(Long courseId, Long memberId);
+
+    /**
+     * 统计课程有效预约人数
+     */
+    Mono<Long> countValidBookings(Long courseId);
+
+    /**
+     * 保存预约记录
+     */
+    Mono<GroupCourseBooking> save(GroupCourseBooking booking);
+
+    /**
+     * 更新预约记录
+     */
+    Mono<GroupCourseBooking> update(GroupCourseBooking booking);
+
+    /**
+     * 更新预约状态
+     */
+    Mono<Integer> updateStatus(Long bookingId, String status);
+
+    /**
+     * 删除预约记录
+     */
+    Mono<Void> deleteById(Long bookingId);
+
+    /**
+     * 根据会员卡记录ID查询预约记录
+     */
+    Flux<GroupCourseBooking> findByMemberCardRecordId(Long memberCardRecordId);
+
+    /**
+     * 查询会员是否有时间冲突的预约
+     * 
+     * @param memberId 会员ID
+     * @param newStartTime 新课程开始时间
+     * @param newEndTime 新课程结束时间
+     * @return 冲突的预约记录列表
+     */
+    Flux<GroupCourseBooking> findConflictingBookings(Long memberId, java.time.LocalDateTime newStartTime, java.time.LocalDateTime newEndTime);
+
+    /**
+     * 查询已开始课程但未到场会员的预约记录
+     * @return 缺席会员的预约记录列表
+     */
+    Flux<GroupCourseBooking> findAbsentMembers();
+
+    /**
+     * 更新预约状态为缺席(3)
+     * @param bookingId 预约ID
+     * @return 更新记录数
+     */
+    Mono<Integer> updateToAbsent(Long bookingId);
+}

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<GroupCourse> findByIdAndDeletedAtIsNull(Long id);
+    Flux<GroupCourse> findAll();
+    Flux<GroupCourse> findAll(Sort sort);
+    Flux<GroupCourse> findByDeletedAtIsNull();
+    Flux<GroupCourse> findByDeletedAtIsNull(Sort sort);
+    
+    Mono<PageResponse<GroupCourse>> findByPage(PageRequest pageRequest);
+    Mono<PageResponse<GroupCourse>> findByPageAndNotDeleted(PageRequest pageRequest);
+    
+    Mono<GroupCourse> save(GroupCourse groupCourse);
+    
+    Mono<GroupCourse> update(GroupCourse groupCourse);
+    
+    Mono<GroupCourse> cancel(Long id);
+    
+    Mono<Void> deleteById(Long id);
+    
+    Mono<GroupCourse> updateCurrentMembers(Long id, Integer delta);
+}

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<GroupCourseBooking> findById(Long id) {
+        return groupCourseBookingDao.findByIdIsAndDeletedAtIsNull(id)
+                .map(groupCourseConverter::toBookingDomain);
+    }
+
+    @Override
+    public Flux<GroupCourseBooking> findByMemberId(Long memberId) {
+        return groupCourseBookingDao.findByMemberIdAndDeletedAtIsNull(memberId, Sort.by(Sort.Direction.DESC, "bookingTime"))
+                .map(groupCourseConverter::toBookingDomain);
+    }
+
+    @Override
+    public Flux<GroupCourseBooking> findByCourseId(Long courseId) {
+        return groupCourseBookingDao.findByCourseIdAndDeletedAtIsNull(courseId)
+                .map(groupCourseConverter::toBookingDomain);
+    }
+
+    @Override
+    public Mono<GroupCourseBooking> findByCourseIdAndMemberId(Long courseId, Long memberId) {
+        return groupCourseBookingDao.findByCourseIdAndMemberIdAndDeletedAtIsNull(courseId, memberId)
+                .map(groupCourseConverter::toBookingDomain);
+    }
+
+    @Override
+    public Mono<GroupCourseBooking> findValidBooking(Long courseId, Long memberId) {
+        return groupCourseBookingDao.findByCourseIdAndMemberIdAndStatusAndDeletedAtIsNull(courseId, memberId, "0")
+                .map(groupCourseConverter::toBookingDomain);
+    }
+
+    @Override
+    public Mono<Long> countValidBookings(Long courseId) {
+        return groupCourseBookingDao.countByCourseIdAndStatusAndDeletedAtIsNull(courseId, "0");
+    }
+
+    @Override
+    public Mono<GroupCourseBooking> save(GroupCourseBooking booking) {
+        GroupCourseBookingEntity entity = groupCourseConverter.toBookingEntity(booking);
+        return groupCourseBookingDao.save(entity)
+                .map(groupCourseConverter::toBookingDomain);
+    }
+
+    @Override
+    public Mono<GroupCourseBooking> update(GroupCourseBooking booking) {
+        GroupCourseBookingEntity entity = groupCourseConverter.toBookingEntity(booking);
+        return groupCourseBookingDao.save(entity)
+                .map(groupCourseConverter::toBookingDomain);
+    }
+
+    @Override
+    public Mono<Integer> 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<Void> deleteById(Long bookingId) {
+        return groupCourseBookingDao.softDelete(bookingId, java.time.LocalDateTime.now()).then();
+    }
+
+    @Override
+    public Flux<GroupCourseBooking> findByMemberCardRecordId(Long memberCardRecordId) {
+        return groupCourseBookingDao.findByMemberCardRecordIdAndDeletedAtIsNull(memberCardRecordId)
+                .map(groupCourseConverter::toBookingDomain);
+    }
+
+    @Override
+    public Flux<GroupCourseBooking> findConflictingBookings(Long memberId, java.time.LocalDateTime newStartTime, java.time.LocalDateTime newEndTime) {
+        return groupCourseBookingDao.findConflictingBookings(memberId, newStartTime, newEndTime)
+                .map(groupCourseConverter::toBookingDomain);
+    }
+
+    @Override
+    public Flux<GroupCourseBooking> findAbsentMembers() {
+        return groupCourseBookingDao.findAbsentMembers()
+                .map(groupCourseConverter::toBookingDomain);
+    }
+
+    @Override
+    public Mono<Integer> updateToAbsent(Long bookingId) {
+        java.time.LocalDateTime now = java.time.LocalDateTime.now();
+        return groupCourseBookingDao.updateToAbsent(bookingId, now);
+    }
+}

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<GroupCourse> findByIdAndDeletedAtIsNull(Long id) {
+        return groupCourseDao.findByIdIsAndDeletedAtIsNull(id)
+                .map(groupCourseConverter::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourse> findAll() {
+        return groupCourseDao.findAll()
+                .map(groupCourseConverter::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourse> findAll(Sort sort) {
+        return groupCourseDao.findAll(sort)
+                .map(groupCourseConverter::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourse> findByDeletedAtIsNull() {
+        return groupCourseDao.findAllByDeletedAtIsNull()
+                .map(groupCourseConverter::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourse> findByDeletedAtIsNull(Sort sort) {
+        return groupCourseDao.findAllByDeletedAtIsNull(sort)
+                .map(groupCourseConverter::toDomain);
+    }
+
+    @Override
+    public Mono<PageResponse<GroupCourse>> 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<GroupCourse> courseList = tuple.getT1().stream()
+                            .map(groupCourseConverter::toDomain)
+                            .toList();
+                    return new PageResponse<>(courseList, totalPages, total, page, size);
+                });
+    }
+
+    @Override
+    public Mono<PageResponse<GroupCourse>> 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<GroupCourseEntity> allEntities = tuple.getT1();
+                    long total = tuple.getT2();
+                    
+                    int fromIndex = page * size;
+                    int toIndex = Math.min(fromIndex + size, allEntities.size());
+                    
+                    List<GroupCourse> 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<GroupCourse> 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<GroupCourse> update(GroupCourse groupCourse) {
+        GroupCourseEntity entity = groupCourseConverter.toEntity(groupCourse);
+        entity.setUpdatedAt(LocalDateTime.now());
+        
+        return r2dbcEntityTemplate.update(entity)
+                .then(findByIdAndDeletedAtIsNull(groupCourse.getId()));
+    }
+
+    @Override
+    public Mono<GroupCourse> cancel(Long id) {
+        return groupCourseDao.cancelCourse(id, LocalDateTime.now())
+                .flatMap(updated -> {
+                    if (updated > 0) {
+                        return findByIdAndDeletedAtIsNull(id);
+                    }
+                    return Mono.empty();
+                });
+    }
+
+    @Override
+    public Mono<Void> deleteById(Long id) {
+        return groupCourseDao.softDelete(id, LocalDateTime.now())
+                .then();
+    }
+
+    @Override
+    public Mono<GroupCourse> updateCurrentMembers(Long id, Integer delta) {
+        return groupCourseDao.updateCurrentMembers(id, delta, LocalDateTime.now())
+                .flatMap(updated -> {
+                    if (updated > 0) {
+                        return findByIdAndDeletedAtIsNull(id);
+                    }
+                    return Mono.empty();
+                });
+    }
+}

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)
+                );
+    }
+}

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<GroupCourseBooking> bookCourse(Long courseId, Long memberId, Long memberCardRecordId);
+
+    /**
+     * 取消预约
+     * 
+     * @param bookingId 预约ID
+     * @param memberId 会员ID
+     * @return 取消后的预约记录
+     */
+    Mono<GroupCourseBooking> cancelBooking(Long bookingId, Long memberId);
+
+    /**
+     * 根据会员ID查询预约记录列表
+     * 
+     * @param memberId 会员ID
+     * @return 预约记录列表
+     */
+    Flux<GroupCourseBooking> getBookingsByMemberId(Long memberId);
+
+    /**
+     * 根据预约ID查询预约详情
+     * 
+     * @param bookingId 预约ID
+     * @return 预约记录
+     */
+    Mono<GroupCourseBooking> getBookingById(Long bookingId);
+
+    /**
+     * 根据团课ID查询预约记录列表
+     * 
+     * @param courseId 团课ID
+     * @return 预约记录列表
+     */
+    Flux<GroupCourseBooking> getBookingsByCourseId(Long courseId);
+
+    /**
+     * 处理已开始课程但未到场会员的预约记录
+     * 将状态更新为缺席(3)
+     * 
+     * @return 处理的记录数
+     */
+    Mono<Integer> processAbsentMembers();
+}

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<GroupCourse> findById(Long id);
+    Flux<GroupCourse> findAll();
+    Flux<GroupCourse> findAll(boolean includeDeleted);
+    
+    Mono<PageResponse<GroupCourse>> findByPage(PageRequest pageRequest, boolean includeDeleted);
+    
+    Mono<GroupCourse> create(GroupCourse groupCourse);
+    
+    Mono<GroupCourse> update(Long id, GroupCourse groupCourse);
+    
+    Mono<GroupCourse> cancel(Long id);
+    
+    Mono<GroupCourse> signIn(Long courseId, Long memberId);
+    
+    Mono<Void> delete(Long id);
+}

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<GroupCourseBooking> 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<GroupCourse> 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<Integer> 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<GroupCourseBooking> releaseLockAndError(Long courseId, String requestId, String errorMessage) {
+        return redisService.releaseLock(courseId, requestId)
+                .then(Mono.error(new RuntimeException(errorMessage)));
+    }
+
+    @Override
+    public Mono<GroupCourseBooking> 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<GroupCourseBooking> getBookingsByMemberId(Long memberId) {
+        logger.debug("查询会员预约记录：memberId={}", memberId);
+        return bookingRepository.findByMemberId(memberId)
+                .doOnComplete(() -> logger.debug("查询完成：memberId={}", memberId));
+    }
+
+    @Override
+    public Mono<GroupCourseBooking> getBookingById(Long bookingId) {
+        logger.debug("查询预约详情：bookingId={}", bookingId);
+        return bookingRepository.findById(bookingId);
+    }
+
+    @Override
+    public Flux<GroupCourseBooking> getBookingsByCourseId(Long courseId) {
+        logger.debug("查询课程预约记录：courseId={}", courseId);
+        return bookingRepository.findByCourseId(courseId)
+                .doOnComplete(() -> logger.debug("查询完成：courseId={}", courseId));
+    }
+
+    @Override
+    public Mono<Integer> 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);
+                            });
+                });
+    }
+}

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<String, Object> reactiveRedisTemplate;
+    private final ObjectMapper objectMapper;
+
+    public GroupCourseRedisService(ReactiveRedisTemplate<String, Object> 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<Void> 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<GroupCourse> 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<Void> 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<Boolean> 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<Boolean> 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<Integer> getBookingCount(Long courseId) {
+        String key = "booking_count:" + courseId;
+        return reactiveRedisTemplate.opsForValue()
+                .get(key)
+                .map(obj -> (Integer) obj)
+                .defaultIfEmpty(0);
+    }
+
+    /**
+     * 增加课程预约人数
+     */
+    public Mono<Long> incrementBookingCount(Long courseId) {
+        String key = "booking_count:" + courseId;
+        return reactiveRedisTemplate.opsForValue()
+                .increment(key)
+                .doOnSuccess(count -> logger.debug("预约人数增加：courseId={}, count={}", courseId, count));
+    }
+
+    /**
+     * 减少课程预约人数
+     */
+    public Mono<Long> decrementBookingCount(Long courseId) {
+        String key = "booking_count:" + courseId;
+        return reactiveRedisTemplate.opsForValue()
+                .decrement(key)
+                .doOnSuccess(count -> logger.debug("预约人数减少：courseId={}, count={}", courseId, count));
+    }
+
+    /**
+     * 设置课程预约人数（用于从数据库同步）
+     */
+    public Mono<Void> 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();
+    }
+}

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<GroupCourse> 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<GroupCourse> findAll() {
+        return groupCourseRepository.findAll();
+    }
+
+    @Override
+    public Flux<GroupCourse> findAll(boolean includeDeleted) {
+        if(includeDeleted){
+            return groupCourseRepository.findAll();
+        }else{
+            return groupCourseRepository.findByDeletedAtIsNull();
+        }
+    }
+
+    @Override
+    public Mono<PageResponse<GroupCourse>> 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<GroupCourse> 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<PageResponse<GroupCourse>> 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<GroupCourse> 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<GroupCourse> 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<GroupCourse> 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<Void> 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<Void> 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<Void> 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<GroupCourse> 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<Void> 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<Void> clearCache() {
+        return redisUtil.deleteByPattern(CACHE_KEY_PREFIX + "*")
+                .then(redisUtil.deleteByPattern(CACHE_KEY_ID_PREFIX + "*")).then();
+    }
+}

gym-manage-api/gym-groupCourse/src/main/resources/application.yaml

@@ -0,0 +1,3 @@
+spring:
+  application:
+    name: gym-groupCourse

gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/GymGroupCourseApplicationTests.java

@@ -1,10 +1,10 @@
-package cn.novalon.gym.manage.gymmembercard;
+package cn.novalon.gym.manage.groupcourse;
 
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
 
 @SpringBootTest
-class GymMemberCardApplicationTests {
+class GymGroupCourseApplicationTests {
 
     @Test
     void contextLoads() {

gym-manage-api/gym-member-card/pom.xml

@@ -1,84 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <parent>
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.5.13</version>
-        <relativePath/> <!-- lookup parent from repository -->
-    </parent>
-    <groupId>cn.novalon.gym.manage</groupId>
-    <artifactId>gym-member-card</artifactId>
-    <version>0.0.1-SNAPSHOT</version>
-    <name>gym-member-card</name>
-    <description>gym-member-card</description>
-
-    <properties>
-        <java.version>21</java.version>
-    </properties>
-
-    <dependencies>
-        <!-- WebFlux 启动器（响应式） -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-webflux</artifactId>
-        </dependency>
-
-        <!-- PostgreSQL 驱动（JDBC，如果工具类需要） -->
-        <dependency>
-            <groupId>org.postgresql</groupId>
-            <artifactId>postgresql</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-
-        <!-- 你的内部模块 -->
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>manage-db</artifactId>
-            <version>1.0.0</version>
-            <scope>compile</scope>
-        </dependency>
-
-        <!-- Lombok -->
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>1.18.36</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <!-- Hutool 工具箱 -->
-        <dependency>
-            <groupId>cn.hutool</groupId>
-            <artifactId>hutool-all</artifactId>
-            <version>5.8.22</version>
-        </dependency>
-
-        <!-- Spring 上下文（其实 WebFlux 已经包含，保留也可以） -->
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-context</artifactId>
-        </dependency>
-
-        <!-- ⭐ 必须添加：测试依赖 -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-maven-plugin</artifactId>
-                <configuration>
-                    <!-- 保留标准 JAR，供其他模块引用 -->
-                    <classifier>exec</classifier>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-</project>

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/GymMemberCardApplication.java

@@ -1,15 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard;
-
-import org.springframework.boot.SpringApplication;
-import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
-
-@SpringBootApplication
-@EnableR2dbcRepositories(basePackages = "cn.novalon.gym.manage.db.dao")
-public class GymMemberCardApplication {
-
-    public static void main(String[] args) {
-        SpringApplication.run(GymMemberCardApplication.class, args);
-    }
-
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/dao/MemberCardDao.java

@@ -1,130 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.dao;
-
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardEntity;
-import org.springframework.data.domain.Pageable;
-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;
-
-@Repository
-public interface MemberCardDao extends R2dbcRepository<MemberCardEntity, Long> {
-
-    /**
-     * 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
-     * @param memberCardId 会员卡ID
-     * @return 会员卡完整信息，如果不存在或已删除则返回空
-     */
-    Mono<MemberCardEntity> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
-
-    /**
-     * 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
-     * 注意：模糊查询使用前后缀通配符，若数据量较大可能影响索引效率，建议后期引入全文索引或改用后缀模糊
-     * @param status 会员卡状态（上架/下架）
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    @Query("SELECT * FROM member_card WHERE deleted_at IS NULL " +
-            "AND (:status IS NULL OR member_card_status = :status) " +
-            "AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
-            "AND (:type IS NULL OR member_card_type = :type) " +
-            "AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
-            "AND (:maxPrice IS NULL OR member_card_price <= :maxPrice) " +
-            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
-    Flux<MemberCardEntity> findWithConditions(Integer status, String name, String type,
-                                              Double minPrice, Double maxPrice, Pageable pageable);
-
-    /**
-     * 统计符合条件的会员卡总数（配合列表查询使用）
-     * @param status 会员卡状态
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @return 符合条件的会员卡数量
-     */
-    @Query("SELECT COUNT(*) FROM member_card WHERE deleted_at IS NULL " +
-            "AND (:status IS NULL OR member_card_status = :status) " +
-            "AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
-            "AND (:type IS NULL OR member_card_type = :type) " +
-            "AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
-            "AND (:maxPrice IS NULL OR member_card_price <= :maxPrice)")
-    Mono<Long> countWithConditions(Integer status, String name, String type,
-                                   Double minPrice, Double maxPrice);
-
-    /**
-     * 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
-     * @param status 会员卡状态（通常传上架状态）
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    Flux<MemberCardEntity> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
-
-    /**
-     * 检查会员卡是否已被购买（用于删除前的校验）
-     * 注意：此查询关联到 member_card_record 表，建议后续独立至 MemberCardRecordDao
-     * @param memberCardId 会员卡ID
-     * @return 如果存在关联的会员记录则返回true，否则返回false
-     */
-    @Query("SELECT EXISTS(SELECT 1 FROM member_card_record WHERE member_card_id = :memberCardId AND deleted_at IS NULL LIMIT 1)")
-    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
-
-    /**
-     * 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
-     * @param memberCardId 会员卡ID
-     * @return 受影响的行数
-     */
-    @Modifying
-    @Query("UPDATE member_card SET deleted_at = NOW() WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
-    Mono<Integer> logicalDelete(Long memberCardId);
-
-    /**
-     * 【新增】安全更新会员卡信息（仅允许修改业务相关字段，防止覆盖敏感字段）
-     * @param memberCardId 会员卡ID
-     * @param name 卡种名称
-     * @param price 价格
-     * @param durationDays 有效天数
-     * @param totalCount 总次数
-     * @param denomination 面额
-     * @param status 状态
-     * @return 受影响的行数
-     */
-    @Modifying
-    @Query("UPDATE member_card SET " +
-            "member_card_name = COALESCE(:name, member_card_name), " +
-            "member_card_price = COALESCE(:price, member_card_price), " +
-            "duration_days = COALESCE(:durationDays, duration_days), " +
-            "total_count = COALESCE(:totalCount, total_count), " +
-            "denomination = COALESCE(:denomination, denomination), " +
-            "member_card_status = COALESCE(:status, member_card_status), " +
-            "updated_at = NOW() " +
-            "WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
-    Mono<Integer> updateSafe(Long memberCardId, String name, Double price,
-                             Integer durationDays, Integer totalCount,
-                             Double denomination, Integer status);
-
-    /**
-     * 保存卡种信息（新增或更新）
-     * - 新增：entity.memberCardId 为 null 时，插入新记录
-     * - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
-     * 注意：直接 save 会更新所有字段，如需安全更新请调用 updateSafe 方法
-     * @param entity 卡种信息
-     * @return 保存后的实体对象
-     */
-    @Override
-    <S extends MemberCardEntity> Mono<S> save(S entity);
-
-    /**
-     * 批量查询上架的会员卡（用于小程序端展示）
-     * @param status 上架状态值
-     * @return 上架的会员卡列表
-     */
-    @Query("SELECT * FROM member_card WHERE deleted_at IS NULL AND member_card_status = :status ORDER BY member_card_price ASC")
-    Flux<MemberCardEntity> findActiveCards(Integer status);
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/dao/MemberCardRecordDao.java

@@ -1,148 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.dao;
-
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardRecordEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.r2dbc.repository.Modifying;
-import org.springframework.data.r2dbc.repository.Query;
-import org.springframework.data.r2dbc.repository.R2dbcRepository;
-import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Repository
-public interface MemberCardRecordDao extends R2dbcRepository<MemberCardRecordEntity, Long> {
-
-    /**
-     * 会员购卡/后台发卡
-     * 支付成功后插入一条记录，状态为ACTIVE，设置有效期和初始剩余次数/余额
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡类型ID
-     * @param expireTime 到期时间
-     * @param remainingTimes 剩余次数
-     * @param remainingAmount 剩余余额
-     * @param sourceOrderId 来源订单ID
-     * @return 插入的记录
-     */
-    @Modifying
-    @Query("INSERT INTO member_card_record (member_id, member_card_id, status, expire_time, remaining_times, remaining_amount, source_order_id, purchase_time, created_at, updated_at) " +
-            "VALUES (:memberId, :memberCardId, 'ACTIVE', :expireTime, :remainingTimes, :remainingAmount, :sourceOrderId, NOW(), NOW(), NOW()) " +
-            "RETURNING *")
-    Mono<MemberCardRecordEntity> insertActiveRecord(@Param("memberId") Long memberId,
-                                                    @Param("memberCardId") Long memberCardId,
-                                                    @Param("expireTime") LocalDateTime expireTime,
-                                                    @Param("remainingTimes") Integer remainingTimes,
-                                                    @Param("remainingAmount") Double remainingAmount,
-                                                    @Param("sourceOrderId") Long sourceOrderId);
-
-    /**
-     * 扣次/扣费（含防超扣校验）
-     * 预约团课或私教成功后，更新 remaining_times 减1 或 remaining_amount 减课程价格
-     * @param recordId 会员卡记录ID
-     * @param deductTimes 扣除次数
-     * @param deductAmount 扣除金额
-     * @return 受影响的行数（0表示余额不足，扣费失败）
-     */
-    @Modifying
-    @Query("UPDATE member_card_record SET " +
-            "remaining_times = remaining_times - :deductTimes, " +
-            "remaining_amount = remaining_amount - :deductAmount, " +
-            "updated_at = NOW() " +
-            "WHERE member_card_record_id = :recordId " +
-            "AND deleted_at IS NULL " +
-            "AND remaining_times >= :deductTimes " +
-            "AND remaining_amount >= :deductAmount")
-    Mono<Integer> deductUsage(@Param("recordId") Long recordId,
-                              @Param("deductTimes") Integer deductTimes,
-                              @Param("deductAmount") Double deductAmount);
-
-    /**
-     * 续费
-     * 累加剩余次数/余额，顺延到期日期
-     * @param recordId 会员卡记录ID
-     * @param addTimes 增加次数
-     * @param addAmount 增加金额
-     * @param newExpireTime 新的到期时间
-     * @return 受影响的行数
-     */
-    @Modifying
-    @Query("UPDATE member_card_record SET remaining_times = remaining_times + :addTimes, " +
-            "remaining_amount = remaining_amount + :addAmount, expire_time = :newExpireTime, updated_at = NOW() " +
-            "WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
-    Mono<Integer> renewCard(@Param("recordId") Long recordId,
-                            @Param("addTimes") Integer addTimes,
-                            @Param("addAmount") Double addAmount,
-                            @Param("newExpireTime") LocalDateTime newExpireTime);
-
-    /**
-     * 状态变更
-     * 过期定时任务将状态改为EXPIRED；退款后改为REFUNDED
-     * @param recordId 会员卡记录ID
-     * @param status 新状态
-     * @return 受影响的行数
-     */
-    @Modifying
-    @Query("UPDATE member_card_record SET status = :status, updated_at = NOW() " +
-            "WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
-    Mono<Integer> updateStatus(@Param("recordId") Long recordId,
-                               @Param("status") MemberCardRecordStatus status);
-
-    /**
-     * 会员端"我的卡包"
-     * 根据会员ID查询所有卡，过滤状态为ACTIVE的，展示剩余次数/天数/余额
-     * @param memberId 会员ID
-     * @return 有效会员卡列表
-     */
-    @Query("SELECT * FROM member_card_record WHERE member_id = :memberId AND status = 'ACTIVE' AND deleted_at IS NULL ORDER BY expire_time ASC")
-    Flux<MemberCardRecordEntity> findActiveCardsByMemberId(@Param("memberId") Long memberId);
-
-    /**
-     * 前台/店长查会员卡
-     * 输入会员手机号或姓名，查出该会员持有的所有卡的信息
-     * @param memberId 会员ID
-     * @param pageable 分页参数
-     * @return 会员卡列表
-     */
-    @Query("SELECT mcr.* FROM member_card_record mcr " +
-            "INNER JOIN member m ON mcr.member_id = m.member_id " +
-            "WHERE mcr.member_id = :memberId AND mcr.deleted_at IS NULL " +
-            "ORDER BY mcr.purchase_time DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
-    Flux<MemberCardRecordEntity> findByMemberId(@Param("memberId") Long memberId, Pageable pageable);
-
-    /**
-     * 验证次卡是否可用（仅检验次数和过期时间）
-     * @param recordId 会员卡记录ID
-     * @param requiredTimes 需要的次数
-     * @return 符合条件的记录，空表示不可用
-     */
-    @Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
-            "AND status = 'ACTIVE' AND deleted_at IS NULL " +
-            "AND expire_time > NOW() " +
-            "AND remaining_times >= :requiredTimes")
-    Mono<MemberCardRecordEntity> validateCountCard(@Param("recordId") Long recordId,
-                                                   @Param("requiredTimes") Integer requiredTimes);
-
-    /**
-     * 验证储值卡是否可用（仅检验余额和过期时间）
-     * @param recordId 会员卡记录ID
-     * @param requiredAmount 需要的金额
-     * @return 符合条件的记录，空表示不可用
-     */
-    @Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
-            "AND status = 'ACTIVE' AND deleted_at IS NULL " +
-            "AND expire_time > NOW() " +
-            "AND remaining_amount >= :requiredAmount")
-    Mono<MemberCardRecordEntity> validateStoredCard(@Param("recordId") Long recordId,
-                                                    @Param("requiredAmount") Double requiredAmount);
-
-    /**
-     * 到期扫描（分批处理，避免内存压力）
-     * 定时任务：查询 status=ACTIVE 且 expire_time < 当前时间 的记录，用于批量过期处理
-     * @return 已过期的会员卡记录列表（最多500条）
-     */
-    @Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND expire_time < NOW() AND deleted_at IS NULL LIMIT 500")
-    Flux<MemberCardRecordEntity> findExpiredCards();
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/dao/MemberCardTransactionsDao.java

@@ -1,159 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.dao;
-
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardTransactionsEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.r2dbc.repository.Modifying;
-import org.springframework.data.r2dbc.repository.Query;
-import org.springframework.data.r2dbc.repository.R2dbcRepository;
-import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Repository
-public interface MemberCardTransactionsDao extends R2dbcRepository<MemberCardTransactionsEntity, Long> {
-    /**
-     * 记录每一次变动
-     * 购卡、扣次、续费、退款、过期，均插入一条流水，记录变动前后快照
-     * 注意：返回值依赖 PostgreSQL 的 RETURNING 语法，若使用 MySQL 请删除 RETURNING * 并改用 save()
-     * @param memberCardId 会员卡ID
-     * @param memberId 会员ID
-     * @param operationType 操作类型
-     * @param changeAmount 变动次数（次卡）
-     * @param changeBalance 变动金额（储值卡）
-     * @param afterRemainingCount 变动后剩余次数
-     * @param afterRemainingBalance 变动后剩余余额
-     * @param relatedBizType 关联业务类型
-     * @param remark 备注
-     * @return 插入的流水记录
-     */
-    @Modifying
-    @Query("INSERT INTO member_card_transactions (member_card_id, member_id, operation_type, change_amount, " +
-            "change_balance, after_remaining_count, after_remaining_balance, related_biz_type, remark, created_at, updated_at) " +
-            "VALUES (:memberCardId, :memberId, :operationType, :changeAmount, :changeBalance, " +
-            ":afterRemainingCount, :afterRemainingBalance, :relatedBizType, :remark, NOW(), NOW()) " +
-            "RETURNING *")
-    Mono<MemberCardTransactionsEntity> insertTransaction(@Param("memberCardId") Long memberCardId,
-                                                         @Param("memberId") Long memberId,
-                                                         @Param("operationType") MemberCardTransactionsAction operationType,
-                                                         @Param("changeAmount") Integer changeAmount,
-                                                         @Param("changeBalance") Double changeBalance,
-                                                         @Param("afterRemainingCount") Integer afterRemainingCount,
-                                                         @Param("afterRemainingBalance") Double afterRemainingBalance,
-                                                         @Param("relatedBizType") MemberCardTransactionsType relatedBizType,
-                                                         @Param("remark") String remark);
-
-    /**
-     * 会员端"使用记录"
-     * 按会员ID和时间范围查询，按时间倒序，显示每次变动明细
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    @Query("SELECT * FROM member_card_transactions WHERE member_id = :memberId " +
-            "AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL " +
-            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
-    Flux<MemberCardTransactionsEntity> findByMemberIdAndTimeRange(@Param("memberId") Long memberId,
-                                                                  @Param("startTime") LocalDateTime startTime,
-                                                                  @Param("endTime") LocalDateTime endTime,
-                                                                  Pageable pageable);
-
-    /**
-     * 后台"使用记录查询"
-     * 按会员、卡号、操作类型、时间范围等条件组合查询
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    @Query("SELECT * FROM member_card_transactions WHERE deleted_at IS NULL " +
-            "AND (:memberId IS NULL OR member_id = :memberId) " +
-            "AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
-            "AND (:operationType IS NULL OR operation_type = :operationType) " +
-            "AND (:startTime IS NULL OR created_at >= :startTime) " +
-            "AND (:endTime IS NULL OR created_at <= :endTime) " +
-            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
-    Flux<MemberCardTransactionsEntity> findWithConditions(@Param("memberId") Long memberId,
-                                                          @Param("memberCardId") Long memberCardId,
-                                                          @Param("operationType") MemberCardTransactionsAction operationType,
-                                                          @Param("startTime") LocalDateTime startTime,
-                                                          @Param("endTime") LocalDateTime endTime,
-                                                          Pageable pageable);
-
-    /**
-     * 统计符合条件的流水总数
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 流水记录数量
-     */
-    @Query("SELECT COUNT(*) FROM member_card_transactions WHERE deleted_at IS NULL " +
-            "AND (:memberId IS NULL OR member_id = :memberId) " +
-            "AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
-            "AND (:operationType IS NULL OR operation_type = :operationType) " +
-            "AND (:startTime IS NULL OR created_at >= :startTime) " +
-            "AND (:endTime IS NULL OR created_at <= :endTime)")
-    Mono<Long> countWithConditions(@Param("memberId") Long memberId,
-                                   @Param("memberCardId") Long memberCardId,
-                                   @Param("operationType") MemberCardTransactionsAction operationType,
-                                   @Param("startTime") LocalDateTime startTime,
-                                   @Param("endTime") LocalDateTime endTime);
-
-    /**
-     * 按会员卡ID查询所有流水记录（补充常用方法）
-     * @param memberCardId 会员卡ID
-     * @return 该卡的所有流水记录，按时间倒序
-     */
-    @Query("SELECT * FROM member_card_transactions WHERE member_card_id = :memberCardId AND deleted_at IS NULL ORDER BY created_at DESC")
-    Flux<MemberCardTransactionsEntity> findByMemberCardId(@Param("memberCardId") Long memberCardId);
-
-    /**
-     * 数据统计 - 统计某卡种的总扣次数
-     * @param memberCardId 会员卡ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 总扣次数
-     */
-    @Query("SELECT COALESCE(SUM(change_amount), 0) FROM member_card_transactions " +
-            "WHERE member_card_id = :memberCardId AND operation_type = 'DEDUCT' " +
-            "AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
-    Mono<Long> sumDeductCountByCardId(@Param("memberCardId") Long memberCardId,
-                                      @Param("startTime") LocalDateTime startTime,
-                                      @Param("endTime") LocalDateTime endTime);
-
-    /**
-     * 数据统计 - 统计某时间段的续费总金额
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 续费总金额
-     */
-    @Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
-            "WHERE operation_type = 'RENEW' AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
-    Mono<Double> sumRenewAmountByTimeRange(@Param("startTime") LocalDateTime startTime,
-                                           @Param("endTime") LocalDateTime endTime);
-
-    /**
-     * 数据统计 - 统计某会员的购卡总金额
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 购卡总金额
-     */
-    @Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
-            "WHERE member_id = :memberId AND operation_type = 'PURCHASE' " +
-            "AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
-    Mono<Double> sumPurchaseAmountByMemberId(@Param("memberId") Long memberId,
-                                             @Param("startTime") LocalDateTime startTime,
-                                             @Param("endTime") LocalDateTime endTime);
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/domain/MemberCard.java

@@ -1,49 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.domain;
-
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-import java.time.LocalDateTime;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 22:47:31
- */
-@Schema(description = "会员卡类型表")
-public class MemberCard extends BaseDomain {
-    //会员卡id
-    @Schema(description = "会员卡Id",example = "1")
-    private Long memberCardId;
-
-    //会员卡名称
-    @Schema(description = "会员卡名称",example = "月卡")
-    private String memberCardName;
-
-    //会员卡类型
-    @Schema(description = "会员卡类型",example = "TIME_CARD")
-    private String memberCardType;
-
-    //会员卡价格
-    @Schema(description = "会员卡价格",example = "199.0")
-    private Double memberCardPrice;
-
-    //会员卡有效天数（时长卡用）
-    @Schema(description = "会员卡有效天数",example = "30")
-    private Integer memberCardValidityDays;
-
-    //会员卡总次数（次卡用）
-    @Schema(description = "会员卡总次数",example = "10")
-    private Integer memberCardTotalTimes;
-
-    //会员卡面额（储值卡用）
-    @Schema(description = "会员卡面额",example = "500.0")
-    private Double memberCardAmount;
-
-    //会员卡状态：0-正常，1-禁用
-    @Schema(description = "会员卡状态",example = "0")
-    private Integer memberCardStatus;
-
-    //会员卡创建时间
-    @Schema(description = "会员卡创建时间",example = "2026-05-10 05:22:47")
-    private LocalDateTime memberCardCreateTime;
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/domain/MemberCardRecord.java

@@ -1,50 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.domain;
-
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-import java.time.LocalDateTime;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 22:47:31
- */
-@Schema(description = "会员卡记录",example = "member_card_record")
-public class MemberCardRecord extends BaseDomain {
-    //会员持有卡id
-    @Schema(description = "会员持有卡Id",example = "1")
-    private Long memberCardRecordId;
-
-    //会员Id
-    @Schema(description = "会员Id",example = "1")
-    private Long memberId;
-
-    //关联会员卡Id
-    @Schema(description = "关联会员卡Id",example = "1")
-    private Long memberCardId;
-
-    //状态：ACTIVE(有效) / USED_UP(用完) / EXPIRED(过期) / REFUNDED(已退款)
-    @Schema(description = "状态",example = "ACTIVE")
-    private MemberCardRecordStatus status;
-
-    //剩余次数
-    @Schema(description = "剩余次数",example = "1")
-    private Integer remainingTimes;
-
-    //剩余余额
-    @Schema(description = "剩余余额",example = "1")
-    private Double remainingAmount;
-
-    //到期时间
-    @Schema(description = "到期时间",example = "2026-05-10 05:22:47")
-    private LocalDateTime expireTime;
-
-    //购买订单Id
-    @Schema(description = "购买订单Id",example = "1")
-    private Long sourceOrderId;
-
-    //购买时间
-    @Schema(description = "购买时间",example = "2026-05-10 05:22:47")
-    private LocalDateTime purchaseTime;
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/domain/MemberCardTransactions.java

@@ -1,59 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.domain;
-
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-import java.time.LocalDateTime;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 22:47:31
- */
-@Schema(description = "会员卡流水")
-public class MemberCardTransactions extends BaseDomain {
-    //会员卡流水Id
-    @Schema(description = "会员卡流水Id",example = "1")
-    private Long memberCardTransactionsId;
-
-    //会员卡Id
-    @Schema(description = "会员卡Id",example = "1")
-    private Long memberCardId;
-
-    //会员Id
-    @Schema(description = "会员Id",example = "1")
-    private Long memberId;
-
-    //操作类型：PURCHASE(购买) / DEDUCT(扣次/扣费) / RENEW(续费) / REFUND(退款) / EXPIRE(过期)
-    @Schema(description = "操作类型",example = "PURCHASE")
-    private MemberCardTransactionsAction operationType;
-
-    //变动次数（次卡用）
-    @Schema(description = "变动次数（次卡用）",example = "1")
-    private Integer changeAmount;
-
-    //变动金额（储值卡用）
-    @Schema(description = "变动金额（储值卡用）",example = "1")
-    private Double changeBalance;
-
-    //变动后剩余次数
-    @Schema(description = "变动后剩余次数",example = "1")
-    private Integer afterRemainingCount;
-
-    //变动后剩余金额
-    @Schema(description = "变动后剩余金额",example = "500.0")
-    private Double afterRemainingBalance;
-
-    //关联业务类型
-    @Schema(description = "关联业务类型",example = "GROUP_CLASS")
-    private MemberCardTransactionsType relatedBizType;
-
-    //备注
-    @Schema(description = "备注",example = "预约团课：瑜伽课扣1次")
-    private String remark;
-
-    //创建时间
-    @Schema(description = "创建时间",example = "2026-05-10 05:22:47")
-    private LocalDateTime createdAt;
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/entity/MemberCardRecordEntity.java

@@ -1,53 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.entity;
-
-import cn.novalon.gym.manage.db.entity.BaseEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import lombok.Data;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.time.LocalDateTime;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 22:47:31
- */
-@Data
-@Table("member_card_record")
-public class MemberCardRecordEntity extends BaseEntity {
-    //会员持有卡id
-    @Column("member_card_record_id")
-    private Long memberCardRecordId;
-
-    //会员Id
-    @Column("member_id")
-    private Long memberId;
-
-    //关联会员卡Id
-    @Column("member_card_id")
-    private Long memberCardId;
-
-    //状态：ACTIVE(有效) / USED_UP(用完) / EXPIRED(过期) / REFUNDED(已退款)
-    @Column("status")
-    private MemberCardRecordStatus status;
-
-    //剩余次数
-    @Column("remaining_times")
-    private Integer remainingTimes;
-
-    //剩余余额
-    @Column("remaining_amount")
-    private Double remainingAmount;
-
-    //到期时间
-    @Column("expire_time")
-    private LocalDateTime expireTime;
-
-    //购买订单Id
-    @Column("source_order_id")
-    private Long sourceOrderId;
-
-    //购买时间
-    @Column("purchase_time")
-    private LocalDateTime purchaseTime;
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/entity/MemberCardTransactionsEntity.java

@@ -1,62 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.entity;
-
-import cn.novalon.gym.manage.db.entity.BaseEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
-import lombok.Data;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.time.LocalDateTime;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 22:47:31
- */
-@Data
-@Table("member_card_transactions")
-public class MemberCardTransactionsEntity extends BaseEntity {
-    //会员卡流水Id
-    @Column("member_card_transactions_id")
-    private Long memberCardTransactionsId;
-
-    //会员卡Id
-    @Column("member_card_id")
-    private Long memberCardId;
-
-    //会员Id
-    @Column("member_id")
-    private Long memberId;
-
-    //操作类型：PURCHASE(购买) / DEDUCT(扣次/扣费) / RENEW(续费) / REFUND(退款) / EXPIRE(过期)
-    @Column("operation_type")
-    private MemberCardTransactionsAction operationType;
-
-    //变动次数（次卡用）
-    @Column("change_amount")
-    private Integer changeAmount;
-
-    //变动金额（储值卡用）
-    @Column("change_balance")
-    private Double changeBalance;
-
-    //变动后剩余次数
-    @Column("after_remaining_count")
-    private Integer afterRemainingCount;
-
-    //变动后剩余金额
-    @Column("after_remaining_balance")
-    private Double afterRemainingBalance;
-
-    //关联业务类型
-    @Column("related_biz_type")
-    private MemberCardTransactionsType relatedBizType;
-
-    //备注
-    @Column("remark")
-    private String remark;
-
-    //创建时间
-    @Column("created_at")
-    private LocalDateTime createdAt;
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/enums/MemberCardRecordStatus.java

@@ -1,36 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.enums;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 23:59:29
- */
-@Schema(description = "会员卡状态枚举")
-public enum MemberCardRecordStatus {
-    //有效
-    @Schema(description = "有效")
-    ACTIVE("有效"),
-
-    //用完
-    @Schema(description = "用完")
-    USED_UP("用完"),
-
-    //过期
-    @Schema(description = "过期")
-    EXPIRED("过期"),
-
-    //已退款
-    @Schema(description = "已退款")
-    REFUNDED("已退款");
-
-    private final String desc;
-
-    MemberCardRecordStatus(String desc) {
-        this.desc = desc;
-    }
-
-    public String getDesc() {
-        return desc;
-    }
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/enums/MemberCardTransactionsAction.java

@@ -1,40 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.enums;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 23:59:29
- */
-@Schema(description = "会员卡流水操作枚举")
-public enum MemberCardTransactionsAction {
-    //购买
-    @Schema(description = "购买")
-    PURCHASE("购买"),
-
-    //扣次/扣费
-    @Schema(description = "扣次/扣费")
-    DEDUCT("扣次/扣费"),
-
-    //续费
-    @Schema(description = "续费")
-    RENEW("续费"),
-
-    //退款
-    @Schema(description = "退款")
-    REFUND("退款"),
-
-    //过期
-    @Schema(description = "过期")
-    EXPIRE("过期");
-
-    private final String desc;
-
-    MemberCardTransactionsAction(String desc) {
-        this.desc = desc;
-    }
-
-    public String getDesc() {
-        return desc;
-    }
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/enums/MemberCardTransactionsType.java

@@ -1,32 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.enums;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 23:59:29
- */
-@Schema(description = "会员卡流水关联业务类型枚举")
-public enum MemberCardTransactionsType {
-    //团课
-    @Schema(description = "团课")
-    GROUP_CLASS("团课"),
-
-    //私教
-    @Schema(description = "私教")
-    PT_CLASS("私教"),
-
-    //签到
-    @Schema(description = "签到")
-    CHECK_IN("签到");
-
-    private final String desc;
-
-    MemberCardTransactionsType(String desc) {
-        this.desc = desc;
-    }
-
-    public String getDesc() {
-        return desc;
-    }
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/handler/MemberCardHandler.java

@@ -1,114 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.handler;
-
-import cn.hutool.db.PageResult;
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
-import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardService;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import jakarta.validation.Validator;
-import org.springframework.data.domain.PageRequest;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.domain.Sort;
-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.Flux;
-import reactor.core.publisher.Mono;
-import java.util.List;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/17-05 20:10:22
- */
-@Component
-@Tag(name = "会员卡类型管理", description = "会员卡类型相关操作")
-public class MemberCardHandler {
-    private final IMemberCardService memberCardService;
-    private final Validator validator;
-
-    public MemberCardHandler(IMemberCardService memberCardService, Validator validator) {
-        this.memberCardService = memberCardService;
-        this.validator = validator;
-    }
-
-    /**
-     * 根据会员卡ID查询会员卡详情
-     */
-    @Operation(summary = "根据会员卡ID查询会员卡详情", description = "用于编辑前回显或小程序端展示")
-    public Mono<ServerResponse> getMemberCardById(ServerRequest request) {
-        Long memberCardId = Long.parseLong(request.pathVariable("memberCardId"));
-        return memberCardService.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
-                .flatMap(card -> ServerResponse.ok().bodyValue(card))
-                .switchIfEmpty(ServerResponse.notFound().build());
-    }
-
-    /**
-     * 条件查询会员卡列表（分页）
-     */
-    @Operation(summary = "条件查询会员卡列表", description = "后台卡种列表展示，支持多条件组合+分页+排序")
-    public Mono<ServerResponse> getMemberCardList(ServerRequest request) {
-        Integer status = request.queryParam("status").map(Integer::parseInt).orElse(null);
-        String name = request.queryParam("name").orElse(null);
-        String type = request.queryParam("type").orElse(null);
-        Double minPrice = request.queryParam("minPrice").map(Double::parseDouble).orElse(null);
-        Double maxPrice = request.queryParam("maxPrice").map(Double::parseDouble).orElse(null);
-
-        int page = request.queryParam("page").map(Integer::parseInt).orElse(0);
-        int size = request.queryParam("size").map(Integer::parseInt).orElse(10);
-        String sortField = request.queryParam("sortField").orElse("created_at");
-        String sortOrder = request.queryParam("sortOrder").orElse("DESC");
-
-        Pageable pageable = PageRequest.of(page, size, Sort.by(Sort.Direction.fromString(sortOrder), sortField));
-
-        Mono<Long> countMono = memberCardService.countWithConditions(status, name, type, minPrice, maxPrice);
-        Flux<MemberCard> cardsFlux = memberCardService.findWithConditions(status, name, type, minPrice, maxPrice, pageable);
-
-        return Mono.zip(countMono, cardsFlux.collectList())
-                .flatMap(tuple -> {
-                    long total = tuple.getT1();
-                    List<MemberCard> list = tuple.getT2();
-
-                    // 使用 PageResult(int page, int pageSize, int total) 构造，
-                    // 它会自动计算 totalPage
-                    PageResult<MemberCard> result = new PageResult<>(page, size, (int) total);
-                    result.addAll(list);   // 将查询结果填充进去
-
-                    return ServerResponse.ok().bodyValue(result);
-                });
-    }
-
-    /**
-     * 保存卡种信息（新增或更新）
-     */
-    @Operation(summary = "保存卡种信息", description = "新增或更新会员卡类型")
-    public Mono<ServerResponse> saveMemberCard(ServerRequest request) {
-        return request.bodyToMono(MemberCard.class)
-                .flatMap(memberCardService::save)
-                .flatMap(card -> ServerResponse.ok().bodyValue(card));
-    }
-
-    /**
-     * 逻辑删除会员卡（下架）
-     */
-    @Operation(summary = "逻辑删除会员卡", description = "下架卡种，防止已购会员数据异常")
-    public Mono<ServerResponse> deleteMemberCard(ServerRequest request) {
-        Long memberCardId = Long.parseLong(request.pathVariable("memberCardId"));
-        return memberCardService.logicalDelete(memberCardId)
-                .flatMap(rows -> {
-                    if (rows > 0) {
-                        return ServerResponse.noContent().build();
-                    } else {
-                        return ServerResponse.notFound().build();
-                    }
-                });
-    }
-
-    /**
-     * 批量查询上架的会员卡
-     */
-    @Operation(summary = "批量查询上架的会员卡", description = "用于小程序端展示")
-    public Mono<ServerResponse> getActiveCards(ServerRequest request) {
-        Integer status = request.queryParam("status").map(Integer::parseInt).orElse(0);
-        return ServerResponse.ok().body(memberCardService.findActiveCards(status), MemberCard.class);
-    }
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/handler/MemberCardRecordHandler.java

@@ -1,179 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.handler;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardRecordService;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import jakarta.validation.Validator;
-import lombok.Data;
-import org.springframework.data.domain.PageRequest;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.domain.Sort;
-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.time.LocalDateTime;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/17-05 20:10:22
- */
-@Component
-@Tag(name = "会员卡记录管理", description = "会员卡记录相关操作")
-public class MemberCardRecordHandler {
-
-    private final IMemberCardRecordService memberCardRecordService;
-    private final Validator validator;
-
-    public MemberCardRecordHandler(IMemberCardRecordService memberCardRecordService, Validator validator) {
-        this.memberCardRecordService = memberCardRecordService;
-        this.validator = validator;
-    }
-
-    /**
-     * 会员购卡/后台发卡
-     */
-    @Operation(summary = "会员购卡/后台发卡", description = "支付成功后插入一条记录，状态为ACTIVE")
-    public Mono<ServerResponse> insertActiveRecord(ServerRequest request) {
-        return request.bodyToMono(MemberCardRecord.class)
-                .flatMap(memberCardRecordService::insertActiveRecord)
-                .flatMap(record -> ServerResponse.ok().bodyValue(record));
-    }
-
-    /**
-     * 扣次/扣费
-     */
-    @Operation(summary = "扣次/扣费", description = "预约团课或私教成功后扣减次数或余额")
-    public Mono<ServerResponse> deductUsage(ServerRequest request) {
-        Long recordId = Long.parseLong(request.pathVariable("id"));
-        return request.bodyToMono(DeductRequest.class)
-                .flatMap(body -> memberCardRecordService.deductUsage(recordId,
-                        body.getDeductTimes(),
-                        body.getDeductAmount()))
-                .flatMap(rows -> {
-                    if (rows > 0) {
-                        return ServerResponse.ok().build();
-                    } else {
-                        return ServerResponse.badRequest().bodyValue("余额不足或卡无效");
-                    }
-                });
-    }
-
-    /**
-     * 续费
-     */
-    @Operation(summary = "续费", description = "累加剩余次数/余额，顺延到期日期")
-    public Mono<ServerResponse> renewCard(ServerRequest request) {
-        Long recordId = Long.parseLong(request.pathVariable("id"));
-        return request.bodyToMono(RenewRequest.class)
-                .flatMap(body -> memberCardRecordService.renewCard(recordId,
-                        body.getAddTimes(),
-                        body.getAddAmount(),
-                        body.getNewExpireTime()))
-                .flatMap(rows -> {
-                    if (rows > 0) {
-                        return ServerResponse.ok().build();
-                    } else {
-                        return ServerResponse.notFound().build();
-                    }
-                });
-    }
-
-    /**
-     * 状态变更（过期、退款）
-     */
-    @Operation(summary = "状态变更", description = "将卡状态改为EXPIRED或REFUNDED")
-    public Mono<ServerResponse> updateStatus(ServerRequest request) {
-        Long recordId = Long.parseLong(request.pathVariable("id"));
-        return request.queryParam("status")
-                .map(s -> {
-                    try {
-                        return MemberCardRecordStatus.valueOf(s.toUpperCase());
-                    } catch (IllegalArgumentException e) {
-                        return null;
-                    }
-                })
-                .map(status -> memberCardRecordService.updateStatus(recordId, status)
-                        .flatMap(rows -> {
-                            if (rows > 0) {
-                                return ServerResponse.ok().build();
-                            } else {
-                                return ServerResponse.notFound().build();
-                            }
-                        }))
-                .orElse(ServerResponse.badRequest().bodyValue("status 参数缺失或无效"));
-    }
-
-    /**
-     * 会员端“我的卡包”
-     */
-    @Operation(summary = "会员我的卡包", description = "查询当前登录会员的所有有效卡")
-    public Mono<ServerResponse> getMyCards(ServerRequest request) {
-        Long memberId = Long.parseLong(request.pathVariable("memberId"));
-        return ServerResponse.ok().body(memberCardRecordService.findActiveCardsByMemberId(memberId),
-                MemberCardRecord.class);
-    }
-
-    /**
-     * 前台/店长查会员卡（分页）
-     */
-    @Operation(summary = "管理端查询会员卡", description = "按会员ID分页查询所有会员卡记录")
-    public Mono<ServerResponse> getMemberCardRecords(ServerRequest request) {
-        Long memberId = Long.parseLong(request.pathVariable("memberId"));
-        int page = request.queryParam("page").map(Integer::parseInt).orElse(0);
-        int size = request.queryParam("size").map(Integer::parseInt).orElse(10);
-        Pageable pageable = PageRequest.of(page, size, Sort.by("purchase_time").descending());
-        return ServerResponse.ok().body(memberCardRecordService.findByMemberId(memberId, pageable),
-                MemberCardRecord.class);
-    }
-
-    /**
-     * 验证次卡是否可用
-     */
-    @Operation(summary = "验证次卡", description = "校验次卡剩余次数是否足够")
-    public Mono<ServerResponse> validateCountCard(ServerRequest request) {
-        Long recordId = Long.parseLong(request.pathVariable("id"));
-        Integer requiredTimes = request.queryParam("times").map(Integer::parseInt).orElse(1);
-        return memberCardRecordService.validateCountCard(recordId, requiredTimes)
-                .flatMap(card -> ServerResponse.ok().bodyValue(card))
-                .switchIfEmpty(ServerResponse.badRequest().bodyValue("次卡不可用"));
-    }
-
-    /**
-     * 验证储值卡是否可用
-     */
-    @Operation(summary = "验证储值卡", description = "校验储值卡余额是否足够")
-    public Mono<ServerResponse> validateStoredCard(ServerRequest request) {
-        Long recordId = Long.parseLong(request.pathVariable("id"));
-        Double requiredAmount = request.queryParam("amount").map(Double::parseDouble).orElse(0.0);
-        return memberCardRecordService.validateStoredCard(recordId, requiredAmount)
-                .flatMap(card -> ServerResponse.ok().bodyValue(card))
-                .switchIfEmpty(ServerResponse.badRequest().bodyValue("储值卡不可用"));
-    }
-
-    /**
-     * 到期扫描（管理端触发）
-     */
-    @Operation(summary = "到期扫描", description = "扫描并返回已过期的会员卡（最多500条）")
-    public Mono<ServerResponse> getExpiredCards(ServerRequest request) {
-        return ServerResponse.ok().body(memberCardRecordService.findExpiredCards(), MemberCardRecord.class);
-    }
-
-    // ==================== 内部请求体 DTO ====================
-
-    @Data
-    public static class DeductRequest {
-        private Integer deductTimes;
-        private Double deductAmount;
-    }
-
-    @Data
-    public static class RenewRequest {
-        private Integer addTimes;
-        private Double addAmount;
-        private LocalDateTime newExpireTime;
-    }
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/IMemberCardRecordRepository.java

@@ -1,83 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import org.springframework.data.domain.Pageable;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-public interface IMemberCardRecordRepository {
-
-    /**
-     * 会员购卡/后台发卡
-     * @param record 会员卡记录
-     * @return 插入的记录
-     */
-    Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
-
-    /**
-     * 扣次/扣费（含防超扣校验）
-     * @param recordId 会员卡记录ID
-     * @param deductTimes 扣除次数
-     * @param deductAmount 扣除金额
-     * @return 受影响的行数（0表示余额不足，扣费失败）
-     */
-    Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
-
-    /**
-     * 续费
-     * @param recordId 会员卡记录ID
-     * @param addTimes 增加次数
-     * @param addAmount 增加金额
-     * @param newExpireTime 新的到期时间
-     * @return 受影响的行数
-     */
-    Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime);
-
-    /**
-     * 状态变更
-     * @param recordId 会员卡记录ID
-     * @param status 新状态
-     * @return 受影响的行数
-     */
-    Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status);
-
-    /**
-     * 会员端"我的卡包"
-     * @param memberId 会员ID
-     * @return 有效会员卡列表
-     */
-    Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
-
-    /**
-     * 前台/店长查会员卡
-     * @param memberId 会员ID
-     * @param pageable 分页参数
-     * @return 会员卡列表
-     */
-    Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
-
-    /**
-     * 验证次卡是否可用（仅检验次数和过期时间）
-     * @param recordId 会员卡记录ID
-     * @param requiredTimes 需要的次数
-     * @return 符合条件的记录，空表示不可用
-     */
-    Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
-
-    /**
-     * 验证储值卡是否可用（仅检验余额和过期时间）
-     * @param recordId 会员卡记录ID
-     * @param requiredAmount 需要的金额
-     * @return 符合条件的记录，空表示不可用
-     */
-    Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
-
-    /**
-     * 到期扫描（分批处理，避免内存压力）
-     * @return 已过期的会员卡记录列表（最多500条）
-     */
-    Flux<MemberCardRecord> findExpiredCards();
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/IMemberCardRepository.java

@@ -1,78 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
-import org.springframework.data.domain.Pageable;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-public interface IMemberCardRepository {
-    /**
-     * 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
-     * @param memberCardId 会员卡ID
-     * @return 会员卡完整信息，如果不存在或已删除则返回空
-     */
-    Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
-
-    /**
-     * 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
-     * @param status 会员卡状态（上架/下架）
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    Flux<MemberCard> findWithConditions(Integer status, String name, String type,
-                                              Double minPrice, Double maxPrice, Pageable pageable);
-
-    /**
-     * 统计符合条件的会员卡总数（配合列表查询使用）
-     * @param status 会员卡状态
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @return 符合条件的会员卡数量
-     */
-    Mono<Long> countWithConditions(Integer status, String name, String type,
-                                   Double minPrice, Double maxPrice);
-
-    /**
-     * 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
-     * @param status 会员卡状态（通常传上架状态）
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
-
-    /**
-     * 检查会员卡是否已被购买（用于删除前的校验）
-     * @param memberCardId 会员卡ID
-     * @return 如果存在关联的会员记录则返回true，否则返回false
-     */
-    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
-
-    /**
-     * 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
-     * @param memberCardId 会员卡ID
-     * @return 受影响的行数
-     */
-    Mono<Integer> logicalDelete(Long memberCardId);
-
-    /**
-     * 保存卡种信息（新增或更新）
-     * - 新增：entity.memberCardId 为 null 时，插入新记录
-     * - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
-     * @param entity 卡种信息
-     * @return 保存后的实体对象
-     */
-    Mono<MemberCard> save(MemberCard entity);
-
-    /**
-     * 批量查询上架的会员卡（用于小程序端展示）
-     * @param status 上架状态值
-     * @return 上架的会员卡列表
-     */
-    Flux<MemberCard> findActiveCards(Integer status);
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/IMemberCardTransactionsRepository.java

@@ -1,91 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import org.springframework.data.domain.Pageable;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-public interface IMemberCardTransactionsRepository {
-
-    /**
-     * 记录每一次变动
-     * @param transactions 流水记录
-     * @return 插入的流水记录
-     */
-    Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions);
-
-    /**
-     * 会员端"使用记录"
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
-                                                             LocalDateTime endTime, Pageable pageable);
-
-    /**
-     * 后台"使用记录查询"
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
-                                                     MemberCardTransactionsAction operationType,
-                                                     LocalDateTime startTime, LocalDateTime endTime,
-                                                     Pageable pageable);
-
-    /**
-     * 统计符合条件的流水总数
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 流水记录数量
-     */
-    Mono<Long> countWithConditions(Long memberId, Long memberCardId,
-                                   MemberCardTransactionsAction operationType,
-                                   LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 按会员卡ID查询所有流水记录
-     * @param memberCardId 会员卡ID
-     * @return 该卡的所有流水记录，按时间倒序
-     */
-    Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId);
-
-    /**
-     * 数据统计 - 统计某卡种的总扣次数
-     * @param memberCardId 会员卡ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 总扣次数
-     */
-    Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 数据统计 - 统计某时间段的续费总金额
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 续费总金额
-     */
-    Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 数据统计 - 统计某会员的购卡总金额
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 购卡总金额
-     */
-    Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/impl/MemberCardRecordRepositoryImpl.java

@@ -1,141 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository.impl;
-
-import cn.novalon.gym.manage.gymmembercard.dao.MemberCardRecordDao;
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardRecordEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
-import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Repository
-public class MemberCardRecordRepositoryImpl implements IMemberCardRecordRepository {
-    private final MemberCardRecordDao memberCardRecordDao;
-    private final BeanConvertUtil beanConvertUtil;
-    private final R2dbcEntityTemplate r2dbcEntityTemplate;
-
-    public MemberCardRecordRepositoryImpl(MemberCardRecordDao memberCardRecordDao,
-                                          BeanConvertUtil beanConvertUtil,
-                                          R2dbcEntityTemplate r2dbcEntityTemplate) {
-        this.memberCardRecordDao = memberCardRecordDao;
-        this.beanConvertUtil = beanConvertUtil;
-        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
-    }
-
-    /**
-     * 会员购卡/后台发卡
-     * @param record 会员卡记录
-     * @return 插入的记录
-     */
-    @Override
-    public Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record) {
-        MemberCardRecordEntity entity = BeanConvertUtil.toBean(record, MemberCardRecordEntity.class);
-        return memberCardRecordDao.insertActiveRecord(
-                        entity.getMemberId(),
-                        entity.getMemberCardId(),
-                        entity.getExpireTime(),
-                        entity.getRemainingTimes(),
-                        entity.getRemainingAmount(),
-                        entity.getSourceOrderId())
-                .map(e -> beanConvertUtil.toBean(e, MemberCardRecord.class));
-    }
-
-    /**
-     * 扣次/扣费（含防超扣校验）
-     * @param recordId 会员卡记录ID
-     * @param deductTimes 扣除次数
-     * @param deductAmount 扣除金额
-     * @return 受影响的行数（0表示余额不足，扣费失败）
-     */
-    @Override
-    public Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount) {
-        return memberCardRecordDao.deductUsage(recordId, deductTimes, deductAmount);
-    }
-
-    /**
-     * 续费
-     * @param recordId 会员卡记录ID
-     * @param addTimes 增加次数
-     * @param addAmount 增加金额
-     * @param newExpireTime 新的到期时间
-     * @return 受影响的行数
-     */
-    @Override
-    public Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime) {
-        return memberCardRecordDao.renewCard(recordId, addTimes, addAmount, newExpireTime);
-    }
-
-    /**
-     * 状态变更
-     * @param recordId 会员卡记录ID
-     * @param status 新状态
-     * @return 受影响的行数
-     */
-    @Override
-    public Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status) {
-        return memberCardRecordDao.updateStatus(recordId, status);
-    }
-
-    /**
-     * 会员端"我的卡包"
-     * @param memberId 会员ID
-     * @return 有效会员卡列表
-     */
-    @Override
-    public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
-        return memberCardRecordDao.findActiveCardsByMemberId(memberId)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
-    }
-
-    /**
-     * 前台/店长查会员卡
-     * @param memberId 会员ID
-     * @param pageable 分页参数
-     * @return 会员卡列表
-     */
-    @Override
-    public Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable) {
-        return memberCardRecordDao.findByMemberId(memberId, pageable)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
-    }
-
-    /**
-     * 验证次卡是否可用（仅检验次数和过期时间）
-     * @param recordId 会员卡记录ID
-     * @param requiredTimes 需要的次数
-     * @return 符合条件的记录，空表示不可用
-     */
-    @Override
-    public Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes) {
-        return memberCardRecordDao.validateCountCard(recordId, requiredTimes)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
-    }
-
-    /**
-     * 验证储值卡是否可用（仅检验余额和过期时间）
-     * @param recordId 会员卡记录ID
-     * @param requiredAmount 需要的金额
-     * @return 符合条件的记录，空表示不可用
-     */
-    @Override
-    public Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount) {
-        return memberCardRecordDao.validateStoredCard(recordId, requiredAmount)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
-    }
-
-    /**
-     * 到期扫描（分批处理，避免内存压力）
-     * @return 已过期的会员卡记录列表（最多500条）
-     */
-    @Override
-    public Flux<MemberCardRecord> findExpiredCards() {
-        return memberCardRecordDao.findExpiredCards()
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
-    }
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/impl/MemberCardRepositoryImpl.java

@@ -1,146 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository.impl;
-
-import cn.novalon.gym.manage.gymmembercard.dao.MemberCardDao;
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardEntity;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRepository;
-import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-@Repository
-public class MemberCardRepositoryImpl implements IMemberCardRepository {
-    private final MemberCardDao memberCardDao;
-    private final BeanConvertUtil beanConvertUtil;
-    private final R2dbcEntityTemplate r2dbcEntityTemplate;
-    //构造函数,初始化
-    public MemberCardRepositoryImpl(MemberCardDao memberCardDao, BeanConvertUtil beanConvertUtil, R2dbcEntityTemplate r2dbcEntityTemplate) {
-        this.memberCardDao = memberCardDao;
-        this.beanConvertUtil = beanConvertUtil;
-        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
-    }
-
-    /**
-     * 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
-     * @param memberCardId 会员卡ID
-     * @return 会员卡完整信息，如果不存在或已删除则返回空
-     */
-    @Override
-    public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
-        return memberCardDao.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
-    }
-
-    /**
-     * 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
-     * @param status 会员卡状态（上架/下架）
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    @Override
-    public Flux<MemberCard> findWithConditions(Integer status, String name, String type,
-                                               Double minPrice, Double maxPrice, Pageable pageable) {
-        return memberCardDao.findWithConditions(status, name, type, minPrice, maxPrice, pageable)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
-    }
-
-    /**
-     * 统计符合条件的会员卡总数（配合列表查询使用）
-     * @param status 会员卡状态
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @return 符合条件的会员卡数量
-     */
-    @Override
-    public Mono<Long> countWithConditions(Integer status, String name, String type,
-                                          Double minPrice, Double maxPrice) {
-        return memberCardDao.countWithConditions(status, name, type, minPrice, maxPrice);
-    }
-
-    /**
-     * 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
-     * @param status 会员卡状态（通常传上架状态）
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    @Override
-    public Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable) {
-        return memberCardDao.findByMemberCardStatusAndDeletedAtIsNull(status, pageable)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
-    }
-
-    /**
-     * 检查会员卡是否已被购买（用于删除前的校验）
-     * @param memberCardId 会员卡ID
-     * @return 如果存在关联的会员记录则返回true，否则返回false
-     */
-    @Override
-    public Mono<Boolean> existsPurchasedRecord(Long memberCardId) {
-        return memberCardDao.existsPurchasedRecord(memberCardId);
-    }
-
-    /**
-     * 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
-     * @param memberCardId 会员卡ID
-     * @return 受影响的行数
-     */
-    @Override
-    public Mono<Integer> logicalDelete(Long memberCardId) {
-        return memberCardDao.logicalDelete(memberCardId);
-    }
-
-    /**
-     * 安全更新会员卡信息（不覆盖不允许修改的字段）
-     * @param memberCardId 会员卡ID
-     * @param updateData 需要更新的卡种信息
-     * @return 受影响的行数
-     */
-    public Mono<Integer> updateSafe(Long memberCardId, MemberCard updateData) {
-        MemberCardEntity memberCardEntity = beanConvertUtil.toBean(updateData, MemberCardEntity.class);
-        return memberCardDao.updateSafe(
-                memberCardId,
-                memberCardEntity.getMemberCardName(),
-                memberCardEntity.getMemberCardPrice(),
-                memberCardEntity.getMemberCardValidityDays(),
-                memberCardEntity.getMemberCardTotalTimes(),
-                memberCardEntity.getMemberCardAmount(),
-                memberCardEntity.getMemberCardStatus()
-        );
-    }
-
-
-    /**
-     * 保存卡种信息（新增或更新）
-     * - 新增：entity.memberCardId 为 null 时，插入新记录
-     * - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
-     * 建议：更新时优先使用 updateSafe 方法避免全字段覆盖
-     * @param entity 卡种信息
-     * @return 保存后的实体对象
-     */
-    @Override
-    public Mono<MemberCard> save(MemberCard entity) {
-        MemberCardEntity cardEntity = beanConvertUtil.toBean(entity, MemberCardEntity.class);
-        return memberCardDao.save(cardEntity)
-                .map(savedEntity -> beanConvertUtil.toBean(savedEntity, MemberCard.class));
-    }
-
-    /**
-     * 批量查询上架的会员卡（用于小程序端展示）
-     * @param status 上架状态值
-     * @return 上架的会员卡列表
-     */
-    @Override
-    public Flux<MemberCard> findActiveCards(Integer status) {
-        return memberCardDao.findActiveCards(status)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
-    }
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/impl/MemberCardTransactionsRepositoryImpl.java

@@ -1,147 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository.impl;
-
-import cn.novalon.gym.manage.gymmembercard.dao.MemberCardTransactionsDao;
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardTransactionsEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardTransactionsRepository;
-import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Repository
-public class MemberCardTransactionsRepositoryImpl implements IMemberCardTransactionsRepository {
-    private final MemberCardTransactionsDao memberCardTransactionsDao;
-    private final BeanConvertUtil beanConvertUtil;
-    private final R2dbcEntityTemplate r2dbcEntityTemplate;
-
-    public MemberCardTransactionsRepositoryImpl(MemberCardTransactionsDao memberCardTransactionsDao, BeanConvertUtil beanConvertUtil, R2dbcEntityTemplate r2dbcEntityTemplate) {
-        this.memberCardTransactionsDao = memberCardTransactionsDao;
-        this.beanConvertUtil = beanConvertUtil;
-        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
-    }
-
-    /**
-     * 记录每一次变动
-     * @param transactions 流水记录
-     * @return 插入的流水记录
-     */
-    @Override
-    public Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions) {
-        MemberCardTransactionsEntity entity = beanConvertUtil.toBean(transactions, MemberCardTransactionsEntity.class);
-        return memberCardTransactionsDao.insertTransaction(
-                        entity.getMemberCardId(),
-                        entity.getMemberId(),
-                        entity.getOperationType(),
-                        entity.getChangeAmount(),
-                        entity.getChangeBalance(),
-                        entity.getAfterRemainingCount(),
-                        entity.getAfterRemainingBalance(),
-                        entity.getRelatedBizType(),
-                        entity.getRemark())
-                .map(e -> beanConvertUtil.toBean(e, MemberCardTransactions.class));
-    }
-
-    /**
-     * 会员端"使用记录"
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    @Override
-    public Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
-                                                                    LocalDateTime endTime, Pageable pageable) {
-        return memberCardTransactionsDao.findByMemberIdAndTimeRange(memberId, startTime, endTime, pageable)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
-    }
-
-    /**
-     * 后台"使用记录查询"
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    @Override
-    public Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
-                                                            MemberCardTransactionsAction operationType,
-                                                            LocalDateTime startTime, LocalDateTime endTime,
-                                                            Pageable pageable) {
-        return memberCardTransactionsDao.findWithConditions(memberId, memberCardId, operationType,
-                                                             startTime, endTime, pageable)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
-    }
-
-    /**
-     * 统计符合条件的流水总数
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 流水记录数量
-     */
-    @Override
-    public Mono<Long> countWithConditions(Long memberId, Long memberCardId,
-                                          MemberCardTransactionsAction operationType,
-                                          LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsDao.countWithConditions(memberId, memberCardId,
-                                                              operationType, startTime, endTime);
-    }
-
-    /**
-     * 按会员卡ID查询所有流水记录
-     * @param memberCardId 会员卡ID
-     * @return 该卡的所有流水记录，按时间倒序
-     */
-    @Override
-    public Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId) {
-        return memberCardTransactionsDao.findByMemberCardId(memberCardId)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
-    }
-
-    /**
-     * 数据统计 - 统计某卡种的总扣次数
-     * @param memberCardId 会员卡ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 总扣次数
-     */
-    @Override
-    public Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsDao.sumDeductCountByCardId(memberCardId, startTime, endTime);
-    }
-
-    /**
-     * 数据统计 - 统计某时间段的续费总金额
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 续费总金额
-     */
-    @Override
-    public Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsDao.sumRenewAmountByTimeRange(startTime, endTime);
-    }
-
-    /**
-     * 数据统计 - 统计某会员的购卡总金额
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 购卡总金额
-     */
-    @Override
-    public Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsDao.sumPurchaseAmountByMemberId(memberId, startTime, endTime);
-    }
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/IMemberCardRecordService.java

@@ -1,83 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.sevice;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import org.springframework.data.domain.Pageable;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-public interface IMemberCardRecordService {
-
-    /**
-     * 会员购卡/后台发卡
-     * @param record 会员卡记录
-     * @return 插入的记录
-     */
-    Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
-
-    /**
-     * 扣次/扣费（含防超扣校验）
-     * @param recordId 会员卡记录ID
-     * @param deductTimes 扣除次数
-     * @param deductAmount 扣除金额
-     * @return 受影响的行数（0表示余额不足，扣费失败）
-     */
-    Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
-
-    /**
-     * 续费
-     * @param recordId 会员卡记录ID
-     * @param addTimes 增加次数
-     * @param addAmount 增加金额
-     * @param newExpireTime 新的到期时间
-     * @return 受影响的行数
-     */
-    Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime);
-
-    /**
-     * 状态变更
-     * @param recordId 会员卡记录ID
-     * @param status 新状态
-     * @return 受影响的行数
-     */
-    Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status);
-
-    /**
-     * 会员端"我的卡包"
-     * @param memberId 会员ID
-     * @return 有效会员卡列表
-     */
-    Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
-
-    /**
-     * 前台/店长查会员卡
-     * @param memberId 会员ID
-     * @param pageable 分页参数
-     * @return 会员卡列表
-     */
-    Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
-
-    /**
-     * 验证次卡是否可用（仅检验次数和过期时间）
-     * @param recordId 会员卡记录ID
-     * @param requiredTimes 需要的次数
-     * @return 符合条件的记录，空表示不可用
-     */
-    Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
-
-    /**
-     * 验证储值卡是否可用（仅检验余额和过期时间）
-     * @param recordId 会员卡记录ID
-     * @param requiredAmount 需要的金额
-     * @return 符合条件的记录，空表示不可用
-     */
-    Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
-
-    /**
-     * 到期扫描（分批处理，避免内存压力）
-     * @return 已过期的会员卡记录列表（最多500条）
-     */
-    Flux<MemberCardRecord> findExpiredCards();
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/IMemberCardService.java

@@ -1,78 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.sevice;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
-import org.springframework.data.domain.Pageable;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-public interface IMemberCardService {
-    /**
-     * 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
-     * @param memberCardId 会员卡ID
-     * @return 会员卡完整信息，如果不存在或已删除则返回空
-     */
-    Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
-
-    /**
-     * 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
-     * @param status 会员卡状态（上架/下架）
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    Flux<MemberCard> findWithConditions(Integer status, String name, String type,
-                                        Double minPrice, Double maxPrice, Pageable pageable);
-
-    /**
-     * 统计符合条件的会员卡总数（配合列表查询使用）
-     * @param status 会员卡状态
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @return 符合条件的会员卡数量
-     */
-    Mono<Long> countWithConditions(Integer status, String name, String type,
-                                   Double minPrice, Double maxPrice);
-
-    /**
-     * 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
-     * @param status 会员卡状态（通常传上架状态）
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
-
-    /**
-     * 检查会员卡是否已被购买（用于删除前的校验）
-     * @param memberCardId 会员卡ID
-     * @return 如果存在关联的会员记录则返回true，否则返回false
-     */
-    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
-
-    /**
-     * 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
-     * @param memberCardId 会员卡ID
-     * @return 受影响的行数
-     */
-    Mono<Integer> logicalDelete(Long memberCardId);
-
-    /**
-     * 保存卡种信息（新增或更新）
-     * - 新增：entity.memberCardId 为 null 时，插入新记录
-     * - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
-     * @param entity 卡种信息
-     * @return 保存后的实体对象
-     */
-    Mono<MemberCard> save(MemberCard entity);
-
-    /**
-     * 批量查询上架的会员卡（用于小程序端展示）
-     * @param status 上架状态值
-     * @return 上架的会员卡列表
-     */
-    Flux<MemberCard> findActiveCards(Integer status);
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/IMemberCardTransactionsService.java

@@ -1,91 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.sevice;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import org.springframework.data.domain.Pageable;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-public interface IMemberCardTransactionsService {
-
-    /**
-     * 记录每一次变动
-     * @param transactions 流水记录
-     * @return 插入的流水记录
-     */
-    Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions);
-
-    /**
-     * 会员端"使用记录"
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
-                                                             LocalDateTime endTime, Pageable pageable);
-
-    /**
-     * 后台"使用记录查询"
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
-                                                     MemberCardTransactionsAction operationType,
-                                                     LocalDateTime startTime, LocalDateTime endTime,
-                                                     Pageable pageable);
-
-    /**
-     * 统计符合条件的流水总数
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 流水记录数量
-     */
-    Mono<Long> countWithConditions(Long memberId, Long memberCardId,
-                                   MemberCardTransactionsAction operationType,
-                                   LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 按会员卡ID查询所有流水记录
-     * @param memberCardId 会员卡ID
-     * @return 该卡的所有流水记录，按时间倒序
-     */
-    Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId);
-
-    /**
-     * 数据统计 - 统计某卡种的总扣次数
-     * @param memberCardId 会员卡ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 总扣次数
-     */
-    Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 数据统计 - 统计某时间段的续费总金额
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 续费总金额
-     */
-    Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 数据统计 - 统计某会员的购卡总金额
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 购卡总金额
-     */
-    Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/MemberCardRecordServiceImpl.java

@@ -1,67 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.sevice.impl;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
-import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardRecordService;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.data.domain.Pageable;
-import org.springframework.stereotype.Service;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Service
-public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
-    private final IMemberCardRecordRepository memberCardRecordRepository;
-
-    public MemberCardRecordServiceImpl(IMemberCardRecordRepository memberCardRecordRepository) {
-        this.memberCardRecordRepository = memberCardRecordRepository;
-    }
-
-    @Override
-    public Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record) {
-        return memberCardRecordRepository.insertActiveRecord(record);
-    }
-
-    @Override
-    public Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount) {
-        return memberCardRecordRepository.deductUsage(recordId, deductTimes, deductAmount);
-    }
-
-    @Override
-    public Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime) {
-        return memberCardRecordRepository.renewCard(recordId, addTimes, addAmount, newExpireTime);
-    }
-
-    @Override
-    public Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status) {
-        return memberCardRecordRepository.updateStatus(recordId, status);
-    }
-
-    @Override
-    public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
-        return memberCardRecordRepository.findActiveCardsByMemberId(memberId);
-    }
-
-    @Override
-    public Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable) {
-        return memberCardRecordRepository.findByMemberId(memberId, pageable);
-    }
-
-    @Override
-    public Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes) {
-        return memberCardRecordRepository.validateCountCard(recordId, requiredTimes);
-    }
-
-    @Override
-    public Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount) {
-        return memberCardRecordRepository.validateStoredCard(recordId, requiredAmount);
-    }
-
-    @Override
-    public Flux<MemberCardRecord> findExpiredCards() {
-        return memberCardRecordRepository.findExpiredCards();
-    }
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/MemberCardServiceImpl.java

@@ -1,65 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.sevice.impl;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRepository;
-import cn.novalon.gym.manage.gymmembercard.repository.impl.MemberCardRepositoryImpl;
-import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardService;
-import org.springframework.data.domain.Pageable;
-import org.springframework.stereotype.Service;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-@Service
-public class MemberCardServiceImpl implements IMemberCardService {
-    private final IMemberCardRepository memberCardRepository;
-
-    public MemberCardServiceImpl(IMemberCardRepository memberCardRepository) {
-        this.memberCardRepository = memberCardRepository;
-    }
-
-    @Override
-    public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
-        return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId);
-    }
-
-    @Override
-    public Flux<MemberCard> findWithConditions(Integer status, String name, String type,
-                                               Double minPrice, Double maxPrice, Pageable pageable) {
-        return memberCardRepository.findWithConditions(status, name, type, minPrice, maxPrice, pageable);
-    }
-
-    @Override
-    public Mono<Long> countWithConditions(Integer status, String name, String type,
-                                          Double minPrice, Double maxPrice) {
-        return memberCardRepository.countWithConditions(status, name, type, minPrice, maxPrice);
-    }
-
-    @Override
-    public Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable) {
-        return memberCardRepository.findByMemberCardStatusAndDeletedAtIsNull(status, pageable);
-    }
-
-    @Override
-    public Mono<Boolean> existsPurchasedRecord(Long memberCardId) {
-        return memberCardRepository.existsPurchasedRecord(memberCardId);
-    }
-
-    @Override
-    public Mono<Integer> logicalDelete(Long memberCardId) {
-        return memberCardRepository.logicalDelete(memberCardId);
-    }
-
-    public Mono<Integer> updateSafe(Long memberCardId, MemberCard updateData) {
-        return ((MemberCardRepositoryImpl) memberCardRepository).updateSafe(memberCardId, updateData);
-    }
-
-    @Override
-    public Mono<MemberCard> save(MemberCard entity) {
-        return memberCardRepository.save(entity);
-    }
-
-    @Override
-    public Flux<MemberCard> findActiveCards(Integer status) {
-        return memberCardRepository.findActiveCards(status);
-    }
-}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/MemberCardTransactionsServiceImpl.java

@@ -1,69 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.sevice.impl;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardTransactionsRepository;
-import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardTransactionsService;
-import org.springframework.data.domain.Pageable;
-import org.springframework.stereotype.Service;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Service
-public class MemberCardTransactionsServiceImpl implements IMemberCardTransactionsService {
-    private final IMemberCardTransactionsRepository memberCardTransactionsRepository;
-
-    public MemberCardTransactionsServiceImpl(IMemberCardTransactionsRepository memberCardTransactionsRepository) {
-        this.memberCardTransactionsRepository = memberCardTransactionsRepository;
-    }
-
-    @Override
-    public Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions) {
-        return memberCardTransactionsRepository.insertTransaction(transactions);
-    }
-
-    @Override
-    public Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
-                                                                    LocalDateTime endTime, Pageable pageable) {
-        return memberCardTransactionsRepository.findByMemberIdAndTimeRange(memberId, startTime, endTime, pageable);
-    }
-
-    @Override
-    public Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
-                                                            MemberCardTransactionsAction operationType,
-                                                            LocalDateTime startTime, LocalDateTime endTime,
-                                                            Pageable pageable) {
-        return memberCardTransactionsRepository.findWithConditions(memberId, memberCardId, operationType,
-                                                             startTime, endTime, pageable);
-    }
-
-    @Override
-    public Mono<Long> countWithConditions(Long memberId, Long memberCardId,
-                                          MemberCardTransactionsAction operationType,
-                                          LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsRepository.countWithConditions(memberId, memberCardId,
-                                                              operationType, startTime, endTime);
-    }
-
-    @Override
-    public Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId) {
-        return memberCardTransactionsRepository.findByMemberCardId(memberCardId);
-    }
-
-    @Override
-    public Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsRepository.sumDeductCountByCardId(memberCardId, startTime, endTime);
-    }
-
-    @Override
-    public Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsRepository.sumRenewAmountByTimeRange(startTime, endTime);
-    }
-
-    @Override
-    public Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsRepository.sumPurchaseAmountByMemberId(memberId, startTime, endTime);
-    }
-}

gym-manage-api/gym-member-card/src/main/resources/application.properties

@@ -1 +0,0 @@
-spring.application.name=gym-member-card

gym-manage-api/gym-member/.gitignore

@@ -0,0 +1,47 @@
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
+
+### Maven ###
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+.mvn/wrapper/maven-wrapper.jar
+
+### System Files ###
+.DS_Store
+Thumbs.db

gym-manage-api/gym-member/CARD_MERGE_REPORT.md

@@ -0,0 +1,199 @@
+# gym-member-card 模块合并到 gym-member 完成报告
+
+## 合并概述
+将 `gym-member-card` 模块的功能合并到 `gym-member` 模块的 `card` 子包中，保持功能不变，代码风格以 `gym-member` 为基准。
+
+## 已完成的工作
+
+### 1. 目录结构创建 ✅
+在 `gym-member/src/main/java/cn/novalon/gym/manage/member/card` 下创建了以下子目录：
+- `entity/` - 实体类
+- `dto/` - 数据传输对象
+- `vo/` - 视图对象
+- `repository/` - 数据访问层
+- `service/` - 服务接口
+- `service/impl/` - 服务实现
+- `handler/` - 业务处理器
+- `enums/` - 枚举类
+- `util/` - 工具类
+
+### 2. 实体类重构（Entity）✅
+按照 gym-member 的风格（使用 Lombok），创建了以下实体类：
+
+| 原文件 | 新文件 | 说明 |
+|--------|--------|------|
+| MemberCardEntity.java + MemberCard.java | card/entity/MemberCard.java | 会员卡类型实体 |
+| MemberCardRecordEntity.java + MemberCardRecord.java | card/entity/MemberCardRecord.java | 会员持卡记录实体 |
+| MemberCardTransactionsEntity.java | card/entity/MemberCardTransaction.java | 交易流水实体 |
+| RefundApplicationEntity.java | card/entity/RefundApplication.java | 退款申请实体 |
+
+**主要改进：**
+- 使用 `@Data`, `@Builder`, `@NoArgsConstructor`, `@AllArgsConstructor` Lombok 注解
+- 继承 `cn.novalon.gym.manage.member.entity.BaseEntity`
+- 移除手动编写的 getter/setter
+- 添加规范的 JavaDoc 注释
+
+### 3. 枚举类创建 ✅
+创建了以下枚举类：
+
+| 原文件 | 新文件 | 说明 |
+|--------|--------|------|
+| MemberCardType.java | card/enums/MemberCardType.java | 会员卡类型 |
+| MemberCardRecordStatus.java | card/enums/MemberCardRecordStatus.java | 卡片状态 |
+| MemberCardTransactionsAction.java | card/enums/TransactionType.java | 交易操作类型 |
+| MemberCardTransactionsType.java | card/enums/BizType.java | 关联业务类型 |
+| MemberCardEvent.java | card/enums/CardEvent.java | 状态机事件 |
+
+### 4. Repository 层合并 ✅
+将原有的 DAO 接口整合为 Repository 接口，直接继承 `R2dbcRepository`：
+
+| 原文件 | 新文件 | 说明 |
+|--------|--------|------|
+| MemberCardDao.java | card/repository/MemberCardRepository.java | 会员卡类型 Repository |
+| MemberCardRecordDao.java | card/repository/MemberCardRecordRepository.java | 持卡记录 Repository |
+| MemberCardTransactionsDao.java | card/repository/MemberCardTransactionRepository.java | 交易流水 Repository |
+| RefundApplicationDao.java | card/repository/RefundApplicationRepository.java | 退款申请 Repository |
+
+**主要改进：**
+- 统一命名规范（移除 Dao，使用 Repository）
+- 继承 `R2dbcRepository<Entity, Long>`
+- 保留所有自定义查询方法
+- 更新参数类型为新的实体类
+
+### 5. 数据库 Schema 迁移 ✅
+将会员卡相关的表结构添加到 `gym-member/src/main/resources/db/schema.sql`：
+
+新增表：
+- `member_card` - 会员卡类型表
+- `member_card_record` - 会员持卡记录表
+- `member_card_transactions` - 交易流水表
+- `refund_application` - 退款申请表
+
+包含完整的索引和注释。
+
+### 6. pom.xml 依赖更新 ✅
+在 `gym-member/pom.xml` 中添加了 Redis 响应式支持：
+```xml
+<dependency>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
+</dependency>
+```
+
+## 待完成的工作
+
+### 需要手动复制的文件（约30个）
+
+以下文件需要从 `gym-member-card` 复制到 `gym-member/card`，并修改包名：
+
+#### Handler 层（8个文件）
+源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/handler/`
+目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/handler/`
+
+- DistributedLockService.java
+- ExpirationReminderService.java
+- MemberCardHandler.java
+- MemberCardRecordHandler.java
+- MemberCardScheduledHandler.java
+- MemberCardStateMachine.java
+- MemberCardTransactionHandler.java
+- RefundSagaHandler.java
+
+#### Service 接口层（4个文件）
+源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/`
+目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/service/`
+
+注意：目录名从 `sevice`（拼写错误）改为 `service`
+
+- IMemberCardService.java
+- IMemberCardRecordService.java
+- IMemberCardTransactionsService.java
+- IRefundApplicationService.java
+
+#### Service 实现层（4个文件）
+源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/`
+目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/service/impl/`
+
+- MemberCardServiceImpl.java
+- MemberCardRecordServiceImpl.java
+- MemberCardTransactionsServiceImpl.java
+- RefundApplicationServiceImpl.java
+
+#### Util 工具类（1个文件）
+源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/util/`
+目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/util/`
+
+- BeanConvertUtil.java
+
+### 批量替换规则
+
+复制每个文件后，需要进行以下文本替换：
+
+1. **包名替换：**
+   ```
+   package cn.novalon.gym.manage.gymmembercard -> package cn.novalon.gym.manage.member.card
+   ```
+
+2. **导入语句替换：**
+   ```
+   import cn.novalon.gym.manage.gymmembercard -> import cn.novalon.gym.manage.member.card
+   ```
+
+3. **BaseEntity 导入替换：**
+   ```
+   import cn.novalon.gym.manage.db.entity.BaseEntity -> import cn.novalon.gym.manage.member.entity.BaseEntity
+   ```
+
+4. **BaseDomain 处理（如果存在）：**
+   ```
+   import cn.novalon.gym.manage.sys.core.domain.BaseDomain -> （注释掉或删除）
+   ```
+
+5. **Repository 引用更新（如果需要）：**
+   ```
+   IMemberCardRepository -> MemberCardRepository
+   IMemberCardRecordRepository -> MemberCardRecordRepository
+   IMemberCardTransactionsRepository -> MemberCardTransactionRepository
+   IRefundApplicationRepository -> RefundApplicationRepository
+   ```
+
+## 验证步骤
+
+完成文件复制后，执行以下验证：
+
+1. **编译验证：**
+   ```bash
+   cd gym-manage-api/gym-member
+   mvn clean compile
+   ```
+
+2. **检查是否有编译错误：**
+   - 修复任何缺失的导入
+   - 确认所有依赖类都已正确迁移
+   - 检查枚举引用是否正确
+
+3. **运行测试（如果有）：**
+   ```bash
+   mvn test
+   ```
+
+## 注意事项
+
+1. **包名一致性：** 确保所有文件中的包声明和导入语句都正确更新
+2. **依赖注入：** Spring 的 `@Autowired` 或构造函数注入应自动工作，因为使用了相同的注解
+3. **数据库兼容性：** schema.sql 已追加新表，不会影响现有表
+4. **Redis 配置：** 确保 application.yml 中有 Redis 配置（如果需要分布式锁功能）
+5. **定时任务：** MemberCardScheduledHandler 和 ExpirationReminderService 可能需要启用 `@EnableScheduling`
+
+## 自动化脚本
+
+项目根目录下提供了两个辅助脚本：
+- `gym-member-card/migrate_to_member.py` - Python 迁移脚本
+- `gym-member-card/migrate-to-member.ps1` - PowerShell 迁移脚本
+
+可以运行这些脚本来自动完成文件复制和包名替换。
+
+---
+
+**生成时间：** 2026-05-27
+**合并状态：** 基础架构完成，待复制业务逻辑文件

gym-manage-api/gym-member/MEMBER_USER_TABLE_SIMPLE.sql

@@ -0,0 +1,58 @@
+-- ============================================
+-- member_user 表 - 简洁版建表语句
+-- ============================================
+-- 用途：直接复制执行，快速创建会员表
+-- ============================================
+
+CREATE TABLE IF NOT EXISTS member_user (
+    -- 主键和基础字段
+    id BIGSERIAL PRIMARY KEY,
+    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),
+    gender INTEGER DEFAULT 0,
+    birthday TIMESTAMP,
+    address VARCHAR(500),
+    avatar VARCHAR(500),
+    subscribed BOOLEAN DEFAULT FALSE,
+    last_login_at TIMESTAMP,
+    
+    -- 微信相关字段
+    union_id VARCHAR(100),
+    miniapp_open_id VARCHAR(100),
+    official_open_id VARCHAR(100),
+    
+    -- 软删除字段
+    is_deleted BOOLEAN DEFAULT FALSE
+);
+
+-- 创建索引
+CREATE UNIQUE INDEX IF NOT EXISTS idx_member_user_member_no ON member_user(member_no);
+CREATE INDEX IF NOT EXISTS idx_member_user_union_id ON member_user(union_id);
+CREATE INDEX IF NOT EXISTS idx_member_user_miniapp_openid ON member_user(miniapp_open_id);
+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);
+
+-- 添加注释
+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 '会员编号（唯一）';
+COMMENT ON COLUMN member_user.nickname IS '昵称';
+COMMENT ON COLUMN member_user.phone IS '手机号（AES加密存储）';
+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 '是否关注服务号';
+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 '是否删除（软删除标记）';

gym-manage-api/gym-member/pom.xml

@@ -0,0 +1,246 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>cn.novalon.gym.manage</groupId>
+        <artifactId>gym-manage-api</artifactId>
+        <version>1.0.0</version>
+    </parent>
+
+    <artifactId>gym-member</artifactId>
+    <packaging>jar</packaging>
+
+    <name>Gym Member</name>
+    <description>Member Management Module - Frontend User Services</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-db</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-sys</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webflux</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-aop</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springdoc</groupId>
+            <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-security</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-commons</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.github.resilience4j</groupId>
+            <artifactId>resilience4j-spring-boot3</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.github.resilience4j</groupId>
+            <artifactId>resilience4j-reactor</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>testcontainers</artifactId>
+            <version>1.21.4</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>1.21.4</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>1.21.4</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.r2dbc</groupId>
+            <artifactId>r2dbc-h2</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>r2dbc-postgresql</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!-- 微信SDK依赖 -->
+        <dependency>
+            <groupId>com.github.binarywang</groupId>
+            <artifactId>weixin-java-miniapp</artifactId>
+            <version>4.6.0</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.binarywang</groupId>
+            <artifactId>weixin-java-mp</artifactId>
+            <version>4.6.0</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.8.25</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.4.2</version>
+                <executions>
+                    <execution>
+                        <id>default-jar</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.11.0</version>
+                <configuration>
+                    <source>21</source>
+                    <target>21</target>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>org.mapstruct</groupId>
+                            <artifactId>mapstruct-processor</artifactId>
+                            <version>1.5.5.Final</version>
+                        </path>
+                        <path>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                            <version>${lombok.version}</version>
+                        </path>
+                        <path>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok-mapstruct-binding</artifactId>
+                            <version>0.2.0</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <version>0.8.12</version>
+                <executions>
+                    <execution>
+                        <id>prepare-agent</id>
+                        <goals>
+                            <goal>prepare-agent</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>report</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>report</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>check</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                        <configuration>
+                            <rules>
+                                <rule>
+                                    <element>BUNDLE</element>
+                                    <limits>
+                                        <limit>
+                                            <counter>INSTRUCTION</counter>
+                                            <value>COVEREDRATIO</value>
+                                            <minimum>0.60</minimum>
+                                        </limit>
+                                    </limits>
+                                </rule>
+                            </rules>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>com.github.spotbugs</groupId>
+                <artifactId>spotbugs-maven-plugin</artifactId>
+                <version>4.8.6.0</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>com.github.spotbugs</groupId>
+                        <artifactId>spotbugs</artifactId>
+                        <version>4.8.6</version>
+                    </dependency>
+                </dependencies>
+                <executions>
+                    <execution>
+                        <id>spotbugs-check</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <effort>Max</effort>
+                    <threshold>High</threshold>
+                    <failOnError>true</failOnError>
+                    <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/config/HttpClientConfig.java

@@ -0,0 +1,22 @@
+package cn.novalon.gym.manage.member.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.function.client.WebClient;
+
+/**
+ * HTTP 客户端配置
+ * 
+ * @author 付嘉
+ * @date 2026-05-01
+ */
+
+@Configuration
+public class HttpClientConfig {
+
+    // WebClient Bean，用于调用微信 API
+    @Bean
+    public WebClient webClient() {
+        return WebClient.builder().build();
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/config/WechatProperties.java

@@ -0,0 +1,63 @@
+package cn.novalon.gym.manage.member.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * 微信配置
+ * 
+ * @author 付嘉
+ * @date 2026-05-01
+ */
+
+@Data
+@Component
+@ConfigurationProperties(prefix = "wechat")
+public class WechatProperties {
+
+    // 小程序配置
+    private MiniApp miniapp = new MiniApp();
+
+    // 服务号配置
+    private Mp mp = new Mp();
+
+    // 手机号加密配置
+    private PhoneEncryption phoneEncryption = new PhoneEncryption();
+
+    @Data
+    public static class MiniApp {
+        // 小程序 AppID
+        private String appId;
+
+        // 小程序 AppSecret
+        private String appSecret;
+    }
+
+    @Data
+    public static class Mp {
+        // 服务号 AppID
+        private String appId;
+
+        // 服务号 AppSecret
+        private String appSecret;
+
+        // Token 验证信息
+        private String token;
+
+        // EncodingAESKey
+        private String aesKey;
+
+        // 回调地址（微信服务号事件推送 URL）
+        private String callbackUrl;
+    }
+
+    @Data
+    public static class PhoneEncryption {
+        // 手机号加密密钥
+        private String secretKey;
+
+        // 初始化向量 IV
+        private String iv;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/AdminUpdatePhoneDto.java

@@ -0,0 +1,17 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+/**
+ * 更新手机号Dto
+ * 
+ * @author 付嘉
+ * @date 2026-05-01
+ */
+
+@Data
+public class AdminUpdatePhoneDto {
+    
+    // 手机号
+    private String phone;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/CreateMemberCardRequest.java

@@ -0,0 +1,61 @@
+package cn.novalon.gym.manage.member.dto
+;
+
+import lombok.Data;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import java.math.BigDecimal;
+
+/**
+ * 创建会员卡类型请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class CreateMemberCardRequest {
+
+    /**
+     * 会员卡名称
+     */
+    @NotBlank(message = "会员卡名称不能为空")
+    private String memberCardName;
+
+    /**
+     * 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
+     */
+    @NotBlank(message = "会员卡类型不能为空")
+    private String memberCardType;
+
+    /**
+     * 会员卡价格
+     */
+    @NotNull(message = "会员卡价格不能为空")
+    private BigDecimal memberCardPrice;
+
+    /**
+     * 有效天数（时长卡用）
+     */
+    private Integer memberCardValidityDays;
+
+    /**
+     * 总次数（次卡用）
+     */
+    private Integer memberCardTotalTimes;
+
+    /**
+     * 面额（储值卡用）
+     */
+    private BigDecimal memberCardAmount;
+
+    /**
+     * 状态：0-下架, 1-上架
+     */
+    private Integer memberCardStatus = 1;
+
+    /**
+     * 扩展配置（JSON格式）
+     */
+    private String extraConfig;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/PurchaseCardRequest.java

@@ -0,0 +1,32 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+import jakarta.validation.constraints.NotNull;
+
+/**
+ * 购买会员卡请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class PurchaseCardRequest {
+
+    /**
+     * 会员ID
+     */
+    @NotNull(message = "会员ID不能为空")
+    private Long memberId;
+
+    /**
+     * 会员卡类型ID
+     */
+    @NotNull(message = "会员卡类型ID不能为空")
+    private Long memberCardId;
+
+    /**
+     * 来源订单ID
+     */
+    private Long sourceOrderId;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/RefundCardRequest.java

@@ -0,0 +1,21 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+import jakarta.validation.constraints.NotBlank;
+
+/**
+ * 退款申请请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class RefundCardRequest {
+
+    /**
+     * 退款原因
+     */
+    @NotBlank(message = "退款原因不能为空")
+    private String reason;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/RenewCardRequest.java

@@ -0,0 +1,35 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+import jakarta.validation.constraints.NotNull;
+
+/**
+ * 续费会员卡请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class RenewCardRequest {
+
+    /**
+     * 增加的次数
+     */
+    private Integer addTimes;
+
+    /**
+     * 增加的金额
+     */
+    private Double addAmount;
+
+    /**
+     * 增加的天数
+     */
+    private Integer addDays;
+
+    /**
+     * 来源订单ID
+     */
+    private Long sourceOrderId;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/SearchMemberDto.java

@@ -0,0 +1,20 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class SearchMemberDto {
+
+    // 搜索字段 - 包括 会员号、昵称、手机号
+    private String searchValue;
+
+    // 页码
+    private Integer pageNum = 1;
+
+    // 页大小
+    private Integer pageSize = 10;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/UpdateMemberCardRequest.java

@@ -0,0 +1,60 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import java.math.BigDecimal;
+
+/**
+ * 更新会员卡类型请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class UpdateMemberCardRequest {
+
+    /**
+     * 会员卡名称
+     */
+    @NotBlank(message = "会员卡名称不能为空")
+    private String memberCardName;
+
+    /**
+     * 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
+     */
+    @NotBlank(message = "会员卡类型不能为空")
+    private String memberCardType;
+
+    /**
+     * 会员卡价格
+     */
+    @NotNull(message = "会员卡价格不能为空")
+    private BigDecimal memberCardPrice;
+
+    /**
+     * 有效天数（时长卡用）
+     */
+    private Integer memberCardValidityDays;
+
+    /**
+     * 总次数（次卡用）
+     */
+    private Integer memberCardTotalTimes;
+
+    /**
+     * 面额（储值卡用）
+     */
+    private BigDecimal memberCardAmount;
+
+    /**
+     * 状态：0-下架, 1-上架
+     */
+    private Integer memberCardStatus;
+
+    /**
+     * 扩展配置（JSON格式）
+     */
+    private String extraConfig;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/UpdateMemberInfoDto.java

@@ -0,0 +1,32 @@
+package cn.novalon.gym.manage.member.dto;
+
+import cn.novalon.gym.manage.member.enums.GenderEnum;
+import lombok.Data;
+
+import java.time.LocalDate;
+import java.util.Date;
+
+/**
+ * 更新会员信息Dto
+ *
+ * @author 付嘉
+ * @date 2026-05-10
+ */
+@Data
+public class UpdateMemberInfoDto {
+
+    // 昵称
+    private String nickname;
+
+    // 性别
+    private GenderEnum gender;
+
+    // 生日
+    private LocalDate birthday;
+
+    // 头像
+    private String avatar;
+
+    // 地址
+    private String address;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/UseCardRequest.java

@@ -0,0 +1,23 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+/**
+ * 使用会员卡请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class UseCardRequest {
+
+    /**
+     * 扣减的次数
+     */
+    private Integer deductTimes;
+
+    /**
+     * 扣减的金额
+     */
+    private Double deductAmount;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/WechatLoginDto.java

@@ -0,0 +1,29 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import jakarta.validation.constraints.NotBlank;
+
+/**
+ * 微信小程序登录 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-01
+ */
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class WechatLoginDto {
+
+    // 微信小程序登录 code
+    @NotBlank(message = "登录code不能为空")
+    private String code;
+
+    // 手机号code
+    private String phoneCode;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/WechatOfficialEventDto.java

@@ -0,0 +1,35 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+/**
+ * 微信服务号事件 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-01
+ */
+
+@Data
+public class WechatOfficialEventDto {
+
+    // 微信号
+    private String toUserName;
+
+    // 发送方帐号（一个 OpenID）
+    private String fromUserName;
+
+    // 消息创建时间（整型）
+    private Long createTime;
+
+    // 消息类型，event
+    private String msgType;
+
+    // 事件类型：subscribe（关注）/ unsubscribe（取消关注）
+    private String event;
+
+    // 事件 KEY
+    private String eventKey;
+
+    // 二维码 ticket（获取二维码图片）
+    private String ticket;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/BaseEntity.java

@@ -0,0 +1,44 @@
+package cn.novalon.gym.manage.member.entity;
+
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.LastModifiedDate;
+import org.springframework.data.domain.Persistable;
+import org.springframework.data.relational.core.mapping.Column;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员模块实体基类
+ * 
+ * @author 付嘉
+ * @date 2026-05-08
+ */
+@Data
+public abstract class BaseEntity implements Persistable<Long> {
+
+    // ID
+    @Id
+    private Long id;
+
+    // 创建时间
+    @CreatedDate
+    @Column("created_at")
+    private LocalDateTime createdAt;
+
+    // 更新时间
+    @LastModifiedDate
+    @Column("updated_at")
+    private LocalDateTime updatedAt;
+
+    @Column("deleted_at")
+    private LocalDateTime deletedAt;
+
+    // 判断当前实体是否是新建的
+    @Override
+    public boolean isNew() {
+        return createdAt == null;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/Member.java

@@ -0,0 +1,78 @@
+package cn.novalon.gym.manage.member.entity;
+
+import lombok.*;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.Date;
+
+/**
+ * 会员实体类 - 对应 member_user 表 
+ * 
+ * @author 付嘉
+ * @date 2026-05-01
+ */
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+@Table("member_user")
+public class Member extends BaseEntity {
+
+    //会员号
+    @Column("member_no")
+    private String memberNo;
+
+    //昵称
+    @Column("nickname")
+    private String nickname;
+
+    //手机号（AES 加密存储
+    @Column("phone")
+    private String phone;
+
+    //性别
+    @Column("gender")
+    private Integer gender;
+
+    //生日
+    @Column("birthday")
+    private LocalDate birthday;
+
+    //地址
+    @Column("address")
+    private String address;
+
+    //是否关注服务号
+    @Column("subscribed")
+    private Boolean subscribed;
+
+    // 最后登录时间
+    @Column("last_login_at")
+    private LocalDateTime lastLoginAt;
+
+    // 头像
+    @Column("avatar")
+    private String avatar;
+
+    // 微信UnionID
+    @Column("union_id")
+    private String unionId;
+
+    // 微信OpenID小程序
+    @Column("miniapp_open_id")
+    private String miniappOpenId;
+
+    // 服务号openid
+    @Column("official_open_id")
+    private String officialOpenId;
+
+    // 软删除
+    @Column("is_deleted")
+    private Boolean isDeleted;
+
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/MemberCard.java

@@ -1,52 +1,63 @@
-package cn.novalon.gym.manage.gymmembercard.entity;
+package cn.novalon.gym.manage.member.entity;
 
-import cn.novalon.gym.manage.db.entity.BaseEntity;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 
 import java.time.LocalDateTime;
 
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 22:47:31
+/**
+ * 会员卡类型实体 - 对应 member_card 表
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
  */
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
 @Table("member_card")
-public class MemberCardEntity extends BaseEntity {
-    //会员卡id
+public class MemberCard extends BaseEntity {
+
+    // 会员卡ID
     @Column("member_card_id")
     private Long memberCardId;
 
-    //会员卡名称
+    // 会员卡名称
     @Column("member_card_name")
     private String memberCardName;
 
-    //会员卡类型
+    // 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
     @Column("member_card_type")
     private String memberCardType;
 
-    //会员卡价格
+    // 会员卡价格
     @Column("member_card_price")
     private Double memberCardPrice;
 
-    //会员卡有效天数（时长卡用）
+    // 有效天数（时长卡用）
     @Column("member_card_validity_days")
     private Integer memberCardValidityDays;
 
-    //会员卡总次数（次卡用）
+    // 总次数（次卡用）
     @Column("member_card_total_times")
     private Integer memberCardTotalTimes;
 
-    //会员卡面额（储值卡用）
+    // 面额（储值卡用）
     @Column("member_card_amount")
     private Double memberCardAmount;
 
-    //会员卡状态：0-正常，1-禁用
+    // 状态：0-下架, 1-上架
     @Column("member_card_status")
     private Integer memberCardStatus;
 
-    //会员卡创建时间
-    @Column("member_card_create_time")
-    private LocalDateTime memberCardCreateTime;
+    // 扩展配置（JSON格式）
+    @Column("extra_config")
+    private String extraConfig;
+
 }

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/MemberCardRecord.java

@@ -0,0 +1,72 @@
+package cn.novalon.gym.manage.member.entity;
+
+import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡记录实体（会员持有的卡）- 对应 member_card_record 表
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+@Table("member_card_record")
+public class MemberCardRecord extends BaseEntity {
+
+    // 会员持有卡ID
+    @Column("member_card_record_id")
+    private Long memberCardRecordId;
+
+    // 会员ID
+    @Column("member_id")
+    private Long memberId;
+
+    // 关联会员卡ID
+    @Column("member_card_id")
+    private Long memberCardId;
+
+    // 状态：ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款
+    @Column("status")
+    private MemberCardRecordStatus status;
+
+    // 剩余次数
+    @Column("remaining_times")
+    private Integer remainingTimes;
+
+    // 剩余金额
+    @Column("remaining_amount")
+    private Double remainingAmount;
+
+    // 到期时间
+    @Column("expire_time")
+    private LocalDateTime expireTime;
+
+    // 来源订单ID
+    @Column("source_order_id")
+    private Long sourceOrderId;
+
+    // 购买时间
+    @Column("purchase_time")
+    private LocalDateTime purchaseTime;
+
+    // 乐观锁版本号
+    @Column("version")
+    private Integer version;
+
+    // 卡片组成（JSON格式，用于组合卡）
+    @Column("card_composition")
+    private String cardComposition;
+
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/MemberCardTransaction.java

@@ -0,0 +1,77 @@
+package cn.novalon.gym.manage.member.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+/**
+ * 会员卡交易流水实体 - 对应 member_card_transactions 表
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+@Table("member_card_transactions")
+public class MemberCardTransaction extends BaseEntity {
+
+    // 交易ID
+    @Column("member_card_record_id")
+    private Long memberCardRecordId;
+
+    // 会员ID
+    @Column("member_id")
+    private Long memberId;
+
+    // 会员卡ID
+    @Column("member_card_id")
+    private Long memberCardId;
+
+    // 操作类型：PURCHASE-购买, DEDUCT-扣次/扣费, RENEW-续费, REFUND-退款, EXPIRE-过期
+    @Column("operation_type")
+    private String operationType;
+
+    // 变动次数
+    @Column("change_amount")
+    private Integer changeAmount;
+
+    // 变动金额
+    @Column("change_balance")
+    private Double changeBalance;
+
+    // 变动后剩余次数
+    @Column("after_remaining_count")
+    private Integer afterRemainingCount;
+
+    // 变动后剩余金额
+    @Column("after_remaining_balance")
+    private Double afterRemainingBalance;
+
+    // 关联业务类型：GROUP_CLASS-团课, PT_CLASS-私教, CHECK_IN-签到
+    @Column("related_biz_type")
+    private String relatedBizType;
+
+    // 来源订单ID
+    @Column("source_order_id")
+    private Long sourceOrderId;
+
+    // 备注
+    @Column("remark")
+    private String remark;
+
+    // 是否已归档
+    @Column("is_archived")
+    private Boolean isArchived;
+
+    // 归档时间
+    @Column("archived_at")
+    private java.time.LocalDateTime archivedAt;
+
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/RefundApplication.java

@@ -0,0 +1,65 @@
+package cn.novalon.gym.manage.member.entity;
+
+import cn.novalon.gym.manage.member.enums.RefundStatus;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+/**
+ * 退款申请实体 - 对应 refund_application 表
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+@Table("refund_application")
+public class RefundApplication extends BaseEntity {
+
+    // 会员卡记录ID
+    @Column("record_id")
+    private Long recordId;
+
+    // 会员ID
+    @Column("member_id")
+    private Long memberId;
+
+    // 状态：PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败
+    @Column("status")
+    private RefundStatus status;
+
+    // 退款原因
+    @Column("reason")
+    private String reason;
+
+    // 申请时间
+    @Column("apply_time")
+    private LocalDateTime applyTime;
+
+    // 审核时间
+    @Column("audit_time")
+    private LocalDateTime auditTime;
+
+    // 审核人ID
+    @Column("auditor_id")
+    private Long auditorId;
+
+    // 审核备注
+    @Column("audit_remark")
+    private String auditRemark;
+
+    // 退款金额
+    @Column("refund_amount")
+    private BigDecimal refundAmount;
+
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/WechatUser.java

@@ -0,0 +1,55 @@
+package cn.novalon.gym.manage.member.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.LocalDateTime;
+
+/**
+ * 微信用户信息
+ * 
+ * @author 付嘉
+ * @date 2026-05-01
+ */
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+@Table("wechat_user")
+public class WechatUser extends BaseEntity {
+
+    // 会员 ID
+    @Column("member_id")
+    private Long memberId;
+
+    // 微信 UnionID
+    @Column("union_id")
+    private String unionId;
+
+    // 小程序 OpenID
+    @Column("miniapp_openid")
+    private String miniappOpenid;
+
+    // 服务号 OpenID
+    @Column("mp_openid")
+    private String mpOpenid;
+
+    // 是否关注服务号
+    @Column("is_subscribed")
+    private Boolean isSubscribed;
+
+    // 首次关注时间公众号的时间
+    @Column("subscribe_time")
+    private LocalDateTime subscribeTime;
+
+    // 最后一次取消关注的时间
+    @Column("unsubscribe_time")
+    private LocalDateTime unsubscribeTime;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/BizType.java

@@ -0,0 +1,24 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 会员卡流水关联业务类型枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum BizType {
+    
+    GROUP_CLASS("团课"),
+    PT_CLASS("私教"),
+    CHECK_IN("签到");
+
+    private final String desc;
+
+    BizType(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/CardEvent.java

@@ -0,0 +1,27 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 会员卡状态机事件枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum CardEvent {
+    
+    ACTIVATE("激活卡片"),
+    USE("使用卡片"),
+    RENEW("续费"),
+    EXPIRE("过期"),
+    REFUND("退款"),
+    DISABLE("禁用");
+
+    private final String desc;
+
+    CardEvent(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/GenderEnum.java

@@ -0,0 +1,37 @@
+package cn.novalon.gym.manage.member.enums;
+
+import lombok.Getter;
+
+/**
+ * 性别枚举
+ *
+ * @author 付嘉
+ * @date 2026-05-29
+ */
+@Getter
+public enum GenderEnum {
+
+    UNKNOWN(0, "未知"),
+    MALE(1, "男"),
+    FEMALE(2, "女");
+
+    private final Integer code;
+    private final String desc;
+
+    GenderEnum(Integer code, String desc) {
+        this.code = code;
+        this.desc = desc;
+    }
+
+    public static GenderEnum fromCode(Integer code) {
+        if (code == null) {
+            return UNKNOWN;
+        }
+        for (GenderEnum gender : values()) {
+            if (gender.code.equals(code)) {
+                return gender;
+            }
+        }
+        return UNKNOWN;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/MemberCardRecordStatus.java

@@ -0,0 +1,25 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 会员卡记录状态枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum MemberCardRecordStatus {
+    
+    ACTIVE("有效"),
+    USED_UP("用完"),
+    EXPIRED("过期"),
+    REFUNDED("已退款");
+
+    private final String desc;
+
+    MemberCardRecordStatus(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/MemberCardType.java

@@ -0,0 +1,24 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 会员卡类型枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum MemberCardType {
+    
+    TIME_CARD("时长卡"),
+    COUNT_CARD("次卡"),
+    STORED_VALUE_CARD("储值卡");
+
+    private final String desc;
+
+    MemberCardType(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/RefundStatus.java

@@ -0,0 +1,27 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 退款申请状态枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum RefundStatus {
+    
+    PENDING("待审核"),
+    APPROVED("已批准"),
+    REJECTED("已拒绝"),
+    PROCESSING("处理中"),
+    SUCCESS("成功"),
+    FAILED("失败");
+
+    private final String desc;
+
+    RefundStatus(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/TransactionType.java

@@ -0,0 +1,26 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 会员卡流水操作类型枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum TransactionType {
+    
+    PURCHASE("购买"),
+    DEDUCT("扣次/扣费"),
+    RENEW("续费"),
+    REFUND("退款"),
+    EXPIRE("过期");
+
+    private final String desc;
+
+    TransactionType(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/es/entity/MemberES.java

@@ -0,0 +1,41 @@
+package cn.novalon.gym.manage.member.es.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.elasticsearch.annotations.Document;
+import org.springframework.data.elasticsearch.annotations.Field;
+import org.springframework.data.elasticsearch.annotations.FieldType;
+
+import java.time.LocalDateTime;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Document(indexName = "gym_members")
+public class MemberES {
+
+    @Id
+    private String id;
+
+    // 会员号 - 需要搜索（精确匹配）
+    @Field(type = FieldType.Keyword)
+    private String memberNo;
+
+    // 昵称 - 需要搜索（模糊搜索）
+    @Field(type = FieldType.Text)
+    private String nickname;
+
+    // 手机号 - 需要搜索（精确匹配）
+    @Field(type = FieldType.Keyword)
+    private String phone;
+
+    // 性别 - 用于筛选
+    @Field(type = FieldType.Integer)
+    private Integer gender;
+
+    // 头像 - 列表展示
+    @Field(type = FieldType.Keyword)
+    private String avatar;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/es/repository/MemberESRepository.java

@@ -0,0 +1,21 @@
+package cn.novalon.gym.manage.member.es.repository;
+
+import cn.novalon.gym.manage.member.es.entity.MemberES;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.elasticsearch.annotations.Query;
+import org.springframework.data.elasticsearch.repository.ReactiveElasticsearchRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+
+/**
+ * ES 会员数据访问层
+ */
+@Repository
+public interface MemberESRepository extends ReactiveElasticsearchRepository<MemberES, String> {
+
+    /**
+     * 前台通用搜索：会员号（精确匹配） 或 昵称（模糊匹配） 或 手机号（精确匹配）并且 性别筛选（精确匹配）
+     */
+    Flux<MemberES> findByMemberNoOrPhoneOrNicknameContaining(
+            String memberNo, String phone, String nickname, Pageable pageable);
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/DistributedLockService.java

@@ -0,0 +1,50 @@
+package cn.novalon.gym.manage.member.handler;
+
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * 分布式锁服务（简化版，使用本地锁）
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Component
+public class DistributedLockService {
+
+    private final ConcurrentHashMap<String, ReentrantLock> locks = new ConcurrentHashMap<>();
+
+    /**
+     * 执行带锁的操作（业务操作）
+     */
+    public <T> Mono<T> executeWithLock(String userId, String cardType, Mono<T> operation) {
+        String lockKey = "lock:member:card:operation:" + userId + ":" + cardType;
+        ReentrantLock lock = locks.computeIfAbsent(lockKey, k -> new ReentrantLock());
+
+        lock.lock();
+        try {
+            return operation.doFinally(signalType -> lock.unlock());
+        } catch (Exception e) {
+            lock.unlock();
+            return Mono.error(e);
+        }
+    }
+
+    /**
+     * 执行带锁的操作（通用/定时任务）
+     */
+    public <T> Mono<T> executeWithLock(String lockKey, Mono<T> operation) {
+        ReentrantLock lock = locks.computeIfAbsent(lockKey, k -> new ReentrantLock());
+
+        lock.lock();
+        try {
+            return operation.doFinally(signalType -> lock.unlock());
+        } catch (Exception e) {
+            lock.unlock();
+            return Mono.error(e);
+        }
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/ExpirationReminderService.java

@@ -0,0 +1,157 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Range;
+import org.springframework.data.redis.connection.RedisZSetCommands;
+import org.springframework.data.redis.core.ReactiveStringRedisTemplate;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+/**
+ * 会员卡到期提醒服务
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class ExpirationReminderService {
+
+    private final ReactiveStringRedisTemplate redisTemplate;
+    private final ObjectMapper objectMapper;
+
+    private static final String REMINDER_QUEUE = "queue:member_card_expiration";
+    private static final String DEAD_LETTER_QUEUE = "queue:member_card_expiration_dead_letter";
+    private static final int REMINDER_DAYS_BEFORE = 7;
+    private static final long MAX_DELAY_MILLIS = Duration.ofDays(365).toMillis();
+
+    /**
+     * 设置到期提醒（购卡/续费时调用）
+     */
+    public Mono<Void> scheduleExpirationReminder(MemberCardRecord record) {
+        if (record.getExpireTime() == null) {
+            return Mono.empty();
+        }
+
+        LocalDateTime now = LocalDateTime.now();
+
+        Flux<Void> reminderFlux = Flux.range(1, REMINDER_DAYS_BEFORE)
+            .flatMap(daysBefore -> {
+                LocalDateTime reminderTime = record.getExpireTime().minusDays(daysBefore);
+
+                if (reminderTime.isBefore(now)) {
+                    log.debug("会员卡记录ID={} 的{}天前提醒时间已过，跳过",
+                        record.getMemberCardRecordId(), daysBefore);
+                    return Mono.empty();
+                }
+
+                long delayMillis = Duration.between(now, reminderTime).toMillis();
+
+                if (delayMillis > MAX_DELAY_MILLIS) {
+                    log.warn("会员卡记录ID={} 的{}天后提醒时间超过1年，跳过",
+                        record.getMemberCardRecordId(), daysBefore);
+                    return Mono.empty();
+                }
+
+                try {
+                    String messageId = UUID.randomUUID().toString();
+                    String message = objectMapper.writeValueAsString(new ExpirationMessage(
+                            messageId,
+                            record.getMemberCardRecordId(),
+                            record.getMemberId(),
+                            record.getExpireTime(),
+                            daysBefore
+                    ));
+
+                    double executeTime = System.currentTimeMillis() + delayMillis;
+
+                    return redisTemplate.opsForZSet()
+                            .add(REMINDER_QUEUE, message, executeTime)
+                            .doOnSuccess(v -> log.info("设置会员卡到期提醒: recordId={}, daysBefore={}, expireTime={}, executeTime={}",
+                                    record.getMemberCardRecordId(), daysBefore, record.getExpireTime(), executeTime))
+                            .then();
+                } catch (Exception e) {
+                    log.error("设置会员卡到期提醒失败: recordId={}, daysBefore={}",
+                        record.getMemberCardRecordId(), daysBefore, e);
+                    return Mono.error(e);
+                }
+            });
+
+        return reminderFlux.then();
+    }
+
+    /**
+     * 定时任务：每分钟扫描到期的提醒并发送
+     */
+    @Scheduled(fixedRate = 60000)
+    public void processDueReminders() {
+        double now = System.currentTimeMillis();
+
+        redisTemplate.opsForZSet()
+                .rangeByScoreWithScores(
+                        REMINDER_QUEUE,
+                        Range.from(Range.Bound.inclusive(0.0))
+                                .to(Range.Bound.inclusive(now)),
+                        RedisZSetCommands.Limit.limit().count(100)
+                )
+                .flatMap(tuple -> {
+                    String message = tuple.getValue();
+                    if (message == null) {
+                        return Mono.empty();
+                    }
+
+                    return Mono.fromCallable(() -> objectMapper.readValue(message, ExpirationMessage.class))
+                        .flatMap(expirationMessage -> {
+                            log.info("处理到期提醒: messageId={}, memberId={}, expireTime={}, daysBefore={}",
+                                    expirationMessage.messageId(),
+                                    expirationMessage.memberId(),
+                                    expirationMessage.expireTime(),
+                                    expirationMessage.daysBefore());
+
+                            // TODO: 集成微信/短信通知服务
+                            sendNotification(expirationMessage);
+
+                            return redisTemplate.opsForZSet()
+                                .remove(REMINDER_QUEUE, message)
+                                .doOnSuccess(removed -> {
+                                    if (removed > 0) {
+                                        log.info("成功删除已处理的提醒消息");
+                                    }
+                                });
+                        })
+                        .onErrorResume(e -> {
+                            log.error("解析到期提醒消息失败，移至死信队列: message={}", message, e);
+                            return redisTemplate.opsForZSet()
+                                .add(DEAD_LETTER_QUEUE, message, System.currentTimeMillis())
+                                .then(Mono.empty());
+                        });
+                })
+                .then()
+                .subscribe();
+    }
+
+
+    private void sendNotification(ExpirationMessage reminder) {
+        // TODO: 实际项目中调用微信模板消息或短信API
+        log.info("[模拟发送] 会员卡到期提醒 - 会员ID: {}, 到期时间: {}, 提前天数: {}",
+            reminder.memberId(), reminder.expireTime(), reminder.daysBefore());
+    }
+
+    public record ExpirationMessage(
+            String messageId,
+            Long recordId,
+            Long memberId,
+            LocalDateTime expireTime,
+            int daysBefore
+    ) {}
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberCardHandler.java

@@ -0,0 +1,132 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.service.IMemberCardService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.http.HttpStatus;
+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;
+
+/**
+ * 会员卡管理处理器
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Slf4j
+@Component
+@Tag(name = "会员卡管理", description = "会员卡类型管理和会员持卡管理")
+public class MemberCardHandler {
+
+    private final IMemberCardService memberCardService;
+
+    public MemberCardHandler(IMemberCardService memberCardService) {
+        this.memberCardService = memberCardService;
+    }
+
+    @Operation(summary = "根据ID查询会员卡类型", description = "查询指定ID的会员卡类型详情")
+    public Mono<ServerResponse> getMemberCardById(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+        return memberCardService.findByMemberCardIdAndDeletedAtIsNull(id)
+                .flatMap(card -> ServerResponse.ok().bodyValue(card))
+                .switchIfEmpty(ServerResponse.notFound().build());
+    }
+
+    @Operation(summary = "查询会员卡类型列表", description = "支持分页和条件查询")
+    public Mono<ServerResponse> listMemberCards(ServerRequest request) {
+        Integer status = request.queryParam("status").map(Integer::valueOf).orElse(null);
+        String name = request.queryParam("name").orElse(null);
+        String type = request.queryParam("type").orElse(null);
+        Double minPrice = request.queryParam("minPrice").map(Double::valueOf).orElse(null);
+        Double maxPrice = request.queryParam("maxPrice").map(Double::valueOf).orElse(null);
+        int page = request.queryParam("page").map(Integer::valueOf).orElse(0);
+        int size = request.queryParam("size").map(Integer::valueOf).orElse(10);
+
+        var pageable = PageRequest.of(page, size);
+        return ServerResponse.ok()
+                .body(memberCardService.findWithConditions(status, name, type, minPrice, maxPrice, pageable),
+                        MemberCard.class);
+    }
+
+    @Operation(summary = "创建会员卡类型", description = "创建新的会员卡类型（时长卡、次卡或储值卡）")
+    public Mono<ServerResponse> createMemberCard(ServerRequest request) {
+        return request.bodyToMono(MemberCard.class)
+                .flatMap(memberCardService::save)
+                .flatMap(card -> ServerResponse.status(HttpStatus.CREATED).bodyValue(card));
+    }
+
+    @Operation(summary = "更新会员卡类型", description = "更新会员卡类型信息")
+    public Mono<ServerResponse> updateMemberCard(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+        return request.bodyToMono(MemberCard.class)
+                .flatMap(card -> {
+                    card.setMemberCardId(id);
+                    return memberCardService.save(card);
+                })
+                .flatMap(updated -> ServerResponse.ok().bodyValue(updated))
+                .switchIfEmpty(ServerResponse.notFound().build());
+    }
+
+    @Operation(summary = "删除会员卡类型", description = "逻辑删除会员卡类型")
+    public Mono<ServerResponse> deleteMemberCard(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+        return memberCardService.logicalDelete(id)
+                .flatMap(rows -> {
+                    if (rows > 0) {
+                        return ServerResponse.noContent().build();
+                    }
+                    return ServerResponse.notFound().build();
+                });
+    }
+
+    @Operation(summary = "购买会员卡", description = "会员购买会员卡，生成会员卡记录")
+    public Mono<ServerResponse> purchaseCard(ServerRequest request) {
+        Long memberId = Long.valueOf(request.queryParam("memberId").orElseThrow());
+        Long memberCardId = Long.valueOf(request.queryParam("memberCardId").orElseThrow());
+        Long sourceOrderId = request.queryParam("sourceOrderId").map(Long::valueOf).orElse(null);
+
+        return memberCardService.purchaseCard(memberId, memberCardId, sourceOrderId)
+                .flatMap(record -> ServerResponse.status(HttpStatus.CREATED).bodyValue(record));
+    }
+
+    @Operation(summary = "续费会员卡", description = "为已有会员卡续费")
+    public Mono<ServerResponse> renewCard(ServerRequest request) {
+        Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
+        Integer addTimes = request.queryParam("addTimes").map(Integer::valueOf).orElse(null);
+        Double addAmount = request.queryParam("addAmount").map(Double::valueOf).orElse(null);
+        Integer addDays = request.queryParam("addDays").map(Integer::valueOf).orElse(null);
+        Long sourceOrderId = request.queryParam("sourceOrderId").map(Long::valueOf).orElse(null);
+
+        return memberCardService.renewCard(recordId, addTimes, addAmount, addDays, sourceOrderId)
+                .flatMap(record -> ServerResponse.ok().bodyValue(record));
+    }
+
+    @Operation(summary = "使用会员卡", description = "扣减会员卡次数或余额")
+    public Mono<ServerResponse> useCard(ServerRequest request) {
+        Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
+        Integer deductTimes = request.queryParam("deductTimes").map(Integer::valueOf).orElse(null);
+        Double deductAmount = request.queryParam("deductAmount").map(Double::valueOf).orElse(null);
+
+        return memberCardService.useCard(recordId, deductTimes, deductAmount)
+                .flatMap(record -> ServerResponse.ok().bodyValue(record));
+    }
+
+    @Operation(summary = "退款会员卡", description = "申请会员卡退款")
+    public Mono<ServerResponse> refundCard(ServerRequest request) {
+        Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
+        return memberCardService.refundCard(recordId)
+                .then(ServerResponse.noContent().build());
+    }
+
+    @Operation(summary = "查询有效会员卡", description = "查询指定状态的会员卡类型")
+    public Mono<ServerResponse> getActiveCards(ServerRequest request) {
+        Integer status = request.queryParam("status").map(Integer::valueOf).orElse(1);
+        return ServerResponse.ok()
+                .body(memberCardService.findActiveCards(status), MemberCard.class);
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberCardRecordHandler.java

@@ -0,0 +1,118 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
+import cn.novalon.gym.manage.member.service.IMemberCardService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.Data;
+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;
+
+/**
+ * 会员卡记录管理处理器
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Component
+@Tag(name = "会员卡记录管理", description = "会员卡购买、续费、使用、退款等核心业务")
+public class MemberCardRecordHandler {
+
+    private final IMemberCardService memberCardService;
+    private final IMemberCardRecordService memberCardRecordService;
+
+    public MemberCardRecordHandler(IMemberCardService memberCardService,
+                                   IMemberCardRecordService memberCardRecordService) {
+        this.memberCardService = memberCardService;
+        this.memberCardRecordService = memberCardRecordService;
+    }
+
+    @Operation(summary = "购买会员卡", description = "支持时长卡、次卡、储值卡，自动设置到期提醒")
+    public Mono<ServerResponse> purchaseCard(ServerRequest request) {
+        return request.bodyToMono(PurchaseRequest.class)
+                .flatMap(body -> memberCardService.purchaseCard(
+                        body.getMemberId(),
+                        body.getMemberCardId(),
+                        body.getSourceOrderId()))
+                .flatMap(record -> ServerResponse.ok().bodyValue(record))
+                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("购买失败: " + e.getMessage()));
+    }
+
+    @Operation(summary = "续费会员卡", description = "累加剩余次数/余额，顺延到期日期，权益立即生效")
+    public Mono<ServerResponse> renewCard(ServerRequest request) {
+        Long recordId = Long.parseLong(request.pathVariable("recordId"));
+        return request.bodyToMono(RenewRequest.class)
+                .flatMap(body -> memberCardService.renewCard(recordId,
+                        body.getAddTimes(),
+                        body.getAddAmount(),
+                        body.getAddDays(),
+                        body.getSourceOrderId()))
+                .flatMap(record -> ServerResponse.ok().bodyValue(record))
+                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("续费失败: " + e.getMessage()));
+    }
+
+    @Operation(summary = "使用会员卡", description = "预约团课或私教成功后扣减次数或余额")
+    public Mono<ServerResponse> useCard(ServerRequest request) {
+        Long recordId = Long.parseLong(request.pathVariable("recordId"));
+        return request.bodyToMono(UseCardRequest.class)
+                .flatMap(body -> memberCardService.useCard(recordId,
+                        body.getDeductTimes(),
+                        body.getDeductAmount()))
+                .flatMap(record -> ServerResponse.ok().bodyValue(record))
+                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("使用失败: " + e.getMessage()));
+    }
+
+    @Operation(summary = "退款会员卡", description = "使用Saga模式执行退款流程，保证事务一致性")
+    public Mono<ServerResponse> refundCard(ServerRequest request) {
+        Long recordId = Long.parseLong(request.pathVariable("recordId"));
+        return memberCardService.refundCard(recordId)
+                .then(ServerResponse.ok().bodyValue("退款成功"))
+                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("退款失败: " + e.getMessage()));
+    }
+
+    @Operation(summary = "查询会员卡记录详情", description = "根据记录ID查询详细信息")
+    public Mono<ServerResponse> getMemberCardRecordById(ServerRequest request) {
+        Long recordId = Long.parseLong(request.pathVariable("recordId"));
+        return memberCardRecordService.findById(recordId)
+                .flatMap(record -> ServerResponse.ok().bodyValue(record))
+                .switchIfEmpty(ServerResponse.notFound().build());
+    }
+
+    @Operation(summary = "会员我的卡包", description = "查询当前会员的所有有效卡")
+    public Mono<ServerResponse> getMyCards(ServerRequest request) {
+        Long memberId = Long.parseLong(request.pathVariable("memberId"));
+        return ServerResponse.ok().body(
+                memberCardRecordService.findActiveCardsByMemberId(memberId),
+                MemberCardRecord.class);
+    }
+
+    @Operation(summary = "处理过期会员卡", description = "定时任务调用，扫描并更新过期卡状态")
+    public Mono<ServerResponse> processExpiredCards(ServerRequest request) {
+        return memberCardService.processExpiredCards()
+                .flatMap(count -> ServerResponse.ok().bodyValue("处理完成，共处理" + count + "条"));
+    }
+
+    @Data
+    public static class PurchaseRequest {
+        private Long memberId;
+        private Long memberCardId;
+        private Long sourceOrderId;
+    }
+
+    @Data
+    public static class UseCardRequest {
+        private Integer deductTimes;
+        private Double deductAmount;
+    }
+
+    @Data
+    public static class RenewRequest {
+        private Integer addTimes;
+        private Double addAmount;
+        private Integer addDays;
+        private Long sourceOrderId;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberCardScheduledHandler.java

@@ -0,0 +1,102 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.enums.CardEvent;
+import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡定时任务处理器
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class MemberCardScheduledHandler {
+
+    private final MemberCardRecordRepository recordRepository;
+    private final ExpirationReminderService expirationReminderService;
+    private final MemberCardStateMachine stateMachine;
+    private final DistributedLockService distributedLockService;
+
+    /**
+     * 每日凌晨2点检查过期会员卡
+     */
+    @Scheduled(cron = "0 0 2 * * ?")
+    public void checkExpiredCards() {
+        String lockKey = "scheduled:check_expired_cards";
+
+        distributedLockService.executeWithLock("SYSTEM", "EXPIRE_CHECK",
+            Mono.fromRunnable(() -> {
+                log.info("开始执行会员卡过期检查任务");
+
+                LocalDateTime now = LocalDateTime.now();
+
+                recordRepository.findActiveRecords()
+                    .filter(record -> record.getExpireTime() != null && record.getExpireTime().isBefore(now))
+                    .flatMap(record ->
+                            stateMachine.transition(record.getStatus(), CardEvent.EXPIRE)
+                                    .flatMap(newState -> {
+                                        record.setStatus(newState);
+                                        return recordRepository.save(record);
+                                    })
+                                .doOnSuccess(r -> log.info("会员卡记录ID={} 已标记为过期", r.getMemberCardRecordId()))
+                                .onErrorResume(e -> {
+                                    log.error("处理会员卡过期失败: recordId={}", record.getMemberCardRecordId(), e);
+                                    return Mono.empty();
+                                })
+                        )
+                        .then()
+                        .subscribe();
+            })
+        ).subscribe();
+    }
+
+    /**
+     * 每日凌晨3点检查是否有遗漏的到期提醒（兜底机制）
+     */
+    @Scheduled(cron = "0 0 3 * * ?")
+    public void checkAndSendExpirationReminders() {
+        String lockKey = "scheduled:expiration_reminder";
+
+        distributedLockService.executeWithLock("SYSTEM", "REMINDER_CHECK",
+            Mono.fromRunnable(() -> {
+                log.info("开始执行到期提醒兜底检查任务");
+
+                LocalDateTime now = LocalDateTime.now();
+
+                // 查询所有活跃的会员卡
+                recordRepository.findActiveRecords()
+                    .filter(record -> record.getExpireTime() != null)
+                    .flatMap(record -> {
+                        try {
+                            // 计算距离到期还有几天
+                            long daysBetween = java.time.Duration.between(now, record.getExpireTime()).toDays();
+
+                            // 如果到期时间在1-7天范围内，记录日志供人工检查
+                            if (daysBetween >= 1 && daysBetween <= 7) {
+                                log.warn("发现到期前{}天的会员卡记录ID={}，请确认是否已发送提醒",
+                                    daysBetween, record.getMemberCardRecordId());
+                            }
+
+                            return Mono.empty();
+                        } catch (Exception e) {
+                            log.error("检查到期提醒失败: recordId={}", record.getMemberCardRecordId(), e);
+                            return Mono.empty();
+                        }
+                    })
+                    .then()
+                    .subscribe();
+            })
+        ).subscribe();
+
+        log.info("到期提醒兜底检查任务完成");
+    }
+}