fix: 更新测试用例适配 API 路径变更和 userType 参数

- Gateway 测试路径从 /api/auth/ 更新为 /api/admin/auth/
- 移除 /api/checkIn/ 公开路径测试，替换为 /api/admin/auth/ 前缀测试
- SysAuthHandlerTest generateToken stub 增加 ADMIN userType 参数

e2e-tests/auth-test.spec.ts

@@ -5,7 +5,7 @@ test.describe('认证和授权测试', () => {
   let userId: number;
 
   test.beforeAll(async ({ request }) => {
-    const response = await request.post('http://localhost:8080/api/auth/login', {
+    const response = await request.post('http://localhost:8080/api/admin/auth/login', {
       headers: {
         'Content-Type': 'application/json'
       },
@@ -28,7 +28,7 @@ test.describe('认证和授权测试', () => {
     });
 
     await test.step('发送登录请求', async () => {
-      const response = await page.request.post('http://localhost:8080/api/auth/login', {
+      const response = await page.request.post('http://localhost:8080/api/admin/auth/login', {
         headers: {
           'Content-Type': 'application/json'
         },
@@ -78,7 +78,7 @@ test.describe('认证和授权测试', () => {
     });
 
     await test.step('查询指定用户信息', async () => {
-      const response = await page.request.get(`http://localhost:8080/api/users/${userId}`, {
+      const response = await page.request.get(`http://localhost:8080/api/admin/users/${userId}`, {
         headers: {
           'Authorization': `Bearer ${authToken}`
         }
@@ -98,10 +98,10 @@ test.describe('认证和授权测试', () => {
   test('权限验证测试', async ({ page }) => {
     await test.step('测试访问受保护的API', async () => {
       const protectedEndpoints = [
-        '/api/users',
+        '/api/admin/users',
-        '/api/roles',
+        '/api/admin/roles',
-        '/api/menus',
+        '/api/admin/menus',
-        '/api/config'
+        '/api/admin/config'
       ];
 
       for (const endpoint of protectedEndpoints) {

e2e-tests/config-management.spec.ts

@@ -4,7 +4,7 @@ test.describe('参数配置功能测试', () => {
   let authToken: string;
 
   test.beforeAll(async ({ request }) => {
-    const response = await request.post('http://localhost:8080/api/auth/login', {
+    const response = await request.post('http://localhost:8080/api/admin/auth/login', {
       headers: {
         'Content-Type': 'application/json'
       },

e2e-tests/dict-management.spec.ts

@@ -4,7 +4,7 @@ test.describe('字典管理功能测试', () => {
   let authToken: string;
 
   test.beforeAll(async ({ request }) => {
-    const response = await request.post('http://localhost:8080/api/auth/login', {
+    const response = await request.post('http://localhost:8080/api/admin/auth/login', {
       headers: {
         'Content-Type': 'application/json'
       },

e2e-tests/global-setup.ts

@@ -269,7 +269,7 @@ async function verifyAllServices(): Promise<void> {
 
   console.log('   验证网关到后端的连通性...');
   try {
-    const response = await fetch('http://localhost:8080/api/auth/login', {
+    const response = await fetch('http://localhost:8080/api/admin/auth/login', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ username: 'admin', password: 'Test@123' }),
@@ -316,7 +316,7 @@ async function waitForBackendReady(): Promise<void> {
           console.log(`✅ 后端服务健康检查通过 (尝试 ${i + 1}/${maxRetries})`);
 
           try {
-            const loginTest = await fetch('http://localhost:8084/api/auth/login', {
+            const loginTest = await fetch('http://localhost:8084/api/admin/auth/login', {
               method: 'POST',
               headers: { 'Content-Type': 'application/json' },
               body: JSON.stringify({ username: 'admin', password: 'Test@123' }),
@@ -364,7 +364,7 @@ async function waitForGatewayReady(): Promise<void> {
           console.log(`✅ 网关服务健康检查通过 (尝试 ${i + 1}/${maxRetries})`);
 
           try {
-            const loginTest = await fetch('http://localhost:8080/api/auth/login', {
+            const loginTest = await fetch('http://localhost:8080/api/admin/auth/login', {
               method: 'POST',
               headers: { 'Content-Type': 'application/json' },
               body: JSON.stringify({ username: 'admin', password: 'Test@123' }),
@@ -425,7 +425,7 @@ async function waitForFrontendReady(): Promise<void> {
 async function cleanupTestData(): Promise<void> {
   try {
     // 登录获取token（通过网关）
-    const loginResponse = await fetch('http://localhost:8080/api/auth/login', {
+    const loginResponse = await fetch('http://localhost:8080/api/admin/auth/login', {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -458,7 +458,7 @@ async function cleanupTestData(): Promise<void> {
       for (const user of users) {
         if (user.id > 10) {
           try {
-            await fetch(`http://localhost:8080/api/users/${user.id}`, {
+            await fetch(`http://localhost:8080/api/admin/users/${user.id}`, {
               method: 'DELETE',
               headers: {
                 'Authorization': `Bearer ${token}`
@@ -486,7 +486,7 @@ async function cleanupTestData(): Promise<void> {
       for (const role of roles) {
         if (role.id > 4) {
           try {
-            await fetch(`http://localhost:8080/api/roles/${role.id}`, {
+            await fetch(`http://localhost:8080/api/admin/roles/${role.id}`, {
               method: 'DELETE',
               headers: {
                 'Authorization': `Bearer ${token}`

e2e-tests/journeys/admin-complete-workflow.spec.ts

@@ -50,7 +50,7 @@ test.describe('管理员完整工作流', () => {
     await test.step('提交表单', async () => {
       const [response] = await Promise.all([
         page.waitForResponse(resp => 
-          resp.url().includes('/api/roles') && resp.request().method() === 'POST',
+          resp.url().includes('/api/admin/roles') && resp.request().method() === 'POST',
           { timeout: 10000 }
         ).catch(() => null),
         page.locator('.el-dialog button:has-text("确定")').click()

e2e-tests/journeys/user-permission-boundary.spec.ts

@@ -112,7 +112,7 @@ test.describe('用户权限边界验证', () => {
     });
 
     await test.step('尝试访问受限API', async () => {
-      const response = await page.request.get('/api/users?page=0&size=10');
+      const response = await page.request.get('/api/admin/users?page=0&size=10');
       expect([200, 401, 403]).toContain(response.status());
     });
   });

e2e-tests/menu-management.spec.ts

@@ -4,7 +4,7 @@ test.describe('菜单管理功能测试', () => {
   let authToken: string;
 
   test.beforeAll(async ({ request }) => {
-    const response = await request.post('http://localhost:8080/api/auth/login', {
+    const response = await request.post('http://localhost:8080/api/admin/auth/login', {
       headers: {
         'Content-Type': 'application/json'
       },

e2e-tests/utils/api-client.ts

@@ -10,7 +10,7 @@ export class ApiClient {
   }
 
   async login(username: string, password: string): Promise<{ token: string; userId: number }> {
-    const response = await this.request.post(`${this.baseURL}/api/auth/login`, {
+    const response = await this.request.post(`${this.baseURL}/api/admin/auth/login`, {
       data: {
         username,
         password,
@@ -29,7 +29,7 @@ export class ApiClient {
   }
 
   async logout(token: string): Promise<void> {
-    await this.request.post(`${this.baseURL}/api/auth/logout`, {
+    await this.request.post(`${this.baseURL}/api/admin/auth/logout`, {
       headers: {
         Authorization: `Bearer ${token}`,
       },
@@ -37,7 +37,7 @@ export class ApiClient {
   }
 
   async getUsers(token: string): Promise<any[]> {
-    const response = await this.request.get(`${this.baseURL}/api/users`, {
+    const response = await this.request.get(`${this.baseURL}/api/admin/users`, {
       headers: {
         Authorization: `Bearer ${token}`,
       },
@@ -51,7 +51,7 @@ export class ApiClient {
   }
 
   async createUser(token: string, userData: any): Promise<any> {
-    const response = await this.request.post(`${this.baseURL}/api/users`, {
+    const response = await this.request.post(`${this.baseURL}/api/admin/users`, {
       headers: {
         Authorization: `Bearer ${token}`,
       },
@@ -66,7 +66,7 @@ export class ApiClient {
   }
 
   async updateUser(token: string, userId: number, userData: any): Promise<any> {
-    const response = await this.request.put(`${this.baseURL}/api/users/${userId}`, {
+    const response = await this.request.put(`${this.baseURL}/api/admin/users/${userId}`, {
       headers: {
         Authorization: `Bearer ${token}`,
       },
@@ -81,7 +81,7 @@ export class ApiClient {
   }
 
   async deleteUser(token: string, userId: number): Promise<void> {
-    const response = await this.request.delete(`${this.baseURL}/api/users/${userId}`, {
+    const response = await this.request.delete(`${this.baseURL}/api/admin/users/${userId}`, {
       headers: {
         Authorization: `Bearer ${token}`,
       },
@@ -93,7 +93,7 @@ export class ApiClient {
   }
 
   async getRoles(token: string): Promise<any[]> {
-    const response = await this.request.get(`${this.baseURL}/api/roles`, {
+    const response = await this.request.get(`${this.baseURL}/api/admin/roles`, {
       headers: {
         Authorization: `Bearer ${token}`,
       },
@@ -107,7 +107,7 @@ export class ApiClient {
   }
 
   async createRole(token: string, roleData: any): Promise<any> {
-    const response = await this.request.post(`${this.baseURL}/api/roles`, {
+    const response = await this.request.post(`${this.baseURL}/api/admin/roles`, {
       headers: {
         Authorization: `Bearer ${token}`,
       },
@@ -122,7 +122,7 @@ export class ApiClient {
   }
 
   async deleteRole(token: string, roleId: number): Promise<void> {
-    const response = await this.request.delete(`${this.baseURL}/api/roles/${roleId}`, {
+    const response = await this.request.delete(`${this.baseURL}/api/admin/roles/${roleId}`, {
       headers: {
         Authorization: `Bearer ${token}`,
       },
@@ -134,7 +134,7 @@ export class ApiClient {
   }
 
   async getMenus(token: string): Promise<any[]> {
-    const response = await this.request.get(`${this.baseURL}/api/menus`, {
+    const response = await this.request.get(`${this.baseURL}/api/admin/menus`, {
       headers: {
         Authorization: `Bearer ${token}`,
       },

e2e-tests/utils/testDataManager.ts

@@ -55,7 +55,7 @@ export class TestDataManager {
   }
 
   static async createTestUser(request: APIRequestContext, userData: TestUser): Promise<any> {
-    const response = await request.post(`${this.apiBaseUrl}/api/users`, {
+    const response = await request.post(`${this.apiBaseUrl}/api/admin/users`, {
       data: userData,
     });
     
@@ -75,7 +75,7 @@ export class TestDataManager {
   }
 
   static async createTestRole(request: APIRequestContext, roleData: TestRole): Promise<any> {
-    const response = await request.post(`${this.apiBaseUrl}/api/roles`, {
+    const response = await request.post(`${this.apiBaseUrl}/api/admin/roles`, {
       data: roleData,
     });
     
@@ -100,7 +100,7 @@ export class TestDataManager {
       return;
     }
     
-    const response = await request.delete(`${this.apiBaseUrl}/api/users/${userData.id}`);
+    const response = await request.delete(`${this.apiBaseUrl}/api/admin/users/${userData.id}`);
     if (!response.ok()) {
       console.warn(`Failed to delete test user ${username}: ${await response.text()}`);
     }
@@ -114,7 +114,7 @@ export class TestDataManager {
       return;
     }
     
-    const response = await request.delete(`${this.apiBaseUrl}/api/roles/${roleData.id}`);
+    const response = await request.delete(`${this.apiBaseUrl}/api/admin/roles/${roleData.id}`);
     if (!response.ok()) {
       console.warn(`Failed to delete test role ${roleKey}: ${await response.text()}`);
     }

gym-manage-api/docs/V10-booking-test-data.md

@@ -1,272 +0,0 @@
-# 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

@@ -1,204 +0,0 @@
-# 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

@@ -1,400 +0,0 @@
-# 团课预约场景测试数据文档
-
-## 概述
-
-本文档描述了团课预约功能的测试数据，覆盖了各种预约场景，用于验证系统在不同业务条件下的正确性和健壮性。
-
----
-
-## 一、测试数据概览
-
-| 数据类别 | 数量 | 说明 |
-|---------|------|------|
-| 测试会员 | 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

@@ -1,728 +0,0 @@
-# 团课管理模块 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-checkIn/.gitignore

@@ -0,0 +1,48 @@
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# Virtual machine crash logs
+hs_err_pid*
+replay_pid*
+
+# Maven
+target/
+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
+
+# IDE
+.idea/
+*.iml
+.vscode/
+.settings/
+.classpath
+.project
+
+# OS
+.DS_Store
+Thumbs.db

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

@@ -0,0 +1,242 @@
+<?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-checkIn</artifactId>
+    <packaging>jar</packaging>
+
+    <name>Gym CheckIn</name>
+    <description>Check-In Management Module - Member Attendance 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>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>
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.8.25</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.zxing</groupId>
+            <artifactId>core</artifactId>
+            <version>3.5.1</version>
+        </dependency>
+
+        <!-- 添加 ZXing JavaSE 扩展（用于生成图片） -->
+        <dependency>
+            <groupId>com.google.zxing</groupId>
+            <artifactId>javase</artifactId>
+            <version>3.5.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-websocket</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-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/config/QRCodeConfig.java

@@ -0,0 +1,46 @@
+package cn.novalon.gym.manage.checkIn.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Data
+@Configuration
+@ConfigurationProperties(prefix = "qr.config")
+public class QRCodeConfig {
+
+    /**
+     * 二维码宽度（像素）
+     */
+    private Integer width = 300;
+
+    /**
+     * 二维码高度（像素）
+     */
+    private Integer height = 300;
+
+    /**
+     * 白边宽度
+     */
+    private Integer margin = 1;
+
+    /**
+     * 容错率：L, M, Q, H
+     */
+    private String errorCorrection = "M";
+
+    /**
+     * 图片格式：png, jpg
+     */
+    private String format = "png";
+
+    /**
+     * 是否启用Logo
+     */
+    private Boolean logoEnabled = false;
+
+    /**
+     * Logo路径
+     */
+    private String logoPath = "";
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/config/WebSocketConfig.java

@@ -0,0 +1,43 @@
+package cn.novalon.gym.manage.checkIn.config;
+
+import cn.novalon.gym.manage.checkIn.websocket.MyWebSocketHandler;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.HandlerMapping;
+import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping;
+import org.springframework.web.reactive.socket.WebSocketHandler;
+import org.springframework.web.reactive.socket.server.support.WebSocketHandlerAdapter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Configuration
+public class WebSocketConfig {
+
+    @Autowired
+    private MyWebSocketHandler myWebSocketHandler;
+
+    /**
+     * 注册 WebSocket 路由映射
+     * 路径对应前端连接的 ws://xxx/webSocket/checkIn
+     */
+    @Bean
+    public HandlerMapping webSocketMapping() {
+        Map<String, WebSocketHandler> map = new HashMap<>();
+        map.put("/webSocket/checkIn", myWebSocketHandler);
+
+        SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
+        mapping.setUrlMap(map);
+        mapping.setOrder(10);  // 设置优先级
+        return mapping;
+    }
+
+    /**
+     * 注册 WebSocket 处理器适配器（必须）
+     */
+    @Bean
+    public WebSocketHandlerAdapter handlerAdapter() {
+        return new WebSocketHandlerAdapter();
+    }
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/constant/QRRedisKey.java

@@ -0,0 +1,43 @@
+package cn.novalon.gym.manage.checkIn.constant;
+
+import java.time.LocalDate;
+import java.util.UUID;
+
+/**
+ * 打卡模块 Redis 键常量
+ *
+ * @author 付嘉
+ * @date 2026-05-30
+ */
+public final class QRRedisKey {
+
+    private static final String SEPARATOR = ":";
+    private static final String QRCODE_USER_DAILY = "qrcode:user:daily";
+    private static final String QRCODE_CONTENT = "QR_";
+    private QRRedisKey() {
+        // 私有构造，防止实例化
+    }
+
+    /**
+     * 用户当日二维码
+     * 格式：qrcode:user:daily:{userId}:{date}
+     * 示例：qrcode:user:daily:1001:2026-05-30
+     */
+    public static String qrcodeUserDaily(Long userId, LocalDate date) {
+        return QRCODE_USER_DAILY + SEPARATOR + userId + SEPARATOR + date;
+    }
+
+    /**
+     * 用户当日二维码（今天）
+     */
+    public static String qrcodeUserToday(Long userId) {
+        return qrcodeUserDaily(userId, LocalDate.now());
+    }
+
+    /**
+     * 生成二维码内容（每个用户每次调用都不同）
+     */
+    public static String generateQrcodeContent() {
+        return QRCODE_CONTENT + UUID.randomUUID().toString().replace("-", "");
+    }
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/dto/QRCodeDto.java

@@ -0,0 +1,13 @@
+package cn.novalon.gym.manage.checkIn.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class QRCodeDto {
+
+    private String qrContent;
+
+    private boolean isUsed;
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/entity/SignInRecord.java

@@ -0,0 +1,41 @@
+package cn.novalon.gym.manage.checkIn.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Table("sign_in_record")
+public class SignInRecord {
+
+    @Id
+    private Long id;
+
+    // 会员ID
+    @Column("member_id")
+    private Long memberId;
+
+    // 签到日期
+    @Column("sign_in_date")
+    private LocalDate signInDate;
+
+    // 签到时间
+    @Column("sign_in_time")
+    private LocalDateTime signInTime;
+
+    // 创建时间
+    @CreatedDate
+    @Column("created_at")
+    private LocalDateTime createdAt;
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/handler/CheckInHandler.java

@@ -0,0 +1,69 @@
+package cn.novalon.gym.manage.checkIn.handler;
+
+import cn.novalon.gym.manage.checkIn.service.impl.CheckServiceImpl;
+import cn.novalon.gym.manage.sys.util.AuthUtil;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+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.Map;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class CheckInHandler {
+
+    private final AuthUtil authUtil;
+    private final CheckServiceImpl checkService;
+
+    /**
+     * 签到
+     *
+     * POST /api/checkIn
+     *
+     */
+    public Mono<ServerResponse> checkIn(ServerRequest request) {
+
+        Long memberId = 1L;
+//        authUtil.getMemberIdOrThrow(request);
+        return request.bodyToMono(Map.class)
+                .flatMap(body -> {
+                    String qrContent = (String) body.get("qrContent");
+                    log.info("收到签到请求, memberId: {}, qrContent: {}", memberId, qrContent);
+
+                    return checkService.checkIn(memberId, qrContent)
+                            .flatMap(result -> ServerResponse.ok()
+                                    .contentType(MediaType.APPLICATION_JSON)
+                                    .bodyValue(Map.of("code", 200, "message", "签到成功")));
+                })
+                .onErrorResume(e -> {
+                    log.error("签到失败", e);
+                    return ServerResponse.status(HttpStatus.BAD_REQUEST)
+                            .bodyValue(Map.of("code", 400, "message", e.getMessage()));
+                });
+    }
+
+    /**
+     * 获取二维码
+     *
+     * GET /api/checkin/qrcode
+     *
+     */
+    public Mono<ServerResponse> getQRCode(ServerRequest request) {
+
+        Long memberId = 1L;
+//        authUtil.getMemberIdOrThrow(request);
+
+        log.info("收到用户{}获取二维码请求", memberId);
+
+        return checkService.getQRCode(memberId)
+                .flatMap(qrCodeVo -> ServerResponse.ok()
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .bodyValue(qrCodeVo));
+    }
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/service/ICheckInService.java

@@ -0,0 +1,11 @@
+package cn.novalon.gym.manage.checkIn.service;
+
+import cn.novalon.gym.manage.checkIn.vo.QRCodeVo;
+import reactor.core.publisher.Mono;
+
+public interface ICheckInService {
+
+    Mono<QRCodeVo> getQRCode(Long memberId);
+
+    Mono<String> checkIn(Long memberId, String qrContent);
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/service/impl/CheckServiceImpl.java

@@ -0,0 +1,97 @@
+package cn.novalon.gym.manage.checkIn.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.extra.qrcode.QrCodeUtil;
+import cn.hutool.extra.qrcode.QrConfig;
+import cn.hutool.json.JSONUtil;
+import cn.novalon.gym.manage.checkIn.config.QRCodeConfig;
+import cn.novalon.gym.manage.checkIn.constant.QRRedisKey;
+import cn.novalon.gym.manage.checkIn.service.ICheckInService;
+import cn.novalon.gym.manage.checkIn.vo.QRCodeVo;
+import cn.novalon.gym.manage.common.constant.RedisKeyConstants;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.util.HashMap;
+import java.util.Map;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class CheckServiceImpl implements ICheckInService {
+
+    @Autowired
+    private final QRCodeConfig qrCodeConfig;
+
+    private final RedisUtil redisUtil;
+
+    @Override
+    public Mono<QRCodeVo> getQRCode(Long memberId) {
+        log.info("开始查询会员信息");
+        // TODO: 获取会员信息 - 查会员卡有效期/剩余次数，过期返回，先查缓存，缓存不存在则查数据库
+        // if (member有效期过了) throw new RuntimeException("会员有效期已过，拒绝生成二维码");
+        log.info("会员信息查询完成");
+
+        log.info("开始生成二维码");
+        String qrContent = QRRedisKey.generateQrcodeContent();
+        Map<String, Object> redisMap = new HashMap<>();
+        redisMap.put("qrContent", qrContent);
+        redisMap.put("isUsed", false);
+
+        return redisUtil.setWithExpire(
+                        RedisKeyConstants.QRCODE_USER_DAILY+memberId+LocalDate.now(),
+                        redisMap,
+                        getSecondsUntilEndOfDay()
+                )
+                .then(Mono.fromSupplier(() -> {
+                    String qrCodeBase64 = QrCodeUtil.generateAsBase64(qrContent,
+                            BeanUtil.copyProperties(qrCodeConfig, QrConfig.class), "png");
+                    return new QRCodeVo(qrCodeBase64,false,qrCodeConfig.getWidth(),qrCodeConfig.getHeight());
+                }));
+    }
+
+    @Override
+    public Mono<String> checkIn(Long memberId, String qrContent) {
+        String key = RedisKeyConstants.QRCODE_USER_DAILY+memberId+LocalDate.now();
+
+        return redisUtil.get(key)
+                .flatMap(cachedQrContent -> {
+                    if (cachedQrContent != null) {
+                        // 匹配成功，执行签到逻辑
+                        Map<String, Object> map = JSONUtil.parseObj(cachedQrContent);
+                        if(map.get("qrContent").equals(qrContent)){
+                            if((boolean)map.get("isUsed")){
+                                log.error("重复签到");
+                                throw new RuntimeException("您已经在"+map.get("checkInTime")+"完成签到，请勿重复签到");
+                            }
+                            log.info("二维码匹配成功，memberId: {}", memberId);
+                            // TODO查会员卡缓存，按照卡有效期进行扣减次数，没有缓存查数据库
+                            map.put("isUsed", true);
+                            map.put("checkInTime", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+
+                            return redisUtil.set(key,map).
+                                    then(Mono.just("签到成功"));
+                        }
+                    }
+                    throw new RuntimeException("二维码无效");
+                })
+                .switchIfEmpty(Mono.error(new RuntimeException("二维码已过期或不存在")));
+    }
+
+    private long getSecondsUntilEndOfDay() {
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime endOfDay = now.toLocalDate().atTime(23, 59, 59);
+
+        if (now.isAfter(endOfDay)) return 1;
+
+        return ChronoUnit.SECONDS.between(now, endOfDay);
+    }
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/vo/QRCodeVo.java

@@ -0,0 +1,17 @@
+package cn.novalon.gym.manage.checkIn.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class QRCodeVo {
+
+    private String qrCodeBase64;
+
+    private boolean isUsed;
+
+    private Integer width;
+
+    private Integer height;
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/websocket/MyWebSocketHandler.java

@@ -0,0 +1,98 @@
+package cn.novalon.gym.manage.checkIn.websocket;
+
+import cn.hutool.json.JSONUtil;
+import cn.novalon.gym.manage.checkIn.dto.QRCodeDto;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.socket.WebSocketHandler;
+import org.springframework.web.reactive.socket.WebSocketMessage;
+import org.springframework.web.reactive.socket.WebSocketSession;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Slf4j
+@Component
+public class MyWebSocketHandler implements WebSocketHandler {
+
+    // 存储所有连接
+    private static final Map<String, WebSocketSession> sessions = new ConcurrentHashMap<>();
+
+    @Override
+    public Mono<Void> handle(WebSocketSession session) {
+        String sessionId = session.getId();
+
+        // 连接建立
+        sessions.put(sessionId, session);
+        log.info("WebSocket 连接建立，sessionId：{}，当前连接数：{}", sessionId, sessions.size());
+
+        // 处理接收到的消息
+        Flux<WebSocketMessage> output = session.receive()
+                .doOnNext(message -> {
+                    String payload = message.getPayloadAsText();
+                    log.info("收到消息：{}", payload);
+                })
+                .map(message -> {
+                    String payload = message.getPayloadAsText();
+                    String response = processMessage(payload, sessionId);
+                    return session.textMessage(response);
+                });
+
+        // 连接关闭时清理
+        return session.send(output)
+                .doFinally(signalType -> {
+                    sessions.remove(sessionId);
+                    log.info("WebSocket 连接关闭，sessionId：{}，剩余连接数：{}", sessionId, sessions.size());
+                });
+    }
+
+    /**
+     * 处理消息逻辑
+     */
+    private String processMessage(String message, String sessionId) {
+        try {
+            // 解析 QRCodeDto
+            QRCodeDto qrCodeDto = JSONUtil.toBean(message, QRCodeDto.class);
+
+            String response;
+
+            // 判断二维码是否有效
+            if (qrCodeDto.getQrContent() != null
+                    && !qrCodeDto.getQrContent().isEmpty()
+                    && !qrCodeDto.isUsed()) {
+                // 有效：qrContent 有值且 isUsed 为 false
+                response = "正在进行签到";
+
+                // 可选：将二维码标记为已使用（需要调用后端服务）
+                // checkInService.handleCheckIn(qrCodeDto.getQrContent());
+
+                log.info("二维码有效，sessionId：{}，qrContent：{}", sessionId, qrCodeDto.getQrContent());
+            } else {
+                // 无效：qrContent 为空 或 isUsed 为 true
+                String reason = "";
+                if (qrCodeDto.getQrContent() == null || qrCodeDto.getQrContent().isEmpty()) {
+                    reason = "二维码内容为空";
+                } else if (qrCodeDto.isUsed()) {
+                    reason = "二维码已被使用";
+                }
+                response = "二维码无效：" + reason;
+                log.warn("二维码无效，sessionId：{}，原因：{}", sessionId, reason);
+            }
+
+            return response;
+
+        } catch (Exception e) {
+            log.error("解析消息失败，sessionId：{}", sessionId, e);
+            return "消息格式错误";
+        }
+    }
+
+    /**
+     * 获取当前在线连接数
+     */
+    public static int getOnlineCount() {
+        return sessions.size();
+    }
+}

gym-manage-api/gym-checkIn/src/main/resources/checkIn-config.yml

@@ -0,0 +1,10 @@
+# 二维码配置
+qr:
+  config:
+    width: 300 # 二维码宽度（像素）
+    height: 300 # 二维码高度（像素）
+    margin: 1 # 白边宽度（像素）
+    format: png # 图片格式：png / jpg
+    error-correction: L #容错率：L, M, Q, H，如果启用Logo（logo-enabled: true），必须设置为 H
+    logo-enabled: false # 是否启用Logo（启用时error-correction必须为H）
+#    logo-path: static/logo.png    # Logo图片路径（支持相对路径或绝对路径）

gym-manage-api/gym-checkIn/src/test/java/cn/novalon/gym/manage/checkin/CheckInModuleTest.java

@@ -1,13 +1,12 @@
-package cn.novalon.gym.manage.groupcourse;
+package cn.novalon.gym.manage.checkin;
 
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
 
 @SpringBootTest
-class GymGroupCourseApplicationTests {
+public class CheckInModuleTest {
 
     @Test
-    void contextLoads() {
+    public void contextLoads() {
     }
-
 }

gym-manage-api/gym-checkIn/src/test/resources/application-test.yml

@@ -0,0 +1 @@
+# Test Configuration

gym-manage-api/gym-groupCourse/.mvn/wrapper/maven-wrapper.properties

@@ -1,3 +0,0 @@
-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

@@ -1,95 +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>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

@@ -1,127 +0,0 @@
-
-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

@@ -1,111 +0,0 @@
-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

@@ -1,39 +0,0 @@
-
-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

@@ -1,166 +0,0 @@
-
-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

@@ -1,135 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,168 +0,0 @@
-
-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

@@ -1,24 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,369 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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

@@ -1,261 +0,0 @@
-
-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

@@ -1,139 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,30 +0,0 @@
-
-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

@@ -1,115 +0,0 @@
-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

@@ -1,181 +0,0 @@
-
-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

@@ -1,42 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,26 +0,0 @@
-
-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

@@ -1,372 +0,0 @@
-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

@@ -1,194 +0,0 @@
-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

@@ -1,396 +0,0 @@
-
-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

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

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

@@ -128,7 +128,11 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
         </dependency>
-
+        <!-- Redis响应式支持（会员卡模块需要） -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

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

@@ -43,7 +43,7 @@ public class MemberHandler {
     @Operation(summary = "获取会员信息", description = "根据当前登录用户获取会员基本信息")
     public Mono<ServerResponse> getMemberInfo(ServerRequest request) {
 
-        Long memberId = authUtil.getMemberIdOrThrow(request);
+        Long memberId = authUtil.getMemberUserIdOrThrow(request);
 
         log.info("获取会员信息, memberId: {}", memberId);
 
@@ -56,7 +56,7 @@ public class MemberHandler {
     @Operation(summary = "更新会员信息", description = "更新会员昵称、性别、生日、头像、地址等信息")
     public Mono<ServerResponse> updateMemberInfo(ServerRequest request) {
 
-        Long memberId = authUtil.getMemberIdOrThrow(request);
+        Long memberId = authUtil.getMemberUserIdOrThrow(request);
 
         log.info("更新会员信息, memberId: {}", memberId);
 
@@ -70,7 +70,7 @@ public class MemberHandler {
     @Operation(summary = "绑定手机号", description = "通过微信小程序手机号code绑定会员手机号")
     public Mono<ServerResponse> bindPhone(ServerRequest request) {
 
-        Long memberId = authUtil.getMemberIdOrThrow(request);
+        Long memberId = authUtil.getMemberUserIdOrThrow(request);
 
         String phoneCode = request.queryParam("phoneCode").orElse("");
 
@@ -87,7 +87,7 @@ public class MemberHandler {
     @Operation(summary = "查询服务号关注状态", description = "查询会员是否关注微信服务号")
     public Mono<ServerResponse> checkSubscribeStatus(ServerRequest request) {
 
-        Long memberId = authUtil.getMemberIdOrThrow(request);
+        Long memberId = authUtil.getMemberUserIdOrThrow(request);
 
         log.info("查询服务号关注状态, memberId: {}", memberId);
 
@@ -102,7 +102,7 @@ public class MemberHandler {
     @Operation(summary = "管理员更新手机号", description = "后台管理员为会员更新手机号")
     public Mono<ServerResponse> adminUpdatePhone(ServerRequest request) {
 
-        Long adminId = authUtil.getMemberIdOrThrow(request);
+        Long adminId = authUtil.getAdminUserIdOrThrow(request);
 
         String memberIdStr = request.pathVariable("id");
         long memberId = NumberUtils.toLong(memberIdStr, 0L);
@@ -134,7 +134,7 @@ public class MemberHandler {
     @Operation(summary = "管理员查看会员详情", description = "后台管理员查看指定会员的详细信息")
     public Mono<ServerResponse> adminGetMemberInfo(ServerRequest request) {
 
-        Long adminId = authUtil.getMemberIdOrThrow(request);
+        Long adminId = authUtil.getAdminUserIdOrThrow(request);
 
         String memberIdStr = request.pathVariable("id");
         long memberId = NumberUtils.toLong(memberIdStr, 0L);
@@ -162,7 +162,7 @@ public class MemberHandler {
     @Operation(summary = "管理员编辑会员信息", description = "后台管理员编辑会员信息")
     public Mono<ServerResponse> adminUpdateMemberInfo(ServerRequest request) {
 
-        Long adminId = authUtil.getMemberIdOrThrow(request);
+        Long adminId = authUtil.getAdminUserIdOrThrow(request);
 
         String memberIdStr = request.pathVariable("id");
         long memberId = NumberUtils.toLong(memberIdStr, 0L);
@@ -181,7 +181,7 @@ public class MemberHandler {
     @Operation(summary = "搜索会员列表", description = "后台管理员按关键词搜索会员，支持性别筛选和分页")
     public Mono<ServerResponse> searchMembers(ServerRequest request) {
 
-        Long adminId = authUtil.getMemberIdOrThrow(request);
+        Long adminId = authUtil.getAdminUserIdOrThrow(request);
 
         String keyword = request.queryParam("searchValue").orElse(null);
         Integer pageNum = NumberUtils.toInt(request.queryParam("pageNum").orElse("1"), 1);
@@ -212,7 +212,7 @@ public class MemberHandler {
     @Operation(summary = "查看会员列表", description = "后台管理员分页查看所有会员列表")
     public Mono<ServerResponse> getAllMembers(ServerRequest request) {
 
-        Long adminId = authUtil.getMemberIdOrThrow(request);
+        Long adminId = authUtil.getAdminUserIdOrThrow(request);
 
         int pageNum = NumberUtils.toInt(request.queryParam("pageNum").orElse("1"), 1);
         int pageSize = NumberUtils.toInt(request.queryParam("pageSize").orElse("10"), 10);

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImpl.java

@@ -1,5 +1,6 @@
 package cn.novalon.gym.manage.member.service.impl;
 
+import cn.novalon.gym.manage.common.util.RedisUtil;
 import cn.novalon.gym.manage.member.entity.MemberCard;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
@@ -15,7 +16,7 @@ import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
 import cn.novalon.gym.manage.member.repository.MemberCardRepository;
 import cn.novalon.gym.manage.member.service.IMemberCardService;
 import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
-import cn.novalon.gym.manage.common.util.RedisUtil;
+
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberServiceImpl.java

@@ -21,17 +21,26 @@ import cn.novalon.gym.manage.common.util.RedisUtil;
 import cn.novalon.gym.manage.member.vo.MemberCardInfoVO;
 import cn.novalon.gym.manage.member.vo.MemberDetailVO;
 import cn.novalon.gym.manage.member.vo.MemberInfoVO;
+import co.elastic.clients.elasticsearch.ElasticsearchClient;
+import co.elastic.clients.elasticsearch.core.IndexResponse;
+import co.elastic.clients.json.jackson.JacksonJsonpMapper;
+import co.elastic.clients.transport.rest_client.RestClientTransport;
 import jakarta.annotation.PostConstruct;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.http.HttpHost;
+import org.elasticsearch.client.RestClient;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import java.time.LocalDateTime;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 /**

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatAuthServiceImpl.java

@@ -4,6 +4,8 @@ import cn.novalon.gym.manage.common.exception.ConflictException;
 import cn.novalon.gym.manage.common.exception.ErrorCode;
 import cn.novalon.gym.manage.common.exception.NotFoundException;
 import cn.novalon.gym.manage.common.exception.SystemException;
+import cn.novalon.gym.manage.common.util.HtmlEscapeUtil;
+import cn.novalon.gym.manage.member.config.WechatProperties;
 import cn.novalon.gym.manage.member.dto.WechatLoginDto;
 import cn.novalon.gym.manage.member.entity.Member;
 import cn.novalon.gym.manage.member.es.entity.MemberES;
@@ -301,9 +303,9 @@ public class WechatAuthServiceImpl implements WechatAuthService {
         }
 
         List<String> roles = new ArrayList<>();
-        String accessToken = jwtTokenProvider.generateToken(String.valueOf(member.getId()), member.getId(), roles);
+        String accessToken = jwtTokenProvider.generateToken(String.valueOf(member.getId()), member.getId(), roles, "MEMBER");
 
-        log.info("JWT Token 生成成功, memberId: {}", member.getId());
+        log.info("JWT Token 生成成功, memberId: {}, userType=MEMBER", member.getId());
 
         int expiresIn = 86400;
 
@@ -314,6 +316,7 @@ public class WechatAuthServiceImpl implements WechatAuthService {
                 .expiresIn(expiresIn)
                 .isNewUser(isNewUser)
                 .needCompleteInfo(needCompleteInfo)
+                .userType("MEMBER")
                 .build();
     }
 }

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/vo/WechatLoginVO.java

@@ -35,4 +35,7 @@ public class WechatLoginVO {
 
     // 是否需要补全信息（昵称、手机号等）
     private Boolean needCompleteInfo;
+
+    // 用户类型（MEMBER）
+    private String userType;
 }

gym-manage-api/log.text

@@ -1,200 +0,0 @@
-2026-06-02T14:56:05.966+08:00 TRACE 22380 --- [gym-manage-api] [ctor-http-nio-7] o.s.w.s.adapter.HttpWebHandlerAdapter    : [7ce54381-10] HTTP POST "/api/groupCourse/11/cancel", headers={masked}
-2026-06-02T14:56:05.967+08:00 DEBUG 22380 --- [gym-manage-api] [    parallel-11] o.s.w.s.s.DefaultWebSessionManager       : Created new WebSession.
-2026-06-02T14:56:05.967+08:00  INFO 22380 --- [gym-manage-api] [    parallel-11] c.n.g.m.sys.audit.OperationLogWebFilter  : WebFilter 拦截请求: POST /api/groupCourse/11/cancel
-2026-06-02T14:56:05.967+08:00  INFO 22380 --- [gym-manage-api] [    parallel-11] c.n.g.m.sys.audit.OperationLogWebFilter  : 未匹配到操作日志配置，跳过: POST /api/groupCourse/11/cancel
-2026-06-02T14:56:05.967+08:00  INFO 22380 --- [gym-manage-api] [    parallel-11] c.n.g.m.sys.audit.OperationLogWebFilter  : WebFilter 拦截请求: POST /api/groupCourse/11/cancel
-2026-06-02T14:56:05.967+08:00  INFO 22380 --- [gym-manage-api] [    parallel-11] c.n.g.m.sys.audit.OperationLogWebFilter  : 未匹配到操作日志配置，跳过: POST /api/groupCourse/11/cancel
-2026-06-02T14:56:05.967+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.967+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.967+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/dictionaries" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/users" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/users/{id}/action/change-password" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/users/{id}/action/logical-delete" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/users/logical-delete" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/users/action/restore" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/users/{id}/action/restore" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/users/{id}/roles" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/menus" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/roles" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/roles/{id}/restore" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/roles/{id}/permissions" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/config" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/logs/login" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/logs/exception" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/logs/operation" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/auth/login" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/auth/register" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/auth/logout" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/dict/types" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/dict/data" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/notices" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/messages" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/files/upload" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/permissions" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.969+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/member/auth/miniapp/login" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/member/auth/mp/callback" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/member/phone/bind" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/admin/member/{id}/phone" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/member-cards" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/member-card-records/purchase" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/member-card-records/{recordId}/renew" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/member-card-records/{recordId}/use" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/member-card-records/{recordId}/refund" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/member-card-records/process-expired" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/member-card-transactions" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/groupCourse/page" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "GET" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/groupCourse" does not match against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "PUT" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "DELETE" does not match against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Method "POST" matches against value "POST"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.server.RequestPredicates       : Pattern "/api/groupCourse/{id}/cancel" matches against value "/api/groupCourse/11/cancel"
-2026-06-02T14:56:05.970+08:00 TRACE 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.function.server.RouterFunctions  : [7ce54381-10] Matched (POST && /api/groupCourse/{id}/cancel)
-2026-06-02T14:56:05.970+08:00 DEBUG 22380 --- [gym-manage-api] [    parallel-11] o.s.w.r.f.s.s.RouterFunctionMapping      : [7ce54381-10] Mapped to cn.novalon.gym.manage.app.config.SystemRouter$$Lambda/0x00000198019592d8@6903bec9
-2026-06-02T14:56:05.972+08:00 DEBUG 22380 --- [gym-manage-api] [    parallel-11] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT group_course.course_name, group_course.coach_id, group_course.course_type, group_course.start_time, group_course.end_time, group_course.max_members, group_course.current_members, group_course.status, group_course.location, group_course.cover_image, group_course.description, group_course.point_card_amount, group_course.stored_value_amount, group_course.id, group_course.create_by, group_course.update_by, group_course.created_at, group_course.updated_at, group_course.deleted_at FROM group_course WHERE group_course.id = $1 AND (group_course.deleted_at IS NULL)]
-2026-06-02T14:56:05.976+08:00  INFO 22380 --- [gym-manage-api] [actor-tcp-nio-5] c.n.g.m.g.c.GroupCourseConverter         : 转换bean，entity-domain：
-2026-06-02T14:56:05.976+08:00 ERROR 22380 --- [gym-manage-api] [actor-tcp-nio-5] c.n.g.m.g.s.impl.GroupCourseService      : 团课取消失败 - id=11, error: 课程取消需提前24小时
-2026-06-02T14:56:05.976+08:00 TRACE 22380 --- [gym-manage-api] [actor-tcp-nio-5] org.springframework.web.HttpLogging      : [7ce54381-10] Encoding [{success=false, message=课程取消需提前24小时}]
-2026-06-02T14:56:05.976+08:00 TRACE 22380 --- [gym-manage-api] [actor-tcp-nio-5] o.s.w.s.adapter.HttpWebHandlerAdapter    : [7ce54381-10] Completed 400 BAD_REQUEST, headers={masked}
-2026-06-02T14:56:05.976+08:00 TRACE 22380 --- [gym-manage-api] [actor-tcp-nio-5] org.springframework.web.HttpLogging      : [7ce54381-1, L:/[0:0:0:0:0:0:0:1]:8084 - R:/[0:0:0:0:0:0:0:1]:57674] Handling completed

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

@@ -43,6 +43,11 @@
             <artifactId>gym-member</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>gym-checkIn</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         
         <dependency>
             <groupId>org.springframework.boot</groupId>
@@ -143,12 +148,6 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-redis</artifactId>
         </dependency>
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>gym-groupCourse</artifactId>
-            <version>1.0.0</version>
-            <scope>compile</scope>
-        </dependency>
     </dependencies>
 
     <build>

gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/ManageApplication.java

@@ -13,20 +13,17 @@ import org.springframework.context.annotation.ComponentScan;
 import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
 import org.springframework.data.elasticsearch.repository.config.EnableReactiveElasticsearchRepositories;
 import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
-import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.web.server.WebFilter;
 
 import java.util.List;
 
 @SpringBootApplication(scanBasePackages = "cn.novalon.gym.manage", exclude = {
         ReactiveUserDetailsServiceAutoConfiguration.class })
-@EnableScheduling
 @EnableR2dbcRepositories(basePackages = {
         "cn.novalon.gym.manage.db.dao",
         "cn.novalon.gym.manage.sys.audit.repository" ,
         "cn.novalon.gym.manage.gymmembercard.dao",
-        "cn.novalon.gym.manage.member.repository",
+        "cn.novalon.gym.manage.member.repository"
-        "cn.novalon.gym.manage.groupcourse.dao"
 })
 @EnableReactiveElasticsearchRepositories(basePackages = "cn.novalon.gym.manage.member.es.repository")
 public class ManageApplication {

gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/config/SystemRouter.java

@@ -1,9 +1,8 @@
 package cn.novalon.gym.manage.app.config;
 
 
+import cn.novalon.gym.manage.checkIn.handler.CheckInHandler;
 import cn.novalon.gym.manage.file.handler.SysFileHandler;
-import cn.novalon.gym.manage.groupcourse.handler.GroupCourseBookingHandler;
-import cn.novalon.gym.manage.groupcourse.handler.GroupCourseHandler;
 import cn.novalon.gym.manage.member.handler.MemberCardHandler;
 import cn.novalon.gym.manage.member.handler.MemberCardRecordHandler;
 import cn.novalon.gym.manage.member.handler.MemberCardTransactionHandler;
@@ -35,7 +34,7 @@ import static org.springframework.web.reactive.function.server.RouterFunctions.r
  * 
  * 文件定义：配置WebFlux函数式路由，将HTTP请求映射到对应的Handler方法
  * 涉及业务：用户、角色、字典、菜单、公告、文件等所有RESTful API路由
- * 算法：使用RouterFunctions.route()构建函数式路由规则
+ * 路由规范：后台管理 API 统一前缀 /api/admin/**，前台会员 API 统一前缀 /api/member/**
  *
  * @author 张翔
  * @date 2026-03-13
@@ -65,155 +64,154 @@ public class SystemRouter {
             MemberCardHandler memberCardHandler,
             MemberCardRecordHandler memberCardRecordHandler,
             MemberCardTransactionHandler memberCardTransactionHandler,
-            GroupCourseHandler groupCourseHandler,
+            CheckInHandler checkInHandler) {
-            GroupCourseBookingHandler groupCourseBookingHandler) {
 
         return route()
-                // ========== 诊断路由 ==========
+                // ========== 诊断路由（管理端） ==========
-                .GET("/api/diagnostic/password", passwordDiagnosticHandler::diagnose)
+                .GET("/api/admin/diagnostic/password", passwordDiagnosticHandler::diagnose)
 
-                // ========== 字典路由 ==========
+                // ========== 字典路由（管理端） ==========
-                .GET("/api/dictionaries", dictionaryHandler::getAllDictionaries)
+                .GET("/api/admin/dictionaries", dictionaryHandler::getAllDictionaries)
-                .GET("/api/dictionaries/{id}", dictionaryHandler::getDictionaryById)
+                .GET("/api/admin/dictionaries/{id}", dictionaryHandler::getDictionaryById)
-                .GET("/api/dictionaries/type/{type}", dictionaryHandler::getDictionariesByType)
+                .GET("/api/admin/dictionaries/type/{type}", dictionaryHandler::getDictionariesByType)
-                .GET("/api/dictionaries/check/exists", dictionaryHandler::checkTypeAndCodeExists)
+                .GET("/api/admin/dictionaries/check/exists", dictionaryHandler::checkTypeAndCodeExists)
-                .POST("/api/dictionaries", dictionaryHandler::createDictionary)
+                .POST("/api/admin/dictionaries", dictionaryHandler::createDictionary)
-                .PUT("/api/dictionaries/{id}", dictionaryHandler::updateDictionary)
+                .PUT("/api/admin/dictionaries/{id}", dictionaryHandler::updateDictionary)
-                .DELETE("/api/dictionaries/{id}", dictionaryHandler::deleteDictionary)
+                .DELETE("/api/admin/dictionaries/{id}", dictionaryHandler::deleteDictionary)
 
-                // ========== 用户路由 ==========
+                // ========== 用户路由（管理端） ==========
-                .GET("/api/users", userHandler::getAllUsers)
+                .GET("/api/admin/users", userHandler::getAllUsers)
-                .GET("/api/users/page", userHandler::getUsersByPage)
+                .GET("/api/admin/users/page", userHandler::getUsersByPage)
-                .GET("/api/users/count", userHandler::getUserCount)
+                .GET("/api/admin/users/count", userHandler::getUserCount)
-                .GET("/api/users/username/{username}", userHandler::getUserByUsername)
+                .GET("/api/admin/users/username/{username}", userHandler::getUserByUsername)
-                .GET("/api/users/check/username", userHandler::checkUsernameExists)
+                .GET("/api/admin/users/check/username", userHandler::checkUsernameExists)
-                .GET("/api/users/check/email", userHandler::checkEmailExists)
+                .GET("/api/admin/users/check/email", userHandler::checkEmailExists)
-                .POST("/api/users", userHandler::createUser)
+                .POST("/api/admin/users", userHandler::createUser)
-                .GET("/api/users/{id}", userHandler::getUserById)
+                .GET("/api/admin/users/{id}", userHandler::getUserById)
-                .PUT("/api/users/{id}", userHandler::updateUser)
+                .PUT("/api/admin/users/{id}", userHandler::updateUser)
-                .DELETE("/api/users/{id}", userHandler::deleteUser)
+                .DELETE("/api/admin/users/{id}", userHandler::deleteUser)
-                .POST("/api/users/{id}/action/change-password", userHandler::changePassword)
+                .POST("/api/admin/users/{id}/action/change-password", userHandler::changePassword)
-                .POST("/api/users/{id}/action/logical-delete", userHandler::logicalDeleteUser)
+                .POST("/api/admin/users/{id}/action/logical-delete", userHandler::logicalDeleteUser)
-                .POST("/api/users/logical-delete", userHandler::logicalDeleteUsers)
+                .POST("/api/admin/users/logical-delete", userHandler::logicalDeleteUsers)
-                .POST("/api/users/action/restore", userHandler::restoreUsers)
+                .POST("/api/admin/users/action/restore", userHandler::restoreUsers)
-                .POST("/api/users/{id}/action/restore", userHandler::restoreUser)
+                .POST("/api/admin/users/{id}/action/restore", userHandler::restoreUser)
-                .GET("/api/users/{id}/roles", userHandler::getUserRoles)
+                .GET("/api/admin/users/{id}/roles", userHandler::getUserRoles)
-                .POST("/api/users/{id}/roles", userHandler::assignRoles)
+                .POST("/api/admin/users/{id}/roles", userHandler::assignRoles)
 
-                // ========== 菜单路由 ==========
+                // ========== 菜单路由（管理端） ==========
-                .GET("/api/menus", menuHandler::getAllMenus)
+                .GET("/api/admin/menus", menuHandler::getAllMenus)
-                .GET("/api/menus/tree", menuHandler::getMenuTree)
+                .GET("/api/admin/menus/tree", menuHandler::getMenuTree)
-                .GET("/api/menus/{id}", menuHandler::getMenuById)
+                .GET("/api/admin/menus/{id}", menuHandler::getMenuById)
-                .POST("/api/menus", menuHandler::createMenu)
+                .POST("/api/admin/menus", menuHandler::createMenu)
-                .PUT("/api/menus/{id}", menuHandler::updateMenu)
+                .PUT("/api/admin/menus/{id}", menuHandler::updateMenu)
-                .DELETE("/api/menus/{id}", menuHandler::deleteMenu)
+                .DELETE("/api/admin/menus/{id}", menuHandler::deleteMenu)
 
-                // ========== 角色路由 ==========
+                // ========== 角色路由（管理端） ==========
-                .GET("/api/roles", roleHandler::getAllRoles)
+                .GET("/api/admin/roles", roleHandler::getAllRoles)
-                .GET("/api/roles/page", roleHandler::getRolesByPage)
+                .GET("/api/admin/roles/page", roleHandler::getRolesByPage)
-                .GET("/api/roles/count", roleHandler::getRoleCount)
+                .GET("/api/admin/roles/count", roleHandler::getRoleCount)
-                .GET("/api/roles/name/{roleName}", roleHandler::getRoleByName)
+                .GET("/api/admin/roles/name/{roleName}", roleHandler::getRoleByName)
-                .GET("/api/roles/check-name", roleHandler::checkNameExists)
+                .GET("/api/admin/roles/check-name", roleHandler::checkNameExists)
-                .GET("/api/roles/{id}", roleHandler::getRoleById)
+                .GET("/api/admin/roles/{id}", roleHandler::getRoleById)
-                .POST("/api/roles", roleHandler::createRole)
+                .POST("/api/admin/roles", roleHandler::createRole)
-                .PUT("/api/roles/{id}", roleHandler::updateRole)
+                .PUT("/api/admin/roles/{id}", roleHandler::updateRole)
-                .DELETE("/api/roles/{id}", roleHandler::deleteRole)
+                .DELETE("/api/admin/roles/{id}", roleHandler::deleteRole)
-                .POST("/api/roles/{id}/restore", roleHandler::restoreRole)
+                .POST("/api/admin/roles/{id}/restore", roleHandler::restoreRole)
-                .GET("/api/roles/{id}/permissions", permissionHandler::getPermissionsByRoleId)
+                .GET("/api/admin/roles/{id}/permissions", permissionHandler::getPermissionsByRoleId)
-                .POST("/api/roles/{id}/permissions", permissionHandler::assignPermissionsToRole)
+                .POST("/api/admin/roles/{id}/permissions", permissionHandler::assignPermissionsToRole)
 
-                // ========== 配置路由 ==========
+                // ========== 配置路由（管理端） ==========
-                .GET("/api/config", configHandler::getAllConfigs)
+                .GET("/api/admin/config", configHandler::getAllConfigs)
-                .GET("/api/config/{id}", configHandler::getConfigById)
+                .GET("/api/admin/config/{id}", configHandler::getConfigById)
-                .GET("/api/config/key/{configKey}", configHandler::getConfigByKey)
+                .GET("/api/admin/config/key/{configKey}", configHandler::getConfigByKey)
-                .POST("/api/config", configHandler::createConfig)
+                .POST("/api/admin/config", configHandler::createConfig)
-                .PUT("/api/config/{id}", configHandler::updateConfig)
+                .PUT("/api/admin/config/{id}", configHandler::updateConfig)
-                .DELETE("/api/config/{id}", configHandler::deleteConfig)
+                .DELETE("/api/admin/config/{id}", configHandler::deleteConfig)
 
-                // ========== 日志路由 ==========
+                // ========== 日志路由（管理端） ==========
-                .GET("/api/logs/login", logHandler::getAllLoginLogs)
+                .GET("/api/admin/logs/login", logHandler::getAllLoginLogs)
-                .GET("/api/logs/login/page", logHandler::getLoginLogsByPage)
+                .GET("/api/admin/logs/login/page", logHandler::getLoginLogsByPage)
-                .GET("/api/logs/login/count", logHandler::getLoginLogCount)
+                .GET("/api/admin/logs/login/count", logHandler::getLoginLogCount)
-                .GET("/api/logs/login/today/count", logHandler::getTodayLoginCount)
+                .GET("/api/admin/logs/login/today/count", logHandler::getTodayLoginCount)
-                .GET("/api/logs/login/recent", logHandler::getRecentLoginLogs)
+                .GET("/api/admin/logs/login/recent", logHandler::getRecentLoginLogs)
-                .GET("/api/logs/login/{id}", logHandler::getLoginLogById)
+                .GET("/api/admin/logs/login/{id}", logHandler::getLoginLogById)
-                .POST("/api/logs/login", logHandler::createLoginLog)
+                .POST("/api/admin/logs/login", logHandler::createLoginLog)
-                .GET("/api/logs/exception", logHandler::getAllExceptionLogs)
+                .GET("/api/admin/logs/exception", logHandler::getAllExceptionLogs)
-                .GET("/api/logs/exception/page", logHandler::getExceptionLogsByPage)
+                .GET("/api/admin/logs/exception/page", logHandler::getExceptionLogsByPage)
-                .GET("/api/logs/exception/count", logHandler::getExceptionLogCount)
+                .GET("/api/admin/logs/exception/count", logHandler::getExceptionLogCount)
-                .GET("/api/logs/exception/{id}", logHandler::getExceptionLogById)
+                .GET("/api/admin/logs/exception/{id}", logHandler::getExceptionLogById)
-                .POST("/api/logs/exception", logHandler::createExceptionLog)
+                .POST("/api/admin/logs/exception", logHandler::createExceptionLog)
-                .GET("/api/logs/operation", operationLogHandler::getAllOperationLogs)
+                .GET("/api/admin/logs/operation", operationLogHandler::getAllOperationLogs)
-                .GET("/api/logs/operation/export", operationLogHandler::exportOperationLogs)
+                .GET("/api/admin/logs/operation/export", operationLogHandler::exportOperationLogs)
-                .GET("/api/logs/operation/page", operationLogHandler::getOperationLogsByPage)
+                .GET("/api/admin/logs/operation/page", operationLogHandler::getOperationLogsByPage)
-                .GET("/api/logs/operation/count", operationLogHandler::getOperationLogCount)
+                .GET("/api/admin/logs/operation/count", operationLogHandler::getOperationLogCount)
-                .GET("/api/logs/operation/{id}", operationLogHandler::getOperationLogById)
+                .GET("/api/admin/logs/operation/{id}", operationLogHandler::getOperationLogById)
-                .POST("/api/logs/operation", operationLogHandler::createOperationLog)
+                .POST("/api/admin/logs/operation", operationLogHandler::createOperationLog)
 
-                // ========== 认证路由 ==========
+                // ========== 认证路由（管理端） ==========
-                .POST("/api/auth/login", authHandler::login)
+                .POST("/api/admin/auth/login", authHandler::login)
-                .POST("/api/auth/register", authHandler::register)
+                .POST("/api/admin/auth/register", authHandler::register)
-                .POST("/api/auth/logout", authHandler::logout)
+                .POST("/api/admin/auth/logout", authHandler::logout)
 
-                // ========== 统计路由 ==========
+                // ========== 统计路由（管理端） ==========
-                .GET("/api/stats/overview", statsHandler::getOverview)
+                .GET("/api/admin/stats/overview", statsHandler::getOverview)
 
-                // ========== 数据字典路由 ==========
+                // ========== 数据字典路由（管理端） ==========
-                .GET("/api/dict/types", dictHandler::getAllDictTypes)
+                .GET("/api/admin/dict/types", dictHandler::getAllDictTypes)
-                .GET("/api/dict/types/{id}", dictHandler::getDictTypeById)
+                .GET("/api/admin/dict/types/{id}", dictHandler::getDictTypeById)
-                .GET("/api/dict/types/type/{dictType}", dictHandler::getDictTypeByType)
+                .GET("/api/admin/dict/types/type/{dictType}", dictHandler::getDictTypeByType)
-                .POST("/api/dict/types", dictHandler::createDictType)
+                .POST("/api/admin/dict/types", dictHandler::createDictType)
-                .PUT("/api/dict/types/{id}", dictHandler::updateDictType)
+                .PUT("/api/admin/dict/types/{id}", dictHandler::updateDictType)
-                .DELETE("/api/dict/types/{id}", dictHandler::deleteDictType)
+                .DELETE("/api/admin/dict/types/{id}", dictHandler::deleteDictType)
-                .GET("/api/dict/data", dictHandler::getAllDictData)
+                .GET("/api/admin/dict/data", dictHandler::getAllDictData)
-                .GET("/api/dict/data/type/{dictType}", dictHandler::getDictDataByType)
+                .GET("/api/admin/dict/data/type/{dictType}", dictHandler::getDictDataByType)
-                .GET("/api/dict/data/{id}", dictHandler::getDictDataById)
+                .GET("/api/admin/dict/data/{id}", dictHandler::getDictDataById)
-                .POST("/api/dict/data", dictHandler::createDictData)
+                .POST("/api/admin/dict/data", dictHandler::createDictData)
-                .PUT("/api/dict/data/{id}", dictHandler::updateDictData)
+                .PUT("/api/admin/dict/data/{id}", dictHandler::updateDictData)
-                .DELETE("/api/dict/data/{id}", dictHandler::deleteDictData)
+                .DELETE("/api/admin/dict/data/{id}", dictHandler::deleteDictData)
 
-                // ========== 公告路由 ==========
+                // ========== 公告路由（管理端） ==========
-                .GET("/api/notices", noticeHandler::getAllNotices)
+                .GET("/api/admin/notices", noticeHandler::getAllNotices)
-                .GET("/api/notices/{id}", noticeHandler::getNoticeById)
+                .GET("/api/admin/notices/{id}", noticeHandler::getNoticeById)
-                .GET("/api/notices/status/{status}", noticeHandler::getNoticesByStatus)
+                .GET("/api/admin/notices/status/{status}", noticeHandler::getNoticesByStatus)
-                .POST("/api/notices", noticeHandler::createNotice)
+                .POST("/api/admin/notices", noticeHandler::createNotice)
-                .PUT("/api/notices/{id}", noticeHandler::updateNotice)
+                .PUT("/api/admin/notices/{id}", noticeHandler::updateNotice)
-                .DELETE("/api/notices/{id}", noticeHandler::deleteNotice)
+                .DELETE("/api/admin/notices/{id}", noticeHandler::deleteNotice)
 
-                // ========== 消息路由 ==========
+                // ========== 消息路由（管理端） ==========
-                .GET("/api/messages/user/{userId}", messageHandler::getMessagesByUser)
+                .GET("/api/admin/messages/user/{userId}", messageHandler::getMessagesByUser)
-                .GET("/api/messages/user/{userId}/unread", messageHandler::getUnreadCount)
+                .GET("/api/admin/messages/user/{userId}/unread", messageHandler::getUnreadCount)
-                .GET("/api/messages/user/{userId}/unread/list", messageHandler::getUnreadList)
+                .GET("/api/admin/messages/user/{userId}/unread/list", messageHandler::getUnreadList)
-                .POST("/api/messages", messageHandler::createMessage)
+                .POST("/api/admin/messages", messageHandler::createMessage)
-                .PUT("/api/messages/{id}/read", messageHandler::markAsRead)
+                .PUT("/api/admin/messages/{id}/read", messageHandler::markAsRead)
-                .DELETE("/api/messages/{id}", messageHandler::deleteMessage)
+                .DELETE("/api/admin/messages/{id}", messageHandler::deleteMessage)
 
-                // ========== 文件路由 ==========
+                // ========== 文件路由（管理端） ==========
-                .GET("/api/files", fileHandler::getAllFiles)
+                .GET("/api/admin/files", fileHandler::getAllFiles)
-                .GET("/api/files/{id}", fileHandler::getFileById)
+                .GET("/api/admin/files/{id}", fileHandler::getFileById)
-                .POST("/api/files/upload", fileHandler::uploadFile)
+                .POST("/api/admin/files/upload", fileHandler::uploadFile)
-                .GET("/api/files/{id}/download", fileHandler::downloadFile)
+                .GET("/api/admin/files/{id}/download", fileHandler::downloadFile)
-                .GET("/api/files/download/{fileName}", fileHandler::downloadFileByName)
+                .GET("/api/admin/files/download/{fileName}", fileHandler::downloadFileByName)
-                .GET("/api/files/{id}/preview", fileHandler::previewFile)
+                .GET("/api/admin/files/{id}/preview", fileHandler::previewFile)
-                .GET("/api/files/preview/{fileName}", fileHandler::previewFileByName)
+                .GET("/api/admin/files/preview/{fileName}", fileHandler::previewFileByName)
-                .DELETE("/api/files/{id}", fileHandler::deleteFile)
+                .DELETE("/api/admin/files/{id}", fileHandler::deleteFile)
 
-                // ========== 权限路由 ==========
+                // ========== 权限路由（管理端） ==========
-                .GET("/api/permissions", permissionHandler::getAllPermissions)
+                .GET("/api/admin/permissions", permissionHandler::getAllPermissions)
-                .GET("/api/permissions/{id}", permissionHandler::getPermissionById)
+                .GET("/api/admin/permissions/{id}", permissionHandler::getPermissionById)
-                .GET("/api/permissions/code/{code}", permissionHandler::getPermissionByCode)
+                .GET("/api/admin/permissions/code/{code}", permissionHandler::getPermissionByCode)
-                .GET("/api/permissions/check-code", permissionHandler::checkCodeExists)
+                .GET("/api/admin/permissions/check-code", permissionHandler::checkCodeExists)
-                .GET("/api/permissions/count", permissionHandler::getPermissionCount)
+                .GET("/api/admin/permissions/count", permissionHandler::getPermissionCount)
-                .POST("/api/permissions", permissionHandler::createPermission)
+                .POST("/api/admin/permissions", permissionHandler::createPermission)
-                .PUT("/api/permissions/{id}", permissionHandler::updatePermission)
+                .PUT("/api/admin/permissions/{id}", permissionHandler::updatePermission)
-                .DELETE("/api/permissions/{id}", permissionHandler::deletePermission)
+                .DELETE("/api/admin/permissions/{id}", permissionHandler::deletePermission)
 
-                // ========== 会员模块路由 - 微信认证 ==========
+                // ========== 会员模块路由 - 微信认证（前台公开） ==========
                 .POST("/api/member/auth/miniapp/login", wechatAuthHandler::miniappLogin)
                 .GET("/api/member/auth/mp/callback", wechatAuthHandler::verifyMpSignature)
                 .POST("/api/member/auth/mp/callback", wechatAuthHandler::mpCallback)
                 
-                // ========== 会员模块路由 - 会员信息 ==========
+                // ========== 会员模块路由 - 会员信息（前台） ==========
                 .GET("/api/member/info", memberHandler::getMemberInfo)
                 .PUT("/api/member/info", memberHandler::updateMemberInfo)
                 .POST("/api/member/phone/bind", memberHandler::bindPhone)
@@ -228,53 +226,35 @@ public class SystemRouter {
 
 
                 // ========================================
-                // ========== 会员卡管理路由 ==============
+                // ========== 会员卡管理路由（管理端） ==============
                 // ========================================
 
                 // ===== 会员卡类型管理 =====
-                .GET("/api/member-cards/active", memberCardHandler::getActiveCards)
+                .GET("/api/admin/member-cards/active", memberCardHandler::getActiveCards)
-                .GET("/api/member-cards/{memberCardId}", memberCardHandler::getMemberCardById)
+                .GET("/api/admin/member-cards/{memberCardId}", memberCardHandler::getMemberCardById)
-                .POST("/api/member-cards", memberCardHandler::createMemberCard)
+                .POST("/api/admin/member-cards", memberCardHandler::createMemberCard)
 
                 // ===== 会员卡记录管理（核心业务）=====
-                .POST("/api/member-card-records/purchase", memberCardRecordHandler::purchaseCard)
+                .POST("/api/admin/member-card-records/purchase", memberCardRecordHandler::purchaseCard)
-                .POST("/api/member-card-records/{recordId}/renew", memberCardRecordHandler::renewCard)
+                .POST("/api/admin/member-card-records/{recordId}/renew", memberCardRecordHandler::renewCard)
-                .POST("/api/member-card-records/{recordId}/use", memberCardRecordHandler::useCard)
+                .POST("/api/admin/member-card-records/{recordId}/use", memberCardRecordHandler::useCard)
-                .POST("/api/member-card-records/{recordId}/refund", memberCardRecordHandler::refundCard)
+                .POST("/api/admin/member-card-records/{recordId}/refund", memberCardRecordHandler::refundCard)
-                .GET("/api/member-card-records/my-cards/{memberId}", memberCardRecordHandler::getMyCards)
+                .GET("/api/admin/member-card-records/my-cards/{memberId}", memberCardRecordHandler::getMyCards)
-                .GET("/api/member-card-records/{recordId}", memberCardRecordHandler::getMemberCardRecordById)
+                .GET("/api/admin/member-card-records/{recordId}", memberCardRecordHandler::getMemberCardRecordById)
-                .POST("/api/member-card-records/process-expired", memberCardRecordHandler::processExpiredCards)
+                .POST("/api/admin/member-card-records/process-expired", memberCardRecordHandler::processExpiredCards)
 
                 // ===== 会员卡交易流水管理 =====
-                .POST("/api/member-card-transactions", memberCardTransactionHandler::insertTransaction)
+                .POST("/api/admin/member-card-transactions", memberCardTransactionHandler::insertTransaction)
-                .GET("/api/member-card-transactions", memberCardTransactionHandler::getTransactionsWithConditions)
+                .GET("/api/admin/member-card-transactions", memberCardTransactionHandler::getTransactionsWithConditions)
-                .GET("/api/member-card-transactions/member/{memberId}", memberCardTransactionHandler::getMemberTransactions)
+                .GET("/api/admin/member-card-transactions/member/{memberId}", memberCardTransactionHandler::getMemberTransactions)
-                .GET("/api/member-card-transactions/card/{cardId}", memberCardTransactionHandler::getTransactionsByCardId)
+                .GET("/api/admin/member-card-transactions/card/{cardId}", memberCardTransactionHandler::getTransactionsByCardId)
-                .GET("/api/member-card-transactions/statistics/deduct/{cardId}", memberCardTransactionHandler::getDeductCountByCardId)
+                .GET("/api/admin/member-card-transactions/statistics/deduct/{cardId}", memberCardTransactionHandler::getDeductCountByCardId)
-                .GET("/api/member-card-transactions/statistics/renew", memberCardTransactionHandler::getRenewAmountByTimeRange)
+                .GET("/api/admin/member-card-transactions/statistics/renew", memberCardTransactionHandler::getRenewAmountByTimeRange)
-                .GET("/api/member-card-transactions/statistics/purchase/{memberId}", memberCardTransactionHandler::getPurchaseAmountByMember)
+                .GET("/api/admin/member-card-transactions/statistics/purchase/{memberId}", memberCardTransactionHandler::getPurchaseAmountByMember)
 
-                // ========================================
+                // ========= 签到路由（前台会员） ==========
-                // ========== 团课管理路由 =================
+                .POST("/api/member/checkIn", checkInHandler::checkIn)
-                // ========================================
+                .GET("/api/member/checkIn/qrcode", checkInHandler::getQRCode)
-
-                // ===== 团课课程管理 =====
-                .GET("/api/groupCourse/list", groupCourseHandler::getAllGroupCourse)
-                .POST("/api/groupCourse/page", groupCourseHandler::getGroupCoursesByPage)
-                .GET("/api/groupCourse/{id}", groupCourseHandler::getGroupCourseById)
-                .POST("/api/groupCourse", groupCourseHandler::createGroupCourse)
-                .PUT("/api/groupCourse/{id}", groupCourseHandler::updateGroupCourse)
-                .DELETE("/api/groupCourse/{id}", groupCourseHandler::deleteGroupCourse)
-                .POST("/api/groupCourse/{id}/cancel", groupCourseHandler::cancelGroupCourse)
-                .POST("/api/groupCourse/{courseId}/signin", groupCourseHandler::signIn)
-
-                // ===== 团课预约管理 =====
-                .POST("/api/groupCourse/book", groupCourseBookingHandler::bookCourse)
-                .POST("/api/groupCourse/booking/{bookingId}/cancel", groupCourseBookingHandler::cancelBooking)
-                .GET("/api/groupCourse/bookings/member/{memberId}", groupCourseBookingHandler::getBookingsByMemberId)
-                .GET("/api/groupCourse/bookings/{bookingId}", groupCourseBookingHandler::getBookingById)
-                .GET("/api/groupCourse/bookings/course/{courseId}", groupCourseBookingHandler::getBookingsByCourseId)
-                
                 .build();
     }
 }

gym-manage-api/manage-app/src/main/resources/application-dev.yml

@@ -15,7 +15,7 @@ spring:
     url: jdbc:postgresql://localhost:55432/manage_system
     user: novalon
     password: novalon123
-    enabled: true
+    enabled: false
     locations: classpath:db/migration
     baseline-on-migrate: true
     validate-on-migrate: true

gym-manage-api/manage-app/src/main/resources/application.yml

@@ -15,8 +15,8 @@ spring:
       - org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration
   r2dbc:
     url: r2dbc:postgresql://${DB_HOST:localhost}:${DB_PORT:55432}/${DB_NAME:manage_system}
-    username: ${DB_USERNAME:novalon}
+    username: ${DB_USERNAME:postgres}
-    password: ${DB_PASSWORD:novalon123}
+    password: ${DB_PASSWORD:postgres}
     pool:
       initial-size: 10
       max-size: 50
@@ -25,11 +25,11 @@ spring:
       acquire-timeout: 5s
   datasource:
     url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:55432}/${DB_NAME:manage_system}
-    username: ${DB_USERNAME:novalon}
+    username: ${DB_USERNAME:postgres}
-    password: ${DB_PASSWORD:novalon123}
+    password: ${DB_PASSWORD:postgres}
     driver-class-name: org.postgresql.Driver
   flyway:
-    enabled: true
+    enabled: false
     locations: classpath:db/migration
     baseline-on-migrate: true
     baseline-version: 0
@@ -38,25 +38,11 @@ spring:
     user:
       name: disabled
       password: disabled
-  data:
-    redis:
-      host: ${REDIS_HOST:localhost}
-      port: ${REDIS_PORT:6379}
-      password: ${REDIS_PASSWORD:novalon123}
-      timeout: 5000
-      lettuce:
-        pool:
-          max-active: 8  # 最大连接数
-          max-idle: 8    # 最大空闲连接
-          min-idle: 0    # 最小空闲连接
-          max-wait: -1ms # 连接等待时间
   profiles:
     active: dev
   config:
     import: classpath:member-config.yml
 
-
-
 management:
   endpoints:
     web:

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

@@ -56,6 +56,10 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-redis</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/constant/RedisKeyConstants.java

@@ -0,0 +1,64 @@
+package cn.novalon.gym.manage.common.constant;
+
+/**
+ * Redis 缓存 Key 常量类
+ * 统一管理项目中所有 Redis 缓存的 key 前缀
+ *
+ * @author auto-generated
+ * @date 2026-05-30
+ */
+public final class RedisKeyConstants {
+
+    private RedisKeyConstants() {
+    }
+
+    // ==================== 会员模块 ====================
+
+    /**
+     * 会员信息缓存
+     * 格式：member:info:{memberId}
+     */
+    public static final String MEMBER_INFO = "member:info:";
+
+    /**
+     * 会员详情缓存
+     * 格式：member:detail:{memberId}
+     */
+    public static final String MEMBER_DETAIL = "member:detail:";
+
+    /**
+     * 会员卡类型缓存
+     * 格式：member:card:{memberCardId}
+     */
+    public static final String MEMBER_CARD = "member:card:";
+
+    /**
+     * 会员卡记录缓存（包含剩余次数/金额）
+     * 格式：member:card:record:{recordId}
+     */
+    public static final String MEMBER_CARD_RECORD = "member:card:record:";
+
+    /**
+     * 会员退款申请缓存
+     * 格式：member:refund:{recordId}
+     */
+    public static final String MEMBER_REFUND = "member:refund:";
+
+    // ==================== 签到模块 ====================
+
+    /**
+     * 用户当日二维码缓存
+     * 格式：qrcode:user:daily:{userId}:{date}
+     * 示例：qrcode:user:daily:1:2026-05-30
+     */
+    public static final String QRCODE_USER_DAILY = "qrcode:user:daily:";
+
+    // ==================== 微信模块 ====================
+
+    /**
+     * 微信 access_token 缓存
+     * 格式：wechat:access_token:{appType}
+     * appType: miniapp(小程序), mp(公众号)
+     */
+    public static final String WECHAT_ACCESS_TOKEN = "wechat:access_token:";
+}

gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/constants/UserType.java

@@ -0,0 +1,22 @@
+package cn.novalon.gym.manage.common.constants;
+
+/**
+ * 用户类型枚举
+ * 用于区分后台管理用户和前台会员用户
+ */
+public enum UserType {
+    ADMIN,
+    MEMBER;
+
+    public static UserType fromString(String value) {
+        if (value == null) {
+            throw new IllegalArgumentException("userType 不能为空");
+        }
+        for (UserType type : values()) {
+            if (type.name().equalsIgnoreCase(value)) {
+                return type;
+            }
+        }
+        throw new IllegalArgumentException("未知的用户类型: " + value);
+    }
+}

gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/util/RedisUtil.java

@@ -69,12 +69,4 @@ public class RedisUtil {
     public Mono<Boolean> expire(String key, long timeoutSeconds) {
         return reactiveRedisTemplate.expire(key, Duration.ofSeconds(timeoutSeconds));
     }
-
-    /**
-     * 根据通配符模式删除key
-     */
-    public Mono<Long> deleteByPattern(String pattern) {
-        return reactiveRedisTemplate.keys(pattern)
-                .flatMap(keys -> reactiveRedisTemplate.delete(keys)).count();
-    }
 }

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

@@ -99,8 +99,6 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
-
-
     </dependencies>
 
     <build>

gym-manage-api/manage-db/src/main/java/cn/novalon/gym/manage/db/repository/SysUserRepository.java

@@ -10,7 +10,6 @@ import cn.novalon.gym.manage.sys.core.query.SysUserQuery;
 import cn.novalon.gym.manage.sys.core.repository.ISysUserRepository;
 import cn.novalon.gym.manage.common.dto.PageRequest;
 import cn.novalon.gym.manage.common.dto.PageResponse;
-import cn.novalon.gym.manage.sys.dto.response.UserResponse;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.data.relational.core.query.Query;

gym-manage-api/manage-db/src/main/resources/db/migration/V10__Insert_Booking_Test_Data.sql

@@ -1,86 +0,0 @@
--- V10: 团课预约业务场景测试数据
--- 测试场景：
--- 1. 用户A刚刚注册，在没有任何会员卡的情况下申请团课预约
--- 2. 用户B已有时长卡，但已经过期
--- 3. 会员C有时长卡，未过期
--- 4. 会员D有次数卡，但次数卡耗尽次数
--- 5. 会员E有次数卡，且次数充足
--- 6. 会员F有储值卡，但余额不足以支付其预约的团课
--- 7. 会员G有储值卡，余额充足
-
--- ============================================
--- 1. 创建测试会员用户 (A-G)
--- ============================================
-
-INSERT INTO member_user (member_no, nickname, phone, gender, is_deleted, created_at, updated_at) VALUES
-    ('MEM_TEST_A', '用户A_无卡新用户', '13800001001', 1, false, '2026-06-02 10:00:00', '2026-06-02 10:00:00'),
-    ('MEM_TEST_B', '用户B_过期时长卡', '13800001002', 1, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
-    ('MEM_TEST_C', '会员C_有效时长卡', '13800001003', 2, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
-    ('MEM_TEST_D', '会员D_次数用尽', '13800001004', 1, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
-    ('MEM_TEST_E', '会员E_次数充足', '13800001005', 2, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
-    ('MEM_TEST_F', '会员F_储值卡余额不足', '13800001006', 1, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00'),
-    ('MEM_TEST_G', '会员G_储值卡余额充足', '13800001007', 2, false, '2026-05-01 10:00:00', '2026-05-01 10:00:00');
-
--- ============================================
--- 2. 团课课程测试数据（用于预约测试）
--- ============================================
-
--- 团课A: 收费类型为次数卡(点卡额度=1)
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
-    ('燃脂搏击_次数卡课程', 102, 2, '2026-06-10 19:30:00', '2026-06-10 20:30:00', 20, 0, '0', '综合训练区', '高强度间歇训练，配合音乐快速燃脂，消耗1次', 1, 0.00, 'admin', '2026-06-01 10:00:00', '2026-06-01 10:00:00');
-
--- 团课B: 收费类型为储值卡(储值额度=50.00)
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
-    ('高端普拉提_储值卡课程', 103, 1, '2026-06-11 19:00:00', '2026-06-11 20:00:00', 15, 0, '0', '普拉提教室', '精准训练核心肌群，消耗储值50元', 0, 20.00, 'admin', '2026-06-01 10:00:00', '2026-06-01 10:00:00');
-
--- ============================================
--- 3. 会员卡类型定义
--- ============================================
-
-INSERT INTO member_card (member_card_name, member_card_type, member_card_price, member_card_validity_days, member_card_total_times, member_card_amount, member_card_status, extra_config, created_at, updated_at) VALUES
-    ('30天时长卡', 'TIME_CARD', 299.00, 30, NULL, NULL, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'),
-    ('10次卡', 'COUNT_CARD', 499.00, NULL, 10, NULL, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'),
-    ('储值卡500', 'STORED_VALUE_CARD', 500.00, NULL, NULL, 500.00, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00');
-
--- ============================================
--- 4. 会员卡记录测试数据
--- ============================================
-
--- 场景2: 用户B - 时长卡已过期 (expire_time < 当前时间)
--- 购买于30天前，有效期30天，现已过期
-INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
-    ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_B'), (SELECT member_card_id FROM member_card WHERE member_card_name = '30天时长卡'), 'EXPIRED', 0, 0.00, '2026-05-31 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
-
--- 场景3: 会员C - 时长卡未过期 (expire_time > 当前时间)
--- 购买于今天，有效期30天，还有30天有效期
-INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
-    ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_C'), (SELECT member_card_id FROM member_card WHERE member_card_name = '30天时长卡'), 'ACTIVE', 0, 0.00, '2026-07-02 23:59:59', '2026-06-02 10:00:00', 0, '{}', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
-
--- 场景4: 会员D - 次数卡耗尽 (remaining_times = 0)
-INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
-    ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_D'), (SELECT member_card_id FROM member_card WHERE member_card_name = '10次卡'), 'ACTIVE', 0, 0.00, '2026-12-31 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
-
--- 场景5: 会员E - 次数卡充足 (remaining_times >= point_card_amount)
-INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
-    ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_E'), (SELECT member_card_id FROM member_card WHERE member_card_name = '10次卡'), 'ACTIVE', 5, 0.00, '2026-12-31 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
-
--- 场景6: 会员F - 储值卡余额不足 (remaining_amount < stored_value_amount of course)
--- 团课B收费50元，但会员F储值卡只有30元
-INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
-    ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_F'), (SELECT member_card_id FROM member_card WHERE member_card_name = '储值卡500'), 'ACTIVE', 0, 30.00, '2027-06-02 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
-
--- 场景7: 会员G - 储值卡余额充足 (remaining_amount >= stored_value_amount of course)
-INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
-    ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_G'), (SELECT member_card_id FROM member_card WHERE member_card_name = '储值卡500'), 'ACTIVE', 0, 200.00, '2027-06-02 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
-
--- ============================================
--- 5. 测试场景说明
--- ============================================
-
--- 场景1: 用户A无会员卡 -> 预约团课时应提示"无可用会员卡"
--- 场景2: 用户B时长卡已过期 -> 预约团课时应提示"会员卡已过期"
--- 场景3: 会员C时长卡有效 -> 可以正常预约次数卡团课
--- 场景4: 会员D次数为0 -> 预约团课时应提示"剩余次数不足"
--- 场景5: 会员E次数充足 -> 可以正常预约次数卡团课
--- 场景6: 会员F储值卡余额30元，团课需50元 -> 预约时应提示"余额不足"
--- 场景7: 会员G储值卡余额200元，团课需50元 -> 可以正常预约储值卡团课

gym-manage-api/manage-db/src/main/resources/db/migration/V11__Insert_Cancel_Booking_Test_Data.sql

@@ -1,116 +0,0 @@
--- V11: 团课预约取消业务场景测试数据
--- 测试场景：
--- 1. 用户张三使用时长卡预约了团课，需要取消预约
--- 2. 用户李四使用次数卡预约了团课，需要取消预约
--- 3. 用户王五使用储值卡预约了团课，需要取消预约
-
--- ============================================
--- 1. 创建测试会员用户 (张三、李四、王五)
--- ============================================
-
-INSERT INTO member_user (member_no, nickname, phone, gender, is_deleted, created_at, updated_at) VALUES
-    ('MEM_TEST_ZHANG', '张三_时长卡用户', '13800002001', 1, false, '2026-06-02 10:00:00', '2026-06-02 10:00:00'),
-    ('MEM_TEST_LI', '李四_次数卡用户', '13800002002', 1, false, '2026-06-02 10:00:00', '2026-06-02 10:00:00'),
-    ('MEM_TEST_WANG', '王五_储值卡用户', '13800002003', 2, false, '2026-06-02 10:00:00', '2026-06-02 10:00:00');
-
--- ============================================
--- 2. 确保会员卡类型已存在（如果不存在则创建）
--- ============================================
-
--- 时长卡类型（30天）
-INSERT INTO member_card (member_card_name, member_card_type, member_card_price, member_card_validity_days, member_card_total_times, member_card_amount, member_card_status, extra_config, created_at, updated_at) 
-SELECT '30天时长卡', 'TIME_CARD', 299.00, 30, NULL, NULL, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'
-WHERE NOT EXISTS (SELECT 1 FROM member_card WHERE member_card_name = '30天时长卡');
-
--- 次数卡类型（10次）
-INSERT INTO member_card (member_card_name, member_card_type, member_card_price, member_card_validity_days, member_card_total_times, member_card_amount, member_card_status, extra_config, created_at, updated_at) 
-SELECT '10次卡', 'COUNT_CARD', 499.00, NULL, 10, NULL, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'
-WHERE NOT EXISTS (SELECT 1 FROM member_card WHERE member_card_name = '10次卡');
-
--- 储值卡类型（500元）
-INSERT INTO member_card (member_card_name, member_card_type, member_card_price, member_card_validity_days, member_card_total_times, member_card_amount, member_card_status, extra_config, created_at, updated_at) 
-SELECT '储值卡500', 'STORED_VALUE_CARD', 500.00, NULL, NULL, 500.00, 1, '{}', '2026-01-01 00:00:00', '2026-01-01 00:00:00'
-WHERE NOT EXISTS (SELECT 1 FROM member_card WHERE member_card_name = '储值卡500');
-
--- ============================================
--- 3. 为测试用户分配会员卡
--- ============================================
-
--- 张三：时长卡（有效期内）
-INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
-    ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_ZHANG'), 
-     (SELECT member_card_id FROM member_card WHERE member_card_name = '30天时长卡'), 
-     'ACTIVE', 0, 0.00, '2026-07-02 23:59:59', '2026-06-02 10:00:00', 0, '{}', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
-
--- 李四：次数卡（剩余5次）
-INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
-    ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_LI'), 
-     (SELECT member_card_id FROM member_card WHERE member_card_name = '10次卡'), 
-     'ACTIVE', 5, 0.00, '2026-12-31 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
-
--- 王五：储值卡（余额200元）
-INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
-    ((SELECT id FROM member_user WHERE member_no = 'MEM_TEST_WANG'), 
-     (SELECT member_card_id FROM member_card WHERE member_card_name = '储值卡500'), 
-     'ACTIVE', 0, 200.00, '2027-06-02 23:59:59', '2026-05-01 10:00:00', 0, '{}', '2026-05-01 10:00:00', '2026-06-02 10:00:00');
-
--- ============================================
--- 4. 创建用于取消预约测试的团课
--- ============================================
-
--- 团课X: 时长卡可用课程（使用次数卡支付，时长卡会员可预约）
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
-    ('晚间瑜伽_取消测试', 101, 1, '2026-06-15 19:00:00', '2026-06-15 20:00:00', 20, 0, '0', '瑜伽教室', '适合所有级别的瑜伽课程，用于测试取消预约功能', 1, 30.00, 'admin', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
-
--- ============================================
--- 5. 创建已预约的记录（状态为0-已预约）
--- ============================================
-
--- 张三使用时长卡预约团课（状态：已预约）
-INSERT INTO group_course_booking (course_id, member_id, member_card_id, booking_time, status, course_name, course_start_time, course_end_time, location, created_at, updated_at) VALUES
-    ((SELECT id FROM group_course WHERE course_name = '晚间瑜伽_取消测试'),
-     (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_ZHANG'),
-     (SELECT id FROM member_card_record WHERE member_id = (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_ZHANG')),
-     '2026-06-02 11:00:00', '0', '晚间瑜伽_取消测试', '2026-06-15 19:00:00', '2026-06-15 20:00:00', '瑜伽教室',
-     '2026-06-02 11:00:00', '2026-06-02 11:00:00');
-
--- 李四使用次数卡预约团课（状态：已预约）
-INSERT INTO group_course_booking (course_id, member_id, member_card_id, booking_time, status, course_name, course_start_time, course_end_time, location, created_at, updated_at) VALUES
-    ((SELECT id FROM group_course WHERE course_name = '晚间瑜伽_取消测试'),
-     (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_LI'),
-     (SELECT id FROM member_card_record WHERE member_id = (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_LI')),
-     '2026-06-02 11:30:00', '0', '晚间瑜伽_取消测试', '2026-06-15 19:00:00', '2026-06-15 20:00:00', '瑜伽教室',
-     '2026-06-02 11:30:00', '2026-06-02 11:30:00');
-
--- 王五使用储值卡预约团课（状态：已预约）
-INSERT INTO group_course_booking (course_id, member_id, member_card_id, booking_time, status, course_name, course_start_time, course_end_time, location, created_at, updated_at) VALUES
-    ((SELECT id FROM group_course WHERE course_name = '晚间瑜伽_取消测试'),
-     (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_WANG'),
-     (SELECT id FROM member_card_record WHERE member_id = (SELECT id FROM member_user WHERE member_no = 'MEM_TEST_WANG')),
-     '2026-06-02 12:00:00', '0', '晚间瑜伽_取消测试', '2026-06-15 19:00:00', '2026-06-15 20:00:00', '瑜伽教室',
-     '2026-06-02 12:00:00', '2026-06-02 12:00:00');
-
--- ============================================
--- 6. 更新团课当前预约人数
--- ============================================
-
-UPDATE group_course 
-SET current_members = current_members + 3 
-WHERE course_name = '晚间瑜伽_取消测试';
-
--- ============================================
--- 测试数据说明
--- ============================================
--- 用户信息：
--- 张三 (MEM_TEST_ZHANG): 13800002001 - 持有有效期内的时长卡
--- 李四 (MEM_TEST_LI): 13800002002 - 持有次数卡（剩余5次）
--- 王五 (MEM_TEST_WANG): 13800002003 - 持有储值卡（余额200元）
-
--- 测试场景：
--- 1. 张三使用时长卡预约了团课 -> 取消预约 -> 应恢复时长卡状态，释放课程名额
--- 2. 李四使用次数卡预约了团课 -> 取消预约 -> 应返还扣除的次数，释放课程名额
--- 3. 王五使用储值卡预约了团课 -> 取消预约 -> 应返还扣除的金额，释放课程名额
-
--- 预约记录状态说明：
--- status = '0' 表示已预约
--- status = '1' 表示已取消（取消后应更新为此状态）

gym-manage-api/manage-db/src/main/resources/db/migration/V12__Insert_Time_Conflict_Test_Data.sql

@@ -1,58 +0,0 @@
--- V12: 团课预约时间冲突测试数据
--- 测试场景：会员预约两个时间重叠的团课时，系统应检测到时间冲突并拒绝预约
-
--- ============================================
--- 1. 创建测试会员
--- ============================================
-
-INSERT INTO member_user (member_no, nickname, phone, gender, is_deleted, created_at, updated_at) VALUES
-    ('MEM_TIME_CONFLICT', '时间冲突测试会员', '13800009999', 1, false, '2026-06-02 10:00:00', '2026-06-02 10:00:00');
-
--- ============================================
--- 2. 创建时间冲突的团课
--- ============================================
-
--- 团课A: 6月15日 13:00 - 15:00
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
-    ('时间冲突测试_A_13点-15点', 102, 2, '2026-06-15 13:00:00', '2026-06-15 15:00:00', 20, 0, '0', '综合训练区', '测试用团课A，用于验证时间冲突检测', 1, 0.00, 'admin', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
-
--- 团课B: 6月15日 14:00 - 16:00 (与团课A时间重叠)
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
-    ('时间冲突测试_B_14点-16点', 103, 1, '2026-06-15 14:00:00', '2026-06-15 16:00:00', 15, 0, '0', '普拉提教室', '测试用团课B，与团课A时间重叠（14:00-15:00）', 1, 0.00, 'admin', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
-
--- 团课C: 6月15日 10:00 - 12:00 (不冲突，作为对照)
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, point_card_amount, stored_value_amount, create_by, created_at, updated_at) VALUES
-    ('时间冲突测试_C_10点-12点', 101, 1, '2026-06-15 10:00:00', '2026-06-15 12:00:00', 15, 0, '0', '瑜伽教室', '测试用团课C，与团课A/B不冲突', 1, 0.00, 'admin', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
-
--- ============================================
--- 3. 会员卡记录（用于预约）
--- ============================================
-
--- 为时间冲突测试会员创建有效次数卡
-INSERT INTO member_card_record (member_id, member_card_id, status, remaining_times, remaining_amount, expire_time, purchase_time, version, card_composition, created_at, updated_at) VALUES
-    ((SELECT id FROM member_user WHERE member_no = 'MEM_TIME_CONFLICT'), (SELECT member_card_id FROM member_card WHERE member_card_name = '10次卡'), 'ACTIVE', 10, 0.00, '2026-12-31 23:59:59', '2026-06-02 10:00:00', 0, '{}', '2026-06-02 10:00:00', '2026-06-02 10:00:00');
-
--- ============================================
--- 4. 测试场景说明
--- ============================================
--- 
--- 测试步骤：
--- 1. 使用会员 MEM_TIME_CONFLICT 预约团课A (course_name='时间冲突测试_A_13点-15点')
---    → 预期：预约成功
--- 
--- 2. 使用会员 MEM_TIME_CONFLICT 预约团课B (course_name='时间冲突测试_B_14点-16点')
---    → 预期：预约失败，提示时间冲突（14:00-15:00与已预约的团课A重叠）
--- 
--- 3. 使用会员 MEM_TIME_CONFLICT 预约团课C (course_name='时间冲突测试_C_10点-12点')
---    → 预期：预约成功（与团课A时间不冲突）
--- 
--- 时间冲突判断逻辑：
--- 新课程开始时间 < 已预约课程结束时间 AND 新课程结束时间 > 已预约课程开始时间
--- 即：newStartTime < existingEndTime AND newEndTime > existingStartTime
--- 
--- 本测试数据中的时间关系：
--- - 团课A: 13:00 - 15:00
--- - 团课B: 14:00 - 16:00
---   → 14:00 < 15:00 AND 16:00 > 13:00 → 冲突
--- - 团课C: 10:00 - 12:00
---   → 10:00 < 15:00 AND 12:00 > 13:00 → 12:00 > 13:00 不成立 → 不冲突

gym-manage-api/manage-db/src/main/resources/db/migration/V6__Create_GroupCourse_table.sql

@@ -1,77 +0,0 @@
--- ============================================
--- 团课相关表
--- ============================================
-
--- 团课课程表
-CREATE TABLE IF NOT EXISTS group_course (
-    id BIGSERIAL PRIMARY KEY,
-    course_name VARCHAR(100) NOT NULL,
-    coach_id BIGINT,
-    course_type BIGINT,
-    start_time TIMESTAMP NOT NULL,
-    end_time TIMESTAMP NOT NULL,
-    max_members INTEGER DEFAULT 20,
-    current_members INTEGER DEFAULT 0,
-    status VARCHAR(1) DEFAULT '0',
-    location VARCHAR(255),
-    cover_image VARCHAR(500),
-    description TEXT,
-    point_card_amount INTEGER DEFAULT 1,
-    stored_value_amount DECIMAL(10,2) DEFAULT 0,
-    create_by VARCHAR(50),
-    update_by VARCHAR(50),
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    deleted_at TIMESTAMP
-);
-
--- 团课预约记录表
-CREATE TABLE IF NOT EXISTS group_course_booking (
-    id BIGSERIAL PRIMARY KEY,
-    course_id BIGINT NOT NULL,
-    member_id BIGINT NOT NULL,
-    member_card_id BIGINT NOT NULL,
-    booking_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    status VARCHAR(1) DEFAULT '0',
-    cancel_time TIMESTAMP,
-    create_by VARCHAR(50),
-    update_by VARCHAR(50),
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    deleted_at TIMESTAMP
-);
-
-COMMENT ON TABLE group_course IS '团课课程表';
-COMMENT ON COLUMN group_course.id IS '主键ID';
-COMMENT ON COLUMN group_course.course_name IS '课程名称';
-COMMENT ON COLUMN group_course.coach_id IS '教练ID（关联sys_user）';
-COMMENT ON COLUMN group_course.course_type IS '课程类型（如瑜伽/普拉提/动感单车）';
-COMMENT ON COLUMN group_course.start_time IS '开始时间';
-COMMENT ON COLUMN group_course.end_time IS '结束时间';
-COMMENT ON COLUMN group_course.max_members IS '最大参与人数';
-COMMENT ON COLUMN group_course.current_members IS '当前参与人数';
-COMMENT ON COLUMN group_course.status IS '状态（0正常 1已取消 2已结束）';
-COMMENT ON COLUMN group_course.location IS '上课地点';
-COMMENT ON COLUMN group_course.cover_image IS '封面图URL';
-COMMENT ON COLUMN group_course.description IS '课程描述';
-COMMENT ON COLUMN group_course.point_card_amount IS '点卡额度（消耗次数）';
-COMMENT ON COLUMN group_course.stored_value_amount IS '储值卡额度（消耗金额）';
-COMMENT ON COLUMN group_course.create_by IS '创建人';
-COMMENT ON COLUMN group_course.update_by IS '更新人';
-COMMENT ON COLUMN group_course.created_at IS '创建时间';
-COMMENT ON COLUMN group_course.updated_at IS '更新时间';
-COMMENT ON COLUMN group_course.deleted_at IS '删除时间（软删除）';
-
-COMMENT ON TABLE group_course_booking IS '团课预约记录表';
-COMMENT ON COLUMN group_course_booking.id IS '主键ID';
-COMMENT ON COLUMN group_course_booking.course_id IS '团课ID';
-COMMENT ON COLUMN group_course_booking.member_id IS '用户ID';
-COMMENT ON COLUMN group_course_booking.member_card_id IS '会员卡ID';
-COMMENT ON COLUMN group_course_booking.booking_time IS '预约时间';
-COMMENT ON COLUMN group_course_booking.status IS '状态（0已预约 1已取消 2已出席 3缺席）';
-COMMENT ON COLUMN group_course_booking.cancel_time IS '取消时间';
-COMMENT ON COLUMN group_course_booking.create_by IS '创建人';
-COMMENT ON COLUMN group_course_booking.update_by IS '更新人';
-COMMENT ON COLUMN group_course_booking.created_at IS '创建时间';
-COMMENT ON COLUMN group_course_booking.updated_at IS '更新时间';
-COMMENT ON COLUMN group_course_booking.deleted_at IS '删除时间（软删除）';

gym-manage-api/manage-db/src/main/resources/db/migration/V7__Insert_GroupCourse_test_data.sql

@@ -1,28 +0,0 @@
--- 场景1: 0人预约，可预约（正常状态，6月15日，距开始还有14天）
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
-    ('极速燃脂单车', 104, 2, '2026-06-02 16:45:00', '2026-06-15 20:20:00', 25, 0, 0, '单车房', '/images/spinning.jpg', '跟随音乐节奏变换阻力和速度，体验爬坡与冲刺的快感，一节课消耗800大卡。', 'admin', '2026-06-01 11:00:00', '2026-06-01 11:00:00');
-
--- 场景2: 已有人预约，可预约（正常状态，6月12日，5/15人）
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
-    ('清晨流瑜伽', 101, 1, '2026-06-12 09:00:00', '2026-06-12 10:30:00', 15, 5, 0, 'A座3楼瑜伽教室', '/images/yoga_flow.jpg', '适合有一定基础的学员，通过流畅的体式连接呼吸，唤醒身体能量。', 'admin', '2026-06-01 10:00:00', '2026-06-01 10:00:00');
-
--- 场景3: 满员，不可预约（正常状态但已满员，6月10日，20/20人）
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
-    ('燃脂搏击', 102, 2, '2026-06-10 18:30:00', '2026-06-10 19:30:00', 20, 20, 0, '综合训练区', '/images/kickboxing.jpg', '高强度间歇训练，配合音乐快速燃脂，释放压力。名额已满，无法预约。', 'coach_zhang', '2026-06-01 14:30:00', '2026-06-01 14:30:00');
-
--- 场景4: 超出可预约时间，不可预约（正常状态但距开始不足30分钟）
--- 当前时间: 2026-06-01 15:00，课程开始: 2026-06-01 15:20
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
-    ('哈他瑜伽', 101, 1, '2026-06-01 15:20:00', '2026-06-01 16:50:00', 12, 3, 0, '瑜伽教室B', '/images/hatha_yoga.jpg', '基础哈他瑜伽，适合所有级别。距开始不足30分钟，已停止预约。', 'coach_li', '2026-06-01 08:00:00', '2026-06-01 08:00:00');
-
--- 场景5: 课程已取消，不可预约（status=1）
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
-    ('周末冥想修复', 101, 1, '2026-06-20 15:00:00', '2026-06-20 16:00:00', 12, 3, 1, '冥想室', '/images/meditation.jpg', '通过呼吸和正念冥想，深度放松身心。该课程已被取消。', 'coach_wang', '2026-05-28 08:00:00', '2026-05-28 08:00:00');
-
--- 场景6: 课程已结束，不可预约（status=2）
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
-    ('蜜桃臀塑造', 103, 3, '2026-05-30 19:00:00', '2026-05-30 20:00:00', 10, 8, 2, '私教专区', '/images/glute.jpg', '针对性训练臀部肌肉群，课程已于5月30日结束，无法预约。', 'coach_li', '2026-05-20 09:15:00', '2026-05-20 09:15:00');
-
--- 场景7（可选）: 已结束但未满员的课程（status=2，即使有空位也不可预约）
-INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
-    ('午间冥想放松', 101, 1, '2026-05-31 12:00:00', '2026-05-31 13:00:00', 15, 6, 2, '冥想室', '/images/meditation_noon.jpg', '午间冥想课程，已于5月31日结束。', 'admin', '2026-05-25 09:00:00', '2026-05-25 09:00:00');

gym-manage-api/manage-db/src/main/resources/db/migration/V8__Create_Member_And_MemberCard.sql

@@ -1,281 +0,0 @@
--- ============================================
--- 1. member_user 表（会员表）
--- ============================================
-
--- Step 1: 删除已存在的表（如果需要重建）
--- DROP TABLE IF EXISTS member_user CASCADE;
-
--- Step 2: 创建 member_user 表
-CREATE TABLE IF NOT EXISTS member_user (
-    -- ========== 主键和基础字段（来自BaseEntity）==========
-                                           id BIGSERIAL PRIMARY KEY,                                      -- 主键ID，自增
-                                           created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,      -- 创建时间
-                                           updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,      -- 更新时间
-
-    -- ========== 会员核心字段 ==========
-                                           member_no VARCHAR(50) NOT NULL UNIQUE,                         -- 会员编号（唯一）
-    nickname VARCHAR(100),                                         -- 昵称
-    phone VARCHAR(255),                                            -- 手机号（AES加密存储）
-    gender INTEGER DEFAULT 0,                                      -- 性别：0-未知，1-男，2-女
-    birthday DATE,                                            -- 生日
-    address VARCHAR(500),                                          -- 地址
-    avatar VARCHAR(500),                                           -- 头像URL
-    subscribed BOOLEAN DEFAULT FALSE,                              -- 是否关注服务号
-    last_login_at TIMESTAMP,                                       -- 最后登录时间
-
--- ========== 微信相关字段 ==========
-    union_id VARCHAR(100),                                         -- 微信UnionID（跨应用唯一标识）
-    miniapp_open_id VARCHAR(100),                                  -- 小程序OpenID
-    official_open_id VARCHAR(100),                                 -- 服务号OpenID
-
--- ========== 软删除字段 ==========
-    is_deleted BOOLEAN DEFAULT FALSE                               -- 是否删除（软删除标记）
-    );
-
--- Step 3: 创建索引
--- 会员编号索引（唯一索引，加速查询）
-CREATE UNIQUE INDEX IF NOT EXISTS idx_member_user_member_no ON member_user(member_no);
-
--- UnionID索引（加速跨平台用户查找）
-CREATE INDEX IF NOT EXISTS idx_member_user_union_id ON member_user(union_id);
-
--- 小程序OpenID索引（加速小程序登录查询）
-CREATE INDEX IF NOT EXISTS idx_member_user_miniapp_openid ON member_user(miniapp_open_id);
-
--- 服务号OpenID索引（加速服务号事件处理）
-CREATE INDEX IF NOT EXISTS idx_member_user_official_openid ON member_user(official_open_id);
-
--- 手机号索引（加速手机号查询和去重）
-CREATE INDEX IF NOT EXISTS idx_member_user_phone ON member_user(phone);
-
--- 软删除索引（加速查询未删除的记录）
-CREATE INDEX IF NOT EXISTS idx_member_user_is_deleted ON member_user(is_deleted);
-
--- Step 4: 添加注释
-COMMENT ON TABLE member_user IS '会员表';
-
-COMMENT ON COLUMN member_user.id IS '主键ID';
-COMMENT ON COLUMN member_user.created_at IS '创建时间';
-COMMENT ON COLUMN member_user.updated_at IS '更新时间';
-
-COMMENT ON COLUMN member_user.member_no IS '会员编号（唯一，格式：MEM + 8位随机字符）';
-COMMENT ON COLUMN member_user.nickname IS '昵称';
-COMMENT ON COLUMN member_user.phone IS '手机号（AES-128-CBC加密存储）';
-COMMENT ON COLUMN member_user.gender IS '性别：0-未知，1-男，2-女';
-COMMENT ON COLUMN member_user.birthday IS '生日';
-COMMENT ON COLUMN member_user.address IS '地址';
-COMMENT ON COLUMN member_user.avatar IS '头像URL';
-COMMENT ON COLUMN member_user.subscribed IS '是否关注服务号：true-已关注，false-未关注';
-COMMENT ON COLUMN member_user.last_login_at IS '最后登录时间';
-
-COMMENT ON COLUMN member_user.union_id IS '微信UnionID（用户在开放平台的唯一标识，跨应用相同）';
-COMMENT ON COLUMN member_user.miniapp_open_id IS '小程序OpenID（用户在当前小程序的唯一标识）';
-COMMENT ON COLUMN member_user.official_open_id IS '服务号OpenID（用户在当前服务号的唯一标识）';
-
-COMMENT ON COLUMN member_user.is_deleted IS '是否删除（软删除标记）：false-正常，true-已删除';
-
-
--- ============================================
--- 2. wechat_user 表（微信用户表）
--- ============================================
-
--- Step 1: 删除已存在的表（如果需要重建）
--- DROP TABLE IF EXISTS wechat_user CASCADE;
-
--- Step 2: 创建 wechat_user 表
-CREATE TABLE IF NOT EXISTS wechat_user (
-    -- ========== 主键和基础字段（来自BaseEntity）==========
-                                           id BIGSERIAL PRIMARY KEY,                                      -- 主键ID，自增
-                                           created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,      -- 创建时间
-                                           updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,      -- 更新时间
-
-    -- ========== 关联字段 ==========
-                                           member_id BIGINT NOT NULL,                                     -- 会员ID（外键）
-
-    -- ========== 微信标识字段 ==========
-                                           union_id VARCHAR(100),                                         -- 微信UnionID
-    miniapp_openid VARCHAR(100),                                   -- 小程序OpenID
-    mp_openid VARCHAR(100),                                        -- 服务号OpenID
-
--- ========== 关注状态字段 ==========
-    is_subscribed BOOLEAN DEFAULT FALSE,                           -- 是否关注服务号
-    subscribe_time TIMESTAMP,                                      -- 首次关注时间
-    unsubscribe_time TIMESTAMP                                     -- 最后一次取消关注时间
-    );
-
--- Step 3: 创建外键约束
-ALTER TABLE wechat_user
-    ADD CONSTRAINT fk_wechat_user_member
-        FOREIGN KEY (member_id) REFERENCES member_user(id) ON DELETE CASCADE;
-
--- Step 4: 创建索引
--- UnionID索引（加速跨平台用户查找）
-CREATE INDEX IF NOT EXISTS idx_wechat_user_union_id ON wechat_user(union_id);
-
--- 小程序OpenID索引（加速小程序登录查询）
-CREATE INDEX IF NOT EXISTS idx_wechat_user_miniapp_openid ON wechat_user(miniapp_openid);
-
--- 服务号OpenID索引（加速服务号事件处理）
-CREATE INDEX IF NOT EXISTS idx_wechat_user_mp_openid ON wechat_user(mp_openid);
-
--- 会员ID索引（加速关联查询）
-CREATE INDEX IF NOT EXISTS idx_wechat_user_member_id ON wechat_user(member_id);
-
--- Step 5: 添加注释
-COMMENT ON TABLE wechat_user IS '微信用户表';
-
-COMMENT ON COLUMN wechat_user.id IS '主键ID';
-COMMENT ON COLUMN wechat_user.created_at IS '创建时间';
-COMMENT ON COLUMN wechat_user.updated_at IS '更新时间';
-
-COMMENT ON COLUMN wechat_user.member_id IS '会员ID（关联 member_user 表的 id 字段）';
-COMMENT ON COLUMN wechat_user.union_id IS '微信UnionID（用户在开放平台的唯一标识）';
-COMMENT ON COLUMN wechat_user.miniapp_openid IS '小程序OpenID（用户在当前小程序的唯一标识）';
-COMMENT ON COLUMN wechat_user.mp_openid IS '服务号OpenID（用户在当前服务号的唯一标识）';
-
-COMMENT ON COLUMN wechat_user.is_subscribed IS '是否关注服务号：true-已关注，false-未关注';
-COMMENT ON COLUMN wechat_user.subscribe_time IS '首次关注时间';
-COMMENT ON COLUMN wechat_user.unsubscribe_time IS '最后一次取消关注时间';
-
-
--- ============================================
--- 3. member_card 表（会员卡类型表）
--- ============================================
-CREATE TABLE IF NOT EXISTS member_card (
-                                           id BIGSERIAL PRIMARY KEY,
-                                           created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-                                           updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-                                           deleted_at TIMESTAMP,
-
-                                           member_card_id BIGSERIAL,
-                                           member_card_name VARCHAR(100) NOT NULL,
-    member_card_type VARCHAR(20) NOT NULL,
-    member_card_price DECIMAL(10, 2) NOT NULL,
-    member_card_validity_days INTEGER,
-    member_card_total_times INTEGER,
-    member_card_amount DECIMAL(10, 2),
-    member_card_status INTEGER DEFAULT 1 NOT NULL,
-    extra_config TEXT DEFAULT '{}'
-    );
-
-COMMENT ON TABLE member_card IS '会员卡类型表';
-COMMENT ON COLUMN member_card.member_card_id IS '会员卡ID';
-COMMENT ON COLUMN member_card.member_card_name IS '会员卡名称';
-COMMENT ON COLUMN member_card.member_card_type IS '会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡';
-COMMENT ON COLUMN member_card.member_card_price IS '会员卡价格';
-COMMENT ON COLUMN member_card.member_card_validity_days IS '有效天数（时长卡用）';
-COMMENT ON COLUMN member_card.member_card_total_times IS '总次数（次卡用）';
-COMMENT ON COLUMN member_card.member_card_amount IS '面额（储值卡用）';
-COMMENT ON COLUMN member_card.member_card_status IS '状态：0-下架, 1-上架';
-COMMENT ON COLUMN member_card.extra_config IS '扩展配置（JSON格式）';
-
-
--- ============================================
--- 4. member_card_record 表（会员卡记录表）
--- ============================================
-CREATE TABLE IF NOT EXISTS member_card_record (
-                                                  id BIGSERIAL PRIMARY KEY,
-                                                  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-                                                  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-                                                  deleted_at TIMESTAMP,
-
-                                                  member_card_record_id BIGSERIAL,
-                                                  member_id BIGINT NOT NULL,
-                                                  member_card_id BIGINT NOT NULL,
-                                                  status VARCHAR(20) NOT NULL DEFAULT 'ACTIVE',
-    remaining_times INTEGER DEFAULT 0,
-    remaining_amount DECIMAL(10, 2) DEFAULT 0.00,
-    expire_time TIMESTAMP,
-    source_order_id BIGINT,
-    purchase_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    version INTEGER DEFAULT 0 NOT NULL,
-    card_composition TEXT
-    );
-
--- 索引优化
-CREATE INDEX IF NOT EXISTS idx_member_card_record_member_id ON member_card_record(member_id);
-CREATE INDEX IF NOT EXISTS idx_member_card_record_status ON member_card_record(status);
-CREATE INDEX IF NOT EXISTS idx_member_card_record_expire_time ON member_card_record(expire_time);
-CREATE INDEX IF NOT EXISTS idx_member_card_record_member_status ON member_card_record(member_id, status);
-CREATE INDEX IF NOT EXISTS idx_member_card_record_status_expire ON member_card_record(status, expire_time)
-    WHERE status = 'ACTIVE';
-
-COMMENT ON TABLE member_card_record IS '会员卡记录表（会员持有的卡）';
-COMMENT ON COLUMN member_card_record.member_card_record_id IS '会员卡记录ID';
-COMMENT ON COLUMN member_card_record.member_id IS '会员ID';
-COMMENT ON COLUMN member_card_record.member_card_id IS '会员卡类型ID';
-COMMENT ON COLUMN member_card_record.status IS '状态：ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款';
-COMMENT ON COLUMN member_card_record.remaining_times IS '剩余次数';
-COMMENT ON COLUMN member_card_record.remaining_amount IS '剩余金额';
-COMMENT ON COLUMN member_card_record.expire_time IS '到期时间';
-COMMENT ON COLUMN member_card_record.source_order_id IS '来源订单ID';
-COMMENT ON COLUMN member_card_record.purchase_time IS '购买时间';
-COMMENT ON COLUMN member_card_record.version IS '乐观锁版本号';
-COMMENT ON COLUMN member_card_record.card_composition IS '卡片组成（JSON格式，用于组合卡）';
-
-
--- ============================================
--- 5. member_card_transactions 表（会员卡交易流水表）
--- ============================================
-CREATE TABLE IF NOT EXISTS member_card_transactions (
-                                                        id BIGSERIAL PRIMARY KEY,
-                                                        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-
-                                                        member_card_record_id BIGINT NOT NULL,
-                                                        member_id BIGINT NOT NULL,
-                                                        member_card_id BIGINT NOT NULL,
-                                                        operation_type VARCHAR(20) NOT NULL,
-    change_amount INTEGER DEFAULT 0,
-    change_balance DECIMAL(10, 2) DEFAULT 0.00,
-    after_remaining_count INTEGER DEFAULT 0,
-    after_remaining_balance DECIMAL(10, 2) DEFAULT 0.00,
-    related_biz_type VARCHAR(20),
-    source_order_id BIGINT,
-    remark VARCHAR(500),
-    is_archived BOOLEAN DEFAULT FALSE,
-    archived_at TIMESTAMP
-    );
-
--- 索引优化
-CREATE INDEX IF NOT EXISTS idx_member_card_transactions_member_id ON member_card_transactions(member_id);
-CREATE INDEX IF NOT EXISTS idx_member_card_transactions_record_id ON member_card_transactions(member_card_record_id);
-CREATE INDEX IF NOT EXISTS idx_member_card_transactions_created_at ON member_card_transactions(created_at);
-CREATE INDEX IF NOT EXISTS idx_member_card_transactions_member_type_time
-    ON member_card_transactions(member_id, operation_type, created_at);
-
-COMMENT ON TABLE member_card_transactions IS '会员卡交易流水表';
-COMMENT ON COLUMN member_card_transactions.operation_type IS '操作类型：PURCHASE-购买, DEDUCT-扣次/扣费, RENEW-续费, REFUND-退款, EXPIRE-过期';
-COMMENT ON COLUMN member_card_transactions.change_amount IS '变动次数';
-COMMENT ON COLUMN member_card_transactions.change_balance IS '变动金额';
-COMMENT ON COLUMN member_card_transactions.after_remaining_count IS '变动后剩余次数';
-COMMENT ON COLUMN member_card_transactions.after_remaining_balance IS '变动后剩余金额';
-COMMENT ON COLUMN member_card_transactions.related_biz_type IS '关联业务类型：GROUP_CLASS-团课, PT_CLASS-私教, CHECK_IN-签到';
-COMMENT ON COLUMN member_card_transactions.is_archived IS '是否已归档';
-COMMENT ON COLUMN member_card_transactions.archived_at IS '归档时间';
-
-
--- ============================================
--- 6. refund_application 表（退款申请表）
--- ============================================
-CREATE TABLE IF NOT EXISTS refund_application (
-                                                  id BIGSERIAL PRIMARY KEY,
-                                                  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-                                                  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-                                                  deleted_at TIMESTAMP,
-
-                                                  record_id BIGINT NOT NULL,
-                                                  member_id BIGINT NOT NULL,
-                                                  status VARCHAR(20) NOT NULL DEFAULT 'PENDING',
-    reason VARCHAR(500),
-    apply_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    audit_time TIMESTAMP,
-    auditor_id BIGINT,
-    audit_remark VARCHAR(500),
-    refund_amount DECIMAL(10, 2)
-    );
-
-CREATE INDEX IF NOT EXISTS idx_refund_application_record_id ON refund_application(record_id);
-CREATE INDEX IF NOT EXISTS idx_refund_application_status ON refund_application(status);
-
-COMMENT ON TABLE refund_application IS '退款申请表';
-COMMENT ON COLUMN refund_application.status IS '状态：PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败';

gym-manage-api/manage-db/src/main/resources/db/migration/V9__Add_GroupCourse_Booking_Snapshot_Fields.sql

@@ -1,15 +0,0 @@
--- ============================================
--- 为团课预约记录表添加课程冗余字段
--- 用于保存预约时的课程快照信息
--- ============================================
-
-ALTER TABLE group_course_booking
-    ADD COLUMN IF NOT EXISTS course_name VARCHAR(100),
-    ADD COLUMN IF NOT EXISTS course_start_time TIMESTAMP,
-    ADD COLUMN IF NOT EXISTS course_end_time TIMESTAMP,
-    ADD COLUMN IF NOT EXISTS location VARCHAR(255);
-
-COMMENT ON COLUMN group_course_booking.course_name IS '课程名称（冗余字段，保存预约时的课程快照）';
-COMMENT ON COLUMN group_course_booking.course_start_time IS '课程开始时间（冗余字段，保存预约时的课程快照）';
-COMMENT ON COLUMN group_course_booking.course_end_time IS '课程结束时间（冗余字段，保存预约时的课程快照）';
-COMMENT ON COLUMN group_course_booking.location IS '上课地点（冗余字段，保存预约时的课程快照）';

gym-manage-api/manage-gateway/src/main/java/cn/novalon/gym/manage/gateway/filter/JwtAuthenticationFilter.java

@@ -42,6 +42,13 @@ public class JwtAuthenticationFilter extends AbstractGatewayFilterFactory<JwtAut
                 return exchange.getResponse().setComplete();
             }
 
+            // 路径-userType 校验：防止越权访问
+            String userType = jwtUtil.getUserTypeFromToken(token);
+            if (!isUserTypeAllowedForPath(path, userType)) {
+                exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
+                return exchange.getResponse().setComplete();
+            }
+
             String username = jwtUtil.getUsernameFromToken(token);
             Long userId = jwtUtil.getUserIdFromToken(token);
 
@@ -49,18 +56,34 @@ public class JwtAuthenticationFilter extends AbstractGatewayFilterFactory<JwtAut
                     .header("X-User-Id", String.valueOf(userId))
                     .header("X-Member-Id", String.valueOf(userId))
                     .header("X-Username", username)
+                    .header("X-User-Type", userType != null ? userType : "UNKNOWN")
                     .build();
 
             return chain.filter(exchange.mutate().request(modifiedRequest).build());
         };
     }
 
+    /**
+     * 校验路径与 userType 是否匹配
+     * - /api/admin/** 路径只允许 userType=ADMIN
+     * - /api/member/** 路径只允许 userType=MEMBER
+     * - 其他路径不做 userType 校验
+     */
+    private boolean isUserTypeAllowedForPath(String path, String userType) {
+        if (path.startsWith("/api/admin/")) {
+            return "ADMIN".equals(userType);
+        }
+        if (path.startsWith("/api/member/")) {
+            return "MEMBER".equals(userType);
+        }
+        // 非特定前缀路径不做 userType 校验
+        return true;
+    }
+
     private boolean isPublicPath(String path) {
-        return path.startsWith("/api/auth/") || 
+        return path.startsWith("/api/admin/auth/") || 
                path.equals("/actuator/health") ||
-               path.equals("/api/member/auth/miniapp/login") || 
+               path.startsWith("/api/member/auth/") || 
-               path.equals("/api/member/auth/mp/callback") || 
-               path.equals("/api/auth/login") || 
                path.startsWith("/actuator/info");
     }
 

gym-manage-api/manage-gateway/src/main/java/cn/novalon/gym/manage/gateway/filter/RbacAuthorizationFilter.java

@@ -61,9 +61,10 @@ public class RbacAuthorizationFilter extends AbstractGatewayFilterFactory<RbacAu
     }
 
     private boolean isPublicPath(String path) {
-        return path.startsWith("/api/auth/") || 
+        return path.startsWith("/api/auth/") ||
                path.equals("/actuator/health") ||
-               path.startsWith("/actuator/info");
+               path.startsWith("/actuator/info") ||
+               path.startsWith("/api/checkIn/");
     }
 
     public static class Config {

gym-manage-api/manage-gateway/src/main/java/cn/novalon/gym/manage/gateway/util/JwtUtil.java

@@ -28,6 +28,10 @@ public class JwtUtil {
     }
 
     public String generateToken(String username, Long userId) {
+        return generateToken(username, userId, "ADMIN");
+    }
+
+    public String generateToken(String username, Long userId, String userType) {
         Date now = new Date();
         Date expiryDate = new Date(now.getTime() + expiration);
 
@@ -35,13 +39,14 @@ public class JwtUtil {
             String token = Jwts.builder()
                     .setSubject(username)
                     .claim("userId", userId)
+                    .claim("userType", userType)
                     .claim("keyVersion", jwtKeyService.getCurrentKeyVersion())
                     .setIssuedAt(now)
                     .setExpiration(expiryDate)
                     .signWith(getSigningKey())
                     .compact();
             
-            logger.debug("Generated JWT token for user: {}, userId: {}", username, userId);
+            logger.debug("Generated JWT token for user: {}, userId: {}, userType: {}", username, userId, userType);
             return token;
             
         } catch (Exception e) {
@@ -74,6 +79,11 @@ public class JwtUtil {
         return claims.get("userId", Long.class);
     }
 
+    public String getUserTypeFromToken(String token) {
+        Claims claims = parseToken(token);
+        return claims.get("userType", String.class);
+    }
+
     public boolean validateToken(String token) {
         try {
             parseToken(token);

gym-manage-api/manage-gateway/src/main/resources/application.yml

@@ -64,7 +64,7 @@ signature:
   max-age-minutes: ${SIGNATURE_MAX_AGE_MINUTES:5}
   nonce-cache-size: ${SIGNATURE_NONCE_CACHE_SIZE:10000}
   whitelist:
-    paths: ${SIGNATURE_WHITELIST_PATHS:/actuator/health,/actuator/info,/api/auth/login,/api/auth/register,/api/member/auth/miniapp/login,/api/member/auth/mp/callback}
+    paths: ${SIGNATURE_WHITELIST_PATHS:/actuator/health,/actuator/info,/api/admin/auth/login,/api/admin/auth/register,/api/member/auth/miniapp/login,/api/member/auth/mp/callback}
 
 resilience:
   enabled: ${RESILIENCE_ENABLED:true}

gym-manage-api/manage-gateway/src/test/java/cn/novalon/gym/manage/gateway/filter/GatewayJwtAuthenticationFilterTest.java

@@ -39,7 +39,7 @@ class GatewayJwtAuthenticationFilterTest {
 
     @Test
     void testPublicPath_AllowAccess() {
-        MockServerHttpRequest request = MockServerHttpRequest.get("/api/auth/login").build();
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/admin/auth/login").build();
         exchange = MockServerWebExchange.from(request);
 
         when(chain.filter(any(ServerWebExchange.class))).thenReturn(Mono.empty());
@@ -56,7 +56,7 @@ class GatewayJwtAuthenticationFilterTest {
 
     @Test
     void testPublicPath_Register() {
-        MockServerHttpRequest request = MockServerHttpRequest.post("/api/auth/register").build();
+        MockServerHttpRequest request = MockServerHttpRequest.post("/api/admin/auth/register").build();
         exchange = MockServerWebExchange.from(request);
 
         when(chain.filter(any(ServerWebExchange.class))).thenReturn(Mono.empty());
@@ -105,6 +105,40 @@ class GatewayJwtAuthenticationFilterTest {
         verify(jwtUtil, never()).validateToken(anyString());
     }
 
+    @Test
+    void testPublicPath_MemberAuth() {
+        MockServerHttpRequest request = MockServerHttpRequest.post("/api/member/auth/miniapp/login").build();
+        exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(any(ServerWebExchange.class))).thenReturn(Mono.empty());
+
+        Mono<Void> result = filter.apply(new JwtAuthenticationFilter.Config())
+                .filter(exchange, chain);
+
+        StepVerifier.create(result)
+                .verifyComplete();
+
+        verify(chain).filter(any(ServerWebExchange.class));
+        verify(jwtUtil, never()).validateToken(anyString());
+    }
+
+    @Test
+    void testPublicPath_AdminAuthPrefix() {
+        MockServerHttpRequest request = MockServerHttpRequest.post("/api/admin/auth/refresh").build();
+        exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(any(ServerWebExchange.class))).thenReturn(Mono.empty());
+
+        Mono<Void> result = filter.apply(new JwtAuthenticationFilter.Config())
+                .filter(exchange, chain);
+
+        StepVerifier.create(result)
+                .verifyComplete();
+
+        verify(chain).filter(any(ServerWebExchange.class));
+        verify(jwtUtil, never()).validateToken(anyString());
+    }
+
     @Test
     void testProtectedPath_NoAuthHeader() {
         MockServerHttpRequest request = MockServerHttpRequest.get("/api/users").build();
@@ -152,6 +186,7 @@ class GatewayJwtAuthenticationFilterTest {
         when(jwtUtil.isTokenExpired(validToken)).thenReturn(false);
         when(jwtUtil.getUsernameFromToken(validToken)).thenReturn("testuser");
         when(jwtUtil.getUserIdFromToken(validToken)).thenReturn(1L);
+        when(jwtUtil.getUserTypeFromToken(validToken)).thenReturn("ADMIN");
 
         Mono<Void> result = filter.apply(new JwtAuthenticationFilter.Config())
                 .filter(exchange, chain);
@@ -163,6 +198,7 @@ class GatewayJwtAuthenticationFilterTest {
         verify(jwtUtil).isTokenExpired(validToken);
         verify(jwtUtil).getUsernameFromToken(validToken);
         verify(jwtUtil).getUserIdFromToken(validToken);
+        verify(jwtUtil).getUserTypeFromToken(validToken);
         verify(chain).filter(any(ServerWebExchange.class));
     }
 
@@ -224,6 +260,7 @@ class GatewayJwtAuthenticationFilterTest {
         when(jwtUtil.isTokenExpired(validToken)).thenReturn(false);
         when(jwtUtil.getUsernameFromToken(validToken)).thenReturn("testuser");
         when(jwtUtil.getUserIdFromToken(validToken)).thenReturn(1L);
+        when(jwtUtil.getUserTypeFromToken(validToken)).thenReturn("ADMIN");
 
         Mono<Void> result = filter.apply(new JwtAuthenticationFilter.Config())
                 .filter(exchange, chain);
@@ -235,6 +272,7 @@ class GatewayJwtAuthenticationFilterTest {
         verify(jwtUtil).isTokenExpired(validToken);
         verify(jwtUtil).getUsernameFromToken(validToken);
         verify(jwtUtil).getUserIdFromToken(validToken);
+        verify(jwtUtil).getUserTypeFromToken(validToken);
         verify(chain).filter(any(ServerWebExchange.class));
     }
 
@@ -251,6 +289,7 @@ class GatewayJwtAuthenticationFilterTest {
         when(jwtUtil.isTokenExpired(validToken)).thenReturn(false);
         when(jwtUtil.getUsernameFromToken(validToken)).thenReturn("testuser");
         when(jwtUtil.getUserIdFromToken(validToken)).thenReturn(1L);
+        when(jwtUtil.getUserTypeFromToken(validToken)).thenReturn("ADMIN");
 
         Mono<Void> result = filter.apply(new JwtAuthenticationFilter.Config())
                 .filter(exchange, chain);
@@ -263,11 +302,12 @@ class GatewayJwtAuthenticationFilterTest {
         ServerHttpRequest modifiedRequest = exchangeCaptor.getValue().getRequest();
         assert modifiedRequest.getHeaders().getFirst("X-User-Id").equals("1");
         assert modifiedRequest.getHeaders().getFirst("X-Username").equals("testuser");
+        assert modifiedRequest.getHeaders().getFirst("X-User-Type").equals("ADMIN");
     }
 
     @Test
-    void testMixedPath_AuthPath() {
+    void testMixedPath_AdminAuthPath() {
-        MockServerHttpRequest request = MockServerHttpRequest.get("/api/auth/logout").build();
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/admin/auth/logout").build();
         exchange = MockServerWebExchange.from(request);
 
         when(chain.filter(any(ServerWebExchange.class))).thenReturn(Mono.empty());
@@ -295,6 +335,7 @@ class GatewayJwtAuthenticationFilterTest {
         when(jwtUtil.isTokenExpired(validToken)).thenReturn(false);
         when(jwtUtil.getUsernameFromToken(validToken)).thenReturn("testuser");
         when(jwtUtil.getUserIdFromToken(validToken)).thenReturn(1L);
+        when(jwtUtil.getUserTypeFromToken(validToken)).thenReturn("ADMIN");
 
         Mono<Void> result = filter.apply(new JwtAuthenticationFilter.Config())
                 .filter(exchange, chain);
@@ -308,4 +349,123 @@ class GatewayJwtAuthenticationFilterTest {
         verify(jwtUtil).getUserIdFromToken(validToken);
         verify(chain).filter(any(ServerWebExchange.class));
     }
+
+    // ========== userType 路径校验测试 ==========
+
+    @Test
+    void testAdminPath_WithAdminToken_ShouldPass() {
+        String adminToken = "admin.jwt.token";
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/admin/users")
+                .header(HttpHeaders.AUTHORIZATION, "Bearer " + adminToken)
+                .build();
+        exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(any(ServerWebExchange.class))).thenReturn(Mono.empty());
+        when(jwtUtil.validateToken(adminToken)).thenReturn(true);
+        when(jwtUtil.isTokenExpired(adminToken)).thenReturn(false);
+        when(jwtUtil.getUsernameFromToken(adminToken)).thenReturn("admin");
+        when(jwtUtil.getUserIdFromToken(adminToken)).thenReturn(1L);
+        when(jwtUtil.getUserTypeFromToken(adminToken)).thenReturn("ADMIN");
+
+        Mono<Void> result = filter.apply(new JwtAuthenticationFilter.Config())
+                .filter(exchange, chain);
+
+        StepVerifier.create(result)
+                .verifyComplete();
+
+        verify(chain).filter(any(ServerWebExchange.class));
+    }
+
+    @Test
+    void testAdminPath_WithMemberToken_ShouldBeForbidden() {
+        String memberToken = "member.jwt.token";
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/admin/users")
+                .header(HttpHeaders.AUTHORIZATION, "Bearer " + memberToken)
+                .build();
+        exchange = MockServerWebExchange.from(request);
+
+        when(jwtUtil.validateToken(memberToken)).thenReturn(true);
+        when(jwtUtil.isTokenExpired(memberToken)).thenReturn(false);
+        when(jwtUtil.getUserTypeFromToken(memberToken)).thenReturn("MEMBER");
+
+        Mono<Void> result = filter.apply(new JwtAuthenticationFilter.Config())
+                .filter(exchange, chain);
+
+        StepVerifier.create(result)
+                .verifyComplete();
+
+        assert exchange.getResponse().getStatusCode() == HttpStatus.FORBIDDEN;
+        verify(chain, never()).filter(any(ServerWebExchange.class));
+    }
+
+    @Test
+    void testMemberPath_WithMemberToken_ShouldPass() {
+        String memberToken = "member.jwt.token";
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/member/info")
+                .header(HttpHeaders.AUTHORIZATION, "Bearer " + memberToken)
+                .build();
+        exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(any(ServerWebExchange.class))).thenReturn(Mono.empty());
+        when(jwtUtil.validateToken(memberToken)).thenReturn(true);
+        when(jwtUtil.isTokenExpired(memberToken)).thenReturn(false);
+        when(jwtUtil.getUsernameFromToken(memberToken)).thenReturn("123");
+        when(jwtUtil.getUserIdFromToken(memberToken)).thenReturn(123L);
+        when(jwtUtil.getUserTypeFromToken(memberToken)).thenReturn("MEMBER");
+
+        Mono<Void> result = filter.apply(new JwtAuthenticationFilter.Config())
+                .filter(exchange, chain);
+
+        StepVerifier.create(result)
+                .verifyComplete();
+
+        verify(chain).filter(any(ServerWebExchange.class));
+    }
+
+    @Test
+    void testMemberPath_WithAdminToken_ShouldBeForbidden() {
+        String adminToken = "admin.jwt.token";
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/member/info")
+                .header(HttpHeaders.AUTHORIZATION, "Bearer " + adminToken)
+                .build();
+        exchange = MockServerWebExchange.from(request);
+
+        when(jwtUtil.validateToken(adminToken)).thenReturn(true);
+        when(jwtUtil.isTokenExpired(adminToken)).thenReturn(false);
+        when(jwtUtil.getUserTypeFromToken(adminToken)).thenReturn("ADMIN");
+
+        Mono<Void> result = filter.apply(new JwtAuthenticationFilter.Config())
+                .filter(exchange, chain);
+
+        StepVerifier.create(result)
+                .verifyComplete();
+
+        assert exchange.getResponse().getStatusCode() == HttpStatus.FORBIDDEN;
+        verify(chain, never()).filter(any(ServerWebExchange.class));
+    }
+
+    @Test
+    void testNonPrefixedPath_NoUserTypeCheck() {
+        String adminToken = "admin.jwt.token";
+        // /api/users 不以 /api/admin/ 或 /api/member/ 开头，不做 userType 校验
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/users")
+                .header(HttpHeaders.AUTHORIZATION, "Bearer " + adminToken)
+                .build();
+        exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(any(ServerWebExchange.class))).thenReturn(Mono.empty());
+        when(jwtUtil.validateToken(adminToken)).thenReturn(true);
+        when(jwtUtil.isTokenExpired(adminToken)).thenReturn(false);
+        when(jwtUtil.getUsernameFromToken(adminToken)).thenReturn("admin");
+        when(jwtUtil.getUserIdFromToken(adminToken)).thenReturn(1L);
+        when(jwtUtil.getUserTypeFromToken(adminToken)).thenReturn("ADMIN");
+
+        Mono<Void> result = filter.apply(new JwtAuthenticationFilter.Config())
+                .filter(exchange, chain);
+
+        StepVerifier.create(result)
+                .verifyComplete();
+
+        verify(chain).filter(any(ServerWebExchange.class));
+    }
 }

gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/config/SecurityConfig.java

@@ -47,18 +47,11 @@ public class SecurityConfig {
                 .addFilterBefore(jwtAuthenticationFilter, SecurityWebFiltersOrder.AUTHENTICATION)
                 .addFilterAfter(operationLogWebFilter, SecurityWebFiltersOrder.AUTHORIZATION)
                 .authorizeExchange(spec -> {
-                    spec.pathMatchers("/api/auth/**").permitAll()
+                    spec.pathMatchers("/api/admin/auth/**").permitAll()
+                            .pathMatchers("/api/member/auth/**").permitAll()
                             .pathMatchers("/api/public/**").permitAll()
                             .pathMatchers("/ws/**").permitAll()
-                            .pathMatchers("/actuator/**").permitAll()
+                            .pathMatchers("/actuator/**").permitAll();
-                            .pathMatchers("/api/groupCourse/**").permitAll()
-                            .pathMatchers("/api/member/**").permitAll()
-                            .pathMatchers("/api/admin/member/**").permitAll()
-                            .pathMatchers("/api/member-cards/**").permitAll()
-                            .pathMatchers("/api/member-card-records/**").permitAll()
-//                            .pathMatchers("/**").permitAll()
-                            .pathMatchers("/api/member-card-transactions/**").permitAll();
-
 
                     if (isDevOrTest) {
                         spec.pathMatchers("/swagger-ui.html").permitAll()
@@ -67,7 +60,7 @@ public class SecurityConfig {
                                 .pathMatchers("/v3/api-docs/**").permitAll()
                                 .pathMatchers("/swagger-resources/**").permitAll()
                                 .pathMatchers("/webjars/**").permitAll()
-                                .pathMatchers("/api/diagnostic/**").permitAll();
+                                .pathMatchers("/api/admin/diagnostic/**").permitAll();
                         logger.info("SecurityConfig: Swagger路径和诊断端点已放行");
                     }
 

gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/core/service/impl/SysUserService.java

@@ -15,7 +15,6 @@ import cn.novalon.gym.manage.sys.core.repository.IUserRoleRepository;
 import cn.novalon.gym.manage.sys.core.service.ISysUserService;
 import cn.novalon.gym.manage.sys.core.command.CreateUserCommand;
 import cn.novalon.gym.manage.sys.core.command.UpdateUserCommand;
-import cn.novalon.gym.manage.sys.dto.response.UserResponse;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Qualifier;

gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/dto/response/AuthResponse.java

@@ -20,6 +20,9 @@ public class AuthResponse {
     @Schema(description = "用户名", example = "admin")
     private String username;
 
+    @Schema(description = "用户类型", example = "ADMIN")
+    private String userType;
+
     public AuthResponse() {
     }
 
@@ -27,6 +30,14 @@ public class AuthResponse {
         this.token = token;
         this.userId = userId;
         this.username = username;
+        this.userType = "ADMIN";
+    }
+
+    public AuthResponse(String token, Long userId, String username, String userType) {
+        this.token = token;
+        this.userId = userId;
+        this.username = username;
+        this.userType = userType;
     }
 
     public String getToken() {
@@ -52,4 +63,12 @@ public class AuthResponse {
     public void setUsername(String username) {
         this.username = username;
     }
+
+    public String getUserType() {
+        return userType;
+    }
+
+    public void setUserType(String userType) {
+        this.userType = userType;
+    }
 }

gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/handler/auth/SysAuthHandler.java

@@ -133,8 +133,9 @@ public class SysAuthHandler {
                                                                                                         .generateToken(
                                                                                                                         user.getUsername(),
                                                                                                                         user.getId(),
-                                                                                                                        roleKeys);
+                                                                                                                        roleKeys,
-                                                                                        logger.info("用户登录成功: username={}, userId={}, roles={}",
+                                                                                                                        "ADMIN");
+                                                                                        logger.info("用户登录成功: username={}, userId={}, roles={}, userType=ADMIN",
                                                                                                         user.getUsername(),
                                                                                                         user.getId(),
                                                                                                         roleKeys);
@@ -146,7 +147,8 @@ public class SysAuthHandler {
                                                                                         AuthResponse response = new AuthResponse(
                                                                                                         token,
                                                                                                         user.getId(),
-                                                                                                        user.getUsername());
+                                                                                                        user.getUsername(),
+                                                                                                        "ADMIN");
                                                                                         return ServerResponse.ok()
                                                                                                         .bodyValue(response);
                                                                                 });

gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/security/JwtAuthenticationFilter.java

@@ -37,6 +37,7 @@ public class JwtAuthenticationFilter implements WebFilter {
             String username = jwtTokenProvider.getUsernameFromToken(token);
             jwtTokenProvider.getUserIdFromToken(token);
             List<String> roles = jwtTokenProvider.getRolesFromToken(token);
+            String userType = jwtTokenProvider.getUserTypeFromToken(token);
             
             List<SimpleGrantedAuthority> authorities = roles.stream()
                     .map(role -> new SimpleGrantedAuthority("ROLE_" + role))
@@ -53,6 +54,9 @@ public class JwtAuthenticationFilter implements WebFilter {
                     authorities
                 );
             
+            // 将 userType 存入 authentication details，供后续 AuthUtil 使用
+            authentication.setDetails(userType);
+            
             return chain.filter(exchange)
                 .contextWrite(ReactiveSecurityContextHolder.withAuthentication(authentication));
         }

gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/security/JwtTokenProvider.java

@@ -32,24 +32,19 @@ public class JwtTokenProvider {
     }
 
     public String generateToken(String username, Long userId) {
-        Map<String, Object> claims = new HashMap<>();
+        return generateToken(username, userId, java.util.Collections.emptyList(), "ADMIN");
-        claims.put("userId", userId);
-        claims.put("username", username);
-        
-        return Jwts.builder()
-                .setClaims(claims)
-                .setSubject(username)
-                .setIssuedAt(new Date())
-                .setExpiration(new Date(System.currentTimeMillis() + jwtProperties.getExpiration()))
-                .signWith(getSigningKey())
-                .compact();
     }
 
     public String generateToken(String username, Long userId, java.util.List<String> roles) {
+        return generateToken(username, userId, roles, "ADMIN");
+    }
+
+    public String generateToken(String username, Long userId, java.util.List<String> roles, String userType) {
         Map<String, Object> claims = new HashMap<>();
         claims.put("userId", userId);
         claims.put("username", username);
         claims.put("roles", roles);
+        claims.put("userType", userType);
         
         return Jwts.builder()
                 .setClaims(claims)
@@ -85,6 +80,10 @@ public class JwtTokenProvider {
         return java.util.Collections.emptyList();
     }
 
+    public String getUserTypeFromToken(String token) {
+        return getClaimsFromToken(token).get("userType", String.class);
+    }
+
     public boolean validateToken(String token) {
         try {
             getClaimsFromToken(token);

gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/util/AuthUtil.java

@@ -29,4 +29,38 @@ public class AuthUtil {
         if (jwtTokenProvider.getUserIdFromToken(token) <= 0L) throw new IllegalArgumentException("ID无效");
         return jwtTokenProvider.getUserIdFromToken(token);
     }
-}
+
+    /**
+     * 获取当前 ADMIN 用户 ID，校验 userType 必须为 ADMIN
+     */
+    public Long getAdminUserIdOrThrow(ServerRequest request) {
+        String token = extractToken(request);
+        if (token == null) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "缺少 Token");
+        if (!jwtTokenProvider.validateToken(token)) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "Token 无效或已过期");
+        String userType = jwtTokenProvider.getUserTypeFromToken(token);
+        if (!"ADMIN".equals(userType)) {
+            log.warn("非管理员用户尝试访问管理端接口, userType={}", userType);
+            throw new ResponseStatusException(HttpStatus.FORBIDDEN, "无权访问管理端接口");
+        }
+        Long userId = jwtTokenProvider.getUserIdFromToken(token);
+        if (userId <= 0L) throw new IllegalArgumentException("ID无效");
+        return userId;
+    }
+
+    /**
+     * 获取当前 MEMBER 用户 ID，校验 userType 必须为 MEMBER
+     */
+    public Long getMemberUserIdOrThrow(ServerRequest request) {
+        String token = extractToken(request);
+        if (token == null) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "缺少 Token");
+        if (!jwtTokenProvider.validateToken(token)) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "Token 无效或已过期");
+        String userType = jwtTokenProvider.getUserTypeFromToken(token);
+        if (!"MEMBER".equals(userType)) {
+            log.warn("非会员用户尝试访问会员接口, userType={}", userType);
+            throw new ResponseStatusException(HttpStatus.FORBIDDEN, "无权访问会员接口");
+        }
+        Long userId = jwtTokenProvider.getUserIdFromToken(token);
+        if (userId <= 0L) throw new IllegalArgumentException("ID无效");
+        return userId;
+    }
+}

gym-manage-api/manage-sys/src/test/java/cn/novalon/gym/manage/sys/handler/auth/SysAuthHandlerTest.java

@@ -80,7 +80,7 @@ class SysAuthHandlerTest {
         // 配置密码编码器Mock来验证密码
         when(passwordEncoder.matches(rawPassword, realEncodedPassword)).thenReturn(true);
         
-        when(jwtTokenProvider.generateToken(eq("testuser"), eq(1L), anyList())).thenReturn("test_token");
+        when(jwtTokenProvider.generateToken(eq("testuser"), eq(1L), anyList(), eq("ADMIN"))).thenReturn("test_token");
         
         // 使用测试数据工厂创建角色
         SysRole mockRole = TestDataFactory.createUserRole();
@@ -103,7 +103,7 @@ class SysAuthHandlerTest {
                 .verifyComplete();
 
         verify(userService).findByUsername("testuser");
-        verify(jwtTokenProvider).generateToken(eq("testuser"), eq(1L), anyList());
+        verify(jwtTokenProvider).generateToken(eq("testuser"), eq(1L), anyList(), eq("ADMIN"));
     }
 
     @Test

gym-manage-api/manage-sys/src/test/java/cn/novalon/gym/manage/sys/security/JwtTokenProviderTest.java

@@ -108,4 +108,52 @@ class JwtTokenProviderTest {
         
         assertThat(isValid).isFalse();
     }
+
+    @Test
+    void testGenerateTokenWithUserType() {
+        when(jwtProperties.getSecret()).thenReturn("test-secret-key-for-testing-purposes-only-1234567890");
+        when(jwtProperties.getExpiration()).thenReturn(3600000L);
+
+        String token = jwtTokenProvider.generateToken("testuser", 1L, java.util.List.of("admin"), "ADMIN");
+
+        assertThat(token).isNotNull();
+        assertThat(token).isNotEmpty();
+    }
+
+    @Test
+    void testGetUserTypeFromToken() {
+        when(jwtProperties.getSecret()).thenReturn("test-secret-key-for-testing-purposes-only-1234567890");
+        when(jwtProperties.getExpiration()).thenReturn(3600000L);
+
+        String token = jwtTokenProvider.generateToken("testuser", 1L, java.util.List.of("admin"), "ADMIN");
+
+        String userType = jwtTokenProvider.getUserTypeFromToken(token);
+
+        assertThat(userType).isEqualTo("ADMIN");
+    }
+
+    @Test
+    void testGetUserTypeFromToken_Member() {
+        when(jwtProperties.getSecret()).thenReturn("test-secret-key-for-testing-purposes-only-1234567890");
+        when(jwtProperties.getExpiration()).thenReturn(3600000L);
+
+        String token = jwtTokenProvider.generateToken("123", 123L, java.util.List.of(), "MEMBER");
+
+        String userType = jwtTokenProvider.getUserTypeFromToken(token);
+
+        assertThat(userType).isEqualTo("MEMBER");
+    }
+
+    @Test
+    void testGetUserTypeFromToken_DefaultIsAdmin() {
+        when(jwtProperties.getSecret()).thenReturn("test-secret-key-for-testing-purposes-only-1234567890");
+        when(jwtProperties.getExpiration()).thenReturn(3600000L);
+
+        // 使用旧的两参数方法生成的 token 默认 userType 为 ADMIN
+        String token = jwtTokenProvider.generateToken("testuser", 1L);
+
+        String userType = jwtTokenProvider.getUserTypeFromToken(token);
+
+        assertThat(userType).isEqualTo("ADMIN");
+    }
 }

gym-manage-api/pom.xml

@@ -43,7 +43,7 @@
         <module>manage-notify</module>
         <module>manage-file</module>
         <module>gym-member</module>
-        <module>gym-groupCourse</module>
+        <module>gym-checkIn</module>
 	</modules>
 
     <dependencyManagement>
@@ -223,19 +223,7 @@
             <artifactId>lombok</artifactId>
             <optional>true</optional>
         </dependency>
-
+    </dependencies>
-        <!--        HuTool工具箱-->
-        <dependency>
-            <groupId>cn.hutool</groupId>
-            <artifactId>hutool-all</artifactId>
-            <version>5.8.38</version>
-        </dependency>
-
-        <dependency>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
-            </dependency>
-        </dependencies>
 
     <build>
         <plugins>

gym-manage-uniapp/.gitignore

@@ -1,4 +0,0 @@
-node_modules/
-unpackage/
-.hbuilderx/
-.DS_Store

gym-manage-uniapp/App.vue

@@ -1,77 +0,0 @@
-<template>
-  <view>
-    <GlobalLoading />
-  </view>
-</template>
-<script>
-	import GlobalLoading from '@/components/global/GlobalLoading.vue'
-export default {
-  onLaunch: function() {
-    console.log('App Launch')
-    this.preloadTabData()
-  },
-  onShow: function() {
-    console.log('App Show')
-  },
-  onHide: function() {
-    console.log('App Hide')
-  },
-  methods: {
-    // 预加载所有 Tab 页面的核心数据
-    preloadTabData() {
-      // 延迟执行，不阻塞首屏
-      setTimeout(() => {
-        // 预加载课程数据
-        // #ifdef MP-WEIXIN
-        // 小程序端预请求数据
-        // #endif
-        
-        // 预加载训练数据
-       
-      }, 1000)
-    }
-  }
-}
-</script>
-
-<style lang="scss">
-@import 'common/style/base.css';
-
-/* 全局骨架屏样式 */
-.skeleton {
-  background: linear-gradient(90deg, #f0f0f0 25%, #e0e0e0 50%, #f0f0f0 75%);
-  background-size: 200% 100%;
-  animation: skeleton-loading 1.5s infinite;
-}
-
-@keyframes skeleton-loading {
-  0% { background-position: 200% 0; }
-  100% { background-position: -200% 0; }
-}
-
-/* 页面切换动画 */
-.page-enter-active,
-.page-leave-active {
-  transition: opacity 0.2s ease, transform 0.2s ease;
-}
-
-.page-enter-from {
-  opacity: 0;
-  transform: translateX(30rpx);
-}
-
-.page-leave-to {
-  opacity: 0;
-  transform: translateX(-30rpx);
-}
-
-.app-container {
-  width: 100%;
-  min-height: 100vh;
-  max-width: 430px;
-  margin: 0 auto;
-  background-color: var(--bg-light);
-  position: relative;
-  overflow-x: hidden;
-}
-</style>