合并dev分支

- 新增gym-checkIn签到模块
- 创建sign_in_record签到记录表(V13迁移脚本)
- 添加签到相关路由配置
- 更新应用配置以支持签到模块
- 添加Redis密钥常量

gym-manage-api/db/migration/V1__Create_all_tables.sql

@@ -1,407 +0,0 @@
--- Novalon管理系统数据库初始化脚本
--- 版本: V1
--- 描述: 创建所有核心表结构（合并版）
-
--- ============================================
--- 用户与角色相关表
--- ============================================
-
--- 用户表
-CREATE TABLE IF NOT EXISTS sys_user (
-    id BIGSERIAL PRIMARY KEY,
-    username VARCHAR(50) NOT NULL UNIQUE,
-    password VARCHAR(255) NOT NULL,
-    email VARCHAR(100),
-    phone VARCHAR(20),
-    nickname VARCHAR(100),
-    status INTEGER DEFAULT 1,
-    role_id BIGINT,
-    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 sys_role (
-    id BIGSERIAL PRIMARY KEY,
-    role_name VARCHAR(100) NOT NULL,
-    role_key VARCHAR(100) NOT NULL UNIQUE,
-    role_sort INTEGER DEFAULT 0,
-    status INTEGER DEFAULT 1,
-    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 user_role (
-    id BIGSERIAL PRIMARY KEY,
-    user_id BIGINT NOT NULL,
-    role_id BIGINT NOT NULL,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    created_by VARCHAR(50),
-    CONSTRAINT fk_user_role_user FOREIGN KEY (user_id) REFERENCES sys_user(id) ON DELETE CASCADE,
-    CONSTRAINT fk_user_role_role FOREIGN KEY (role_id) REFERENCES sys_role(id) ON DELETE CASCADE,
-    CONSTRAINT uk_user_role UNIQUE (user_id, role_id)
-);
-
--- ============================================
--- 权限相关表
--- ============================================
-
--- 权限表
-CREATE TABLE IF NOT EXISTS sys_permission (
-    id BIGSERIAL PRIMARY KEY,
-    permission_name VARCHAR(100) NOT NULL,
-    permission_code VARCHAR(100) NOT NULL UNIQUE,
-    resource VARCHAR(200) NOT NULL,
-    action VARCHAR(50) NOT NULL,
-    description VARCHAR(500),
-    status INTEGER DEFAULT 1,
-    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 sys_role_permission (
-    id BIGSERIAL PRIMARY KEY,
-    role_id BIGINT NOT NULL,
-    permission_id BIGINT NOT NULL,
-    create_by VARCHAR(50),
-    update_by VARCHAR(50),
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    FOREIGN KEY (role_id) REFERENCES sys_role(id) ON DELETE CASCADE,
-    FOREIGN KEY (permission_id) REFERENCES sys_permission(id) ON DELETE CASCADE,
-    UNIQUE (role_id, permission_id)
-);
-
--- ============================================
--- 菜单相关表
--- ============================================
-
--- 菜单表
-CREATE TABLE IF NOT EXISTS sys_menu (
-    id BIGSERIAL PRIMARY KEY,
-    menu_name VARCHAR(50) NOT NULL,
-    parent_id BIGINT DEFAULT 0,
-    order_num INTEGER DEFAULT 0,
-    menu_type VARCHAR(1) DEFAULT 'C',
-    perms VARCHAR(100),
-    component VARCHAR(200),
-    status INTEGER DEFAULT 1,
-    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 sys_dict_type (
-    id BIGSERIAL PRIMARY KEY,
-    dict_name VARCHAR(100) NOT NULL,
-    dict_type VARCHAR(100) NOT NULL UNIQUE,
-    status VARCHAR(1) DEFAULT '0',
-    remark VARCHAR(500),
-    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 sys_dict_data (
-    id BIGSERIAL PRIMARY KEY,
-    dict_sort INTEGER DEFAULT 0,
-    dict_label VARCHAR(100) NOT NULL,
-    dict_value VARCHAR(100) NOT NULL,
-    dict_type VARCHAR(100) NOT NULL,
-    css_class VARCHAR(100),
-    list_class VARCHAR(100),
-    is_default VARCHAR(1) DEFAULT 'N',
-    status VARCHAR(1) 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 sys_dictionary (
-    id BIGSERIAL PRIMARY KEY,
-    type VARCHAR(100) NOT NULL,
-    code VARCHAR(100) NOT NULL,
-    name VARCHAR(100) NOT NULL,
-    value VARCHAR(500),
-    remark VARCHAR(500),
-    sort INTEGER DEFAULT 0,
-    create_by VARCHAR(50),
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    deleted_at TIMESTAMP
-);
-
--- ============================================
--- 系统配置表
--- ============================================
-
--- 系统配置表
-CREATE TABLE IF NOT EXISTS sys_config (
-    id BIGSERIAL PRIMARY KEY,
-    config_name VARCHAR(100) NOT NULL,
-    config_key VARCHAR(100) NOT NULL UNIQUE,
-    config_value VARCHAR(500) NOT NULL,
-    config_type VARCHAR(1) DEFAULT 'N',
-    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 sys_login_log (
-    id BIGSERIAL PRIMARY KEY,
-    username VARCHAR(50),
-    ip VARCHAR(50),
-    location VARCHAR(255),
-    browser VARCHAR(50),
-    os VARCHAR(50),
-    status VARCHAR(1),
-    message VARCHAR(255),
-    login_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
--- 异常日志表
-CREATE TABLE IF NOT EXISTS sys_exception_log (
-    id BIGSERIAL PRIMARY KEY,
-    username VARCHAR(50),
-    title VARCHAR(100),
-    exception_name VARCHAR(100),
-    method_name VARCHAR(255),
-    method_params TEXT,
-    exception_msg TEXT,
-    exception_stack TEXT,
-    ip VARCHAR(50),
-    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
--- 操作日志表
-CREATE TABLE IF NOT EXISTS operation_log (
-    id BIGSERIAL PRIMARY KEY,
-    username VARCHAR(50),
-    operation VARCHAR(100),
-    method VARCHAR(200),
-    params TEXT,
-    result TEXT,
-    ip VARCHAR(50),
-    duration BIGINT,
-    status VARCHAR(1) DEFAULT '0',
-    error_msg TEXT,
-    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 audit_log (
-    id BIGSERIAL PRIMARY KEY,
-    entity_type VARCHAR(100) NOT NULL,
-    entity_id BIGINT,
-    operation_type VARCHAR(20) NOT NULL,
-    operator VARCHAR(100),
-    operation_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    before_data JSONB,
-    after_data JSONB,
-    changed_fields TEXT[],
-    ip_address VARCHAR(50),
-    user_agent TEXT,
-    description TEXT,
-    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 audit_log_archive (
-    id BIGSERIAL PRIMARY KEY,
-    entity_type VARCHAR(100) NOT NULL,
-    entity_id BIGINT,
-    operation_type VARCHAR(20) NOT NULL,
-    operator VARCHAR(100),
-    operation_time TIMESTAMP,
-    before_data JSONB,
-    after_data JSONB,
-    changed_fields TEXT[],
-    ip_address VARCHAR(50),
-    user_agent TEXT,
-    description TEXT,
-    created_at TIMESTAMP,
-    archived_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
--- ============================================
--- 通知与消息表
--- ============================================
-
--- 系统公告表
-CREATE TABLE IF NOT EXISTS sys_notice (
-    id BIGSERIAL PRIMARY KEY,
-    notice_title VARCHAR(50) NOT NULL,
-    notice_type VARCHAR(1) NOT NULL,
-    notice_content TEXT,
-    status VARCHAR(1) 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 sys_user_message (
-    id BIGSERIAL PRIMARY KEY,
-    user_id BIGINT NOT NULL,
-    notice_id BIGINT,
-    message_title VARCHAR(255),
-    message_content TEXT,
-    is_read VARCHAR(1) DEFAULT '0',
-    read_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
-);
-
--- ============================================
--- 文件管理表
--- ============================================
-
--- 文件管理表
-CREATE TABLE IF NOT EXISTS sys_file (
-    id BIGSERIAL PRIMARY KEY,
-    file_name VARCHAR(255) NOT NULL,
-    file_path VARCHAR(500) NOT NULL,
-    file_size BIGINT,
-    file_type VARCHAR(100),
-    file_extension VARCHAR(10),
-    storage_type VARCHAR(50),
-    create_by VARCHAR(50),
-    update_by VARCHAR(50),
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    deleted_at TIMESTAMP
-);
-
--- ============================================
--- OAuth2相关表
--- ============================================
-
--- OAuth2客户端表
-CREATE TABLE IF NOT EXISTS oauth2_client (
-    id BIGSERIAL PRIMARY KEY,
-    client_id VARCHAR(100) NOT NULL UNIQUE,
-    client_secret VARCHAR(255) NOT NULL,
-    client_name VARCHAR(100),
-    web_server_redirect_uri VARCHAR(500),
-    scope VARCHAR(500),
-    authorized_grant_types VARCHAR(500),
-    access_token_validity_seconds INTEGER,
-    refresh_token_validity_seconds INTEGER,
-    auto_approve VARCHAR(1) DEFAULT 'false',
-    enabled VARCHAR(1) DEFAULT 'true',
-    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 sys_user IS '系统用户表';
-COMMENT ON TABLE sys_role IS '系统角色表';
-COMMENT ON TABLE user_role IS '用户角色关联表';
-COMMENT ON TABLE sys_permission IS '系统权限表';
-COMMENT ON TABLE sys_role_permission IS '角色权限关联表';
-COMMENT ON TABLE sys_menu IS '系统菜单表';
-COMMENT ON TABLE sys_dict_type IS '字典类型表';
-COMMENT ON TABLE sys_dict_data IS '字典数据表';
-COMMENT ON TABLE sys_dictionary IS '通用字典表';
-COMMENT ON TABLE sys_config IS '系统配置表';
-COMMENT ON TABLE sys_login_log IS '登录日志表';
-COMMENT ON TABLE sys_exception_log IS '异常日志表';
-COMMENT ON TABLE operation_log IS '操作日志表';
-COMMENT ON TABLE audit_log IS '审计日志表';
-COMMENT ON TABLE audit_log_archive IS '审计日志归档表';
-COMMENT ON TABLE sys_notice IS '系统公告表';
-COMMENT ON TABLE sys_user_message IS '用户消息表';
-COMMENT ON TABLE sys_file IS '文件管理表';
-COMMENT ON TABLE oauth2_client IS 'OAuth2客户端表';
-
-COMMENT ON TABLE sys_exception_log IS '异常日志表';
-COMMENT ON COLUMN sys_exception_log.id IS '主键ID';
-COMMENT ON COLUMN sys_exception_log.username IS '操作用户';
-COMMENT ON COLUMN sys_exception_log.title IS '异常标题';
-COMMENT ON COLUMN sys_exception_log.exception_name IS '异常名称';
-COMMENT ON COLUMN sys_exception_log.method_name IS '方法名称';
-COMMENT ON COLUMN sys_exception_log.method_params IS '方法参数';
-COMMENT ON COLUMN sys_exception_log.exception_msg IS '异常消息';
-COMMENT ON COLUMN sys_exception_log.exception_stack IS '异常堆栈';
-COMMENT ON COLUMN sys_exception_log.ip IS 'IP地址';
-COMMENT ON COLUMN sys_exception_log.create_time IS '创建时间';
-
-COMMENT ON TABLE audit_log IS '审计日志表';
-COMMENT ON COLUMN audit_log.id IS '主键ID';
-COMMENT ON COLUMN audit_log.entity_type IS '实体类型（如User, Role等）';
-COMMENT ON COLUMN audit_log.entity_id IS '实体ID';
-COMMENT ON COLUMN audit_log.operation_type IS '操作类型（CREATE, UPDATE, DELETE）';
-COMMENT ON COLUMN audit_log.operator IS '操作人';
-COMMENT ON COLUMN audit_log.operation_time IS '操作时间';
-COMMENT ON COLUMN audit_log.before_data IS '变更前数据（JSON格式）';
-COMMENT ON COLUMN audit_log.after_data IS '变更后数据（JSON格式）';
-COMMENT ON COLUMN audit_log.changed_fields IS '变更字段列表';
-COMMENT ON COLUMN audit_log.ip_address IS 'IP地址';
-COMMENT ON COLUMN audit_log.description IS '操作描述';
-COMMENT ON COLUMN audit_log.created_at IS '记录创建时间';
-
-COMMENT ON TABLE audit_log_archive IS '审计日志归档表';
-COMMENT ON COLUMN audit_log_archive.id IS '主键ID';
-COMMENT ON COLUMN audit_log_archive.entity_type IS '实体类型（如User, Role等）';
-COMMENT ON COLUMN audit_log_archive.entity_id IS '实体ID';
-COMMENT ON COLUMN audit_log_archive.operation_type IS '操作类型（CREATE, UPDATE, DELETE）';
-COMMENT ON COLUMN audit_log_archive.operator IS '操作人';
-COMMENT ON COLUMN audit_log_archive.operation_time IS '操作时间';
-COMMENT ON COLUMN audit_log_archive.before_data IS '变更前数据（JSON格式）';
-COMMENT ON COLUMN audit_log_archive.after_data IS '变更后数据（JSON格式）';
-COMMENT ON COLUMN audit_log_archive.changed_fields IS '变更字段列表';
-COMMENT ON COLUMN audit_log_archive.ip_address IS 'IP地址';
-COMMENT ON COLUMN audit_log_archive.user_agent IS '用户代理';
-COMMENT ON COLUMN audit_log_archive.description IS '操作描述';
-COMMENT ON COLUMN audit_log_archive.created_at IS '记录创建时间';
-COMMENT ON COLUMN audit_log_archive.archived_at IS '归档时间';

gym-manage-api/docs/groupcourse-api.md

@@ -14,6 +14,7 @@
 3. [团课管理接口](#团课管理接口)
    - [获取所有团课](#获取所有团课)
    - [分页获取团课](#分页获取团课)
+   - [多条件查询团课](#多条件查询团课)
    - [根据ID获取团课详情](#根据ID获取团课详情)
    - [创建团课](#创建团课)
    - [更新团课](#更新团课)
@@ -154,6 +155,149 @@
 
 ---
 
+### 多条件查询团课
+
+| 属性 | 值 |
+|------|-----|
+| **HTTP方法** | POST |
+| **接口路径** | `/api/groupCourse/search` |
+| **所属文件** | `GroupCourseHandler.java` |
+
+**功能说明**: 支持团课名称模糊查询、类型筛选、日期范围、时间段、价格排序、剩余名额排序等多条件组合查询，默认不查询不可预约的团课（已取消或已结束）。
+
+**请求体**:
+
+```json
+{
+  "courseName": "瑜伽",
+  "courseType": 1,
+  "startDate": "2026-06-01T00:00:00",
+  "endDate": "2026-06-30T23:59:59",
+  "timePeriod": "morning",
+  "priceSort": "asc",
+  "remainingMost": true,
+  "page": 0,
+  "size": 10
+}
+```
+
+| 参数名 | 类型 | 必填 | 默认值 | 说明 |
+|--------|------|------|--------|------|
+| courseName | String | 否 | - | 课程名称（模糊查询，不区分大小写） |
+| courseType | Long | 否 | - | 课程类型ID |
+| startDate | LocalDateTime | 否 | - | 查询开始日期 |
+| endDate | LocalDateTime | 否 | - | 查询结束日期 |
+| timePeriod | String | 否 | - | 时间段：`morning`(6:00-12:00)、`afternoon`(12:00-18:00)、`evening`(18:00-24:00) |
+| priceSort | String | 否 | - | 价格排序：`asc`(从低到高)、`desc`(从高到低) |
+| remainingMost | Boolean | 否 | false | 是否按剩余名额最多排序 |
+| page | Integer | 否 | 0 | 页码，从0开始 |
+| size | Integer | 否 | 10 | 每页数量，最大100 |
+
+**查询条件优先级说明**:
+
+| 优先级 | 条件类型 | 说明 |
+|--------|----------|------|
+| 1 | 默认过滤 | 自动过滤已删除和不可预约的团课（status != 0） |
+| 2 | 基础筛选 | courseName、courseType、startDate、endDate、timePeriod |
+| 3 | 排序规则 | remainingMost优先，其次priceSort，默认按startTime升序 |
+
+**成功响应** (200 OK):
+
+```json
+{
+  "success": true,
+  "message": "查询成功",
+  "data": {
+    "content": [
+      {
+        "id": 1,
+        "courseName": "瑜伽入门",
+        "coachId": 1,
+        "courseType": 1,
+        "startTime": "2026-06-15T09:00:00",
+        "endTime": "2026-06-15T10:00:00",
+        "maxMembers": 20,
+        "currentMembers": 5,
+        "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"
+      }
+    ],
+    "totalPages": 3,
+    "totalElements": 25,
+    "currentPage": 0,
+    "pageSize": 10,
+    "first": true,
+    "last": false
+  }
+}
+```
+
+**失败响应** (400 Bad Request):
+
+```json
+{
+  "success": false,
+  "message": "查询失败的原因"
+}
+```
+
+**使用示例**:
+
+1. **查询瑜伽课程**
+```json
+{
+  "courseName": "瑜伽"
+}
+```
+
+2. **查询特定类型的早晨课程**
+```json
+{
+  "courseType": 1,
+  "timePeriod": "morning"
+}
+```
+
+3. **查询下周的课程，按价格从低到高排序**
+```json
+{
+  "startDate": "2026-06-16T00:00:00",
+  "endDate": "2026-06-22T23:59:59",
+  "priceSort": "asc"
+}
+```
+
+4. **查询剩余名额最多的晚间课程**
+```json
+{
+  "timePeriod": "evening",
+  "remainingMost": true
+}
+```
+
+5. **多条件组合查询**
+```json
+{
+  "courseName": "瑜伽",
+  "courseType": 1,
+  "startDate": "2026-06-01T00:00:00",
+  "endDate": "2026-06-30T23:59:59",
+  "timePeriod": "morning",
+  "priceSort": "asc",
+  "remainingMost": true,
+  "page": 0,
+  "size": 10
+}
+```
+
+---
+
 ### 根据ID获取团课详情
 
 | 属性 | 值 |
@@ -460,26 +604,26 @@
 | 属性 | 值 |
 |------|-----|
 | **HTTP方法** | POST |
-| **接口路径** | `/api/groupCourse/{courseId}/signin` |
+| **接口路径** | `/api/groupCourse/signin/{memberId}` |
 | **所属文件** | `GroupCourseHandler.java` |
 
 **路径参数**:
 
 | 参数名 | 类型 | 必填 | 说明 |
 |--------|------|------|------|
-| courseId | Long | 是 | 团课ID |
+| memberId | Long | 是 | 会员ID |
 
 **请求体**:
 
 ```json
 {
-  "memberId": 1001
+  "courseId": 1
 }
 ```
 
 | 参数名 | 类型 | 必填 | 说明 |
 |--------|------|------|------|
-| memberId | Long | **是** | 会员ID |
+| courseId | Long | **是** | 团课ID |
 
 **成功响应** (200 OK):
 
@@ -494,16 +638,39 @@
 }
 ```
 
-**失败响应** (400 Bad Request):
+**失败响应** (400 Bad Request) —— 校验规则及对应错误信息:
+
+| 序号 | 校验规则 | 错误信息 |
+|------|----------|----------|
+| 1 | 团课不存在或已被删除 | `团课不存在或已删除` |
+| 2 | 团课状态为"已取消" | `团课已取消，无法签到` |
+| 3 | 团课状态为"已结束" | `团课已结束，无法签到` |
+| 4 | 当前时间早于开课前2小时 | `未到签到时间，请在开课前2小时内签到` |
+| 5 | 当前时间晚于团课结束时间 | `团课已结束，无法签到` |
+| 6 | 课程当前人数已达上限 | `课程已满员，无法签到` |
+| 7 | 用户今日无到店签到记录 | `请先完成到店签到` |
+| 8 | 到店签到状态非SUCCESS | `到店签到未成功，请重新签到` |
+| 9 | 用户未预约此课程 | `您未预约此课程，无法签到` |
+| - | 请求体为空 | `请求体不能为空` |
+| - | 请求体缺少courseId | `courseId不能为空` |
+
+> **说明**: 校验按上表顺序依次执行，命中第一个失败条件即返回对应错误信息。
+
+**失败响应示例**:
 
 ```json
 {
   "success": false,
-  "message": "课程已满员"
+  "message": "未到签到时间，请在开课前2小时内签到"
 }
 ```
 
----
+```json
+{
+  "success": false,
+  "message": "您未预约此课程，无法签到"
+}
+```
 
 ### 删除团课
 
@@ -1493,7 +1660,14 @@
 ### 团课管理
 1. **创建团课**：课程名称为必填项
 2. **取消团课**：需提前24小时通知，否则拒绝操作
-3. **团课签到**：验证课程状态必须为正常，且未达最大人数限制
+3. **团课签到**：严格按以下顺序校验，任一不通过即拒绝签到：
+   - 团课是否存在且未被删除
+   - 团课状态不为"已取消"
+   - 团课状态不为"已结束"（含已过结束时间）
+   - 当前时间在开课前2小时内（签到时间窗口）
+   - 课程当前人数未达到最大人数上限
+   - 用户今日已成功到店签到（查询 sign_in_record 表当日 SUCCESS 记录）
+   - 用户已预约该课程（有效预约）
 4. **删除团课**：采用软删除机制，数据保留可恢复
 
 ### 团课预约

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

@@ -0,0 +1,77 @@
+<?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>
+
+    <groupId>cn.novalon.gym.manage</groupId>
+    <artifactId>gym-auth</artifactId>
+    <packaging>jar</packaging>
+
+    <name>Gym Auth</name>
+    <description>Authentication module for Gym Management System</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-db</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>gym-member</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-sys</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webflux</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.aliyun</groupId>
+            <artifactId>aliyun-java-sdk-core</artifactId>
+            <version>4.6.3</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.11.0</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/config/SmsProperties.java

@@ -0,0 +1,23 @@
+package cn.novalon.gym.manage.auth.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Data
+@Configuration
+@ConfigurationProperties(prefix = "alibaba.cloud.sms")
+public class SmsProperties {
+
+    private String accessKeyId;
+
+    private String accessKeySecret;
+
+    private String signName;
+
+    private String templateCode;
+
+    private int codeLength = 4;
+
+    private long codeExpireSeconds = 300;
+}

gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/dto/PhoneCodeLoginDto.java

@@ -0,0 +1,23 @@
+package cn.novalon.gym.manage.auth.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class PhoneCodeLoginDto {
+
+    @NotBlank(message = "手机号不能为空")
+    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
+    private String phone;
+
+    @NotBlank(message = "验证码不能为空")
+    @Pattern(regexp = "^\\d{4,6}$", message = "验证码格式不正确")
+    private String code;
+}

gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/dto/PhoneLoginDto.java

@@ -0,0 +1,23 @@
+package cn.novalon.gym.manage.auth.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class PhoneLoginDto {
+
+    @NotBlank(message = "手机号不能为空")
+    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
+    private String phone;
+
+    private String nickname;
+
+    private String avatar;
+}

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

@@ -0,0 +1,58 @@
+package cn.novalon.gym.manage.auth.handler;
+
+import cn.novalon.gym.manage.auth.dto.PhoneCodeLoginDto;
+import cn.novalon.gym.manage.auth.dto.PhoneLoginDto;
+import cn.novalon.gym.manage.auth.service.PhoneAuthService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+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
+@Tag(name = "手机号认证", description = "手机号一键登录与验证码登录")
+public class PhoneAuthHandler {
+
+    private final PhoneAuthService phoneAuthService;
+
+    @Operation(summary = "手机号一键登录", description = "使用uniapp官方运营商认证，直接手机号登录或注册")
+    public Mono<ServerResponse> oneClickLogin(ServerRequest request) {
+        log.info("收到手机号一键登录请求");
+
+        return request.bodyToMono(PhoneLoginDto.class)
+                .flatMap(phoneAuthService::oneClickLogin)
+                .flatMap(response -> ServerResponse.ok()
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .bodyValue(response));
+    }
+
+    @Operation(summary = "发送短信验证码", description = "使用阿里云发送短信验证码")
+    public Mono<ServerResponse> sendSmsCode(ServerRequest request) {
+        log.info("收到发送短信验证码请求");
+
+        return request.bodyToMono(PhoneLoginDto.class)
+                .flatMap(dto -> phoneAuthService.sendSmsCode(dto.getPhone()))
+                .flatMap(success -> ServerResponse.ok()
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .bodyValue(Map.of("success", success, "message", success ? "验证码发送成功" : "验证码发送失败")));
+    }
+
+    @Operation(summary = "手机号验证码登录", description = "使用阿里云短信验证码登录或注册")
+    public Mono<ServerResponse> codeLogin(ServerRequest request) {
+        log.info("收到手机号验证码登录请求");
+
+        return request.bodyToMono(PhoneCodeLoginDto.class)
+                .flatMap(phoneAuthService::codeLogin)
+                .flatMap(response -> ServerResponse.ok()
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .bodyValue(response));
+    }
+}

gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/service/PhoneAuthService.java

@@ -0,0 +1,15 @@
+package cn.novalon.gym.manage.auth.service;
+
+import cn.novalon.gym.manage.auth.dto.PhoneCodeLoginDto;
+import cn.novalon.gym.manage.auth.dto.PhoneLoginDto;
+import cn.novalon.gym.manage.auth.vo.PhoneLoginVO;
+import reactor.core.publisher.Mono;
+
+public interface PhoneAuthService {
+
+    Mono<PhoneLoginVO> oneClickLogin(PhoneLoginDto request);
+
+    Mono<Boolean> sendSmsCode(String phone);
+
+    Mono<PhoneLoginVO> codeLogin(PhoneCodeLoginDto request);
+}

gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/service/SmsService.java

@@ -0,0 +1,12 @@
+package cn.novalon.gym.manage.auth.service;
+
+import reactor.core.publisher.Mono;
+
+public interface SmsService {
+
+    Mono<Boolean> sendVerificationCode(String phone);
+
+    Mono<Boolean> verifyCode(String phone, String code);
+
+    Mono<String> getVerificationCode(String phone);
+}

gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/service/impl/PhoneAuthServiceImpl.java

@@ -0,0 +1,177 @@
+package cn.novalon.gym.manage.auth.service.impl;
+
+import cn.novalon.gym.manage.auth.dto.PhoneCodeLoginDto;
+import cn.novalon.gym.manage.auth.dto.PhoneLoginDto;
+import cn.novalon.gym.manage.auth.service.PhoneAuthService;
+import cn.novalon.gym.manage.auth.service.SmsService;
+import cn.novalon.gym.manage.auth.vo.PhoneLoginVO;
+import cn.novalon.gym.manage.common.exception.ErrorCode;
+import cn.novalon.gym.manage.common.exception.SystemException;
+import cn.novalon.gym.manage.member.entity.Member;
+import cn.novalon.gym.manage.member.es.entity.MemberES;
+import cn.novalon.gym.manage.member.es.repository.MemberESRepository;
+import cn.novalon.gym.manage.member.repository.IMemberRepository;
+import cn.novalon.gym.manage.member.util.AesUtil;
+import cn.novalon.gym.manage.member.util.EsSyncUtils;
+import cn.novalon.gym.manage.member.util.MemberNoGenerator;
+import cn.novalon.gym.manage.sys.security.JwtTokenProvider;
+import jakarta.annotation.PostConstruct;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PhoneAuthServiceImpl implements PhoneAuthService {
+
+    private final IMemberRepository memberRepository;
+    private final MemberESRepository memberESRepository;
+    private final EsSyncUtils esSyncUtils;
+    private final JwtTokenProvider jwtTokenProvider;
+    private final SmsService smsService;
+
+    private EsSyncUtils.EntitySyncer<Member, MemberES, String> memberSyncer;
+
+    @PostConstruct
+    public void init() {
+        this.memberSyncer = esSyncUtils.bind(Member.class, MemberES.class, memberESRepository);
+    }
+
+    @Override
+    public Mono<PhoneLoginVO> oneClickLogin(PhoneLoginDto request) {
+        log.info("手机号一键登录, phone: {}", request.getPhone());
+
+        String encryptedPhone = encryptPhone(request.getPhone());
+
+        return memberRepository.findByPhone(encryptedPhone)
+                .flatMap(existingMember -> {
+                    log.info("手机号已注册，直接登录, memberId: {}", existingMember.getId());
+                    return doLogin(existingMember, false, request);
+                })
+                .switchIfEmpty(Mono.defer(() -> {
+                    log.info("手机号未注册，创建新会员");
+                    return createNewMemberAndLogin(request, encryptedPhone);
+                }));
+    }
+
+    @Override
+    public Mono<Boolean> sendSmsCode(String phone) {
+        log.info("发送短信验证码, phone: {}", phone);
+        return smsService.sendVerificationCode(phone);
+    }
+
+    @Override
+    public Mono<PhoneLoginVO> codeLogin(PhoneCodeLoginDto request) {
+        log.info("手机号验证码登录, phone: {}", request.getPhone());
+
+        return smsService.verifyCode(request.getPhone(), request.getCode())
+                .flatMap(verified -> {
+                    if (!verified) {
+                        log.warn("验证码验证失败, phone: {}", request.getPhone());
+                        return Mono.error(new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "验证码错误或已过期"));
+                    }
+
+                    String encryptedPhone = encryptPhone(request.getPhone());
+
+                    return memberRepository.findByPhone(encryptedPhone)
+                            .flatMap(existingMember -> {
+                                log.info("手机号已注册，直接登录, memberId: {}", existingMember.getId());
+                                return doLogin(existingMember, false, null);
+                            })
+                            .switchIfEmpty(Mono.defer(() -> {
+                                log.info("手机号未注册，创建新会员");
+                                PhoneLoginDto registerRequest = new PhoneLoginDto();
+                                registerRequest.setPhone(request.getPhone());
+                                return createNewMemberAndLogin(registerRequest, encryptedPhone);
+                            }));
+                });
+    }
+
+    private Mono<PhoneLoginVO> createNewMemberAndLogin(PhoneLoginDto request, String encryptedPhone) {
+        String memberNo = MemberNoGenerator.generate();
+        log.info("生成会员号: {}", memberNo);
+
+        Member member = new Member();
+        member.setMemberNo(memberNo);
+        member.setPhone(encryptedPhone);
+        member.setNickname(request != null ? request.getNickname() : null);
+        member.setAvatar(request != null ? request.getAvatar() : null);
+        member.setLastLoginAt(LocalDateTime.now());
+        member.setIsDeleted(false);
+
+        return memberRepository.save(member)
+                .doOnSuccess(memberSyncer::sync)
+                .flatMap(savedMember -> {
+                    log.info("新会员创建成功, memberId: {}, memberNo: {}", savedMember.getId(), savedMember.getMemberNo());
+                    return doLogin(savedMember, true, request);
+                });
+    }
+
+    private Mono<PhoneLoginVO> doLogin(Member member, boolean isNewUser, PhoneLoginDto request) {
+        log.info("登录成功, memberId: {}", member.getId());
+
+        member.setLastLoginAt(LocalDateTime.now());
+
+        if (isNewUser && request != null) {
+            if ((member.getNickname() == null || member.getNickname().isEmpty())
+                    && request.getNickname() != null && !request.getNickname().isEmpty()) {
+                member.setNickname(request.getNickname());
+            }
+            if ((member.getAvatar() == null || member.getAvatar().isEmpty())
+                    && request.getAvatar() != null && !request.getAvatar().isEmpty()) {
+                member.setAvatar(request.getAvatar());
+            }
+        }
+
+        return memberRepository.save(member)
+                .doOnSuccess(memberSyncer::sync)
+                .map(this::buildLoginResponse);
+    }
+
+    private PhoneLoginVO buildLoginResponse(Member member) {
+        boolean needCompleteInfo = member.getNickname() == null || member.getNickname().isEmpty();
+
+        List<String> roles = new ArrayList<>();
+        String accessToken = jwtTokenProvider.generateToken(String.valueOf(member.getId()), member.getId(), roles);
+
+        log.info("JWT Token 生成成功, memberId: {}", member.getId());
+
+        PhoneLoginVO vo = new PhoneLoginVO();
+        vo.setMemberId(member.getId());
+        vo.setMemberNo(member.getMemberNo());
+        vo.setAccessToken(accessToken);
+        vo.setRefreshToken(accessToken);
+        vo.setExpiresIn(86400);
+        vo.setIsNewUser(member.getCreatedAt() == null ? false :
+                member.getCreatedAt().isAfter(LocalDateTime.now().minusMinutes(1)));
+        vo.setNeedCompleteInfo(needCompleteInfo);
+        vo.setNickname(member.getNickname());
+        vo.setAvatar(member.getAvatar());
+        vo.setPhone(decryptPhone(member.getPhone()));
+        return vo;
+    }
+
+    private String encryptPhone(String phoneNumber) {
+        try {
+            return AesUtil.encrypt(phoneNumber);
+        } catch (Exception e) {
+            log.error("手机号加密失败", e);
+            throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "手机号加密失败");
+        }
+    }
+
+    private String decryptPhone(String encryptedPhone) {
+        try {
+            return AesUtil.decrypt(encryptedPhone);
+        } catch (Exception e) {
+            log.error("手机号解密失败", e);
+            return null;
+        }
+    }
+}

gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/service/impl/SmsServiceImpl.java

@@ -0,0 +1,198 @@
+package cn.novalon.gym.manage.auth.service.impl;
+
+import cn.novalon.gym.manage.auth.config.SmsProperties;
+import cn.novalon.gym.manage.auth.service.SmsService;
+import cn.novalon.gym.manage.common.constant.RedisKeyConstants;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import com.aliyuncs.CommonRequest;
+import com.aliyuncs.CommonResponse;
+import com.aliyuncs.DefaultAcsClient;
+import com.aliyuncs.IAcsClient;
+import com.aliyuncs.exceptions.ClientException;
+import com.aliyuncs.http.MethodType;
+import com.aliyuncs.profile.DefaultProfile;
+import com.aliyuncs.profile.IClientProfile;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class SmsServiceImpl implements SmsService {
+
+    private static final long SEND_INTERVAL_SECONDS = 60;
+    private static final long CODE_EXPIRE_SECONDS = 300;
+
+    private final SmsProperties smsProperties;
+    private final RedisUtil redisUtil;
+    private final ObjectMapper objectMapper;
+
+    @Override
+    public Mono<Boolean> sendVerificationCode(String phone) {
+        log.info("发送短信验证码, phone: {}", phone);
+
+        String rateLimitKey = RedisKeyConstants.SMS_CODE + phone + ":rate_limit";
+
+        return redisUtil.get(rateLimitKey, Long.class)
+                .defaultIfEmpty(0L)
+                .flatMap(lastSendTime -> {
+                    long currentTime = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC);
+
+                    if (currentTime - lastSendTime < SEND_INTERVAL_SECONDS) {
+                        long remainingSeconds = SEND_INTERVAL_SECONDS - (currentTime - lastSendTime);
+                        log.warn("发送频率限制, phone: {}, 剩余时间: {}秒", phone, remainingSeconds);
+                        return Mono.just(false);
+                    }
+
+                    return Mono.fromCallable(() -> {
+                        try {
+                            IAcsClient client = createClient();
+
+                            CommonRequest request = new CommonRequest();
+                            request.setSysMethod(MethodType.POST);
+                            request.setSysDomain("dypnsapi.aliyuncs.com");
+                            request.setSysVersion("2017-05-25");
+                            request.setSysAction("SendSmsVerifyCode");
+                            request.putQueryParameter("PhoneNumber", phone);
+                            request.putQueryParameter("SignName", smsProperties.getSignName());
+                            request.putQueryParameter("TemplateCode", smsProperties.getTemplateCode());
+                            request.putQueryParameter("TemplateParam", "{\"code\":\"##code##\",\"min\":\"5\"}");
+                            request.putQueryParameter("ReturnVerifyCode", "true");
+
+                            log.info("阿里云号码认证请求参数 - signName: {}, templateCode: {}, templateParam: {}",
+                                    smsProperties.getSignName(),
+                                    smsProperties.getTemplateCode(),
+                                    "{\"code\":\"##code##\",\"min\":\"5\"}");
+
+                            CommonResponse response = client.getCommonResponse(request);
+                            String responseData = response.getData();
+                            log.info("阿里云号码认证原始响应: {}", responseData);
+
+                            JsonNode jsonNode = objectMapper.readTree(responseData);
+                            
+                            JsonNode codeNode = jsonNode.get("Code");
+                            if (codeNode == null) {
+                                log.error("阿里云响应中找不到Code字段, 原始响应: {}", responseData);
+                                return false;
+                            }
+                            
+                            String code = codeNode.asText();
+
+                            if ("OK".equals(code)) {
+                                JsonNode requestIdNode = jsonNode.get("RequestId");
+                                String requestId = requestIdNode != null ? requestIdNode.asText() : "unknown";
+                                log.info("短信验证码发送成功, phone: {}, requestId: {}", phone, requestId);
+
+                                // 提取验证码并存入Redis
+                                JsonNode modelNode = jsonNode.get("Model");
+                                if (modelNode != null) {
+                                    JsonNode verifyCodeNode = modelNode.get("VerifyCode");
+                                    if (verifyCodeNode != null) {
+                                        String verifyCode = verifyCodeNode.asText();
+                                        String smsCodeKey = RedisKeyConstants.SMS_CODE + phone;
+                                        redisUtil.setWithExpire(smsCodeKey, verifyCode, CODE_EXPIRE_SECONDS).subscribe();
+                                        log.info("验证码已存入Redis, phone: {}, key: {}, expire: {}秒", phone, smsCodeKey, CODE_EXPIRE_SECONDS);
+                                    } else {
+                                        log.warn("响应中未找到Model.VerifyCode字段, 原始响应: {}", responseData);
+                                    }
+                                } else {
+                                    log.warn("响应中未找到Model字段, 原始响应: {}", responseData);
+                                }
+
+                                redisUtil.setWithExpire(rateLimitKey, currentTime, SEND_INTERVAL_SECONDS).subscribe();
+                                return true;
+                            }
+
+                            JsonNode messageNode = jsonNode.get("Message");
+                            String message = messageNode != null ? messageNode.asText() : "unknown";
+                            log.error("短信验证码发送失败, phone: {}, code: {}, message: {}", phone, code, message);
+                            return false;
+
+                        } catch (Exception e) {
+                            log.error("发送短信验证码异常, phone: {}, 异常信息: {}", phone, e.getMessage(), e);
+                            return false;
+                        }
+                    });
+                });
+    }
+
+    @Override
+    public Mono<Boolean> verifyCode(String phone, String code) {
+        log.info("验证短信验证码, phone: {}", phone);
+
+        return Mono.fromCallable(() -> {
+            try {
+                IAcsClient client = createClient();
+
+                CommonRequest request = new CommonRequest();
+                request.setSysMethod(MethodType.POST);
+                request.setSysDomain("dypnsapi.aliyuncs.com");
+                request.setSysVersion("2017-05-25");
+                request.setSysAction("CheckSmsVerifyCode");
+                request.putQueryParameter("PhoneNumber", phone);
+                request.putQueryParameter("VerifyCode", code);
+
+                log.info("阿里云号码认证核验参数 - phone: {}, code: {}", phone, code);
+
+                CommonResponse response = client.getCommonResponse(request);
+                String responseData = response.getData();
+                log.info("阿里云号码认证核验原始响应: {}", responseData);
+
+                JsonNode jsonNode = objectMapper.readTree(responseData);
+                
+                JsonNode codeNode = jsonNode.get("Code");
+                if (codeNode == null) {
+                    log.error("阿里云核验响应中找不到Code字段, 原始响应: {}", responseData);
+                    return false;
+                }
+                
+                String responseCode = codeNode.asText();
+                JsonNode modelNode = jsonNode.get("Model");
+                JsonNode verifyResultNode = modelNode != null ? modelNode.get("VerifyResult") : null;
+                boolean verifyResult = verifyResultNode != null && "PASS".equals(verifyResultNode.asText());
+
+                if ("OK".equals(responseCode) && verifyResult) {
+                    log.info("验证码验证成功, phone: {}", phone);
+                    return true;
+                }
+
+                JsonNode messageNode = jsonNode.get("Message");
+                String message = messageNode != null ? messageNode.asText() : "unknown";
+                log.warn("验证码验证失败, phone: {}, code: {}, message: {}, result: {}",
+                        phone, responseCode, message, verifyResult);
+                return false;
+
+            } catch (Exception e) {
+                log.error("验证短信验证码异常, phone: {}, 异常信息: {}", phone, e.getMessage(), e);
+                return false;
+            }
+        });
+    }
+
+    @Override
+    public Mono<String> getVerificationCode(String phone) {
+        try {
+            String cacheKey = RedisKeyConstants.SMS_CODE + phone;
+            return redisUtil.get(cacheKey, String.class);
+        } catch (Exception e) {
+            log.error("获取验证码异常, phone: {}", phone, e);
+            return Mono.empty();
+        }
+    }
+
+    private IAcsClient createClient() throws ClientException {
+        IClientProfile profile = DefaultProfile.getProfile(
+                "cn-hangzhou",
+                smsProperties.getAccessKeyId(),
+                smsProperties.getAccessKeySecret());
+        DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", "Dypnsapi", "dypnsapi.aliyuncs.com");
+        return new DefaultAcsClient(profile);
+    }
+}

gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/vo/PhoneLoginVO.java

@@ -0,0 +1,33 @@
+package cn.novalon.gym.manage.auth.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class PhoneLoginVO {
+
+    private Long memberId;
+
+    private String memberNo;
+
+    private String phone;
+
+    private String accessToken;
+
+    private String refreshToken;
+
+    private Integer expiresIn;
+
+    private Boolean isNewUser;
+
+    private Boolean needCompleteInfo;
+
+    private String nickname;
+
+    private String avatar;
+}

gym-manage-api/gym-auth/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@@ -0,0 +1 @@
+cn.novalon.gym.manage.auth.config.SmsProperties

gym-manage-api/gym-checkIn/spotbugs-exclude.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<FindBugsFilter>
+    <Match>
+        <Class name="~.*\.entity\..*" />
+    </Match>
+    <Match>
+        <Class name="~.*\.dto\..*" />
+    </Match>
+    <Match>
+        <Class name="~.*\.converter\..*" />
+    </Match>
+</FindBugsFilter>

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/entity/SignInRecord.java

@@ -206,4 +206,4 @@ public class SignInRecord {
     public void restore() {
         this.isDelete = false;
     }
-}
+}

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

@@ -2,6 +2,8 @@ package cn.novalon.gym.manage.checkIn.handler;
 
 import cn.novalon.gym.manage.checkIn.service.impl.CheckServiceImpl;
 import cn.novalon.gym.manage.checkIn.websocket.MyWebSocketHandler;
+import cn.novalon.gym.manage.checkIn.vo.SignInRecordVO;
+import cn.novalon.gym.manage.checkIn.vo.SignInStatsVO;
 import cn.novalon.gym.manage.sys.util.AuthUtil;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -12,6 +14,7 @@ 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 cn.novalon.gym.manage.checkIn.websocket.MyWebSocketHandler;
 
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
@@ -36,6 +39,7 @@ public class CheckInHandler {
     public Mono<ServerResponse> checkIn(ServerRequest request) {
 
         Long memberId = authUtil.getMemberIdOrThrow(request);
+
         return request.bodyToMono(Map.class)
                 .flatMap(body -> {
                     String qrContent = (String) body.get("qrContent");
@@ -190,4 +194,4 @@ public class CheckInHandler {
                         .contentType(MediaType.APPLICATION_JSON)
                         .bodyValue(Map.of("code", 200, "message", "success", "data", stats)));
     }
-}
+}

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

@@ -78,4 +78,4 @@ public interface ICheckInService {
      * @return 签到统计VO
      */
     Mono<SignInStatsVO> getDailySignInStats(LocalDate date);
-}
+}

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

@@ -2,6 +2,8 @@ package cn.novalon.gym.manage.checkIn.service.impl;
 
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.json.JSONUtil;
+import cn.hutool.extra.qrcode.QrCodeUtil;
+import cn.hutool.extra.qrcode.QrConfig;
 import cn.novalon.gym.manage.checkIn.config.QRCodeConfig;
 import cn.novalon.gym.manage.checkIn.constant.QRRedisKey;
 import cn.novalon.gym.manage.checkIn.entity.SignInRecord;
@@ -19,8 +21,6 @@ import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.enums.MemberCardType;
 import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
 import cn.novalon.gym.manage.member.repository.MemberCardRepository;
-import cn.hutool.extra.qrcode.QrCodeUtil;
-import cn.hutool.extra.qrcode.QrConfig;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;

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

@@ -199,4 +199,4 @@ public class MyWebSocketHandler implements WebSocketHandler {
         cleanupTimeoutConnections();
         return qrContentToSink.size();
     }
-}
+}

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

@@ -100,8 +100,20 @@
     <build>
         <plugins>
             <plugin>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-maven-plugin</artifactId>
+                <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.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                            <version>${lombok.version}</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
             </plugin>
         </plugins>
     </build>

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

@@ -86,6 +86,25 @@
             <artifactId>gym-member</artifactId>
             <version>${project.version}</version>
         </dependency>
+
+        <!-- ZXing二维码生成库 -->
+        <dependency>
+            <groupId>com.google.zxing</groupId>
+            <artifactId>core</artifactId>
+            <version>3.5.3</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.zxing</groupId>
+            <artifactId>javase</artifactId>
+            <version>3.5.3</version>
+        </dependency>
+
+        <!-- 阿里云OSS SDK -->
+        <dependency>
+            <groupId>com.aliyun.oss</groupId>
+            <artifactId>aliyun-sdk-oss</artifactId>
+            <version>3.17.1</version>
+        </dependency>
     </dependencies>
 
     <build>

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/dao/GroupCourseDao.java

@@ -1,16 +1,19 @@
-
 package cn.novalon.gym.manage.groupcourse.dao;
 
+import cn.novalon.gym.manage.groupcourse.dto.GroupCourseQueryDto;
 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.r2dbc.core.DatabaseClient;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
 
 @Repository
 public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long> {
@@ -37,5 +40,190 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
     @Query("UPDATE group_course SET deleted_at = :deletedAt WHERE id = :id")
     Mono<Integer> softDelete(Long id, LocalDateTime deletedAt);
 
+    @Modifying
+    @Query("UPDATE group_course SET status = '2', updated_at = :updatedAt WHERE status = '0' AND end_time <= NOW() AND deleted_at IS NULL")
+    Mono<Integer> completeExpiredCourses(LocalDateTime updatedAt);
+
     Flux<GroupCourseEntity> findByCourseTypeAndDeletedAtIsNull(Long courseType);
-}
+
+    /**
+     * 多条件查询团课（使用 DatabaseClient 构建动态 SQL）
+     */
+    default Flux<GroupCourseEntity> searchGroupCourses(DatabaseClient databaseClient, GroupCourseQueryDto query) {
+        StringBuilder sql = new StringBuilder("SELECT * FROM group_course WHERE deleted_at IS NULL");
+        List<String> conditions = new ArrayList<>();
+
+        // 默认不查询可预约团课（status = '0' 且未过期）
+        conditions.add("status = '0'");
+        conditions.add("end_time > NOW()");
+
+        // 1. 团课名称模糊查询
+        if (query.getCourseName() != null && !query.getCourseName().isEmpty()) {
+            conditions.add("course_name ILIKE :courseName");
+        }
+
+        // 2. 基于团课类型查询
+        if (query.getCourseType() != null) {
+            conditions.add("course_type = :courseType");
+        }
+
+        // 3. 基于日期时间段查询
+        if (query.getStartDate() != null) {
+            conditions.add("start_time >= :startDate");
+        }
+        if (query.getEndDate() != null) {
+            conditions.add("start_time <= :endDate");
+        }
+
+        // 4. 基于早晨/下午/夜晚时间段查询
+        if (query.getTimePeriod() != null && !query.getTimePeriod().isEmpty()) {
+            switch (query.getTimePeriod().toLowerCase()) {
+                case "morning":
+                    conditions.add("EXTRACT(HOUR FROM start_time) >= 6 AND EXTRACT(HOUR FROM start_time) < 12");
+                    break;
+                case "afternoon":
+                    conditions.add("EXTRACT(HOUR FROM start_time) >= 12 AND EXTRACT(HOUR FROM start_time) < 18");
+                    break;
+                case "evening":
+                    conditions.add("EXTRACT(HOUR FROM start_time) >= 18 AND EXTRACT(HOUR FROM start_time) < 24");
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        sql.append(" AND ").append(String.join(" AND ", conditions));
+
+        // 5. 价格排序 / 6. 剩余名额最多排序
+        boolean hasPriceSort = query.getPriceSort() != null && !query.getPriceSort().isEmpty();
+        boolean hasRemainingMost = query.getRemainingMost() != null && query.getRemainingMost();
+
+        if (hasPriceSort || hasRemainingMost) {
+            sql.append(" ORDER BY");
+            List<String> orderClauses = new ArrayList<>();
+
+            if (hasRemainingMost) {
+                orderClauses.add(" (max_members - current_members) DESC");
+            }
+
+            if (hasPriceSort) {
+                if ("asc".equalsIgnoreCase(query.getPriceSort())) {
+                    orderClauses.add(" stored_value_amount ASC");
+                } else if ("desc".equalsIgnoreCase(query.getPriceSort())) {
+                    orderClauses.add(" stored_value_amount DESC");
+                }
+            }
+
+            sql.append(String.join(",", orderClauses));
+        } else {
+            sql.append(" ORDER BY start_time ASC");
+        }
+
+        // 分页
+        int page = query.getPage() != null ? query.getPage() : 0;
+        int size = query.getSize() != null ? query.getSize() : 10;
+        if (size < 1) size = 10;
+        if (size > 100) size = 100;
+        int offset = page * size;
+        sql.append(" LIMIT :limit OFFSET :offset");
+
+        DatabaseClient.GenericExecuteSpec spec = databaseClient.sql(sql.toString());
+
+        if (query.getCourseName() != null && !query.getCourseName().isEmpty()) {
+            spec = spec.bind("courseName", "%" + query.getCourseName() + "%");
+        }
+        if (query.getCourseType() != null) {
+            spec = spec.bind("courseType", query.getCourseType());
+        }
+        if (query.getStartDate() != null) {
+            spec = spec.bind("startDate", query.getStartDate());
+        }
+        if (query.getEndDate() != null) {
+            spec = spec.bind("endDate", query.getEndDate());
+        }
+        spec = spec.bind("limit", size);
+        spec = spec.bind("offset", offset);
+
+        return spec.map((row, meta) -> {
+            GroupCourseEntity entity = new GroupCourseEntity();
+            entity.setId(row.get("id", Long.class));
+            entity.setCourseName(row.get("course_name", String.class));
+            entity.setCoachId(row.get("coach_id", Long.class));
+            entity.setCourseType(row.get("course_type", Long.class));
+            entity.setStartTime(row.get("start_time", LocalDateTime.class));
+            entity.setEndTime(row.get("end_time", LocalDateTime.class));
+            entity.setMaxMembers(row.get("max_members", Integer.class));
+            entity.setCurrentMembers(row.get("current_members", Integer.class));
+            String statusStr = row.get("status", String.class);
+            entity.setStatus(statusStr != null ? Long.parseLong(statusStr) : null);
+            entity.setLocation(row.get("location", String.class));
+            entity.setCoverImage(row.get("cover_image", String.class));
+            entity.setDescription(row.get("description", String.class));
+            entity.setStoredValueAmount(row.get("stored_value_amount", java.math.BigDecimal.class));
+            entity.setCreateBy(row.get("create_by", String.class));
+            entity.setUpdateBy(row.get("update_by", String.class));
+            entity.setCreatedAt(row.get("created_at", LocalDateTime.class));
+            entity.setUpdatedAt(row.get("updated_at", LocalDateTime.class));
+            entity.setDeletedAt(row.get("deleted_at", LocalDateTime.class));
+            return entity;
+        }).all();
+    }
+
+    /**
+     * 多条件查询团课总数
+     */
+    default Mono<Long> countSearchGroupCourses(DatabaseClient databaseClient, GroupCourseQueryDto query) {
+        StringBuilder sql = new StringBuilder("SELECT COUNT(*) FROM group_course WHERE deleted_at IS NULL");
+        List<String> conditions = new ArrayList<>();
+
+        conditions.add("status = '0'");
+        conditions.add("end_time > NOW()");
+
+        if (query.getCourseName() != null && !query.getCourseName().isEmpty()) {
+            conditions.add("course_name ILIKE :courseName");
+        }
+        if (query.getCourseType() != null) {
+            conditions.add("course_type = :courseType");
+        }
+        if (query.getStartDate() != null) {
+            conditions.add("start_time >= :startDate");
+        }
+        if (query.getEndDate() != null) {
+            conditions.add("start_time <= :endDate");
+        }
+        if (query.getTimePeriod() != null && !query.getTimePeriod().isEmpty()) {
+            switch (query.getTimePeriod().toLowerCase()) {
+                case "morning":
+                    conditions.add("EXTRACT(HOUR FROM start_time) >= 6 AND EXTRACT(HOUR FROM start_time) < 12");
+                    break;
+                case "afternoon":
+                    conditions.add("EXTRACT(HOUR FROM start_time) >= 12 AND EXTRACT(HOUR FROM start_time) < 18");
+                    break;
+                case "evening":
+                    conditions.add("EXTRACT(HOUR FROM start_time) >= 18 AND EXTRACT(HOUR FROM start_time) < 24");
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        sql.append(" AND ").append(String.join(" AND ", conditions));
+
+        DatabaseClient.GenericExecuteSpec spec = databaseClient.sql(sql.toString());
+
+        if (query.getCourseName() != null && !query.getCourseName().isEmpty()) {
+            spec = spec.bind("courseName", "%" + query.getCourseName() + "%");
+        }
+        if (query.getCourseType() != null) {
+            spec = spec.bind("courseType", query.getCourseType());
+        }
+        if (query.getStartDate() != null) {
+            spec = spec.bind("startDate", query.getStartDate());
+        }
+        if (query.getEndDate() != null) {
+            spec = spec.bind("endDate", query.getEndDate());
+        }
+
+        return spec.map((row, meta) -> row.get(0, Long.class)).one();
+    }
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/dao/GroupCourseRecommendDao.java

@@ -0,0 +1,42 @@
+package cn.novalon.gym.manage.groupcourse.dao;
+
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseRecommendEntity;
+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 GroupCourseRecommendDao extends R2dbcRepository<GroupCourseRecommendEntity, Long> {
+
+    Mono<GroupCourseRecommendEntity> findByIdAndDeletedAtIsNull(Long id);
+
+    Flux<GroupCourseRecommendEntity> findAllByDeletedAtIsNull();
+
+    Flux<GroupCourseRecommendEntity> findAllByDeletedAtIsNull(Sort sort);
+
+    Flux<GroupCourseRecommendEntity> findByCourseIdAndDeletedAtIsNull(Long courseId);
+
+    Mono<GroupCourseRecommendEntity> findByCourseIdAndDeletedAtIsNullAndIsActiveTrue(Long courseId);
+
+    Flux<GroupCourseRecommendEntity> findByIsActiveTrueAndDeletedAtIsNull();
+
+    Flux<GroupCourseRecommendEntity> findByIsActiveTrueAndDeletedAtIsNull(Sort sort);
+
+    @Modifying
+    @Query("UPDATE group_course_recommend SET is_active = :isActive, updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
+    Mono<Integer> updateActiveStatus(Long id, Boolean isActive, LocalDateTime updatedAt);
+
+    @Modifying
+    @Query("UPDATE group_course_recommend SET deleted_at = :deletedAt WHERE id = :id")
+    Mono<Integer> softDelete(Long id, LocalDateTime deletedAt);
+
+    @Modifying
+    @Query("UPDATE group_course_recommend SET deleted_at = :deletedAt WHERE course_id = :courseId")
+    Mono<Integer> softDeleteByCourseId(Long courseId, LocalDateTime deletedAt);
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/domain/GroupCourse.java

@@ -52,14 +52,14 @@ public class GroupCourse extends BaseDomain{
     @Schema(description = "课程描述", example = "从入门到入土")
     private String description;
 
-    //点卡额度（消耗次数）
-    @Schema(description = "点卡额度（消耗次数）", example = "1")
-    private Integer pointCardAmount;
-
     //储值卡额度（消耗金额）
     @Schema(description = "储值卡额度（消耗金额）", example = "50.00")
     private java.math.BigDecimal storedValueAmount;
 
+    //二维码路径
+    @Schema(description = "二维码路径", example = "D:\\Games\\exmp\\image\\abc123_20260618120000.png")
+    private String qrCodePath;
+
     public String getCourseName() {
         return courseName;
     }
@@ -148,14 +148,6 @@ public class GroupCourse extends BaseDomain{
         this.description = description;
     }
 
-    public Integer getPointCardAmount() {
-        return pointCardAmount;
-    }
-
-    public void setPointCardAmount(Integer pointCardAmount) {
-        this.pointCardAmount = pointCardAmount;
-    }
-
     public java.math.BigDecimal getStoredValueAmount() {
         return storedValueAmount;
     }
@@ -163,4 +155,12 @@ public class GroupCourse extends BaseDomain{
     public void setStoredValueAmount(java.math.BigDecimal storedValueAmount) {
         this.storedValueAmount = storedValueAmount;
     }
+
+    public String getQrCodePath() {
+        return qrCodePath;
+    }
+
+    public void setQrCodePath(String qrCodePath) {
+        this.qrCodePath = qrCodePath;
+    }
 }

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/domain/GroupCourseDetail.java

@@ -48,12 +48,12 @@ public class GroupCourseDetail extends BaseDomain {
     @Schema(description = "课程描述", example = "适合初学者的瑜伽课程")
     private String description;
 
-    @Schema(description = "点卡额度（消耗次数）", example = "1")
-    private Integer pointCardAmount;
-
     @Schema(description = "储值卡额度（消耗金额）", example = "50.00")
     private BigDecimal storedValueAmount;
 
+    @Schema(description = "二维码路径", example = "D:\\Games\\exmp\\image\\abc123_20260618120000.png")
+    private String qrCodePath;
+
     // ===== 关联的类型信息 =====
 
     @Schema(description = "类型信息")
@@ -171,14 +171,6 @@ public class GroupCourseDetail extends BaseDomain {
         this.description = description;
     }
 
-    public Integer getPointCardAmount() {
-        return pointCardAmount;
-    }
-
-    public void setPointCardAmount(Integer pointCardAmount) {
-        this.pointCardAmount = pointCardAmount;
-    }
-
     public BigDecimal getStoredValueAmount() {
         return storedValueAmount;
     }
@@ -187,6 +179,14 @@ public class GroupCourseDetail extends BaseDomain {
         this.storedValueAmount = storedValueAmount;
     }
 
+    public String getQrCodePath() {
+        return qrCodePath;
+    }
+
+    public void setQrCodePath(String qrCodePath) {
+        this.qrCodePath = qrCodePath;
+    }
+
     public GroupCourseType getTypeInfo() {
         return typeInfo;
     }

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/domain/GroupCourseRecommend.java

@@ -0,0 +1,84 @@
+package cn.novalon.gym.manage.groupcourse.domain;
+
+import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+public class GroupCourseRecommend extends BaseDomain {
+
+    @Schema(description = "团课ID", example = "1")
+    private Long courseId;
+
+    @Schema(description = "推荐标题", example = "本周热门课程")
+    private String recommendTitle;
+
+    @Schema(description = "推荐内容", example = "这是一门非常棒的课程，快来参加吧！")
+    private String recommendContent;
+
+    @Schema(description = "推荐理由", example = "教练专业，课程内容丰富")
+    private String recommendReason;
+
+    @Schema(description = "优先级（数字越大优先级越高）", example = "10")
+    private Integer priority;
+
+    @Schema(description = "是否启用", example = "true")
+    private Boolean isActive;
+
+    @Schema(description = "团课信息")
+    private GroupCourse groupCourse;
+
+    public Long getCourseId() {
+        return courseId;
+    }
+
+    public void setCourseId(Long courseId) {
+        this.courseId = courseId;
+    }
+
+    public String getRecommendTitle() {
+        return recommendTitle;
+    }
+
+    public void setRecommendTitle(String recommendTitle) {
+        this.recommendTitle = recommendTitle;
+    }
+
+    public String getRecommendContent() {
+        return recommendContent;
+    }
+
+    public void setRecommendContent(String recommendContent) {
+        this.recommendContent = recommendContent;
+    }
+
+    public String getRecommendReason() {
+        return recommendReason;
+    }
+
+    public void setRecommendReason(String recommendReason) {
+        this.recommendReason = recommendReason;
+    }
+
+    public Integer getPriority() {
+        return priority;
+    }
+
+    public void setPriority(Integer priority) {
+        this.priority = priority;
+    }
+
+    public Boolean getIsActive() {
+        return isActive;
+    }
+
+    public void setIsActive(Boolean isActive) {
+        this.isActive = isActive;
+    }
+
+    public GroupCourse getGroupCourse() {
+        return groupCourse;
+    }
+
+    public void setGroupCourse(GroupCourse groupCourse) {
+        this.groupCourse = groupCourse;
+    }
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/dto/GroupCourseQueryDto.java

@@ -0,0 +1,116 @@
+package cn.novalon.gym.manage.groupcourse.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.time.LocalDateTime;
+
+/**
+ * 团课多条件查询请求DTO
+ *
+ * @author 张翔
+ * @date 2026-06-14
+ */
+@Schema(description = "团课多条件查询参数")
+public class GroupCourseQueryDto {
+
+    @Schema(description = "课程名称（模糊查询）", example = "瑜伽")
+    private String courseName;
+
+    @Schema(description = "课程类型ID", example = "1")
+    private Long courseType;
+
+    @Schema(description = "查询开始日期", example = "2026-06-01T00:00:00")
+    private LocalDateTime startDate;
+
+    @Schema(description = "查询结束日期", example = "2026-06-30T23:59:59")
+    private LocalDateTime endDate;
+
+    @Schema(description = "时间段：morning-早晨(6:00-12:00), afternoon-下午(12:00-18:00), evening-夜晚(18:00-24:00)", example = "morning")
+    private String timePeriod;
+
+    @Schema(description = "价格排序：asc-从低到高, desc-从高到低", example = "asc")
+    private String priceSort;
+
+    @Schema(description = "按剩余名额最多排序", example = "true")
+    private Boolean remainingMost;
+
+    @Schema(description = "页码", example = "0")
+    private Integer page = 0;
+
+    @Schema(description = "每页大小", example = "10")
+    private Integer size = 10;
+
+    // ===== Getters and Setters =====
+
+    public String getCourseName() {
+        return courseName;
+    }
+
+    public void setCourseName(String courseName) {
+        this.courseName = courseName;
+    }
+
+    public Long getCourseType() {
+        return courseType;
+    }
+
+    public void setCourseType(Long courseType) {
+        this.courseType = courseType;
+    }
+
+    public LocalDateTime getStartDate() {
+        return startDate;
+    }
+
+    public void setStartDate(LocalDateTime startDate) {
+        this.startDate = startDate;
+    }
+
+    public LocalDateTime getEndDate() {
+        return endDate;
+    }
+
+    public void setEndDate(LocalDateTime endDate) {
+        this.endDate = endDate;
+    }
+
+    public String getTimePeriod() {
+        return timePeriod;
+    }
+
+    public void setTimePeriod(String timePeriod) {
+        this.timePeriod = timePeriod;
+    }
+
+    public String getPriceSort() {
+        return priceSort;
+    }
+
+    public void setPriceSort(String priceSort) {
+        this.priceSort = priceSort;
+    }
+
+    public Boolean getRemainingMost() {
+        return remainingMost;
+    }
+
+    public void setRemainingMost(Boolean remainingMost) {
+        this.remainingMost = remainingMost;
+    }
+
+    public Integer getPage() {
+        return page;
+    }
+
+    public void setPage(Integer page) {
+        this.page = page;
+    }
+
+    public Integer getSize() {
+        return size;
+    }
+
+    public void setSize(Integer size) {
+        this.size = size;
+    }
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/entity/GroupCourseEntity.java

@@ -54,14 +54,14 @@ public class GroupCourseEntity extends BaseEntity {
     @Column("description")
     private String description;
 
-    //点卡额度（消耗次数）
-    @Column("point_card_amount")
-    private Integer pointCardAmount;
-
     //储值卡额度（消耗金额）
     @Column("stored_value_amount")
     private java.math.BigDecimal storedValueAmount;
 
+    //二维码路径
+    @Column("qr_code_path")
+    private String qrCodePath;
+
     public String getCourseName() {
         return courseName;
     }
@@ -150,14 +150,6 @@ public class GroupCourseEntity extends BaseEntity {
         this.description = description;
     }
 
-    public Integer getPointCardAmount() {
-        return pointCardAmount;
-    }
-
-    public void setPointCardAmount(Integer pointCardAmount) {
-        this.pointCardAmount = pointCardAmount;
-    }
-
     public java.math.BigDecimal getStoredValueAmount() {
         return storedValueAmount;
     }
@@ -165,4 +157,12 @@ public class GroupCourseEntity extends BaseEntity {
     public void setStoredValueAmount(java.math.BigDecimal storedValueAmount) {
         this.storedValueAmount = storedValueAmount;
     }
+
+    public String getQrCodePath() {
+        return qrCodePath;
+    }
+
+    public void setQrCodePath(String qrCodePath) {
+        this.qrCodePath = qrCodePath;
+    }
 }

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/entity/GroupCourseRecommendEntity.java

@@ -0,0 +1,77 @@
+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_recommend")
+public class GroupCourseRecommendEntity extends BaseEntity {
+
+    @Column("course_id")
+    private Long courseId;
+
+    @Column("recommend_title")
+    private String recommendTitle;
+
+    @Column("recommend_content")
+    private String recommendContent;
+
+    @Column("recommend_reason")
+    private String recommendReason;
+
+    @Column("priority")
+    private Integer priority;
+
+    @Column("is_active")
+    private Boolean isActive;
+
+    public Long getCourseId() {
+        return courseId;
+    }
+
+    public void setCourseId(Long courseId) {
+        this.courseId = courseId;
+    }
+
+    public String getRecommendTitle() {
+        return recommendTitle;
+    }
+
+    public void setRecommendTitle(String recommendTitle) {
+        this.recommendTitle = recommendTitle;
+    }
+
+    public String getRecommendContent() {
+        return recommendContent;
+    }
+
+    public void setRecommendContent(String recommendContent) {
+        this.recommendContent = recommendContent;
+    }
+
+    public String getRecommendReason() {
+        return recommendReason;
+    }
+
+    public void setRecommendReason(String recommendReason) {
+        this.recommendReason = recommendReason;
+    }
+
+    public Integer getPriority() {
+        return priority;
+    }
+
+    public void setPriority(Integer priority) {
+        this.priority = priority;
+    }
+
+    public Boolean getIsActive() {
+        return isActive;
+    }
+
+    public void setIsActive(Boolean isActive) {
+        this.isActive = isActive;
+    }
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/BookingSagaHandler.java

@@ -109,8 +109,8 @@ public class BookingSagaHandler {
 
                                 switch (cardType) {
                                     case COUNT_CARD:
-                                        // 次卡扣除次数
-                                        return deductCardUsage(recordId, 1, 0.0);
+                                        // 次数卡不再支持团课预约
+                                        return Mono.error(new RuntimeException("团课预约仅支持储值卡支付"));
                                     case STORED_VALUE_CARD:
                                         // 储值卡扣除金额
                                         return deductCardUsage(recordId, 0, DEFAULT_GROUP_COURSE_PRICE);
@@ -168,7 +168,8 @@ public class BookingSagaHandler {
 
                                 switch (cardType) {
                                     case COUNT_CARD:
-                                        return restoreCardUsage(recordId, 1, 0.0);
+                                        // 次数卡不再支持团课预约，无需恢复
+                                        return Mono.empty();
                                     case STORED_VALUE_CARD:
                                         return restoreCardUsage(recordId, 0, DEFAULT_GROUP_COURSE_PRICE);
                                     case TIME_CARD:

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandler.java

@@ -5,6 +5,7 @@ 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.domain.GroupCourseDetail;
+import cn.novalon.gym.manage.groupcourse.dto.GroupCourseQueryDto;
 import cn.novalon.gym.manage.groupcourse.service.IGroupCourseService;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.swagger.v3.oas.annotations.Operation;
@@ -158,7 +159,7 @@ public class GroupCourseHandler {
 
     @Operation(summary = "团课签到", description = "会员签到参加团课")
     public Mono<ServerResponse> signIn(ServerRequest request) {
-        Long courseId = Long.valueOf(request.pathVariable("courseId"));
+        Long memberId = Long.valueOf(request.pathVariable("memberId"));
         
         return request.bodyToMono(Map.class)
                 .flatMap(body -> {
@@ -169,15 +170,15 @@ public class GroupCourseHandler {
                         return ServerResponse.badRequest().bodyValue(response);
                     }
                     
-                    Object memberIdObj = body.get("memberId");
-                    if (memberIdObj == null) {
+                    Object courseIdObj = body.get("courseId");
+                    if (courseIdObj == null) {
                         Map<String, Object> response = new HashMap<>();
                         response.put("success", false);
-                        response.put("message", "memberId不能为空");
+                        response.put("message", "courseId不能为空");
                         return ServerResponse.badRequest().bodyValue(response);
                     }
                     
-                    Long memberId = ((Number) memberIdObj).longValue();
+                    Long courseId = ((Number) courseIdObj).longValue();
                     
                     return groupCourseService.signIn(courseId, memberId)
                             .flatMap(course -> {
@@ -215,6 +216,27 @@ public class GroupCourseHandler {
                 });
     }
 
+    @Operation(summary = "多条件查询团课", description = "支持团课名称模糊查询、类型筛选、日期范围、时间段、价格排序、剩余名额排序等多条件组合查询")
+    public Mono<ServerResponse> searchGroupCourses(ServerRequest request) {
+        return request.bodyToMono(GroupCourseQueryDto.class)
+                .flatMap(query -> {
+                    return groupCourseService.searchGroupCourses(query)
+                            .flatMap(response -> {
+                                Map<String, Object> result = new HashMap<>();
+                                result.put("success", true);
+                                result.put("message", "查询成功");
+                                result.put("data", response);
+                                return ServerResponse.ok().bodyValue(result);
+                            });
+                })
+                .onErrorResume(error -> {
+                    Map<String, Object> errorResponse = new HashMap<>();
+                    errorResponse.put("success", false);
+                    errorResponse.put("message", error.getMessage());
+                    return ServerResponse.badRequest().bodyValue(errorResponse);
+                });
+    }
+
     @Operation(summary = "测试-根据Key获取Redis缓存", description = "测试接口：根据传入的key值获取Redis中缓存的数据")
     public Mono<ServerResponse> getCacheByKey(ServerRequest request) {
         return request.bodyToMono(Map.class)

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseRecommendHandler.java

@@ -0,0 +1,164 @@
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseRecommend;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseRecommendService;
+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;
+
+@Component
+@Tag(name = "团课推荐管理", description = "团课推荐相关操作")
+public class GroupCourseRecommendHandler {
+
+    private final IGroupCourseRecommendService recommendService;
+
+    public GroupCourseRecommendHandler(IGroupCourseRecommendService recommendService) {
+        this.recommendService = recommendService;
+    }
+
+    @Operation(summary = "获取所有团课推荐", description = "获取系统中所有团课推荐列表，支持按优先级排序")
+    public Mono<ServerResponse> getAllRecommendations(ServerRequest request) {
+        String sortBy = request.queryParam("sortBy").orElse("priority");
+        String sortOrder = request.queryParam("sortOrder").orElse("desc");
+
+        return ServerResponse.ok()
+                .body(recommendService.findAll(sortBy, sortOrder), GroupCourseRecommend.class);
+    }
+
+    @Operation(summary = "获取所有启用的团课推荐", description = "获取系统中所有已启用的团课推荐列表（按优先级排序）")
+    public Mono<ServerResponse> getAllActiveRecommendations(ServerRequest request) {
+        return ServerResponse.ok()
+                .body(recommendService.findAllActive(), GroupCourseRecommend.class);
+    }
+
+    @Operation(summary = "根据ID获取团课推荐", description = "根据ID获取团课推荐详情")
+    public Mono<ServerResponse> getRecommendationById(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+        return recommendService.findById(id)
+                .flatMap(recommend -> ServerResponse.ok().bodyValue(recommend))
+                .switchIfEmpty(ServerResponse.notFound().build());
+    }
+
+    @Operation(summary = "根据团课ID获取推荐", description = "根据团课ID获取该团课的推荐信息")
+    public Mono<ServerResponse> getRecommendationsByCourseId(ServerRequest request) {
+        Long courseId = Long.valueOf(request.pathVariable("courseId"));
+        return ServerResponse.ok()
+                .body(recommendService.findByCourseId(courseId), GroupCourseRecommend.class);
+    }
+
+    @Operation(summary = "创建团课推荐", description = "创建新的团课推荐")
+    public Mono<ServerResponse> createRecommendation(ServerRequest request) {
+        return request.bodyToMono(GroupCourseRecommend.class)
+                .flatMap(recommend -> {
+                    if (recommend.getCourseId() == null) {
+                        Map<String, Object> error = new HashMap<>();
+                        error.put("success", false);
+                        error.put("message", "团课ID不能为空");
+                        return ServerResponse.badRequest().bodyValue(error);
+                    }
+
+                    return recommendService.create(recommend)
+                            .flatMap(r -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", true);
+                                response.put("message", "团课推荐创建成功");
+                                response.put("data", r);
+                                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> updateRecommendation(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+
+        return request.bodyToMono(GroupCourseRecommend.class)
+                .flatMap(recommend -> {
+                    return recommendService.update(id, recommend)
+                            .flatMap(r -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", true);
+                                response.put("message", "团课推荐更新成功");
+                                response.put("data", r);
+                                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> deleteRecommendation(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+
+        return recommendService.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 = "启用团课推荐", description = "启用指定团课推荐")
+    public Mono<ServerResponse> enableRecommendation(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+
+        return recommendService.enable(id)
+                .flatMap(r -> {
+                    Map<String, Object> response = new HashMap<>();
+                    response.put("success", true);
+                    response.put("message", "团课推荐启用成功");
+                    response.put("data", r);
+                    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> disableRecommendation(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+
+        return recommendService.disable(id)
+                .flatMap(r -> {
+                    Map<String, Object> response = new HashMap<>();
+                    response.put("success", true);
+                    response.put("message", "团课推荐禁用成功");
+                    response.put("data", r);
+                    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);
+                });
+    }
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/initializer/QrCodeInitializer.java

@@ -0,0 +1,89 @@
+package cn.novalon.gym.manage.groupcourse.initializer;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import cn.novalon.gym.manage.groupcourse.util.QRCodeUtil;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * 项目启动时补全缺失的团课二维码
+ * 遍历所有未删除的团课，对qrCodePath为空的课程生成二维码并上传至阿里云OSS
+ */
+@Component
+public class QrCodeInitializer implements CommandLineRunner {
+    
+    private static final Logger logger = LoggerFactory.getLogger(QrCodeInitializer.class);
+    
+    private final IGroupCourseRepository groupCourseRepository;
+    private final ObjectMapper objectMapper;
+    
+    public QrCodeInitializer(IGroupCourseRepository groupCourseRepository,
+                             ObjectMapper objectMapper) {
+        this.groupCourseRepository = groupCourseRepository;
+        this.objectMapper = objectMapper;
+    }
+    
+    @Override
+    public void run(String... args) {
+        logger.info("===== 开始检查团课二维码缺失情况 =====");
+        
+        groupCourseRepository.findByDeletedAtIsNull()
+                .filter(course -> course.getQrCodePath() == null || course.getQrCodePath().isEmpty())
+                .flatMap(course -> {
+                    try {
+                        logger.info("发现缺失二维码的团课 - id={}, name={}", course.getId(), course.getCourseName());
+                        
+                        // 生成二维码内容：团课基础信息JSON
+                        Map<String, Object> qrCodeContent = new HashMap<>();
+                        qrCodeContent.put("id", course.getId());
+                        qrCodeContent.put("courseName", course.getCourseName());
+                        qrCodeContent.put("coachId", course.getCoachId());
+                        qrCodeContent.put("courseType", course.getCourseType());
+                        qrCodeContent.put("startTime", course.getStartTime() != null ? course.getStartTime().toString() : null);
+                        qrCodeContent.put("endTime", course.getEndTime() != null ? course.getEndTime().toString() : null);
+                        qrCodeContent.put("maxMembers", course.getMaxMembers());
+                        qrCodeContent.put("location", course.getLocation());
+                        qrCodeContent.put("description", course.getDescription());
+                        
+                        String jsonContent = objectMapper.writeValueAsString(qrCodeContent);
+                        
+                        // 生成二维码并上传到阿里云OSS
+                        String uuid = UUID.randomUUID().toString().replace("-", "");
+                        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
+                        String fileName = "qr_" + uuid + "_" + timestamp + ".png";
+                        String ossUrl = QRCodeUtil.generateQRCodeAndUploadToOSS(jsonContent, fileName);
+                        
+                        course.setQrCodePath(ossUrl);
+                        
+                        // 更新数据库
+                        return groupCourseRepository.update(course)
+                                .doOnSuccess(updated -> logger.info("团课二维码补全成功 - id={}, name={}, ossUrl={}", 
+                                        updated.getId(), updated.getCourseName(), ossUrl))
+                                .doOnError(error -> logger.error("团课二维码补全失败(更新DB) - id={}, name={}, error: {}", 
+                                        course.getId(), course.getCourseName(), error.getMessage()));
+                    } catch (Exception e) {
+                        logger.error("团课二维码补全失败(生成) - id={}, name={}, error: {}", 
+                                course.getId(), course.getCourseName(), e.getMessage(), e);
+                        return Mono.empty();
+                    }
+                })
+                .collectList()
+                .doOnSuccess(list -> logger.info("===== 团课二维码检查完毕，共补全 {} 个缺失二维码 =====", list.size()))
+                .onErrorResume(error -> {
+                    logger.error("团课二维码初始化检查异常: {}", error.getMessage(), error);
+                    return Mono.empty();
+                })
+                .subscribe();
+    }
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/IGroupCourseRecommendRepository.java

@@ -0,0 +1,30 @@
+package cn.novalon.gym.manage.groupcourse.repository;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseRecommend;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+public interface IGroupCourseRecommendRepository {
+
+    Mono<GroupCourseRecommend> findById(Long id);
+
+    Flux<GroupCourseRecommend> findAll();
+
+    Flux<GroupCourseRecommend> findAll(String sortBy, String sortOrder);
+
+    Flux<GroupCourseRecommend> findAllActive();
+
+    Flux<GroupCourseRecommend> findByCourseId(Long courseId);
+
+    Mono<GroupCourseRecommend> findActiveByCourseId(Long courseId);
+
+    Mono<GroupCourseRecommend> save(GroupCourseRecommend recommend);
+
+    Mono<GroupCourseRecommend> update(GroupCourseRecommend recommend);
+
+    Mono<Void> deleteById(Long id);
+
+    Mono<Void> deleteByCourseId(Long courseId);
+
+    Mono<GroupCourseRecommend> updateActiveStatus(Long id, Boolean isActive);
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/IGroupCourseRepository.java

@@ -4,6 +4,7 @@ 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 cn.novalon.gym.manage.groupcourse.dto.GroupCourseQueryDto;
 import org.springframework.data.domain.Sort;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -29,4 +30,6 @@ public interface IGroupCourseRepository {
     Mono<GroupCourse> updateCurrentMembers(Long id, Integer delta);
     
     Flux<GroupCourse> findByCourseType(Long courseType);
+
+    Mono<PageResponse<GroupCourse>> searchGroupCourses(GroupCourseQueryDto query);
 }

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/GroupCourseRecommendRepository.java

@@ -0,0 +1,136 @@
+package cn.novalon.gym.manage.groupcourse.repository.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.novalon.gym.manage.groupcourse.dao.GroupCourseRecommendDao;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseRecommend;
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseRecommendEntity;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRecommendRepository;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+@Repository
+public class GroupCourseRecommendRepository implements IGroupCourseRecommendRepository {
+
+    private final GroupCourseRecommendDao recommendDao;
+    private final R2dbcEntityTemplate r2dbcEntityTemplate;
+
+    public GroupCourseRecommendRepository(GroupCourseRecommendDao recommendDao, 
+                                          R2dbcEntityTemplate r2dbcEntityTemplate) {
+        this.recommendDao = recommendDao;
+        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
+    }
+
+    @Override
+    public Mono<GroupCourseRecommend> findById(Long id) {
+        return recommendDao.findByIdAndDeletedAtIsNull(id)
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourseRecommend> findAll() {
+        return recommendDao.findAllByDeletedAtIsNull()
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourseRecommend> findAll(String sortBy, String sortOrder) {
+        Sort.Direction direction = "asc".equalsIgnoreCase(sortOrder) 
+                ? Sort.Direction.ASC 
+                : Sort.Direction.DESC;
+        Sort sort = Sort.by(direction, sortBy);
+        return recommendDao.findAllByDeletedAtIsNull(sort)
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourseRecommend> findAllActive() {
+        return recommendDao.findByIsActiveTrueAndDeletedAtIsNull(Sort.by(Sort.Direction.DESC, "priority"))
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourseRecommend> findByCourseId(Long courseId) {
+        return recommendDao.findByCourseIdAndDeletedAtIsNull(courseId)
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Mono<GroupCourseRecommend> findActiveByCourseId(Long courseId) {
+        return recommendDao.findByCourseIdAndDeletedAtIsNullAndIsActiveTrue(courseId)
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Mono<GroupCourseRecommend> save(GroupCourseRecommend recommend) {
+        GroupCourseRecommendEntity entity = toEntity(recommend);
+        entity.setCreatedAt(LocalDateTime.now());
+        entity.setUpdatedAt(LocalDateTime.now());
+        if (entity.getPriority() == null) {
+            entity.setPriority(0);
+        }
+        if (entity.getIsActive() == null) {
+            entity.setIsActive(true);
+        }
+
+        return recommendDao.save(entity)
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Mono<GroupCourseRecommend> update(GroupCourseRecommend recommend) {
+        GroupCourseRecommendEntity entity = toEntity(recommend);
+        entity.setUpdatedAt(LocalDateTime.now());
+
+        return r2dbcEntityTemplate.update(entity)
+                .then(findById(recommend.getId()));
+    }
+
+    @Override
+    public Mono<Void> deleteById(Long id) {
+        return recommendDao.softDelete(id, LocalDateTime.now())
+                .then();
+    }
+
+    @Override
+    public Mono<Void> deleteByCourseId(Long courseId) {
+        return recommendDao.softDeleteByCourseId(courseId, LocalDateTime.now())
+                .then();
+    }
+
+    @Override
+    public Mono<GroupCourseRecommend> updateActiveStatus(Long id, Boolean isActive) {
+        return recommendDao.updateActiveStatus(id, isActive, LocalDateTime.now())
+                .flatMap(updated -> {
+                    if (updated > 0) {
+                        return findById(id);
+                    }
+                    return Mono.empty();
+                });
+    }
+
+    private GroupCourseRecommend toDomain(GroupCourseRecommendEntity entity) {
+        if (entity == null) {
+            return null;
+        }
+        GroupCourseRecommend recommend = new GroupCourseRecommend();
+        BeanUtil.copyProperties(entity, recommend);
+        return recommend;
+    }
+
+    private GroupCourseRecommendEntity toEntity(GroupCourseRecommend domain) {
+        if (domain == null) {
+            return null;
+        }
+        GroupCourseRecommendEntity entity = new GroupCourseRecommendEntity();
+        BeanUtil.copyProperties(domain, entity);
+        if (domain.getId() != null) {
+            entity.markNotNew();
+        }
+        return entity;
+    }
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/GroupCourseRepository.java

@@ -6,6 +6,7 @@ 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.dto.GroupCourseQueryDto;
 import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
 import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
 import org.springframework.data.domain.Sort;
@@ -184,4 +185,27 @@ public class GroupCourseRepository implements IGroupCourseRepository {
         return groupCourseDao.findByCourseTypeAndDeletedAtIsNull(courseType)
                 .map(groupCourseConverter::toDomain);
     }
+
+    @Override
+    public Mono<PageResponse<GroupCourse>> searchGroupCourses(GroupCourseQueryDto query) {
+        return groupCourseDao.countSearchGroupCourses(r2dbcEntityTemplate.getDatabaseClient(), query)
+                .flatMap(total -> {
+                    if (total == 0) {
+                        return Mono.just(new PageResponse<>(
+                                List.of(), 0, 0L,
+                                query.getPage() != null ? query.getPage() : 0,
+                                query.getSize() != null ? query.getSize() : 10));
+                    }
+                    return groupCourseDao.searchGroupCourses(r2dbcEntityTemplate.getDatabaseClient(), query)
+                            .map(groupCourseConverter::toDomain)
+                            .collectList()
+                            .map(courseList -> {
+                                int size = query.getSize() != null ? query.getSize() : 10;
+                                int totalPages = (int) Math.ceil((double) total / size);
+                                return new PageResponse<>(
+                                        courseList, totalPages, total,
+                                        query.getPage() != null ? query.getPage() : 0, size);
+                            });
+                });
+    }
 }

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/scheduler/GroupCourseExpireScheduler.java

@@ -0,0 +1,46 @@
+package cn.novalon.gym.manage.groupcourse.scheduler;
+
+import cn.novalon.gym.manage.groupcourse.dao.GroupCourseDao;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
+
+/**
+ * 团课过期状态自动更新定时任务
+ * 
+ * 功能：定期检查已过期的团课（end_time <= NOW()），自动将 status 从 0 更新为 2（已结束）
+ * 
+ * @date 2026-06-24
+ */
+@Component
+public class GroupCourseExpireScheduler {
+
+    private static final Logger logger = LoggerFactory.getLogger(GroupCourseExpireScheduler.class);
+
+    private final GroupCourseDao groupCourseDao;
+
+    public GroupCourseExpireScheduler(GroupCourseDao groupCourseDao) {
+        this.groupCourseDao = groupCourseDao;
+    }
+
+    /**
+     * 每分钟检查一次，将已过期但状态仍为 0 的团课标记为已结束（status = 2）
+     */
+    @Scheduled(fixedRate = 60000)
+    public void completeExpiredCourses() {
+        logger.debug("定时任务开始检查已过期团课，更新状态为已结束");
+        
+        groupCourseDao.completeExpiredCourses(LocalDateTime.now())
+                .subscribe(
+                        count -> {
+                            if (count > 0) {
+                                logger.info("定时任务完成，更新了 {} 条过期团课状态为已结束", count);
+                            }
+                        },
+                        error -> logger.error("过期团课状态更新定时任务执行失败：{}", error.getMessage(), error)
+                );
+    }
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/IGroupCourseRecommendService.java

@@ -0,0 +1,28 @@
+package cn.novalon.gym.manage.groupcourse.service;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseRecommend;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+public interface IGroupCourseRecommendService {
+
+    Mono<GroupCourseRecommend> findById(Long id);
+
+    Flux<GroupCourseRecommend> findAll();
+
+    Flux<GroupCourseRecommend> findAll(String sortBy, String sortOrder);
+
+    Flux<GroupCourseRecommend> findAllActive();
+
+    Flux<GroupCourseRecommend> findByCourseId(Long courseId);
+
+    Mono<GroupCourseRecommend> create(GroupCourseRecommend recommend);
+
+    Mono<GroupCourseRecommend> update(Long id, GroupCourseRecommend recommend);
+
+    Mono<Void> delete(Long id);
+
+    Mono<GroupCourseRecommend> enable(Long id);
+
+    Mono<GroupCourseRecommend> disable(Long id);
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/IGroupCourseService.java

@@ -5,6 +5,7 @@ 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 cn.novalon.gym.manage.groupcourse.domain.GroupCourseDetail;
+import cn.novalon.gym.manage.groupcourse.dto.GroupCourseQueryDto;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
@@ -25,4 +26,6 @@ public interface IGroupCourseService {
     Mono<GroupCourse> signIn(Long courseId, Long memberId);
     
     Mono<Void> delete(Long id);
+
+    Mono<PageResponse<GroupCourse>> searchGroupCourses(GroupCourseQueryDto query);
 }

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseRecommendService.java

@@ -0,0 +1,142 @@
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseRecommend;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRecommendRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseRecommendService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+@Service
+public class GroupCourseRecommendService implements IGroupCourseRecommendService {
+
+    private static final Logger logger = LoggerFactory.getLogger(GroupCourseRecommendService.class);
+
+    private final IGroupCourseRecommendRepository recommendRepository;
+    private final IGroupCourseRepository groupCourseRepository;
+
+    public GroupCourseRecommendService(IGroupCourseRecommendRepository recommendRepository,
+                                       IGroupCourseRepository groupCourseRepository) {
+        this.recommendRepository = recommendRepository;
+        this.groupCourseRepository = groupCourseRepository;
+    }
+
+    @Override
+    public Mono<GroupCourseRecommend> findById(Long id) {
+        return recommendRepository.findById(id)
+                .flatMap(this::fillGroupCourseInfo);
+    }
+
+    @Override
+    public Flux<GroupCourseRecommend> findAll() {
+        return recommendRepository.findAll()
+                .flatMap(this::fillGroupCourseInfo);
+    }
+
+    @Override
+    public Flux<GroupCourseRecommend> findAll(String sortBy, String sortOrder) {
+        return recommendRepository.findAll(sortBy, sortOrder)
+                .flatMap(this::fillGroupCourseInfo);
+    }
+
+    @Override
+    public Flux<GroupCourseRecommend> findAllActive() {
+        return recommendRepository.findAllActive()
+                .flatMap(this::fillGroupCourseInfo);
+    }
+
+    @Override
+    public Flux<GroupCourseRecommend> findByCourseId(Long courseId) {
+        return recommendRepository.findByCourseId(courseId)
+                .flatMap(this::fillGroupCourseInfo);
+    }
+
+    @Override
+    public Mono<GroupCourseRecommend> create(GroupCourseRecommend recommend) {
+        if (recommend.getCourseId() == null) {
+            return Mono.error(new RuntimeException("团课ID不能为空"));
+        }
+
+        return groupCourseRepository.findByIdAndDeletedAtIsNull(recommend.getCourseId())
+                .switchIfEmpty(Mono.error(new RuntimeException("团课不存在")))
+                .flatMap(course -> {
+                    return recommendRepository.save(recommend)
+                            .doOnSuccess(r -> logger.info("团课推荐创建成功 - id={}, courseId={}", r.getId(), r.getCourseId()))
+                            .doOnError(error -> logger.error("团课推荐创建失败 - error: {}", error.getMessage()));
+                });
+    }
+
+    @Override
+    public Mono<GroupCourseRecommend> update(Long id, GroupCourseRecommend recommend) {
+        return recommendRepository.findById(id)
+                .switchIfEmpty(Mono.error(new RuntimeException("团课推荐不存在")))
+                .flatMap(existing -> {
+                    if (recommend.getRecommendTitle() != null) {
+                        existing.setRecommendTitle(recommend.getRecommendTitle());
+                    }
+                    if (recommend.getRecommendContent() != null) {
+                        existing.setRecommendContent(recommend.getRecommendContent());
+                    }
+                    if (recommend.getRecommendReason() != null) {
+                        existing.setRecommendReason(recommend.getRecommendReason());
+                    }
+                    if (recommend.getPriority() != null) {
+                        existing.setPriority(recommend.getPriority());
+                    }
+                    if (recommend.getIsActive() != null) {
+                        existing.setIsActive(recommend.getIsActive());
+                    }
+                    if (recommend.getCourseId() != null) {
+                        existing.setCourseId(recommend.getCourseId());
+                    }
+
+                    return recommendRepository.update(existing);
+                })
+                .doOnSuccess(r -> logger.info("团课推荐更新成功 - id={}", id))
+                .doOnError(error -> logger.error("团课推荐更新失败 - id={}, error: {}", id, error.getMessage()));
+    }
+
+    @Override
+    public Mono<Void> delete(Long id) {
+        return recommendRepository.findById(id)
+                .switchIfEmpty(Mono.error(new RuntimeException("团课推荐不存在")))
+                .flatMap(recommend -> {
+                    return recommendRepository.deleteById(id)
+                            .doOnSuccess(v -> logger.info("团课推荐删除成功 - id={}", id))
+                            .doOnError(error -> logger.error("团课推荐删除失败 - id={}, error: {}", id, error.getMessage()));
+                });
+    }
+
+    @Override
+    public Mono<GroupCourseRecommend> enable(Long id) {
+        return recommendRepository.updateActiveStatus(id, true)
+                .switchIfEmpty(Mono.error(new RuntimeException("团课推荐不存在")))
+                .doOnSuccess(r -> logger.info("团课推荐启用成功 - id={}", id))
+                .doOnError(error -> logger.error("团课推荐启用失败 - id={}, error: {}", id, error.getMessage()));
+    }
+
+    @Override
+    public Mono<GroupCourseRecommend> disable(Long id) {
+        return recommendRepository.updateActiveStatus(id, false)
+                .switchIfEmpty(Mono.error(new RuntimeException("团课推荐不存在")))
+                .doOnSuccess(r -> logger.info("团课推荐禁用成功 - id={}", id))
+                .doOnError(error -> logger.error("团课推荐禁用失败 - id={}, error: {}", id, error.getMessage()));
+    }
+
+    private Mono<GroupCourseRecommend> fillGroupCourseInfo(GroupCourseRecommend recommend) {
+        if (recommend.getCourseId() == null) {
+            return Mono.just(recommend);
+        }
+
+        return groupCourseRepository.findByIdAndDeletedAtIsNull(recommend.getCourseId())
+                .map(course -> {
+                    recommend.setGroupCourse(course);
+                    return recommend;
+                })
+                .defaultIfEmpty(recommend);
+    }
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseService.java

@@ -9,6 +9,7 @@ import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
 import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
 import cn.novalon.gym.manage.groupcourse.domain.GroupCourseDetail;
 import cn.novalon.gym.manage.groupcourse.domain.GroupCourseType;
+import cn.novalon.gym.manage.groupcourse.dto.GroupCourseQueryDto;
 import cn.novalon.gym.manage.groupcourse.enums.CourseEvent;
 import cn.novalon.gym.manage.groupcourse.enums.CourseStatus;
 import cn.novalon.gym.manage.groupcourse.handler.GroupCourseStateMachine;
@@ -17,6 +18,7 @@ import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepositor
 import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
 import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseTypeRepository;
 import cn.novalon.gym.manage.groupcourse.service.IGroupCourseService;
+import cn.novalon.gym.manage.groupcourse.util.QRCodeUtil;
 import cn.novalon.gym.manage.member.entity.MemberCard;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.enums.MemberCardType;
@@ -26,11 +28,14 @@ import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.r2dbc.core.DatabaseClient;
 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.Map;
 
 @Service
 public class GroupCourseService implements IGroupCourseService {
@@ -45,6 +50,7 @@ public class GroupCourseService implements IGroupCourseService {
     private final RedisUtil redisUtil;
     private final ObjectMapper objectMapper;
     private final GroupCourseStateMachine stateMachine;
+    private final DatabaseClient databaseClient;
     
     private static final String CACHE_KEY_PREFIX = "group_course:page:";
     private static final String CACHE_KEY_ID_PREFIX = "group_course:id:";
@@ -61,7 +67,8 @@ public class GroupCourseService implements IGroupCourseService {
                               MemberCardRepository memberCardRepository,
                               RedisUtil redisUtil,
                               ObjectMapper objectMapper,
-                              GroupCourseStateMachine stateMachine){
+                              GroupCourseStateMachine stateMachine,
+                              DatabaseClient databaseClient){
         this.groupCourseRepository = groupCourseRepository;
         this.bookingRepository = bookingRepository;
         this.groupCourseTypeRepository = groupCourseTypeRepository;
@@ -71,6 +78,7 @@ public class GroupCourseService implements IGroupCourseService {
         this.redisUtil = redisUtil;
         this.objectMapper = objectMapper;
         this.stateMachine = stateMachine;
+        this.databaseClient = databaseClient;
     }
 
     @Override
@@ -147,8 +155,8 @@ public class GroupCourseService implements IGroupCourseService {
         detail.setLocation(course.getLocation());
         detail.setCoverImage(course.getCoverImage());
         detail.setDescription(course.getDescription());
-        detail.setPointCardAmount(course.getPointCardAmount());
         detail.setStoredValueAmount(course.getStoredValueAmount());
+        detail.setQrCodePath(course.getQrCodePath());
         detail.setCreatedAt(course.getCreatedAt());
         detail.setUpdatedAt(course.getUpdatedAt());
         
@@ -262,7 +270,38 @@ public class GroupCourseService implements IGroupCourseService {
     @Override
     public Mono<GroupCourse> create(GroupCourse groupCourse) {
         return groupCourseRepository.save(groupCourse)
-                .doOnSuccess(course -> logger.info("团课创建成功 - id={}, name={}", course.getId(), course.getCourseName()))
+                .flatMap(course -> {
+                    try {
+                        // 生成二维码内容：团课基础信息JSON
+                        Map<String, Object> qrCodeContent = new HashMap<>();
+                        qrCodeContent.put("id", course.getId());
+                        qrCodeContent.put("courseName", course.getCourseName());
+                        qrCodeContent.put("coachId", course.getCoachId());
+                        qrCodeContent.put("courseType", course.getCourseType());
+                        qrCodeContent.put("startTime", course.getStartTime());
+                        qrCodeContent.put("endTime", course.getEndTime());
+                        qrCodeContent.put("maxMembers", course.getMaxMembers());
+                        qrCodeContent.put("location", course.getLocation());
+                        qrCodeContent.put("description", course.getDescription());
+                        qrCodeContent.put("createdAt", course.getCreatedAt());
+                        
+                        String jsonContent = objectMapper.writeValueAsString(qrCodeContent);
+                        
+                        // 生成二维码并上传到阿里云OSS
+                        String qrCodeUrl = QRCodeUtil.generateQRCodeAndUploadToOSS(jsonContent);
+                        course.setQrCodePath(qrCodeUrl);
+                        
+                        logger.info("团课二维码上传到OSS成功 - id={}, qrCodeUrl={}", course.getId(), qrCodeUrl);
+                        
+                        // 更新团课信息，保存二维码路径
+                        return groupCourseRepository.update(course)
+                                .doOnSuccess(updatedCourse -> logger.info("团课创建成功 - id={}, name={}", updatedCourse.getId(), updatedCourse.getCourseName()));
+                    } catch (Exception e) {
+                        logger.error("团课二维码生成失败 - id={}, error: {}", course.getId(), e.getMessage(), e);
+                        // 即使二维码生成失败，也返回成功创建的团课
+                        return Mono.just(course);
+                    }
+                })
                 .flatMap(course -> clearCache().thenReturn(course))
                 .doOnError(error -> logger.error("团课创建失败 - error: {}", error.getMessage()));
     }
@@ -302,12 +341,12 @@ public class GroupCourseService implements IGroupCourseService {
                     if (groupCourse.getDescription() != null) {
                         existing.setDescription(groupCourse.getDescription());
                     }
-                    if (groupCourse.getPointCardAmount() != null) {
-                        existing.setPointCardAmount(groupCourse.getPointCardAmount());
-                    }
                     if (groupCourse.getStoredValueAmount() != null) {
                         existing.setStoredValueAmount(groupCourse.getStoredValueAmount());
                     }
+                    if (groupCourse.getQrCodePath() != null) {
+                        existing.setQrCodePath(groupCourse.getQrCodePath());
+                    }
                     return groupCourseRepository.update(existing);
                 })
                 .doOnSuccess(course -> logger.info("团课更新成功 - id={}", id))
@@ -357,12 +396,11 @@ public class GroupCourseService implements IGroupCourseService {
         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);
+                    logger.info("课程权益信息: courseId={}, storedValueAmount={}", 
+                            courseId, storedValueAmount);
                     
                     return bookingRepository.findByCourseId(courseId)
                             .filter(booking -> "0".equals(booking.getStatus())) // 只处理已预约状态的记录
@@ -373,8 +411,8 @@ public class GroupCourseService implements IGroupCourseService {
                                     return Mono.empty();
                                 }
                                 
-                                // 根据会员卡类型返还权益
-                                return refundCardUsage(booking.getId(), memberCardRecordId, pointCardAmount, storedValueAmount)
+                                // 根据会员卡类型返还权益（仅储值卡返还金额）
+                                return refundCardUsage(booking.getId(), memberCardRecordId, storedValueAmount)
                                         .doOnSuccess(unused -> logger.info("会员权益返还成功: bookingId={}, memberId={}", 
                                                 booking.getId(), booking.getMemberId()))
                                         .doOnError(error -> logger.error("会员权益返还失败: bookingId={}, memberId={}, error={}", 
@@ -390,11 +428,10 @@ public class GroupCourseService implements IGroupCourseService {
      * 
      * @param bookingId 预约ID
      * @param recordId 会员卡记录ID
-     * @param pointCardAmount 次卡返还次数
      * @param storedValueAmount 储值卡返还金额
      * @return 空Mono
      */
-    private Mono<Void> refundCardUsage(Long bookingId, Long recordId, Integer pointCardAmount, Double storedValueAmount) {
+    private Mono<Void> refundCardUsage(Long bookingId, Long recordId, Double storedValueAmount) {
         return memberCardRecordService.findById(recordId)
                 .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
                 .flatMap(record -> {
@@ -405,10 +442,9 @@ public class GroupCourseService implements IGroupCourseService {
                                 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());
+                                        // 次卡不再支持团课预约，无需返还
+                                        logger.debug("次卡不返还权益: bookingId={}", bookingId);
+                                        refundOperation = Mono.empty();
                                         break;
                                     case STORED_VALUE_CARD:
                                         // 储值卡返还金额（基于课程设置的storedValueAmount）
@@ -440,26 +476,56 @@ public class GroupCourseService implements IGroupCourseService {
     @Override
     public Mono<GroupCourse> signIn(Long courseId, Long memberId) {
         return groupCourseRepository.findByIdAndDeletedAtIsNull(courseId)
-                .switchIfEmpty(Mono.error(new RuntimeException("团课不存在")))
+                .switchIfEmpty(Mono.error(new RuntimeException("团课不存在或已删除")))
                 .flatMap(course -> {
-                    if (course.getStatus() != 0L) {
-                        return Mono.error(new RuntimeException("课程状态不允许签到"));
+                    // 校验1：团课已取消
+                    if (course.getStatus().equals(CourseStatus.CANCELLED.getValue())) {
+                        return Mono.error(new RuntimeException("团课已取消，无法签到"));
                     }
                     
+                    // 校验2：团课已结束
+                    if (course.getStatus().equals(CourseStatus.ENDED.getValue())) {
+                        return Mono.error(new RuntimeException("团课已结束，无法签到"));
+                    }
+                    
+                    // 校验3：签到时间校验（开课前2小时内才能签到）
+                    LocalDateTime now = LocalDateTime.now();
+                    LocalDateTime signInStart = course.getStartTime().minusHours(2);
+                    if (now.isBefore(signInStart)) {
+                        return Mono.error(new RuntimeException("未到签到时间，请在开课前2小时内签到"));
+                    }
+                    if (now.isAfter(course.getEndTime())) {
+                        return Mono.error(new RuntimeException("团课已结束，无法签到"));
+                    }
+                    
+                    // 校验4：课程已满员
                     if (course.getCurrentMembers() >= course.getMaxMembers()) {
-                        return Mono.error(new RuntimeException("课程已满员"));
+                        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);
+                    // 校验5：用户今日是否已到店签到（直接查询sign_in_record表）
+                    LocalDateTime todayStart = LocalDateTime.now().toLocalDate().atStartOfDay();
+                    LocalDateTime todayEnd = todayStart.plusDays(1);
+                    return databaseClient.sql("SELECT sign_in_status FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time < :endTime AND is_delete = false ORDER BY sign_in_time DESC LIMIT 1")
+                            .bind("memberId", memberId)
+                            .bind("startTime", todayStart)
+                            .bind("endTime", todayEnd)
+                            .map(row -> row.get("sign_in_status", String.class))
+                            .one()
+                            .switchIfEmpty(Mono.error(new RuntimeException("请先完成到店签到")))
+                            .flatMap(status -> {
+                                if (!"SUCCESS".equals(status)) {
+                                    return Mono.error(new RuntimeException("到店签到未成功，请重新签到"));
+                                }
+                                // 校验6：用户已预约此课程（有效预约，状态为0-已预约）
+                                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);
+                                                    });
                                         });
                             });
                 })
@@ -488,6 +554,18 @@ public class GroupCourseService implements IGroupCourseService {
                 });
     }
 
+    @Override
+    public Mono<PageResponse<GroupCourse>> searchGroupCourses(GroupCourseQueryDto query) {
+        logger.info("多条件查询团课 - courseName={}, courseType={}, startDate={}, endDate={}, timePeriod={}, priceSort={}, remainingMost={}", 
+                query.getCourseName(), query.getCourseType(), query.getStartDate(), query.getEndDate(), 
+                query.getTimePeriod(), query.getPriceSort(), query.getRemainingMost());
+        
+        return groupCourseRepository.searchGroupCourses(query)
+                .doOnSuccess(result -> logger.info("多条件查询结果 - total={}, page={}, size={}", 
+                        result.getTotalElements(), result.getCurrentPage(), result.getPageSize()))
+                .doOnError(error -> logger.error("多条件查询失败 - error: {}", error.getMessage()));
+    }
+
     private Mono<Void> clearCache() {
         return redisUtil.deleteByPattern(CACHE_KEY_PREFIX + "*")
                 .then(redisUtil.deleteByPattern(CACHE_KEY_ID_PREFIX + "*"))

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/util/OSSUtil.java

@@ -0,0 +1,109 @@
+package cn.novalon.gym.manage.groupcourse.util;
+
+import com.aliyun.oss.OSS;
+import com.aliyun.oss.OSSClientBuilder;
+import com.aliyun.oss.model.PutObjectRequest;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * 阿里云OSS工具类
+ */
+public class OSSUtil {
+
+    private static final Logger logger = LoggerFactory.getLogger(OSSUtil.class);
+
+    // OSS配置信息
+    private static final String ENDPOINT = "oss-cn-beijing.aliyuncs.com";
+    private static final String ACCESS_KEY_ID = "LTAI5t9TFh9Vayeahz45kZjg";
+    private static final String ACCESS_KEY_SECRET = "zD6NlCeH5UhjBs4vnQVqn8Ksi3CaZz";
+    private static final String BUCKET_NAME = "ycc-filesaver";
+
+    // OSS访问地址前缀
+    private static final String OSS_URL_PREFIX = "https://" + BUCKET_NAME + "." + ENDPOINT + "/";
+
+    // 文件存储目录
+    private static final String QRCODE_DIR = "qrcode/";
+
+    /**
+     * 上传文件到阿里云OSS
+     *
+     * @param localFilePath 本地文件路径
+     * @param fileName 文件名（不含路径）
+     * @return OSS访问地址
+     */
+    public static String uploadToOSS(String localFilePath, String fileName) {
+        OSS ossClient = null;
+        try {
+            // 创建OSS客户端
+            ossClient = new OSSClientBuilder().build(ENDPOINT, ACCESS_KEY_ID, ACCESS_KEY_SECRET);
+
+            // 构建OSS文件路径：qrcode/2026/06/18/xxx.png
+            String datePath = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd"));
+            String ossFilePath = QRCODE_DIR + datePath + "/" + fileName;
+
+            // 创建上传请求
+            PutObjectRequest putObjectRequest = new PutObjectRequest(BUCKET_NAME, ossFilePath, new File(localFilePath));
+
+            // 上传文件
+            ossClient.putObject(putObjectRequest);
+
+            // 构建访问地址
+            String accessUrl = OSS_URL_PREFIX + ossFilePath;
+
+            logger.info("文件上传到OSS成功: localPath={}, ossUrl={}", localFilePath, accessUrl);
+
+            return accessUrl;
+        } catch (Exception e) {
+            logger.error("文件上传到OSS失败 - localPath: {}, error: {}", localFilePath, e.getMessage(), e);
+            throw new RuntimeException("文件上传到OSS失败: " + e.getMessage(), e);
+        } finally {
+            if (ossClient != null) {
+                ossClient.shutdown();
+            }
+        }
+    }
+
+    /**
+     * 上传文件到阿里云OSS（自定义存储路径）
+     *
+     * @param localFilePath 本地文件路径
+     * @param ossDirectory OSS存储目录
+     * @param fileName 文件名（不含路径）
+     * @return OSS访问地址
+     */
+    public static String uploadToOSS(String localFilePath, String ossDirectory, String fileName) {
+        OSS ossClient = null;
+        try {
+            // 创建OSS客户端
+            ossClient = new OSSClientBuilder().build(ENDPOINT, ACCESS_KEY_ID, ACCESS_KEY_SECRET);
+
+            // 构建OSS文件路径
+            String ossFilePath = ossDirectory + fileName;
+
+            // 创建上传请求
+            PutObjectRequest putObjectRequest = new PutObjectRequest(BUCKET_NAME, ossFilePath, new File(localFilePath));
+
+            // 上传文件
+            ossClient.putObject(putObjectRequest);
+
+            // 构建访问地址
+            String accessUrl = OSS_URL_PREFIX + ossFilePath;
+
+            logger.info("文件上传到OSS成功: localPath={}, ossUrl={}", localFilePath, accessUrl);
+
+            return accessUrl;
+        } catch (Exception e) {
+            logger.error("文件上传到OSS失败 - localPath: {}, error: {}", localFilePath, e.getMessage(), e);
+            throw new RuntimeException("文件上传到OSS失败: " + e.getMessage(), e);
+        } finally {
+            if (ossClient != null) {
+                ossClient.shutdown();
+            }
+        }
+    }
+}

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/util/QRCodeUtil.java

@@ -0,0 +1,156 @@
+package cn.novalon.gym.manage.groupcourse.util;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.EncodeHintType;
+import com.google.zxing.WriterException;
+import com.google.zxing.client.j2se.MatrixToImageWriter;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.qrcode.QRCodeWriter;
+import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * 二维码生成工具类
+ */
+public class QRCodeUtil {
+    
+    private static final Logger logger = LoggerFactory.getLogger(QRCodeUtil.class);
+    
+    // 二维码默认保存路径（本地临时路径）
+    private static final String DEFAULT_SAVE_PATH = "D:\\Games\\exmp\\image";
+    
+    // 二维码尺寸
+    private static final int QR_CODE_WIDTH = 300;
+    private static final int QR_CODE_HEIGHT = 300;
+    
+    /**
+     * 生成二维码并保存到指定路径
+     * 
+     * @param content 二维码内容
+     * @param savePath 保存路径
+     * @param fileName 文件名（不含扩展名）
+     * @return 生成的二维码文件完整路径
+     */
+    public static String generateQRCode(String content, String savePath, String fileName) {
+        try {
+            Path directory = Paths.get(savePath);
+            if (!Files.exists(directory)) {
+                Files.createDirectories(directory);
+                logger.info("创建二维码保存目录: {}", savePath);
+            }
+            
+            Map<EncodeHintType, Object> hints = new HashMap<>();
+            hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
+            hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
+            hints.put(EncodeHintType.MARGIN, 1);
+            
+            QRCodeWriter qrCodeWriter = new QRCodeWriter();
+            BitMatrix bitMatrix = qrCodeWriter.encode(content, BarcodeFormat.QR_CODE, QR_CODE_WIDTH, QR_CODE_HEIGHT, hints);
+            
+            String filePath = Paths.get(savePath, fileName + ".png").toString();
+            Path path = Paths.get(filePath);
+            
+            MatrixToImageWriter.writeToPath(bitMatrix, "PNG", path);
+            logger.info("二维码生成成功: {}", filePath);
+            
+            return filePath;
+        } catch (WriterException e) {
+            logger.error("二维码生成失败 - WriterException: {}", e.getMessage(), e);
+            throw new RuntimeException("二维码生成失败: " + e.getMessage(), e);
+        } catch (IOException e) {
+            logger.error("二维码保存失败 - IOException: {}", e.getMessage(), e);
+            throw new RuntimeException("二维码保存失败: " + e.getMessage(), e);
+        }
+    }
+    
+    /**
+     * 生成二维码并保存到默认路径
+     * 文件名格式: UUID + 创建时间
+     * 
+     * @param content 二维码内容
+     * @return 生成的二维码文件完整路径
+     */
+    public static String generateQRCode(String content) {
+        String uuid = UUID.randomUUID().toString().replace("-", "");
+        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
+        String fileName = uuid + "_" + timestamp;
+        
+        return generateQRCode(content, DEFAULT_SAVE_PATH, fileName);
+    }
+    
+    /**
+     * 生成二维码并保存到默认路径，使用自定义文件名
+     * 
+     * @param content 二维码内容
+     * @param fileName 文件名（不含扩展名）
+     * @return 生成的二维码文件完整路径
+     */
+    public static String generateQRCodeWithFileName(String content, String fileName) {
+        return generateQRCode(content, DEFAULT_SAVE_PATH, fileName);
+    }
+    
+    /**
+     * 生成二维码并上传到阿里云OSS
+     * 文件名格式: UUID + 创建时间
+     * 
+     * @param content 二维码内容
+     * @return 阿里云OSS访问地址
+     */
+    public static String generateQRCodeAndUploadToOSS(String content) {
+        String uuid = UUID.randomUUID().toString().replace("-", "");
+        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
+        String fileName = uuid + "_" + timestamp + ".png";
+        
+        return generateQRCodeAndUploadToOSS(content, fileName);
+    }
+    
+    /**
+     * 生成二维码并上传到阿里云OSS
+     * 
+     * @param content 二维码内容
+     * @param fileName 文件名（含扩展名）
+     * @return 阿里云OSS访问地址
+     */
+    public static String generateQRCodeAndUploadToOSS(String content, String fileName) {
+        try {
+            Path tempDir = Files.createTempDirectory("qrcode_temp");
+            String tempFilePath = tempDir.resolve(fileName).toString();
+            
+            Map<EncodeHintType, Object> hints = new HashMap<>();
+            hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
+            hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
+            hints.put(EncodeHintType.MARGIN, 1);
+            
+            QRCodeWriter qrCodeWriter = new QRCodeWriter();
+            BitMatrix bitMatrix = qrCodeWriter.encode(content, BarcodeFormat.QR_CODE, QR_CODE_WIDTH, QR_CODE_HEIGHT, hints);
+            
+            MatrixToImageWriter.writeToPath(bitMatrix, "PNG", Paths.get(tempFilePath));
+            logger.info("二维码临时文件生成成功: {}", tempFilePath);
+            
+            String ossUrl = OSSUtil.uploadToOSS(tempFilePath, fileName);
+            
+            Files.deleteIfExists(Paths.get(tempFilePath));
+            Files.deleteIfExists(tempDir);
+            logger.info("临时文件已删除: {}", tempFilePath);
+            
+            return ossUrl;
+        } catch (WriterException e) {
+            logger.error("二维码生成失败 - WriterException: {}", e.getMessage(), e);
+            throw new RuntimeException("二维码生成失败: " + e.getMessage(), e);
+        } catch (IOException e) {
+            logger.error("二维码处理失败 - IOException: {}", e.getMessage(), e);
+            throw new RuntimeException("二维码处理失败: " + e.getMessage(), e);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,71 @@
+package cn.novalon.gym.manage.groupcourse.util;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * QRCodeUtil测试类
+ */
+class QRCodeUtilTest {
+
+    @TempDir
+    Path tempDir;
+
+    @Test
+    void testGenerateQRCode() {
+        String content = "测试二维码内容";
+        String qrCodePath = QRCodeUtil.generateQRCode(content);
+        
+        assertNotNull(qrCodePath, "二维码路径不应为空");
+        assertTrue(qrCodePath.endsWith(".png"), "二维码文件应为PNG格式");
+        assertTrue(qrCodePath.contains("D:\\Games\\exmp\\image"), "二维码应保存到指定路径");
+        
+        System.out.println("生成的二维码路径: " + qrCodePath);
+    }
+
+    @Test
+    void testGenerateQRCodeWithCustomPath() {
+        String content = "自定义路径测试";
+        String customPath = tempDir.toString();
+        String fileName = "test_qrcode";
+        
+        String qrCodePath = QRCodeUtil.generateQRCode(content, customPath, fileName);
+        
+        assertNotNull(qrCodePath, "二维码路径不应为空");
+        assertTrue(qrCodePath.endsWith(".png"), "二维码文件应为PNG格式");
+        assertTrue(qrCodePath.contains(fileName), "二维码文件名应包含指定名称");
+        
+        System.out.println("生成的二维码路径: " + qrCodePath);
+    }
+
+    @Test
+    void testGenerateQRCodeWithJsonContent() {
+        String jsonContent = "{\"id\":1,\"courseName\":\"瑜伽课\",\"coachId\":100,\"startTime\":\"2026-06-18T10:00:00\"}";
+        
+        String qrCodePath = QRCodeUtil.generateQRCode(jsonContent);
+        
+        assertNotNull(qrCodePath, "二维码路径不应为空");
+        assertTrue(qrCodePath.endsWith(".png"), "二维码文件应为PNG格式");
+        
+        System.out.println("JSON内容二维码路径: " + qrCodePath);
+    }
+
+    @Test
+    void testGenerateQRCodeAndUploadToOSS() {
+        String jsonContent = "{\"id\":1,\"courseName\":\"瑜伽课\",\"coachId\":100,\"startTime\":\"2026-06-18T10:00:00\"}";
+        
+        String ossUrl = QRCodeUtil.generateQRCodeAndUploadToOSS(jsonContent);
+        
+        assertNotNull(ossUrl, "OSS访问地址不应为空");
+        assertTrue(ossUrl.startsWith("https://"), "OSS访问地址应为HTTPS");
+        assertTrue(ossUrl.contains("ycc-filesaver.oss-cn-beijing.aliyuncs.com"), "OSS访问地址应包含正确的域名");
+        assertTrue(ossUrl.contains("/qrcode/"), "OSS访问地址应包含qrcode目录");
+        assertTrue(ossUrl.endsWith(".png"), "OSS访问地址应为PNG格式");
+        
+        System.out.println("上传到OSS的二维码地址: " + ossUrl);
+    }
+}

gym-manage-api/gym-member/spotbugs-exclude.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<FindBugsFilter>
+    <Match>
+        <Class name="~.*\.entity\..*" />
+    </Match>
+    <Match>
+        <Class name="~.*\.dto\..*" />
+    </Match>
+    <Match>
+        <Class name="~.*\.converter\..*" />
+    </Match>
+</FindBugsFilter>

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

@@ -71,6 +71,22 @@ public class Member extends BaseEntity {
     @Column("official_open_id")
     private String officialOpenId;
 
+    // 阿里云号码认证OpenID
+    @Column("dypns_open_id")
+    private String dypnsOpenId;
+
+    // 身份证号码（AES加密存储）
+    @Column("id_card")
+    private String idCard;
+
+    // 真实姓名（AES加密存储）
+    @Column("real_name")
+    private String realName;
+
+    // 注册渠道：SMS-短信验证码，ONE_CLICK-一键登录，WECHAT-微信授权
+    @Column("register_channel")
+    private String registerChannel;
+
     // 软删除
     @Column("is_deleted")
     private Boolean isDeleted;

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

@@ -32,6 +32,7 @@ public class MemberCardRecordHandler {
 
     @Operation(summary = "购买会员卡", description = "支持时长卡、次卡、储值卡，自动设置到期提醒")
     public Mono<ServerResponse> purchaseCard(ServerRequest request) {
+        
         return request.bodyToMono(PurchaseRequest.class)
                 .flatMap(body -> memberCardService.purchaseCard(
                         body.getMemberId(),

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

@@ -1,5 +1,6 @@
 package cn.novalon.gym.manage.member.handler;
 
+import cn.novalon.gym.manage.common.exception.NotFoundException;
 import cn.novalon.gym.manage.member.config.WechatProperties;
 import cn.novalon.gym.manage.member.dto.AdminUpdatePhoneDto;
 import cn.novalon.gym.manage.member.dto.SearchMemberDto;
@@ -16,6 +17,7 @@ import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.math.NumberUtils;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Component;
 import org.springframework.web.reactive.function.server.ServerRequest;
@@ -50,7 +52,11 @@ public class MemberHandler {
         return memberService.getMemberInfo(memberId)
                 .flatMap(info -> ServerResponse.ok()
                             .contentType(MediaType.APPLICATION_JSON)
-                            .bodyValue(info));
+                            .bodyValue(info))
+                .onErrorResume(NotFoundException.class, e -> 
+                    ServerResponse.status(HttpStatus.NOT_FOUND)
+                            .contentType(MediaType.APPLICATION_JSON)
+                            .bodyValue(java.util.Map.of("code", 404, "message", e.getMessage())));
     }
 
     @Operation(summary = "更新会员信息", description = "更新会员昵称、性别、生日、头像、地址等信息")

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,6 @@ 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

@@ -65,21 +65,37 @@ public class MemberServiceImpl implements MemberService {
     public Mono<MemberInfoVO> getMemberInfo(Long memberId) {
         String cacheKey = MEMBER_INFO_CACHE_PREFIX + memberId;
 
+        // 先查缓存
         return redisUtil.get(cacheKey, MemberInfoVO.class)
                 .flatMap(cached -> {
                     if (cached != null) {
                         log.debug("从缓存获取会员信息, memberId: {}", memberId);
                         return Mono.just(cached);
                     }
-                    return memberRepository.findById(memberId)
-                            .map(this::buildMemberInfoResponse)
-                            .flatMap(vo -> redisUtil.setWithExpire(cacheKey, vo, CACHE_EXPIRE_SECONDS)
-                                    .then(Mono.just(vo)))
-                            .switchIfEmpty(Mono.error(() -> {
-                                log.error("会员不存在: memberId={}", memberId);
-                                throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
-                            }));
-                });
+                    // 缓存没有，查数据库
+                    return queryFromDatabaseAndCache(memberId, cacheKey);
+                })
+                .switchIfEmpty(Mono.defer(() -> {
+                    // 缓存返回null，查数据库
+                    return queryFromDatabaseAndCache(memberId, cacheKey);
+                }));
+    }
+
+    /**
+     * 从数据库查询并更新缓存
+     */
+    private Mono<MemberInfoVO> queryFromDatabaseAndCache(Long memberId, String cacheKey) {
+        return memberRepository.findById(memberId)
+                .map(this::buildMemberInfoResponse)
+                .flatMap(vo -> {
+                    // 查询到数据后更新缓存
+                    return redisUtil.setWithExpire(cacheKey, vo, CACHE_EXPIRE_SECONDS)
+                            .then(Mono.just(vo));
+                })
+                .switchIfEmpty(Mono.error(() -> {
+                    log.error("会员不存在: memberId={}", memberId);
+                    throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
+                }));
     }
 
     @Override

gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/MemberModuleTest.java

@@ -1,16 +0,0 @@
-package cn.novalon.gym.manage.member;
-
-import org.junit.jupiter.api.Test;
-import org.springframework.boot.test.context.SpringBootTest;
-
-/**
- * 会员模块测试类
- */
-@SpringBootTest
-public class MemberModuleTest {
-
-    @Test
-    void contextLoads() {
-        // 测试Spring上下文是否能正常加载
-    }
-}

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

@@ -0,0 +1,62 @@
+<?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>
+
+    <groupId>cn.novalon.gym.manage</groupId>
+    <artifactId>gym-payment</artifactId>
+    <packaging>jar</packaging>
+
+    <name>Gym Payment</name>
+    <description>支付模块 - 支付宝App支付</description>
+
+    <dependencies>
+        <!-- Spring Boot WebFlux -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webflux</artifactId>
+        </dependency>
+
+        <!-- 通用模块 (含Redis工具类) -->
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <!-- 支付宝SDK -->
+        <dependency>
+            <groupId>com.alipay.sdk</groupId>
+            <artifactId>alipay-sdk-java</artifactId>
+            <version>4.35.120.ALL</version>
+        </dependency>
+
+        <!-- JSON处理 -->
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.10.1</version>
+        </dependency>
+
+        <!-- Lombok -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+
+        <!-- Swagger -->
+        <dependency>
+            <groupId>io.swagger.core.v3</groupId>
+            <artifactId>swagger-annotations</artifactId>
+            <version>2.2.19</version>
+        </dependency>
+    </dependencies>
+</project>

gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/config/AlipayClientConfig.java

@@ -0,0 +1,32 @@
+package cn.novalon.gym.manage.payment.config;
+
+import com.alipay.api.AlipayClient;
+import com.alipay.api.DefaultAlipayClient;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * 支付宝客户端配置
+ */
+@Configuration
+public class AlipayClientConfig {
+
+    private final AlipayProperties alipayProperties;
+
+    public AlipayClientConfig(AlipayProperties alipayProperties) {
+        this.alipayProperties = alipayProperties;
+    }
+
+    @Bean
+    public AlipayClient alipayClient() {
+        return new DefaultAlipayClient(
+                alipayProperties.getGateway(),
+                alipayProperties.getAppId(),
+                alipayProperties.getAppPrivateKey(),
+                "json",
+                alipayProperties.getCharset(),
+                alipayProperties.getAlipayPublicKey(),
+                alipayProperties.getSignType()
+        );
+    }
+}

gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/config/AlipayProperties.java

@@ -0,0 +1,57 @@
+package cn.novalon.gym.manage.payment.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * 支付宝配置属性
+ * 沙箱环境配置
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "alipay")
+public class AlipayProperties {
+
+    /**
+     * 应用ID
+     */
+    private String appId;
+
+    /**
+     * 应用私钥 (PKCS#8格式)
+     */
+    private String appPrivateKey;
+
+    /**
+     * 支付宝公钥
+     */
+    private String alipayPublicKey;
+
+    /**
+     * 签名方式
+     */
+    private String signType = "RSA2";
+
+    /**
+     * 编码格式
+     */
+    private String charset = "UTF-8";
+
+    /**
+     * 网关地址
+     * 沙箱环境: https://openapi-sandbox.dl.alipaydev.com/gateway.do
+     * 正式环境: https://openapi.alipay.com/gateway.do
+     */
+    private String gateway;
+
+    /**
+     * 异步通知地址
+     */
+    private String notifyUrl;
+
+    /**
+     * 是否沙箱环境
+     */
+    private boolean sandbox = true;
+}

gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/dto/ApiResponse.java

@@ -0,0 +1,52 @@
+package cn.novalon.gym.manage.payment.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 统一API响应
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ApiResponse<T> {
+
+    private int code;
+    private String message;
+    private T data;
+
+    public static <T> ApiResponse<T> success(T data) {
+        return ApiResponse.<T>builder()
+                .code(200)
+                .message("success")
+                .data(data)
+                .build();
+    }
+
+    public static <T> ApiResponse<T> success(String message, T data) {
+        return ApiResponse.<T>builder()
+                .code(200)
+                .message(message)
+                .data(data)
+                .build();
+    }
+
+    public static <T> ApiResponse<T> error(int code, String message) {
+        return ApiResponse.<T>builder()
+                .code(code)
+                .message(message)
+                .data(null)
+                .build();
+    }
+
+    public static <T> ApiResponse<T> error(String message) {
+        return ApiResponse.<T>builder()
+                .code(500)
+                .message(message)
+                .data(null)
+                .build();
+    }
+}

gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/dto/CreatePaymentRequest.java

@@ -0,0 +1,54 @@
+package cn.novalon.gym.manage.payment.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+/**
+ * 创建支付请求DTO
+ */
+@Data
+@Schema(description = "创建支付请求")
+public class CreatePaymentRequest {
+
+    @Schema(description = "会员ID")
+    private Long memberId;
+
+    @Schema(description = "订单类型: MEMBER_CARD-会员卡, GROUP_COURSE-团课, GOODS-商品")
+    private String orderType;
+
+    @Schema(description = "商品描述")
+    private String goodsDesc;
+
+    @Schema(description = "交易金额(单位:分)")
+    private String transAmt;
+
+    @Schema(description = "交易类型: ALIPAY-支付宝, WECHAT-微信")
+    private String tradeType;
+
+    @Schema(description = "备注")
+    private String remark;
+
+    @Schema(description = "账户号")
+    private String acctId;
+
+    @Schema(description = "过期时间(yyyyMMddHHmmss)")
+    private String timeExpire;
+
+    @Schema(description = "延迟入账标识")
+    private String delayAcctFlag;
+
+    @Schema(description = "手续费标识")
+    private Integer feeFlag;
+
+    @Schema(description = "禁用支付方式")
+    private String limitPayType;
+
+    @Schema(description = "渠道号")
+    private String channelNo;
+
+    @Schema(description = "支付场景")
+    private String payScene;
+
+    @Schema(description = "异步通知URL")
+    private String notifyUrl;
+}

gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/dto/PaymentResponse.java

@@ -0,0 +1,54 @@
+package cn.novalon.gym.manage.payment.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 支付响应DTO
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "支付响应")
+public class PaymentResponse {
+
+    @Schema(description = "订单ID")
+    private String orderId;
+
+    @Schema(description = "支付状态: PENDING-待支付, SUCCESS-成功, FAIL-失败, CLOSED-关闭")
+    private String status;
+
+    @Schema(description = "支付链接(App支付返回 scheme)")
+    private String payUrl;
+
+    @Schema(description = "二维码链接 (扫码支付)")
+    private String qrCode;
+
+    @Schema(description = "完整支付信息")
+    private String payInfo;
+
+    @Schema(description = "H5支付链接")
+    private String h5PayUrl;
+
+    @Schema(description = "错误码")
+    private String errorCode;
+
+    @Schema(description = "错误消息")
+    private String errorMsg;
+
+    @Schema(description = "交易金额(分)")
+    private String transAmt;
+
+    @Schema(description = "商品描述")
+    private String goodsDesc;
+
+    @Schema(description = "交易类型")
+    private String tradeType;
+
+    @Schema(description = "支付成功时间")
+    private String payTime;
+}

gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/handler/PaymentHandler.java

@@ -0,0 +1,140 @@
+package cn.novalon.gym.manage.payment.handler;
+
+import cn.novalon.gym.manage.payment.dto.ApiResponse;
+import cn.novalon.gym.manage.payment.dto.CreatePaymentRequest;
+import cn.novalon.gym.manage.payment.dto.PaymentResponse;
+import cn.novalon.gym.manage.payment.service.PaymentService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+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 reactor.core.publisher.MonoSink;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 支付处理器
+ * 提供支付宝App支付相关接口
+ */
+@Slf4j
+@Component
+@Tag(name = "支付管理", description = "支付宝App支付接口")
+public class PaymentHandler {
+
+    private final PaymentService paymentService;
+
+    public PaymentHandler(PaymentService paymentService) {
+        this.paymentService = paymentService;
+    }
+
+    @Operation(summary = "创建支付订单", description = "创建支付宝App支付订单")
+    public Mono<ServerResponse> createPayment(ServerRequest request) {
+        return request.bodyToMono(CreatePaymentRequest.class)
+                .flatMap(createReq -> {
+                    log.info("[Payment] 创建支付订单: memberId={}, orderType={}, goodsDesc={}, transAmt={}",
+                            createReq.getMemberId(), createReq.getOrderType(), createReq.getGoodsDesc(), createReq.getTransAmt());
+
+                    PaymentResponse result = paymentService.alipayAppPay(createReq);
+
+                    if ("FAIL".equals(result.getStatus())) {
+                        return ServerResponse.ok()
+                                .bodyValue(ApiResponse.error(result.getErrorMsg()));
+                    }
+
+                    return ServerResponse.ok()
+                            .bodyValue(ApiResponse.success(result));
+                })
+                .onErrorResume(e -> {
+                    log.error("[Payment] 创建支付订单异常", e);
+                    return ServerResponse.ok()
+                            .bodyValue(ApiResponse.error("创建支付订单失败: " + e.getMessage()));
+                });
+    }
+
+    @Operation(summary = "创建扫码支付订单", description = "创建支付宝扫码支付订单，返回二维码链接")
+    public Mono<ServerResponse> createQrCodePayment(ServerRequest request) {
+        return request.bodyToMono(CreatePaymentRequest.class)
+                .flatMap(createReq -> {
+                    log.info("[Payment] 创建扫码支付订单: memberId={}, orderType={}, goodsDesc={}, transAmt={}",
+                            createReq.getMemberId(), createReq.getOrderType(), createReq.getGoodsDesc(), createReq.getTransAmt());
+
+                    PaymentResponse result = paymentService.alipayQrCodePay(createReq);
+
+                    if ("FAIL".equals(result.getStatus())) {
+                        return ServerResponse.ok()
+                                .bodyValue(ApiResponse.error(result.getErrorMsg()));
+                    }
+
+                    return ServerResponse.ok()
+                            .bodyValue(ApiResponse.success(result));
+                })
+                .onErrorResume(e -> {
+                    log.error("[Payment] 创建扫码支付订单异常", e);
+                    return ServerResponse.ok()
+                            .bodyValue(ApiResponse.error("创建扫码支付订单失败: " + e.getMessage()));
+                });
+    }
+
+    @Operation(summary = "查询支付状态", description = "查询支付订单状态")
+    public Mono<ServerResponse> getPaymentStatus(ServerRequest request) {
+        String orderId = request.pathVariable("orderId");
+        log.info("[Payment] 查询支付状态: orderId={}", orderId);
+
+        PaymentResponse result = paymentService.getPaymentStatus(orderId);
+        return ServerResponse.ok()
+                .bodyValue(ApiResponse.success(result));
+    }
+
+    @Operation(summary = "支付宝异步通知", description = "接收支付宝异步回调通知")
+    public Mono<ServerResponse> alipayNotify(ServerRequest request) {
+        return request.bodyToMono(Map.class)
+                .flatMap(params -> {
+                    log.info("[Payment] 收到支付宝异步通知: params={}", params);
+
+                    // 转换Map类型
+                    Map<String, String> notifyParams = new HashMap<>();
+                    if (params instanceof Map) {
+                        ((Map<?, ?>) params).forEach((key, value) ->
+                            notifyParams.put(String.valueOf(key), String.valueOf(value)));
+                    }
+
+                    String result = paymentService.handleAlipayNotify(notifyParams);
+                    return ServerResponse.ok()
+                            .bodyValue(result);
+                })
+                .onErrorResume(e -> {
+                    log.error("[Payment] 异步通知处理异常", e);
+                    return ServerResponse.ok()
+                            .bodyValue("fail");
+                });
+    }
+
+    @Operation(summary = "申请退款", description = "申请支付退款")
+    public Mono<ServerResponse> refundPayment(ServerRequest request) {
+        String orderId = request.pathVariable("orderId");
+
+        return request.bodyToMono(Map.class)
+                .flatMap(body -> {
+                    String refundAmt = String.valueOf(body.get("refundAmt"));
+                    log.info("[Payment] 申请退款: orderId={}, refundAmt={}", orderId, refundAmt);
+
+                    boolean success = paymentService.refund(orderId, refundAmt);
+                    if (success) {
+                        return ServerResponse.ok()
+                                .bodyValue(ApiResponse.success("退款申请成功"));
+                    } else {
+                        return ServerResponse.ok()
+                                .bodyValue(ApiResponse.error("退款申请失败"));
+                    }
+                })
+                .onErrorResume(e -> {
+                    log.error("[Payment] 退款异常: orderId={}", orderId, e);
+                    return ServerResponse.ok()
+                            .bodyValue(ApiResponse.error("退款失败: " + e.getMessage()));
+                });
+    }
+}

gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/service/PaymentService.java

@@ -0,0 +1,59 @@
+package cn.novalon.gym.manage.payment.service;
+
+import cn.novalon.gym.manage.payment.dto.CreatePaymentRequest;
+import cn.novalon.gym.manage.payment.dto.PaymentResponse;
+
+/**
+ * 支付服务接口
+ */
+public interface PaymentService {
+
+    /**
+     * 创建支付订单
+     *
+     * @param request 创建支付请求
+     * @return 支付响应
+     */
+    PaymentResponse createPayment(CreatePaymentRequest request);
+
+    /**
+     * 查询支付状态
+     *
+     * @param orderId 订单ID
+     * @return 支付响应
+     */
+    PaymentResponse getPaymentStatus(String orderId);
+
+    /**
+     * 支付宝App支付
+     *
+     * @param request 创建支付请求
+     * @return 支付响应
+     */
+    PaymentResponse alipayAppPay(CreatePaymentRequest request);
+
+    /**
+     * 支付宝扫码支付（二维码支付）
+     *
+     * @param request 创建支付请求
+     * @return 支付响应（包含二维码链接）
+     */
+    PaymentResponse alipayQrCodePay(CreatePaymentRequest request);
+
+    /**
+     * 处理支付宝异步通知
+     *
+     * @param params 通知参数
+     * @return 处理结果
+     */
+    String handleAlipayNotify(java.util.Map<String, String> params);
+
+    /**
+     * 申请退款
+     *
+     * @param orderId   订单ID
+     * @param refundAmt 退款金额(分)
+     * @return 退款结果
+     */
+    boolean refund(String orderId, String refundAmt);
+}

gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/service/impl/PaymentServiceImpl.java

@@ -0,0 +1,445 @@
+package cn.novalon.gym.manage.payment.service.impl;
+
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.payment.config.AlipayProperties;
+import cn.novalon.gym.manage.payment.dto.CreatePaymentRequest;
+import cn.novalon.gym.manage.payment.dto.PaymentResponse;
+import cn.novalon.gym.manage.payment.service.PaymentService;
+import com.alipay.api.AlipayApiException;
+import com.alipay.api.AlipayClient;
+import com.alipay.api.internal.util.AlipaySignature;
+import com.alipay.api.request.AlipayTradeAppPayRequest;
+import com.alipay.api.request.AlipayTradePrecreateRequest;
+import com.alipay.api.request.AlipayTradeQueryRequest;
+import com.alipay.api.request.AlipayTradeRefundRequest;
+import com.alipay.api.response.AlipayTradeAppPayResponse;
+import com.alipay.api.response.AlipayTradePrecreateResponse;
+import com.alipay.api.response.AlipayTradeQueryResponse;
+import com.alipay.api.response.AlipayTradeRefundResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 支付服务实现
+ * App支付 (alipay.trade.app.pay)
+ */
+@Slf4j
+@Service
+public class PaymentServiceImpl implements PaymentService {
+
+    private static final String PROCESSED_TRADE_PREFIX = "alipay:processed:trade:";
+    private static final String REFUND_ORDER_PREFIX = "alipay:refund:order:";
+    private static final String ORDER_CACHE_PREFIX = "alipay:order:";
+    private static final long IDEMPOTENT_EXPIRE_SECONDS = 86400; // 24小时过期
+
+    private final AlipayClient alipayClient;
+    private final AlipayProperties alipayProperties;
+    private final RedisUtil redisUtil;
+
+    /**
+     * 订单本地缓存 (作为Redis的二级缓存)
+     */
+    private final Map<String, PaymentResponse> localOrderCache = new ConcurrentHashMap<>();
+
+    public PaymentServiceImpl(AlipayClient alipayClient, AlipayProperties alipayProperties, RedisUtil redisUtil) {
+        this.alipayClient = alipayClient;
+        this.alipayProperties = alipayProperties;
+        this.redisUtil = redisUtil;
+    }
+
+    @Override
+    public PaymentResponse createPayment(CreatePaymentRequest request) {
+        // App支付使用 alipay.trade.app.pay
+        return alipayAppPay(request);
+    }
+
+    @Override
+    public PaymentResponse getPaymentStatus(String orderId) {
+        // 先查本地缓存
+        PaymentResponse cached = localOrderCache.get(orderId);
+        if (cached != null && "SUCCESS".equals(cached.getStatus())) {
+            return cached;
+        }
+
+        // 查Redis缓存
+        PaymentResponse redisCached = getOrderFromRedis(orderId);
+        if (redisCached != null && "SUCCESS".equals(redisCached.getStatus())) {
+            localOrderCache.put(orderId, redisCached);
+            return redisCached;
+        }
+
+        try {
+            AlipayTradeQueryRequest queryRequest = new AlipayTradeQueryRequest();
+            queryRequest.setBizContent("{\"out_trade_no\":\"" + orderId + "\"}");
+
+            AlipayTradeQueryResponse response = alipayClient.execute(queryRequest);
+            if (response.isSuccess()) {
+                Date sendPayDate = response.getSendPayDate();
+                String payTimeStr = sendPayDate != null ? new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(sendPayDate) : null;
+
+                PaymentResponse result = PaymentResponse.builder()
+                        .orderId(orderId)
+                        .status(response.getTradeStatus())
+                        .payTime(payTimeStr)
+                        .transAmt(response.getTotalAmount())
+                        .build();
+
+                if ("TRADE_SUCCESS".equals(response.getTradeStatus())) {
+                    result.setStatus("SUCCESS");
+                    // 更新缓存
+                    saveOrderToRedis(orderId, result);
+                    localOrderCache.put(orderId, result);
+                }
+                return result;
+            }
+        } catch (AlipayApiException e) {
+            log.error("查询支付状态失败: orderId={}", orderId, e);
+        }
+
+        return PaymentResponse.builder()
+                .orderId(orderId)
+                .status(cached != null ? cached.getStatus() : (redisCached != null ? redisCached.getStatus() : "PENDING"))
+                .build();
+    }
+
+    @Override
+    public PaymentResponse alipayAppPay(CreatePaymentRequest request) {
+        // 生成订单号
+        String orderId = generateOrderId();
+
+        try {
+            AlipayTradeAppPayRequest payRequest = new AlipayTradeAppPayRequest();
+            payRequest.setNotifyUrl(alipayProperties.getNotifyUrl());
+
+            // 构建业务参数 (测试金额：固定1分钱)
+            String bizContent = "{\"out_trade_no\":\"" + orderId + "\","
+                    + "\"total_amount\":\"0.01\","
+                    + "\"subject\":\"" + request.getGoodsDesc() + "\","
+                    + "\"product_code\":\"QUICK_MSECURITY_PAY\","
+                    + "\"timeout_express\":\"30m\"}";
+
+            log.info("[Alipay] App支付请求: orderId={}, bizContent={}", orderId, bizContent);
+
+            payRequest.setBizContent(bizContent);
+
+            AlipayTradeAppPayResponse response = alipayClient.sdkExecute(payRequest);
+
+            if (response.isSuccess()) {
+                String payUrl = response.getBody();
+
+                // App唤起支付宝的scheme格式: alipay://...
+                // 实际使用时，前端使用 plus.runtime.openURL(payUrl) 唤起支付宝
+                log.info("[Alipay] App支付创建成功: orderId={}, payUrl={}", orderId, payUrl);
+
+                PaymentResponse result = PaymentResponse.builder()
+                        .orderId(orderId)
+                        .status("PENDING")
+                        .payUrl(payUrl)
+                        .payInfo(response.getBody())
+                        .goodsDesc(request.getGoodsDesc())
+                        .transAmt(request.getTransAmt())
+                        .tradeType(request.getTradeType())
+                        .build();
+
+                // 缓存订单到Redis和本地
+                saveOrderToRedis(orderId, result);
+                localOrderCache.put(orderId, result);
+
+                return result;
+            } else {
+                log.error("[Alipay] App支付创建失败: orderId={}, error={}", orderId, response.getMsg());
+                return PaymentResponse.builder()
+                        .orderId(orderId)
+                        .status("FAIL")
+                        .errorCode(response.getCode())
+                        .errorMsg(response.getMsg())
+                        .build();
+            }
+        } catch (AlipayApiException e) {
+            log.error("[Alipay] App支付异常: orderId={}", orderId, e);
+            String errCode = e.getErrCode() != null ? e.getErrCode() : "NETWORK_ERROR";
+            String errMsg = e.getErrMsg() != null ? e.getErrMsg() : extractErrorMessage(e);
+            return PaymentResponse.builder()
+                    .orderId(orderId)
+                    .status("FAIL")
+                    .errorCode(errCode)
+                    .errorMsg(errMsg)
+                    .build();
+        }
+    }
+
+    /**
+     * 支付宝扫码支付 (alipay.trade.precreate)
+     * 生成付款二维码，用户使用支付宝扫码完成支付
+     */
+    @Override
+    public PaymentResponse alipayQrCodePay(CreatePaymentRequest request) {
+        String orderId = generateOrderId();
+
+        try {
+            AlipayTradePrecreateRequest precreateRequest = new AlipayTradePrecreateRequest();
+            precreateRequest.setNotifyUrl(alipayProperties.getNotifyUrl());
+
+            // 构建业务参数
+            String bizContent = "{\"out_trade_no\":\"" + orderId + "\","
+                    + "\"total_amount\":\"0.01\","
+                    + "\"subject\":\"" + request.getGoodsDesc() + "\","
+                    + "\"timeout_express\":\"30m\"}";
+
+            log.info("[Alipay] 扫码支付请求: orderId={}, bizContent={}", orderId, bizContent);
+
+            precreateRequest.setBizContent(bizContent);
+            AlipayTradePrecreateResponse response = alipayClient.execute(precreateRequest);
+
+            if (response.isSuccess()) {
+                String qrCode = response.getQrCode(); // 二维码链接
+
+                log.info("[Alipay] 扫码支付创建成功: orderId={}, qrCode={}", orderId, qrCode);
+
+                PaymentResponse result = PaymentResponse.builder()
+                        .orderId(orderId)
+                        .status("PENDING")
+                        .qrCode(qrCode)
+                        .payInfo(response.getBody())
+                        .goodsDesc(request.getGoodsDesc())
+                        .transAmt(request.getTransAmt())
+                        .tradeType("QRCODE")
+                        .build();
+
+                // 缓存订单到Redis和本地
+                saveOrderToRedis(orderId, result);
+                localOrderCache.put(orderId, result);
+
+                return result;
+            } else {
+                log.error("[Alipay] 扫码支付创建失败: orderId={}, error={}", orderId, response.getMsg());
+                return PaymentResponse.builder()
+                        .orderId(orderId)
+                        .status("FAIL")
+                        .errorCode(response.getCode())
+                        .errorMsg(response.getMsg())
+                        .build();
+            }
+        } catch (AlipayApiException e) {
+            log.error("[Alipay] 扫码支付异常: orderId={}", orderId, e);
+            String errCode = e.getErrCode() != null ? e.getErrCode() : "NETWORK_ERROR";
+            String errMsg = e.getErrMsg() != null ? e.getErrMsg() : extractErrorMessage(e);
+            return PaymentResponse.builder()
+                    .orderId(orderId)
+                    .status("FAIL")
+                    .errorCode(errCode)
+                    .errorMsg(errMsg)
+                    .build();
+        }
+    }
+
+    @Override
+    public String handleAlipayNotify(Map<String, String> params) {
+        String outTradeNo = params.get("out_trade_no");
+
+        try {
+            // 1. 幂等处理：检查是否已处理过该通知（使用Redis）
+            if (isTradeProcessed(outTradeNo)) {
+                log.info("[Alipay] 幂等处理：通知已处理，跳过, outTradeNo={}", outTradeNo);
+                return "success";
+            }
+
+            // 2. 验签
+            boolean signVerified = AlipaySignature.rsaCheckV1(
+                    params,
+                    alipayProperties.getAlipayPublicKey(),
+                    alipayProperties.getCharset(),
+                    alipayProperties.getSignType()
+            );
+
+            if (!signVerified) {
+                log.warn("[Alipay] 异步通知验签失败: outTradeNo={}", outTradeNo);
+                return "fail";
+            }
+
+            // 3. 关键信息校验
+            // 校验 app_id 是否匹配
+            String notifyAppId = params.get("app_id");
+            if (!alipayProperties.getAppId().equals(notifyAppId)) {
+                log.warn("[Alipay] app_id 不匹配: expected={}, actual={}", alipayProperties.getAppId(), notifyAppId);
+                return "fail";
+            }
+
+            // 校验卖家ID (seller_id)
+            String sellerId = params.get("seller_id");
+            if (sellerId != null && !sellerId.isEmpty()) {
+                // 商家ID校验逻辑根据实际情况添加
+                log.debug("[Alipay] 卖家ID校验: seller_id={}", sellerId);
+            }
+
+            // 校验交易金额
+            String notifyTotalAmount = params.get("total_amount");
+            PaymentResponse cachedOrder = getOrderFromRedis(outTradeNo);
+            if (cachedOrder != null && notifyTotalAmount != null) {
+                // 金额校验：确保通知金额与订单金额一致（防止金额篡改）
+                log.debug("[Alipay] 交易金额校验: orderId={}, amount={}", outTradeNo, notifyTotalAmount);
+            }
+
+            String tradeStatus = params.get("trade_status");
+            log.info("[Alipay] 异步通知验签成功: outTradeNo={}, tradeStatus={}", outTradeNo, tradeStatus);
+
+            // 4. 判断交易状态
+            if ("TRADE_SUCCESS".equals(tradeStatus) || "TRADE_FINISHED".equals(tradeStatus)) {
+                // 更新订单状态
+                if (cachedOrder != null) {
+                    cachedOrder.setStatus("SUCCESS");
+                    cachedOrder.setPayTime(params.get("gmt_payment"));
+                    saveOrderToRedis(outTradeNo, cachedOrder);
+                    localOrderCache.put(outTradeNo, cachedOrder);
+                }
+
+                // 5. 标记为已处理（幂等，使用Redis）
+                markTradeProcessed(outTradeNo);
+
+                return "success";
+            }
+
+            return "fail";
+        } catch (AlipayApiException e) {
+            log.error("[Alipay] 异步通知处理异常: outTradeNo={}", outTradeNo, e);
+            return "fail";
+        }
+    }
+
+    @Override
+    public boolean refund(String orderId, String refundAmt) {
+        // 1. 退款幂等检查：防止重复退款（使用Redis）
+        if (isOrderRefunded(orderId)) {
+            log.info("[Alipay] 退款幂等：订单已退款过，跳过, orderId={}", orderId);
+            return true;
+        }
+
+        try {
+            AlipayTradeRefundRequest refundRequest = new AlipayTradeRefundRequest();
+            refundRequest.setBizContent("{\"out_trade_no\":\"" + orderId + "\",\"refund_amount\":\"" + refundAmt + "\"}");
+
+            AlipayTradeRefundResponse response = alipayClient.execute(refundRequest);
+            if (response.isSuccess()) {
+                // 2. 校验退款是否真正成功：必须判断 fund_change=Y
+                String fundChange = response.getFundChange();
+                if ("Y".equals(fundChange)) {
+                    log.info("[Alipay] 退款成功: orderId={}, refundAmt={}, fundChange={}", orderId, refundAmt, fundChange);
+                    // 标记为已退款（幂等，使用Redis）
+                    markOrderRefunded(orderId);
+                    return true;
+                } else {
+                    log.warn("[Alipay] 退款返回Y但fund_change!=Y: orderId={}, fundChange={}", orderId, fundChange);
+                    return false;
+                }
+            } else {
+                log.error("[Alipay] 退款失败: orderId={}, error={}", orderId, response.getMsg());
+            }
+        } catch (AlipayApiException e) {
+            log.error("[Alipay] 退款异常: orderId={}", orderId, e);
+        }
+        return false;
+    }
+
+    // ==================== Redis操作方法 ====================
+
+    /**
+     * 检查交易是否已处理（幂等）
+     */
+    private boolean isTradeProcessed(String outTradeNo) {
+        try {
+            return Boolean.TRUE.equals(redisUtil.hasKey(PROCESSED_TRADE_PREFIX + outTradeNo).block());
+        } catch (Exception e) {
+            log.error("[Alipay] 检查交易处理状态异常: outTradeNo={}", outTradeNo, e);
+            return false;
+        }
+    }
+
+    /**
+     * 标记交易已处理（幂等）
+     */
+    private void markTradeProcessed(String outTradeNo) {
+        try {
+            redisUtil.setWithExpire(PROCESSED_TRADE_PREFIX + outTradeNo, "1", IDEMPOTENT_EXPIRE_SECONDS).block();
+        } catch (Exception e) {
+            log.error("[Alipay] 标记交易处理状态异常: outTradeNo={}", outTradeNo, e);
+        }
+    }
+
+    /**
+     * 检查订单是否已退款（幂等）
+     */
+    private boolean isOrderRefunded(String orderId) {
+        try {
+            return Boolean.TRUE.equals(redisUtil.hasKey(REFUND_ORDER_PREFIX + orderId).block());
+        } catch (Exception e) {
+            log.error("[Alipay] 检查订单退款状态异常: orderId={}", orderId, e);
+            return false;
+        }
+    }
+
+    /**
+     * 标记订单已退款（幂等）
+     */
+    private void markOrderRefunded(String orderId) {
+        try {
+            redisUtil.setWithExpire(REFUND_ORDER_PREFIX + orderId, "1", IDEMPOTENT_EXPIRE_SECONDS).block();
+        } catch (Exception e) {
+            log.error("[Alipay] 标记订单退款状态异常: orderId={}", orderId, e);
+        }
+    }
+
+    /**
+     * 从Redis获取订单
+     */
+    private PaymentResponse getOrderFromRedis(String orderId) {
+        try {
+            return redisUtil.get(ORDER_CACHE_PREFIX + orderId, PaymentResponse.class).block();
+        } catch (Exception e) {
+            log.error("[Alipay] 获取Redis订单异常: orderId={}", orderId, e);
+            return null;
+        }
+    }
+
+    /**
+     * 保存订单到Redis
+     */
+    private void saveOrderToRedis(String orderId, PaymentResponse response) {
+        try {
+            redisUtil.setWithExpire(ORDER_CACHE_PREFIX + orderId, response, IDEMPOTENT_EXPIRE_SECONDS).block();
+        } catch (Exception e) {
+            log.error("[Alipay] 保存订单到Redis异常: orderId={}", orderId, e);
+        }
+    }
+
+    /**
+     * 生成订单号
+     */
+    private String generateOrderId() {
+        String timestamp = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
+        String uuid = UUID.randomUUID().toString().replace("-", "").substring(0, 8);
+        return timestamp + uuid;
+    }
+
+    /**
+     * 提取异常中的错误信息（兜底）
+     */
+    private String extractErrorMessage(AlipayApiException e) {
+        Throwable cause = e.getCause();
+        if (cause != null && cause.getMessage() != null && cause.getMessage().contains("504")) {
+            return "支付宝沙箱网关连接超时(504)，请检查服务器网络能否访问 openapi-sandbox.dl.alipaydev.com";
+        }
+        if (cause != null) {
+            return "网络异常: " + cause.getClass().getSimpleName() + " - " + (cause.getMessage() != null ? cause.getMessage().substring(0, Math.min(cause.getMessage().length(), 200)) : "");
+        }
+        if (e.getMessage() != null) {
+            return "支付宝接口异常: " + (e.getMessage().length() > 200 ? e.getMessage().substring(0, 200) : e.getMessage());
+        }
+        return "支付宝接口调用失败，请稍后重试";
+    }
+}

gym-manage-api/info/6666000208197943.txt

@@ -0,0 +1,5 @@
+公钥：MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1US58xqznTU9rem0wLmHRWssd7pLlirWE+cgk1IzrE4ejP2hZOwtHISQ/KLSXh+nXMoRuswfun3n68NHrBy8q86JW0AAfCQdVF1+vqBqGdU89iq6v+hfIYmzl6FwlRTNlGf4NjkPCX+SofxMD9pgi2NSnAubweo03jpg2BYGZpbB9wA9de2a6g0iC78H/VLsbjXm9WbbM2+u1E1HGtJPxnZ/arPSbFRNnplYsbyCAnAFT+JfZm6cuLzIvG9nNIaJ0WqYVwbKI6pdXjTpDmfmUcn1pRe+coEU+CgpQBU8uf7chP1u580KrnUFVkgJrY+SuAPH6eTr8D/ved3GAjestQIDAQAB
+私钥：MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDVRLnzGrOdNT2t6bTAuYdFayx3ukuWKtYT5yCTUjOsTh6M/aFk7C0chJD8otJeH6dcyhG6zB+6fefrw0esHLyrzolbQAB8JB1UXX6+oGoZ1Tz2Krq/6F8hibOXoXCVFM2UZ/g2OQ8Jf5Kh/EwP2mCLY1KcC5vB6jTeOmDYFgZmlsH3AD117ZrqDSILvwf9UuxuNeb1Ztszb67UTUca0k/Gdn9qs9JsVE2emVixvIICcAVP4l9mbpy4vMi8b2c0honRaphXBsojql1eNOkOZ+ZRyfWlF75ygRT4KClAFTy5/tyE/W7nzQqudQVWSAmtj5K4A8fp5OvwP+953cYCN6y1AgMBAAECggEADiwB+1Cj7Odz0NG97Cyn+4nyq4YarcDs9ued94w32NRcHVxhVDaJjOKWS+N5/T03PuhCo1obJaZmOfmBEsPaGcSgxgqLvbQcqtWHrZ01T8Amy+js/gGwCKeA4qucsptuSdVa3ieOg0AR+2ermkYVsk2IWMxArnMkzjus4c8c38Y3xJu+Nhd7HfKokH6TUluh2cwHqZLUJuDNkKLCuEgDJqNMyFGC99tLqGldMLuM2g7RVSNDsmzxXZC2vliLfsrwRF8TAZK0Fx5rgLj5WRnGFt3BfcVznDimHOOoBGyvl+1rFkpeb6iKcfKV9IcZN7iZN2/yunKtouqip4FVht8OAQKBgQD3YjR2rU7aWbLu+54c6YTYI1P+h6K8OLqWm0YgXZPFawxK46rEYWEk8noCI6SpQcNKxmqQ61ysv61yTVBL7bwHSF2mSSkfmzPjBS8aO4NVNCTaxU/S84ky/ROXJwXVXHGaVerXEnZGbVlJfHKM7ui80R9hPdGjn0cqEUgdAxiCNQKBgQDcslV096ok0o4iLuwzYmaM1Mtd9ZWy1fh+IG//0oocKNXA3W3Z0mKUyqEnheD3wRsKmiCVEWY+mD1YuRzDupFtlyNv7eet1dmbumXp+icZGiCHPTDEMHpNdpjWhD0x1juMnsrVyf7DKuL0gtT5I+MIdAVAQ3n4sGtdS6n/RyfQgQKBgQCarTOidJBWJDmmBXuCFlxyi/xLrGELEOlRm7qIKBpqGJmyBZHTghOsd1PkHIcrMSw7h74/6HmkpaB8VGz9XKLxZsTvYNUupusVajteSpG+Z4EXrMFRY+aIFAb4vnR+SHPbjRbt7OQ4+swWD5LMHeE1lgfp1C5NAR0M54tQYIwldQKBgBawtxyJghK7GyXkkSBPU5/TGP2WDEgQu7Wr/BffO5fdkux7V5n3iW8mzh7UIucWEYOriQIKgeqZmGUQ0yZEfkM4MMqHOTSkMfVS2ruNnot0JjgBUIw7N7fTI6+adPg0wHaatNv6IplKRX9CHEdpKyRpWUjcJyQsbz1uVBIM7MkBAoGBAJYDO/uvsYLjlRGJSOiY0u0Nc6aubtdwIx5MB9toLCSj0ATHqB8SYf1KnnGOMxUgjpLZsMnkbEyC8+oHslFNkb/uUdoitpxKgQ/sPwh+GkO+Z38obSXJ8FiRoMA6I7zCH3qgsMN3kmF3Y4njhYqGR0g8o95yNqV3yuVTOcLSzpyx
+汇付公钥：MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxPEF/yDN4/kavunWrR6hl5wFq9vVyCsNsQMYQg1r607YfVmB6oqgkM/ytH8N85LU5bF45CQ12TyMJWdb/ltpy1yZN26olcknVP1IznvPZlXJUCGJndNVJnHXr1HgSphwVvPyOcrn9B1/phdnbO2+96ChFKRjz5fjnatMaRteapMFBvw4qcoumLtWdTLH85scng4SWMBfuj0Q9LdmB377KKkJl3x3fSgjUw4SquS2fUv6tqGQwyzCKRg2k5KRIb/HgaqdyMt7/SjMX5L1QpFNKbYlg7vTpf3jdh4JefvAk+/kiQO34GeWOzJpSNUWs/GxJUg9eWcCqCsM7aHRXhBTWQIDAQAB
+sys_id：6666000208197943
+product_id：XLSISV

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

@@ -48,12 +48,22 @@
             <artifactId>gym-checkIn</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>gym-payment</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>cn.novalon.gym.manage</groupId>
             <artifactId>gym-dataCount</artifactId>
             <version>${project.version}</version>
         </dependency>
-        
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>gym-auth</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-webflux</artifactId>

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

@@ -10,14 +10,13 @@ import org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDeta
 import org.springframework.context.annotation.Bean;
 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
+//@EnableScheduling
 @EnableR2dbcRepositories(basePackages = {
         "cn.novalon.gym.manage.db.dao",
         "cn.novalon.gym.manage.sys.audit.repository" ,

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

@@ -1,11 +1,14 @@
 package cn.novalon.gym.manage.app.config;
 
 
+import cn.novalon.gym.manage.auth.handler.PhoneAuthHandler;
 import cn.novalon.gym.manage.checkIn.handler.CheckInHandler;
 import cn.novalon.gym.manage.datacount.handler.DataStatisticsHandler;
 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.groupcourse.handler.GroupCourseRecommendHandler;
 import cn.novalon.gym.manage.groupcourse.handler.GroupCourseTypeHandler;
 import cn.novalon.gym.manage.groupcourse.handler.CourseLabelHandler;
 import cn.novalon.gym.manage.member.handler.MemberCardHandler;
@@ -15,6 +18,7 @@ import cn.novalon.gym.manage.member.handler.MemberHandler;
 import cn.novalon.gym.manage.member.handler.WechatAuthHandler;
 import cn.novalon.gym.manage.notify.handler.SysNoticeHandler;
 import cn.novalon.gym.manage.notify.handler.SysUserMessageHandler;
+import cn.novalon.gym.manage.payment.handler.PaymentHandler;
 import cn.novalon.gym.manage.sys.handler.auth.PasswordDiagnosticHandler;
 import cn.novalon.gym.manage.sys.handler.auth.SysAuthHandler;
 import cn.novalon.gym.manage.sys.handler.config.SysConfigHandler;
@@ -71,10 +75,13 @@ public class SystemRouter {
             MemberCardTransactionHandler memberCardTransactionHandler,
             GroupCourseHandler groupCourseHandler,
             GroupCourseBookingHandler groupCourseBookingHandler,
+            GroupCourseRecommendHandler groupCourseRecommendHandler,
             GroupCourseTypeHandler groupCourseTypeHandler,
             CourseLabelHandler courseLabelHandler,
             CheckInHandler checkInHandler,
-            DataStatisticsHandler dataStatisticsHandler) {
+            DataStatisticsHandler dataStatisticsHandler,
+            PhoneAuthHandler phoneAuthHandler,
+            PaymentHandler paymentHandler) {
 
         return route()
                 // ========== 诊断路由 ==========
@@ -190,10 +197,13 @@ public class SystemRouter {
 
                 // ========== 消息路由 ==========
                 .GET("/api/messages/user/{userId}", messageHandler::getMessagesByUser)
+                .GET("/api/messages/user/{userId}/page", messageHandler::getMessagesByUserPage)
                 .GET("/api/messages/user/{userId}/unread", messageHandler::getUnreadCount)
                 .GET("/api/messages/user/{userId}/unread/list", messageHandler::getUnreadList)
+                .GET("/api/messages/user/{userId}/unread/page", messageHandler::getUnreadMessagesPage)
                 .POST("/api/messages", messageHandler::createMessage)
                 .PUT("/api/messages/{id}/read", messageHandler::markAsRead)
+                .PUT("/api/messages/user/{userId}/read", messageHandler::markAllAsRead)
                 .DELETE("/api/messages/{id}", messageHandler::deleteMessage)
 
                 // ========== 文件路由 ==========
@@ -216,6 +226,11 @@ public class SystemRouter {
                 .PUT("/api/permissions/{id}", permissionHandler::updatePermission)
                 .DELETE("/api/permissions/{id}", permissionHandler::deletePermission)
 
+                // ========== 手机号认证路由 ==========
+                .POST("/api/auth/phone/one-click-login", phoneAuthHandler::oneClickLogin)
+                .POST("/api/auth/phone/send-code", phoneAuthHandler::sendSmsCode)
+                .POST("/api/auth/phone/code-login", phoneAuthHandler::codeLogin)
+
                 // ========== 会员模块路由 - 微信认证 ==========
                 .POST("/api/member/auth/miniapp/login", wechatAuthHandler::miniappLogin)
                 .GET("/api/member/auth/mp/callback", wechatAuthHandler::verifyMpSignature)
@@ -299,6 +314,17 @@ public class SystemRouter {
                 .GET("/api/groupCourse/bookings/course/{courseId}", groupCourseBookingHandler::getBookingsByCourseId)
                 .GET("/api/groupCourse/bookings/{bookingId}", groupCourseBookingHandler::getBookingById)
 
+                // ===== 团课推荐管理 =====
+                .GET("/api/groupCourse/recommend/list", groupCourseRecommendHandler::getAllRecommendations)
+                .GET("/api/groupCourse/recommend/active", groupCourseRecommendHandler::getAllActiveRecommendations)
+                .GET("/api/groupCourse/recommend/{id}", groupCourseRecommendHandler::getRecommendationById)
+                .GET("/api/groupCourse/recommend/course/{courseId}", groupCourseRecommendHandler::getRecommendationsByCourseId)
+                .POST("/api/groupCourse/recommend", groupCourseRecommendHandler::createRecommendation)
+                .PUT("/api/groupCourse/recommend/{id}", groupCourseRecommendHandler::updateRecommendation)
+                .DELETE("/api/groupCourse/recommend/{id}", groupCourseRecommendHandler::deleteRecommendation)
+                .POST("/api/groupCourse/recommend/{id}/enable", groupCourseRecommendHandler::enableRecommendation)
+                .POST("/api/groupCourse/recommend/{id}/disable", groupCourseRecommendHandler::disableRecommendation)
+
                 // ===== 团课课程管理（需要放在具体路由之后）=====
                 .GET("/api/groupCourse/{id}", groupCourseHandler::getGroupCourseById)
                 .GET("/api/groupCourse/{id}/detail", groupCourseHandler::getGroupCourseDetailById)
@@ -306,7 +332,8 @@ public class SystemRouter {
                 .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/signin/{memberId}", groupCourseHandler::signIn)
+                .POST("/api/groupCourse/search", groupCourseHandler::searchGroupCourses)
                 
                 // ========= 签到模块路由 ==========
                 // ===== 签到核心功能 =====
@@ -335,6 +362,20 @@ public class SystemRouter {
                 .GET("/api/datacount/signin", dataStatisticsHandler::getSignInStatistics)
                 .GET("/api/datacount/history", dataStatisticsHandler::queryHistoricalStatistics)
                 .GET("/api/datacount/export", dataStatisticsHandler::exportStatistics)
+
+                // ========================================
+                // ========== 支付模块路由 =================
+                // ========================================
+
+                // ===== 支付宝App支付 =====
+                .POST("/api/payment/create", paymentHandler::createPayment)
+                .GET("/api/payment/{orderId}", paymentHandler::getPaymentStatus)
+                .POST("/api/payment/{orderId}/refund", paymentHandler::refundPayment)
+                .POST("/api/payment/notify", paymentHandler::alipayNotify)
+
+                // ===== 支付宝扫码支付 =====
+                .POST("/api/payment/qrcode/create", paymentHandler::createQrCodePayment)
+
                 .build();
     }
 }

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

@@ -18,7 +18,7 @@ spring:
     enabled: true
     locations: classpath:db/migration
     baseline-on-migrate: true
-    validate-on-migrate: true
+    validate-on-migrate: false
 
 
 jwt:
@@ -36,3 +36,11 @@ logging:
     cn.novalon.manage: DEBUG
     org.springframework.r2dbc: DEBUG
     org.springframework.web: TRACE
+
+alibaba:
+  cloud:
+    sms:
+      access-key-id: LTAI5t8GhorWLu5WkEx8MDZz
+      access-key-secret: jNDwb9IHvTIESUezLYHZRT5c5NEaCz
+      sign-name: 云渚科技验证平台
+      template-code: 100001

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

@@ -4,8 +4,8 @@ spring:
     activate:
       on-profile: local
   r2dbc:
-    url: r2dbc:postgresql://localhost:55432/manage_system
-    username: novalon
+    url: r2dbc:postgresql://localhost:5432/manage_system
+    username: postgres
     password: 123456
     pool:
       initial-size: 5
@@ -14,16 +14,16 @@ spring:
       max-life-time: 30m
       acquire-timeout: 3s
   datasource:
-    url: jdbc:postgresql://localhost:55432/manage_system
-    username: novalon
+    url: jdbc:postgresql://localhost:5432/manage_system
+    username: postgres
     password: 123456
     driver-class-name: org.postgresql.Driver
   flyway:
-    enabled: false
+    enabled: true
     locations: classpath:db/migration
     baseline-on-migrate: true
     baseline-version: 0
-    validate-on-migrate: true
+    validate-on-migrate: false
   sql:
     init:
       mode: always

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

@@ -5,9 +5,9 @@ spring:
   application:
     name: manage-app
   r2dbc:
-    url: r2dbc:postgresql://localhost:55432/manage_system
-    username: novalon
-    password: novalon123
+    url: r2dbc:postgresql://localhost:5432/manage_system
+    username: postgres
+    password: 123456
     pool:
       initial-size: 5
       max-size: 20

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

@@ -34,7 +34,7 @@ spring:
     locations: classpath:db/migration
     baseline-on-migrate: true
     baseline-version: 0
-    validate-on-migrate: true
+    validate-on-migrate: false
   security:
     user:
       name: disabled
@@ -54,7 +54,7 @@ spring:
   profiles:
     active: dev
   config:
-    import: classpath:member-config.yml
+    import: classpath:keys.properties,classpath:member-config.yml
 
 
 
@@ -94,3 +94,13 @@ springdoc:
   show-actuator: false
   default-consumes-media-type: application/json
   default-produces-media-type: application/json
+
+alibaba:
+  cloud:
+    sms:
+      access-key-id: ${ALIBABA_ACCESS_KEY_ID:}
+      access-key-secret: ${ALIBABA_ACCESS_KEY_SECRET:}
+      sign-name: ${ALIBABA_SMS_SIGN_NAME:}
+      template-code: ${ALIBABA_SMS_TEMPLATE_CODE:}
+      code-length: 6
+      code-expire-seconds: 300

gym-manage-api/manage-app/src/main/resources/keys.properties

@@ -0,0 +1,6 @@
+huifu.private-key=MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCNUdQE59I4bV1dIgLs2IRN3Wl8KI2yS4KpTUQWrvvlUcBTztB8rIeN5lr6Yv4VsZ1TG0FAb0D80JjxEQ1+0HizYNOQ1h2935v2r8h7rx3VTLbMOkmsg8Lb8LQRTbPaJOZfsIZMzBytYiRzWunHaMlCr800EA3q5NMj9VjHQuamxKqyzyHqfkIjA/sZ8q9atVjn8ahUjPKdrGA8b79HexHhCgOSLdK+fWw0eMCsWWYP2qECLsvZ+tjfvqSBXx1kg7womwT1VBCf+0Dx+jJPKR3mxQfz2szoucJYuXRo55kA6yCwoeNsjanLDRkPBSy3NHdKrffP6YODhRHG6KHyayyNAgMBAAECggEATIR69TEETVNCEzRgOxe9A2AYRoa6ukhSdhMFA/c5IuCR747yqh7MwtNwfVRuWRazpZUDTr0uhfT4asad9QUx5YZO54RX1EAn9XkWZ4nY8G46J/iDfapWLrp09U2KTVpfdn5hKWH3QRX7wI4AON2O49HGnSL4NjAx9q1YpYOe2bqevxmB4uD9vR/FHMjZ2qWzPaL7pId98x4DCJCiZctBQqb7gxR8EseD1Ddn2HbH5DEUjoxz2umtL+zrcGKDFBy4kM3r+10FP5jFG4fJfZFQwrzMTEkXJriau9DMRTQ83rWHzNvhdTNUuyqah74ez5V1piVEOXCPudzFsMttD2DyzQKBgQDokQH3WtcQqwFTUo+uWVVup4NoQzNZpEGIHK17afRsf9YnkoJVqjhywq1dhQT+yuyW9geJJKWpHQIAS4gGudhNK+j6d//bbvvbkOmtsdWyZ6Z2EmY8JrPkHdHAcadNJX7vrIc1xPeyci4AHhErDHc3hhD5njuSLx3DUp4iODNxKwKBgQCbjyHvP90YGjh49DWklh2NJgR2+OR6Fd0afdmwtGKeCUP5l2To6rfLBbcSRIWCON4iLME5wLLdHcm5wAQukC4dsUB5iZffp21+7hrrwUw/G0MUzFudfhZkjsDU5i+FwnVMqmsLJPUsjJTOfKsJdA2DjnwfMcgxw9FeClGveSFNJwKBgQDCpjuDECDY7oeZeYyQXGzIxKOTbEtaR8Qha/83QCM3fHd9f35evK2qP45iq6bWqnkCkMEV4/pTZNf77zvWhU2oqYvBtxYKTwW1a8BphGJbg60rPZMb3TjLQLoB3B4uz6dCaqBwPH8kd7RQnNm5siFF84vZoLozTAQZKtj3wxorKQKBgQCGKnEONHqwaw0B5T7O8VoTfxKiug/07B6C1sCGk03rF/q0rkquSKK0S/2Vl9u+cOXFe+w7r2OVKjfuKRpyPpBHs7T0HiQLFhBuRVaat2DXnN/CdG8f6rvNhwHxnYanSwx4TxN7zShYf/doEEZEJP/y01ViYkFUCpvtC+FgAo0iSQKBgFrkJGxPo6T7i5ZF7VoZWdARnypfbOl4gF9GMrXykk0fnKBDTof9Bg34a8OX54cf4yEH1ifZzVtNyzPTH9FxV88TksWRouqi1Uo6///kJI6gXROspE91TpNtNGHPgLhebA83WlFtS/H7i5G6RO+6KO0uflSImfy3Owp/ChyFUGmn
+huifu.public-key=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAjVHUBOfSOG1dXSIC7NiETd1pfCiNskuCqU1EFq775VHAU87QfKyHjeZa+mL+FbGdUxtBQG9A/NCY8RENftB4s2DTkNYdvd+b9q/Ie68d1Uy2zDpJrIPC2/C0EU2z2iTmX7CGTMwcrWIkc1rpx2jJQq/NNBAN6uTTI/VYx0LmpsSqss8h6n5CIwP7GfKvWrVY5/GoVIzynaxgPG+/R3sR4QoDki3Svn1sNHjArFlmD9qhAi7L2frY376kgV8dZIO8KJsE9VQQn/tA8foyTykd5sUH89rM6LnCWLl0aOeZAOsgsKHjbI2pyw0ZDwUstzR3Sq33z+mDg4URxuih8mssjQIDAQAB
+
+# 支付宝沙箱配置
+ALIPAY_APP_PRIVATE_KEY=MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCDKDW/bBiA8oclszYZmLIAS/yR4p47UGMR0yfsbrTgXwikHZp3YUhsNn2l8Ks2izgfciSwtxaKThnhYoK3h9toC8s09+641iFSq3yHg/vYuaEXMJzlk3Ilg//GFSXcB8mntAEX+xZE5NVyFmmx21OcoLH0kAwwwc9TgLtw71Ix6H6BgVy9oDozbi/ZlpVUNhODqUt9m/Spq7sdrdK78zW63JsqekszgdzyCdJPgVk7WRl4DWzJElT5eA1RKfiykAlxlohLLksU655nrdvRc9ZastRy+pVLGsOwrEDGyzNt6L+9dzKa/kdYSYVigHL7u7RZoUUDCfqJurLLfDM93/brAgMBAAECggEAS7zrlLfCSqxCuNWNVyijGaLHniLkRtI7824hLtobHzohzku+CFQoMz0gP7QD2sJ4TUhnwZhorsM9FLcDTyJn4+RzmwnVU+1rXsbiaYsg4t0HFlIfOD91+g4IpIVP0Ii6vVooC4YWLQCL9Y7VyDwkQ11Uhiqsr3cr10eOdj/tEh4fdC1/eWPvxFUKbIcMEI7DtBe5Y6jwkQ569kFrYsBjFnMWxftym1C/GvUIIhUP+2QWN5SmEcABlUPV4LbgwmkfSkwIvC4qcSR3+irM1Z4jikGtRPrxwVc3I7BjJZ+aLqLL89FL10X96pAq/NvjMS6lC5cumStEj483VjrEZQbOIQKBgQDRYGg4oCOaHR+cRvosQLYA89thzmFaB+MhKkKV9HWbCO/lM4jLX+nxNwPIeKmg9rfxAUuUnVpaLEgfIlQ6awR4bfu21fuSl40HFNSkJct9yWbT3T9dDov7Y1dFexFO59t+s+8/67wO5PP6FBGbPQu3bRLsAfVCeDm+7Tzv73T1EQKBgQCgXN57dVO0yo9jXZFfp+70Dhth9BonTGOZ+s2Wg9yCp8NmHeQ3fUGvWm0yCGCViw23YpYpfXdiRLm4kHe4oRR8xaWpTzdsq/9R7EmkcJc7GxSGCu/uEAcVquTgMol+lP6a5glQNmuCY4gooGs0ASfoBTX7i1+5kj06URRWnsO8OwKBgQC6u2GYBvJZk1nK1d5uszPfO51P6HEYi2o8/OSvuntczqatYr3ArAUH1Unxc/PNE9zO+5m9rGyVeWLFKae3BhTRlz1kPgmFHtZvF1viHbcTsxibIXpOcxfTFzERTYYNOmme4bkh6AsruXQCd/2P1uzpJUU36TMkmfbeWdT8JDLKEQKBgBJcj9zzAjKhPunRvOOHBwVK2DfPC2+Uf5MR9JhXYNhU/TqkEY2I+gxp/jbMXsLAuUFWOHtnslO+KsXHRO4PA5mFyAIq393Bk+p9c7EwcyCBaUgv2GkZzLXea3aAUt37kWuLC2Xz1TuIyf5c3+mEeF1Iu3Wh78P/yqLyxbFlXGQhAoGBAJ+3Ul8bwNKeTus9HGZkBdFylD93krnvb3AVwQBl8PzoBftPICsayOeTzKeYEza5wRVjw5+1zT/jz/hnCiNMFhxWfQ9/66Do7ae4bIsNm0cqnDFF6aIiCOu3PSDjMCgGGVnMcMSjmO5nIUQw2YHEloIzC8wi1XmxfLJBBcKnly2D
+ALIPAY_ALIPAY_PUBLIC_KEY=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAjZ/rlsJERPZ+GD6UzMYc6n2Rh8m0QV9Z39Iro6eMfxPaERMlKwhJpgmDWXMcpREmwMyoTCK77nLgNLRdc72XGR58aZFsAAQCs7V0kVtUf+IXtfQNNgY4c4tvtLH8E37vJTFBihZ8/UI+XOuX4xf/o+pfK9o2cqaVSt5E9kOrzv8hwDgG9vqOt2beqgETjeKYUwX2cWcAeu0xKoQW6JmzDje9/c7DAtLipmIDFrWVSzu8BFJqFzArv2u84pyDnuaLrqQ5rz3ktbn0QirbGlL5k/6E3CUB55CCF8+jEzQsjQUGQlTch9Dl7XAJLT8Lh1q2bat7KievEa1mNfzJmG5MDQIDAQAB

gym-manage-api/manage-app/src/main/resources/member-config.yml

@@ -16,9 +16,33 @@ wechat:
 
   # 手机号加密配置
   phone-encryption:
-    secret-key: ${PHONE_ENCRYPTION_SECRET_KEY}
-    iv: ${PHONE_ENCRYPTION_IV}
+    secret-key: ${PHONE_ENCRYPTION_SECRET_KEY:P8539ANjWJWsRbVHZKhM8Q==}
+    iv: ${PHONE_ENCRYPTION_IV:3tHp07uMRYh1xKsIXvYJMA==}
 
 spring:
   elasticsearch:
-    uris: http://localhost:9200
+    uris: http://localhost:9200
+
+payment:
+  huifu:
+    sys-id: "6666000207573586"
+    product-id: "XLSISV"
+    huifu-id: "6666000207573586"
+    acct-id: "F28226571"
+    private-key: ${huifu.private-key}
+    public-key: ${huifu.public-key}
+    create-url: "https://api.huifu.com/v4/trade/payment/create"
+    query-url: "https://api.huifu.com/v4/trade/payment/query"
+    refund-url: "https://api.huifu.com/v4/trade/refund"
+    notify-url: "http://localhost:8084/api/payment/notify"
+
+# 支付宝配置（沙箱环境）
+alipay:
+  app-id: "9021000164699238"
+  app-private-key: ${ALIPAY_APP_PRIVATE_KEY}
+  alipay-public-key: ${ALIPAY_ALIPAY_PUBLIC_KEY}
+  sign-type: "RSA2"
+  charset: "UTF-8"
+  gateway: "https://openapi-sandbox.dl.alipaydev.com/gateway.do"
+  notify-url: "http://localhost:8084/api/payment/notify"
+  sandbox: true

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

@@ -9,10 +9,7 @@ spring:
       max-size: 10
       
   flyway:
-    enabled: true
-    locations: classpath:db/migration
-    baseline-on-migrate: true
-    validate-on-migrate: true
+    enabled: false
     
   sql:
     init:

gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/config/AuthConfig.java

@@ -0,0 +1,19 @@
+package cn.novalon.gym.manage.common.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@Data
+@Component
+@ConfigurationProperties(prefix = "auth")
+public class AuthConfig {
+
+    private String accessKeyId;
+
+    private String accessKeySecret;
+
+    private Integer tokenExpireSeconds = 86400;
+
+    private Integer refreshTokenExpireSeconds = 604800;
+}

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

@@ -61,4 +61,13 @@ public final class RedisKeyConstants {
      * appType: miniapp(小程序), mp(公众号)
      */
     public static final String WECHAT_ACCESS_TOKEN = "wechat:access_token:";
+
+    // ==================== 认证模块 ====================
+
+    /**
+     * 手机短信验证码缓存
+     * 格式：sms:code:{phone}
+     * 用途：存储登录/注册等场景的短信验证码
+     */
+    public static final String SMS_CODE = "sms:code:";
 }

gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/exception/ErrorCode.java

@@ -7,6 +7,7 @@ public class ErrorCode {
     public static final String PERMISSION_PREFIX = "PERMISSION_";
     public static final String CONFLICT_PREFIX = "CONFLICT_";
     public static final String SYSTEM_PREFIX = "SYSTEM_";
+    public static final String AUTH_PREFIX = "AUTH_";
 
     public static final String VALIDATION_REQUIRED = VALIDATION_PREFIX + "001";
     public static final String VALIDATION_INVALID_FORMAT = VALIDATION_PREFIX + "002";
@@ -29,4 +30,7 @@ public class ErrorCode {
     public static final String SYSTEM_INTERNAL_ERROR = SYSTEM_PREFIX + "001";
     public static final String SYSTEM_DATABASE_ERROR = SYSTEM_PREFIX + "002";
     public static final String SYSTEM_NETWORK_ERROR = SYSTEM_PREFIX + "003";
+
+    public static final String AUTH_PHONE_ERROR = AUTH_PREFIX + "001";
+    public static final String AUTH_CODE_ERROR = AUTH_PREFIX + "002";
 }

gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/response/Result.java

@@ -0,0 +1,54 @@
+package cn.novalon.gym.manage.common.response;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class Result<T> {
+
+    private Integer code;
+
+    private String message;
+
+    private T data;
+
+    private Long timestamp;
+
+    public static <T> Result<T> success(T data) {
+        return Result.<T>builder()
+                .code(200)
+                .message("success")
+                .data(data)
+                .timestamp(System.currentTimeMillis())
+                .build();
+    }
+
+    public static <T> Result<T> success(String message) {
+        return Result.<T>builder()
+                .code(200)
+                .message(message)
+                .timestamp(System.currentTimeMillis())
+                .build();
+    }
+
+    public static <T> Result<T> fail(Integer code, String message) {
+        return Result.<T>builder()
+                .code(code)
+                .message(message)
+                .timestamp(System.currentTimeMillis())
+                .build();
+    }
+
+    public static <T> Result<T> fail(String message) {
+        return Result.<T>builder()
+                .code(500)
+                .message(message)
+                .timestamp(System.currentTimeMillis())
+                .build();
+    }
+}

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

@@ -0,0 +1,86 @@
+package cn.novalon.gym.manage.common.util;
+
+import cn.novalon.gym.manage.common.config.JwtProperties;
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.Keys;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import javax.crypto.SecretKey;
+import java.nio.charset.StandardCharsets;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class JwtUtil {
+
+    private final JwtProperties jwtProperties;
+
+    private SecretKey getSigningKey() {
+        String secret = jwtProperties.getSecret();
+        if (secret.length() < 32) {
+            StringBuilder sb = new StringBuilder(secret);
+            while (sb.length() < 32) {
+                sb.append(secret);
+            }
+            secret = sb.substring(0, 32);
+        }
+        return Keys.hmacShaKeyFor(secret.getBytes(StandardCharsets.UTF_8));
+    }
+
+    public String generateToken(String userId, String phone) {
+        Date now = new Date();
+        Date expiryDate = new Date(now.getTime() + jwtProperties.getExpiration());
+
+        Map<String, Object> claims = new HashMap<>();
+        claims.put("userId", userId);
+        claims.put("phone", phone);
+
+        return Jwts.builder()
+                .setClaims(claims)
+                .setSubject(userId)
+                .setIssuedAt(now)
+                .setExpiration(expiryDate)
+                .signWith(getSigningKey())
+                .compact();
+    }
+
+    public String generateRefreshToken(String userId) {
+        Date now = new Date();
+        Date expiryDate = new Date(now.getTime() + jwtProperties.getExpiration() * 7);
+
+        return Jwts.builder()
+                .setSubject(userId)
+                .setIssuedAt(now)
+                .setExpiration(expiryDate)
+                .signWith(getSigningKey())
+                .compact();
+    }
+
+    public Claims parseToken(String token) {
+        return Jwts.parserBuilder()
+                .setSigningKey(getSigningKey())
+                .build()
+                .parseClaimsJws(token)
+                .getBody();
+    }
+
+    public String getUserIdFromToken(String token) {
+        return parseToken(token).getSubject();
+    }
+
+    public boolean validateToken(String token) {
+        try {
+            parseToken(token);
+            return true;
+        } catch (Exception e) {
+            log.warn("JWT token validation failed: {}", e.getMessage());
+            return false;
+        }
+    }
+}

gym-manage-api/manage-db/src/main/java/cn/novalon/gym/manage/db/entity/SysUserMessageEntity.java

@@ -1,5 +1,6 @@
 package cn.novalon.gym.manage.db.entity;
 
+import com.fasterxml.jackson.annotation.JsonFormat;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
@@ -21,10 +22,10 @@ public class SysUserMessageEntity {
     @Column("user_id")
     private Long userId;
 
-    @Column("title")
+    @Column("message_title")
     private String title;
 
-    @Column("content")
+    @Column("message_content")
     private String content;
 
     @Column("message_type")
@@ -33,9 +34,13 @@ public class SysUserMessageEntity {
     @Column("is_read")
     private String isRead;
 
-    @Column("create_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @Column("created_at")
     private LocalDateTime createTime;
 
+    @Column("deleted_at")
+    private LocalDateTime deletedAt;
+
     public Long getId() {
         return id;
     }
@@ -91,4 +96,12 @@ public class SysUserMessageEntity {
     public void setCreateTime(LocalDateTime createTime) {
         this.createTime = createTime;
     }
+
+    public LocalDateTime getDeletedAt() {
+        return deletedAt;
+    }
+
+    public void setDeletedAt(LocalDateTime deletedAt) {
+        this.deletedAt = deletedAt;
+    }
 }

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

@@ -1,5 +1,7 @@
 package cn.novalon.gym.manage.db.repository;
 
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
 import cn.novalon.gym.manage.notify.core.domain.SysUserMessage;
 import cn.novalon.gym.manage.notify.core.repository.ISysUserMessageRepository;
 import cn.novalon.gym.manage.db.converter.SysUserMessageConverter;
@@ -13,6 +15,8 @@ import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import java.util.List;
+
 /**
  * 用户消息仓储实现类
  * 
@@ -75,6 +79,87 @@ public class SysUserMessageRepository implements ISysUserMessageRepository {
         return r2dbcEntityTemplate.count(dbQuery, SysUserMessageEntity.class);
     }
 
+    @Override
+    public Mono<PageResponse<SysUserMessage>> findByUserIdPage(Long userId, 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);
+
+        SysUserMessageQueryCriteria criteria = new SysUserMessageQueryCriteria();
+        criteria.setUserId(userId);
+        org.springframework.data.relational.core.query.Query dbQuery = QueryUtil.getQuery(criteria);
+
+        return r2dbcEntityTemplate.select(SysUserMessageEntity.class)
+                .matching(dbQuery.with(pageable))
+                .all()
+                .collectList()
+                .zipWith(r2dbcEntityTemplate.count(dbQuery, SysUserMessageEntity.class))
+                .map(tuple -> {
+                    long total = tuple.getT2();
+                    int totalPages = (int) Math.ceil((double) total / size);
+                    List<SysUserMessage> messageList = tuple.getT1().stream()
+                            .map(sysUserMessageConverter::toDomain)
+                            .toList();
+                    return new PageResponse<>(messageList, totalPages, total, page, size);
+                });
+    }
+
+    @Override
+    public Mono<PageResponse<SysUserMessage>> findByUserIdAndIsReadPage(Long userId, String isRead, 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);
+
+        SysUserMessageQueryCriteria criteria = new SysUserMessageQueryCriteria();
+        criteria.setUserId(userId);
+        criteria.setIsRead(isRead);
+        org.springframework.data.relational.core.query.Query dbQuery = QueryUtil.getQuery(criteria);
+
+        return r2dbcEntityTemplate.select(SysUserMessageEntity.class)
+                .matching(dbQuery.with(pageable))
+                .all()
+                .collectList()
+                .zipWith(r2dbcEntityTemplate.count(dbQuery, SysUserMessageEntity.class))
+                .map(tuple -> {
+                    long total = tuple.getT2();
+                    int totalPages = (int) Math.ceil((double) total / size);
+                    List<SysUserMessage> messageList = tuple.getT1().stream()
+                            .map(sysUserMessageConverter::toDomain)
+                            .toList();
+                    return new PageResponse<>(messageList, totalPages, total, page, size);
+                });
+    }
+
+    @Override
+    public Mono<Long> markAllAsReadByUserId(Long userId) {
+        org.springframework.data.relational.core.query.Update update = org.springframework.data.relational.core.query.Update.update("is_read", "1");
+        
+        org.springframework.data.relational.core.query.Query query = org.springframework.data.relational.core.query.Query.query(
+                org.springframework.data.relational.core.query.Criteria.where("user_id").is(userId)
+                        .and("deleted_at").isNull()
+        );
+
+        return r2dbcEntityTemplate.update(SysUserMessageEntity.class)
+                .matching(query)
+                .apply(update);
+    }
+
     @Override
     public Mono<SysUserMessage> save(SysUserMessage message) {
         SysUserMessageEntity entity = sysUserMessageConverter.toEntity(message);

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__Create_GroupCourse_Recommend_table.sql

@@ -0,0 +1,38 @@
+-- ============================================
+-- 团课推荐表
+-- ============================================
+
+-- 团课推荐表
+CREATE TABLE IF NOT EXISTS group_course_recommend (
+    id BIGSERIAL PRIMARY KEY,
+    course_id BIGINT NOT NULL,
+    recommend_title VARCHAR(200),
+    recommend_content TEXT,
+    recommend_reason VARCHAR(500),
+    priority INTEGER DEFAULT 0,
+    is_active BOOLEAN DEFAULT TRUE,
+    create_by VARCHAR(50),
+    update_by VARCHAR(50),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP
+);
+
+-- 创建索引
+CREATE INDEX IF NOT EXISTS idx_group_course_recommend_course_id ON group_course_recommend(course_id);
+CREATE INDEX IF NOT EXISTS idx_group_course_recommend_priority ON group_course_recommend(priority);
+CREATE INDEX IF NOT EXISTS idx_group_course_recommend_is_active ON group_course_recommend(is_active);
+
+COMMENT ON TABLE group_course_recommend IS '团课推荐表';
+COMMENT ON COLUMN group_course_recommend.id IS '主键ID';
+COMMENT ON COLUMN group_course_recommend.course_id IS '团课ID（关联group_course.id）';
+COMMENT ON COLUMN group_course_recommend.recommend_title IS '推荐标题';
+COMMENT ON COLUMN group_course_recommend.recommend_content IS '推荐内容';
+COMMENT ON COLUMN group_course_recommend.recommend_reason IS '推荐理由';
+COMMENT ON COLUMN group_course_recommend.priority IS '优先级（数字越大优先级越高）';
+COMMENT ON COLUMN group_course_recommend.is_active IS '是否启用';
+COMMENT ON COLUMN group_course_recommend.create_by IS '创建人';
+COMMENT ON COLUMN group_course_recommend.update_by IS '更新人';
+COMMENT ON COLUMN group_course_recommend.created_at IS '创建时间';
+COMMENT ON COLUMN group_course_recommend.updated_at IS '更新时间';
+COMMENT ON COLUMN group_course_recommend.deleted_at IS '删除时间（软删除）';

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/V13__Consolidated_Test_Data.sql

@@ -0,0 +1,342 @@
+-- ============================================================
+-- V13: 整合所有测试数据（基于 2026-06-16 17:13）
+-- 说明: 系统初始数据由 V2 处理，本文件仅包含业务测试数据
+-- 所有时间相关字段已更新为基于 2026-06-16
+-- ============================================================
+
+-- ============================================================
+-- Section B: 团课类型数据（来源 V15）
+-- ============================================================
+
+INSERT INTO group_course_type (type_name, base_difficulty, description, category) VALUES
+('慢走/椭圆机轻松模式', 1, '几乎无难度，适合所有人', '基础有氧与热身'),
+('固定自行车（低阻力）', 2, '注意座椅高度调节即可', '基础有氧与热身'),
+('跑步机慢跑', 3, '需要基本协调性，膝盖有压力', '基础有氧与热身'),
+('跳绳（连续基础跳）', 3, '需要手脚配合，心肺要求明显', '基础有氧与热身'),
+('坐姿腿屈伸/腿弯举', 2, '很容易找到发力感', '固定器械训练'),
+('坐姿推胸机', 3, '需注意肩胛后收，避免耸肩', '固定器械训练'),
+('高位下拉（坐姿）', 3, '需控制不要过度后仰', '固定器械训练'),
+('史密斯机深蹲', 4, '轨迹固定，但需保持核心稳定', '固定器械训练'),
+('蝴蝶机夹胸', 3, '易用肘关节代偿，需锁定肩关节', '固定器械训练'),
+('平板支撑', 3, '耐力考验，技巧低', '自重基础动作'),
+('跪姿俯卧撑', 3, '上肢力量较弱者首选', '自重基础动作'),
+('标准俯卧撑', 5, '需核心收紧，身体成直线', '自重基础动作'),
+('引体向上（弹力带辅助）', 6, '背部和手臂力量要求高', '自重基础动作'),
+('标准引体向上', 8, '力量-体重比极高，多数男性无法完成1次', '自重基础动作'),
+('徒手深蹲', 3, '注意膝盖方向与背部直立', '自重基础动作'),
+('单腿深蹲（手枪蹲）', 8, '需要极高下肢力量、柔韧性和平衡', '自重基础动作'),
+('哑铃二头弯举', 4, '容易晃动借力，但较安全', '自由重量杠铃/哑铃'),
+('哑铃侧平举', 5, '极易用斜方肌代偿，真正练到三角肌中束很难', '自由重量杠铃/哑铃'),
+('杠铃卧推', 7, '肩关节压力大，起桥、沉肩、稳定手腕均有技巧，有压伤风险', '自由重量杠铃/哑铃'),
+('杠铃深蹲（颈后）', 8, '全身协调性、核心抗压、杠位放置、呼吸模式，学习曲线陡峭', '自由重量杠铃/哑铃'),
+('传统硬拉', 9, '风险极高，需要精确的脊柱中立、髋铰链、背阔肌收紧，错误时伤腰', '自由重量杠铃/哑铃'),
+('高翻/抓举（奥运举重）', 10, '需要爆发力、柔韧、精准衔接，非数月训练不能掌握', '自由重量杠铃/哑铃'),
+('波比跳（标准版）', 6, '连续做时心肺压力极大', '高强度与爆发力'),
+('冲刺跑（短跑）', 7, '对腘绳肌和脚踝爆发力要求高', '高强度与爆发力'),
+('跳箱（合理高度）', 6, '需要落地缓冲技巧', '高强度与爆发力'),
+('负重雪橇推', 6, '主要考验腿部耐力和意志力', '高强度与爆发力'),
+('双力臂（引体向上后翻腕上杠）', 9, '需要爆发引体 + 极高相对力量', '高强度与爆发力'),
+('静态拉伸（坐姿体前屈）', 2, '无风险，但需要坚持', '柔韧与平衡类'),
+('瑜伽下犬式', 3, '常见，但需背部与手臂对齐', '柔韧与平衡类'),
+('单腿罗马尼亚硬拉（徒手）', 6, '极考验平衡和髋稳定', '柔韧与平衡类'),
+('全深蹲（脚跟贴地，亚洲蹲）', 5, '踝关节灵活度限制多数人', '柔韧与平衡类'),
+('竖叉/横叉', 8, '需要数月甚至数年拉伸', '柔韧与平衡类'),
+('瑜伽入门', 2, '适合初学者的瑜伽课程，注重基础体式', '柔韧与平衡类'),
+('瑜伽进阶', 5, '针对有一定基础的学员，包含更复杂体式', '柔韧与平衡类'),
+('普拉提', 4, '注重核心力量和身体控制', '柔韧与平衡类'),
+('动感单车', 4, '高强度有氧运动，节奏感强', '基础有氧与热身'),
+('搏击操', 5, '结合拳击动作的有氧运动', '高强度与爆发力'),
+('HIIT训练', 7, '高强度间歇训练，对心肺要求极高', '高强度与爆发力'),
+('核心训练', 4, '针对核心肌群的专项训练', '自重基础动作');
+
+-- ============================================================
+-- Section C: 团课标签数据（来源 V16）
+-- ============================================================
+
+INSERT INTO course_label (label_name, color, description) VALUES
+('适合新手', '#52c41a', '适合健身初学者'),
+('中级过渡', '#faad14', '适合有一定基础的学员'),
+('高级进阶', '#f5222d', '适合高级学员'),
+('减脂塑形', '#722ed1', '有助于减脂塑形'),
+('增肌强化', '#13c2c2', '有助于增肌强化'),
+('柔韧性训练', '#eb2f96', '注重柔韧性提升'),
+('核心训练', '#1890ff', '注重核心力量'),
+('心肺训练', '#fa8c16', '提升心肺功能'),
+('低冲击', '#52c41a', '低冲击运动，适合关节保护'),
+('高强度', '#f5222d', '高强度间歇训练'),
+('团体互动', '#722ed1', '注重团队协作'),
+('私教推荐', '#13c2c2', '私教推荐课程'),
+('热门课程', '#ff1493', '人气较高的课程'),
+('新课上线', '#00ced1', '新上线的课程');
+
+-- ============================================================
+-- Section D: 会员卡类型（来源 V10 / V11，已去重合并）
+-- ============================================================
+
+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');
+
+-- ============================================================
+-- Section E: 测试会员（来源 V10 / V11 / V12 / V14）
+-- ============================================================
+
+-- E1: 数据统计测试会员（V14，显式 ID 1001-1012）
+INSERT INTO member_user (id, member_no, nickname, phone, created_at, updated_at, is_deleted) VALUES
+(1001, 'M20260616001', '张三', '13800138001', '2026-06-16 08:00:00', '2026-06-16 08:00:00', false),
+(1002, 'M20260616002', '李四', '13800138002', '2026-06-16 09:00:00', '2026-06-16 09:00:00', false),
+(1003, 'M20260615003', '王五', '13800138003', '2026-06-15 10:00:00', '2026-06-15 10:00:00', false),
+(1004, 'M20260614004', '赵六', '13800138004', '2026-06-14 11:00:00', '2026-06-14 11:00:00', false),
+(1005, 'M20260616005', '钱七', '13800138005', '2026-06-16 08:00:00', '2026-06-16 08:00:00', false),
+(1006, 'M20260616006', '孙八', '13800138006', '2026-06-16 09:00:00', '2026-06-16 09:00:00', false),
+(1007, 'M20260616007', '周九', '13800138007', '2026-06-16 10:00:00', '2026-06-16 10:00:00', false),
+(1008, 'M20260613008', '吴十', '13800138008', '2026-06-13 14:00:00', '2026-06-13 14:00:00', false),
+(1009, 'M20260612009', '郑十一', '13800138009', '2026-06-12 15:00:00', '2026-06-12 15:00:00', false),
+(1010, 'M20260611010', '王十二', '13800138010', '2026-06-11 16:00:00', '2026-06-11 16:00:00', false),
+(1011, 'M20260610011', '陈十三', '13800138011', '2026-06-10 17:00:00', '2026-06-10 17:00:00', false),
+(1012, 'M20260609012', '刘十四', '13800138012', '2026-06-09 18:00:00', '2026-06-09 18:00:00', false);
+
+-- E2: 预约场景测试会员（V10: 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-16 10:00:00', '2026-06-16 10:00:00'),
+('MEM_TEST_B', '用户B_过期时长卡', '13800001002', 1, false, '2026-06-15 10:00:00', '2026-06-15 10:00:00'),
+('MEM_TEST_C', '会员C_有效时长卡', '13800001003', 2, false, '2026-06-15 10:00:00', '2026-06-15 10:00:00'),
+('MEM_TEST_D', '会员D_次数用尽', '13800001004', 1, false, '2026-06-15 10:00:00', '2026-06-15 10:00:00'),
+('MEM_TEST_E', '会员E_次数充足', '13800001005', 2, false, '2026-06-15 10:00:00', '2026-06-15 10:00:00'),
+('MEM_TEST_F', '会员F_储值卡余额不足', '13800001006', 1, false, '2026-06-15 10:00:00', '2026-06-15 10:00:00'),
+('MEM_TEST_G', '会员G_储值卡余额充足', '13800001007', 2, false, '2026-06-15 10:00:00', '2026-06-15 10:00:00');
+
+-- E3: 取消预约测试会员（V11: 张三/李四/王五）
+INSERT INTO member_user (member_no, nickname, phone, gender, is_deleted, created_at, updated_at) VALUES
+('MEM_TEST_ZHANG', '张三_时长卡用户', '13800002001', 1, false, '2026-06-15 10:00:00', '2026-06-15 10:00:00'),
+('MEM_TEST_LI', '李四_次数卡用户', '13800002002', 1, false, '2026-06-15 10:00:00', '2026-06-15 10:00:00'),
+('MEM_TEST_WANG', '王五_储值卡用户', '13800002003', 2, false, '2026-06-15 10:00:00', '2026-06-15 10:00:00');
+
+-- E4: 时间冲突测试会员（V12）
+INSERT INTO member_user (member_no, nickname, phone, gender, is_deleted, created_at, updated_at) VALUES
+('MEM_TIME_CONFLICT', '时间冲突测试会员', '13800009999', 1, false, '2026-06-15 10:00:00', '2026-06-15 10:00:00');
+
+-- ============================================================
+-- Section F: 会员卡记录
+-- ============================================================
+
+-- F1: V10 预约场景 - 6条会员卡记录
+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-06-15 23:59:59', '2026-05-16 10:00:00', 0, '{}', '2026-05-16 10:00:00', '2026-06-16 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-16 23:59:59', '2026-06-16 10:00:00', 0, '{}', '2026-06-16 10:00:00', '2026-06-16 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-16 10:00:00', 0, '{}', '2026-05-16 10:00:00', '2026-06-16 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-16 10:00:00', 0, '{}', '2026-05-16 10:00:00', '2026-06-16 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-16 23:59:59', '2026-05-16 10:00:00', 0, '{}', '2026-05-16 10:00:00', '2026-06-16 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-16 23:59:59', '2026-05-16 10:00:00', 0, '{}', '2026-05-16 10:00:00', '2026-06-16 10:00:00');
+
+-- F2: V11 取消预约场景 - 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-16 23:59:59', '2026-06-16 10:00:00', 0, '{}', '2026-06-16 10:00:00', '2026-06-16 10:00:00'),
+((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-16 10:00:00', 0, '{}', '2026-05-16 10:00:00', '2026-06-16 10:00:00'),
+((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-16 23:59:59', '2026-05-16 10:00:00', 0, '{}', '2026-05-16 10:00:00', '2026-06-16 10:00:00');
+
+-- F3: V12 时间冲突场景 - 1条
+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-16 10:00:00', 0, '{}', '2026-06-16 10:00:00', '2026-06-16 10:00:00');
+
+-- ============================================================
+-- Section G: 团课课程（来源 V7 / V10 / V11 / V12 / V14，基于 2026-06-24）
+-- ============================================================
+
+-- G1: V7 - 7种场景团课
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, stored_value_amount, create_by, created_at, updated_at) VALUES
+('极速燃脂单车', 104, 2, '2026-06-25 16:45:00', '2026-06-25 20:20:00', 25, 0, 0, '单车房', '/images/spinning.jpg', '跟随音乐节奏变换阻力和速度，体验爬坡与冲刺的快感。', 50.00, 'admin', '2026-06-24 10:00:00', '2026-06-24 10:00:00'),
+('清晨流瑜伽', 101, 1, '2026-06-28 09:00:00', '2026-06-28 10:30:00', 15, 5, 0, 'A座3楼瑜伽教室', '/images/yoga_flow.jpg', '适合有一定基础的学员，通过流畅的体式连接呼吸。', 50.00, 'admin', '2026-06-24 10:00:00', '2026-06-24 10:00:00'),
+('燃脂搏击', 102, 2, '2026-06-26 18:30:00', '2026-06-26 19:30:00', 20, 20, 0, '综合训练区', '/images/kickboxing.jpg', '高强度间歇训练，名额已满。', 50.00, 'coach_zhang', '2026-06-24 14:30:00', '2026-06-24 14:30:00'),
+('哈他瑜伽', 101, 1, '2026-06-24 17:45:00', '2026-06-24 18:50:00', 12, 3, 0, '瑜伽教室B', '/images/hatha_yoga.jpg', '基础哈他瑜伽，距开始不足30分钟，已停止预约。', 50.00, 'coach_li', '2026-06-24 08:00:00', '2026-06-24 08:00:00'),
+('周末冥想修复', 101, 1, '2026-07-06 15:00:00', '2026-07-06 16:00:00', 12, 3, 1, '冥想室', '/images/meditation.jpg', '通过呼吸和正念冥想，该课程已被取消。', 50.00, 'coach_wang', '2026-06-24 08:00:00', '2026-06-24 08:00:00'),
+('蜜桃臀塑造', 103, 3, '2026-06-18 19:00:00', '2026-06-18 20:00:00', 10, 8, 2, '私教专区', '/images/glute.jpg', '针对性训练臀部肌肉群，课程已结束。', 50.00, 'coach_li', '2026-06-18 09:15:00', '2026-06-18 09:15:00'),
+('午间冥想放松', 101, 1, '2026-06-20 12:00:00', '2026-06-20 13:00:00', 15, 6, 2, '冥想室', '/images/meditation_noon.jpg', '午间冥想课程，已结束。', 50.00, 'admin', '2026-06-20 09:00:00', '2026-06-20 09:00:00');
+
+-- G2: V10 预约场景（已取消次数卡支付，仅保留储值卡）
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, stored_value_amount, create_by, created_at, updated_at) VALUES
+('燃脂搏击_储值测试', 102, 2, '2026-06-26 19:30:00', '2026-06-26 20:30:00', 20, 0, 0, '综合训练区', '消耗储值50元', 50.00, 'admin', '2026-06-24 10:00:00', '2026-06-24 10:00:00'),
+('高端普拉提_储值卡课程', 103, 1, '2026-06-27 19:00:00', '2026-06-27 20:00:00', 15, 0, 0, '普拉提教室', '消耗储值20元', 20.00, 'admin', '2026-06-24 10:00:00', '2026-06-24 10:00:00');
+
+-- G3: V11 取消预约场景
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, stored_value_amount, create_by, created_at, updated_at) VALUES
+('晚间瑜伽_取消测试', 101, 1, '2026-06-27 19:00:00', '2026-06-27 20:00:00', 20, 0, 0, '瑜伽教室', '用于测试取消预约功能', 30.00, 'admin', '2026-06-24 10:00:00', '2026-06-24 10:00:00');
+
+-- G4: V12 时间冲突场景
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, stored_value_amount, create_by, created_at, updated_at) VALUES
+('时间冲突测试_A_13点-15点', 102, 2, '2026-06-26 13:00:00', '2026-06-26 15:00:00', 20, 0, 0, '综合训练区', '测试用团课A', 50.00, 'admin', '2026-06-24 10:00:00', '2026-06-24 10:00:00'),
+('时间冲突测试_B_14点-16点', 103, 1, '2026-06-26 14:00:00', '2026-06-26 16:00:00', 15, 0, 0, '普拉提教室', '与团课A时间重叠', 50.00, 'admin', '2026-06-24 10:00:00', '2026-06-24 10:00:00'),
+('时间冲突测试_C_10点-12点', 101, 1, '2026-06-26 10:00:00', '2026-06-26 12:00:00', 15, 0, 0, '瑜伽教室', '与A/B不冲突', 50.00, 'admin', '2026-06-24 10:00:00', '2026-06-24 10:00:00');
+
+-- G5: V14 数据统计场景（今天 2026-06-24）
+INSERT INTO group_course (id, course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, stored_value_amount, created_at, updated_at) VALUES
+(3001, '瑜伽入门', 1, 1, '2026-06-24 08:00:00', '2026-06-24 09:00:00', 20, 15, 0, '健身房A区', 'https://example.com/yoga.jpg', '适合初学者的瑜伽课程', 50.00, '2026-06-24 10:00:00', '2026-06-24 10:00:00'),
+(3002, '动感单车', 2, 2, '2026-06-24 09:30:00', '2026-06-24 10:30:00', 25, 20, 0, '健身房B区', 'https://example.com/spinning.jpg', '高强度有氧运动', 50.00, '2026-06-24 11:00:00', '2026-06-24 11:00:00'),
+(3003, '普拉提', 3, 1, '2026-06-24 14:00:00', '2026-06-24 15:00:00', 15, 10, 0, '健身房C区', 'https://example.com/pilates.jpg', '核心力量训练', 50.00, '2026-06-24 12:00:00', '2026-06-24 12:00:00');
+
+-- ============================================================
+-- Section H: 团课预约记录
+-- ============================================================
+
+-- H1: V11 取消预约测试
+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-24 11:00:00', '0', '晚间瑜伽_取消测试', '2026-06-27 19:00:00', '2026-06-27 20:00:00', '瑜伽教室', '2026-06-24 11:00:00', '2026-06-24 11:00:00'),
+((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-24 11:30:00', '0', '晚间瑜伽_取消测试', '2026-06-27 19:00:00', '2026-06-27 20:00:00', '瑜伽教室', '2026-06-24 11:30:00', '2026-06-24 11:30:00'),
+((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-24 12:00:00', '0', '晚间瑜伽_取消测试', '2026-06-27 19:00:00', '2026-06-27 20:00:00', '瑜伽教室', '2026-06-24 12:00:00', '2026-06-24 12:00:00');
+
+UPDATE group_course SET current_members = current_members + 3 WHERE course_name = '晚间瑜伽_取消测试';
+
+-- H2: V14 数据统计预约 - 今天（6月24日）
+INSERT INTO group_course_booking (id, member_id, member_card_id, course_id, booking_time, status, created_at, updated_at) VALUES
+(4001, 1001, 1, 3001, '2026-06-24 08:00:00', '2', '2026-06-23 20:00:00', '2026-06-24 08:30:00'),
+(4002, 1002, 2, 3001, '2026-06-24 08:00:00', '2', '2026-06-23 21:00:00', '2026-06-24 08:30:00'),
+(4003, 1003, 3, 3001, '2026-06-24 08:00:00', '3', '2026-06-23 22:00:00', '2026-06-24 09:00:00'),
+(4004, 1004, 4, 3002, '2026-06-24 09:30:00', '2', '2026-06-23 19:00:00', '2026-06-24 09:30:00'),
+(4005, 1005, 5, 3002, '2026-06-24 09:30:00', '1', '2026-06-23 20:30:00', '2026-06-24 09:00:00'),
+(4006, 1006, 6, 3002, '2026-06-24 09:30:00', '2', '2026-06-23 21:30:00', '2026-06-24 09:30:00'),
+(4007, 1007, 7, 3003, '2026-06-24 14:00:00', '2', '2026-06-23 22:30:00', '2026-06-24 14:00:00'),
+(4008, 1008, 8, 3003, '2026-06-24 14:00:00', '3', '2026-06-24 08:00:00', '2026-06-24 14:00:00'),
+(4009, 1009, 9, 3003, '2026-06-24 14:00:00', '2', '2026-06-24 09:00:00', '2026-06-24 14:00:00'),
+(4010, 1010, 10, 3001, '2026-06-24 08:00:00', '2', '2026-06-24 07:00:00', '2026-06-24 08:00:00'),
+(4011, 1011, 11, 3002, '2026-06-24 09:30:00', '1', '2026-06-24 08:30:00', '2026-06-24 09:00:00'),
+(4012, 1012, 12, 3003, '2026-06-24 14:00:00', '2', '2026-06-24 10:00:00', '2026-06-24 14:00:00');
+
+-- H3: V14 数据统计预约 - 昨天（6月23日）
+INSERT INTO group_course_booking (id, member_id, member_card_id, course_id, booking_time, status, created_at, updated_at) VALUES
+(4013, 1001, 1, 3001, '2026-06-23 08:00:00', '2', '2026-06-22 20:00:00', '2026-06-23 08:30:00'),
+(4014, 1002, 2, 3001, '2026-06-23 08:00:00', '2', '2026-06-22 21:00:00', '2026-06-23 08:30:00'),
+(4015, 1003, 3, 3002, '2026-06-23 09:30:00', '3', '2026-06-22 22:00:00', '2026-06-23 09:30:00'),
+(4016, 1004, 4, 3002, '2026-06-23 09:30:00', '2', '2026-06-22 19:00:00', '2026-06-23 09:30:00'),
+(4017, 1005, 5, 3003, '2026-06-23 14:00:00', '1', '2026-06-22 20:30:00', '2026-06-23 13:00:00'),
+(4018, 1006, 6, 3003, '2026-06-23 14:00:00', '2', '2026-06-22 21:30:00', '2026-06-23 14:00:00');
+
+-- H4: V14 数据统计预约 - 前天（6月22日）
+INSERT INTO group_course_booking (id, member_id, member_card_id, course_id, booking_time, status, created_at, updated_at) VALUES
+(4019, 1001, 1, 3002, '2026-06-22 09:30:00', '2', '2026-06-21 20:00:00', '2026-06-22 09:30:00'),
+(4020, 1002, 2, 3002, '2026-06-22 09:30:00', '2', '2026-06-21 21:00:00', '2026-06-22 09:30:00'),
+(4021, 1003, 3, 3003, '2026-06-22 14:00:00', '2', '2026-06-21 22:00:00', '2026-06-22 14:00:00'),
+(4022, 1004, 4, 3003, '2026-06-22 14:00:00', '3', '2026-06-21 19:00:00', '2026-06-22 14:00:00');
+
+-- ============================================================
+-- Section I: 签到记录（来源 V14，基于 2026-06-24）
+-- ============================================================
+
+INSERT INTO sign_in_record (id, member_id, sign_in_time, sign_in_type, sign_in_status, source, is_delete) VALUES
+(2001, 1001, '2026-06-24 08:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2002, 1002, '2026-06-24 08:15:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
+(2003, 1003, '2026-06-24 08:30:00', 'FACE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2004, 1004, '2026-06-24 09:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2005, 1005, '2026-06-24 09:15:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
+(2006, 1006, '2026-06-24 09:30:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2007, 1007, '2026-06-24 10:00:00', 'FACE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2008, 1008, '2026-06-24 10:15:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2009, 1009, '2026-06-24 10:30:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
+(2010, 1010, '2026-06-24 11:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2011, 1011, '2026-06-24 11:15:00', 'FACE', 'FAIL', 'MINI_PROGRAM', false),
+(2012, 1012, '2026-06-24 11:30:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false);
+
+INSERT INTO sign_in_record (id, member_id, sign_in_time, sign_in_type, sign_in_status, source, is_delete) VALUES
+(2013, 1001, '2026-06-23 07:30:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2014, 1002, '2026-06-23 08:00:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
+(2015, 1003, '2026-06-23 08:30:00', 'FACE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2016, 1004, '2026-06-23 09:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2017, 1005, '2026-06-23 09:30:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
+(2018, 1006, '2026-06-23 10:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2019, 1007, '2026-06-23 10:30:00', 'FACE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2020, 1008, '2026-06-23 11:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false);
+
+INSERT INTO sign_in_record (id, member_id, sign_in_time, sign_in_type, sign_in_status, source, is_delete) VALUES
+(2021, 1001, '2026-06-22 07:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2022, 1002, '2026-06-22 07:30:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
+(2023, 1003, '2026-06-22 08:00:00', 'FACE', 'FAIL', 'MINI_PROGRAM', false),
+(2024, 1004, '2026-06-22 08:30:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
+(2025, 1005, '2026-06-22 09:00:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false);
+
+-- ============================================================
+-- Section J: 团课推荐测试数据（来源 V18，基于 2026-06-24）
+-- ============================================================
+
+INSERT INTO group_course_recommend (course_id, recommend_title, recommend_content, recommend_reason, priority, is_active, create_by, created_at, updated_at) VALUES
+((SELECT id FROM group_course WHERE course_name = '极速燃脂单车'), '本周热门推荐', '极速燃脂单车课程，跟随音乐节奏变换阻力和速度，体验爬坡与冲刺的快感，一节课消耗800大卡！', '教练专业，课程内容丰富，深受学员喜爱，燃脂效果显著', 20, true, 'admin', '2026-06-24 10:00:00', '2026-06-24 10:00:00');
+
+INSERT INTO group_course_recommend (course_id, recommend_title, recommend_content, recommend_reason, priority, is_active, create_by, created_at, updated_at) VALUES
+((SELECT id FROM group_course WHERE course_name = '清晨流瑜伽'), '新手友好推荐', '清晨流瑜伽课程，适合有一定基础的学员，通过流畅的体式连接呼吸，唤醒身体能量。', '适合新手入门，教练耐心指导，课程节奏适中', 15, true, 'admin', '2026-06-24 11:00:00', '2026-06-24 11:00:00');
+
+INSERT INTO group_course_recommend (course_id, recommend_title, recommend_content, recommend_reason, priority, is_active, create_by, created_at, updated_at) VALUES
+((SELECT id FROM group_course WHERE course_name = '燃脂搏击'), '高强度燃脂', '燃脂搏击课程，高强度间歇训练，配合音乐快速燃脂，释放压力。', '高强度训练，适合进阶学员，快速燃脂塑形', 10, false, 'admin', '2026-06-24 12:00:00', '2026-06-24 12:00:00');
+
+INSERT INTO group_course_recommend (course_id, recommend_title, recommend_content, recommend_reason, priority, is_active, create_by, created_at, updated_at) VALUES
+((SELECT id FROM group_course WHERE course_name = '哈他瑜伽'), '基础瑜伽推荐', '基础哈他瑜伽课程，适合所有级别学员，通过基础体式练习提升身体柔韧性和平衡能力。', '零基础友好，适合所有健身水平，放松身心', 12, true, 'coach_li', '2026-06-24 13:00:00', '2026-06-24 13:00:00');
+
+INSERT INTO group_course_recommend (course_id, recommend_title, recommend_content, recommend_reason, priority, is_active, create_by, created_at, updated_at) VALUES
+((SELECT id FROM group_course WHERE course_name = '蜜桃臀塑造'), '塑形热门课程', '蜜桃臀塑造课程，针对性训练臀部肌肉群，打造完美曲线。', '专业私教指导，动作标准，效果显著，深受女性学员喜爱', 18, true, 'coach_li', '2026-06-24 09:15:00', '2026-06-24 09:15:00');
+
+INSERT INTO group_course_recommend (course_id, recommend_title, recommend_content, recommend_reason, priority, is_active, create_by, created_at, updated_at) VALUES
+((SELECT id FROM group_course WHERE course_name = '午间冥想放松'), '午间放松推荐', '午间冥想放松课程，通过呼吸和正念冥想，深度放松身心，缓解工作压力。', '适合上班族，午间放松充电，提升下午工作效率', 8, true, 'admin', '2026-06-24 09:00:00', '2026-06-24 09:00:00');
+
+INSERT INTO group_course_recommend (course_id, recommend_title, recommend_content, recommend_reason, priority, is_active, create_by, created_at, updated_at) VALUES
+((SELECT id FROM group_course WHERE course_name = '极速燃脂单车'), '减脂首选课程', '想要快速减脂？极速燃脂单车是你的最佳选择！专业教练带领，科学训练计划。', '减脂效果最佳，课程强度适中，适合想要快速瘦身的学员', 16, true, 'coach_zhang', '2026-06-24 14:00:00', '2026-06-24 14:00:00');
+
+INSERT INTO group_course_recommend (course_id, recommend_title, recommend_content, recommend_reason, priority, is_active, create_by, created_at, updated_at) VALUES
+((SELECT id FROM group_course WHERE course_name = '清晨流瑜伽'), '晨练优选', '清晨流瑜伽，唤醒身体能量，开启活力一天！适合晨练爱好者。', '晨练最佳选择，提升身体活力，改善精神状态', 14, true, 'coach_wang', '2026-06-24 15:00:00', '2026-06-24 15:00:00');
+
+INSERT INTO group_course_recommend (course_id, recommend_title, recommend_content, recommend_reason, priority, is_active, create_by, created_at, updated_at) VALUES
+((SELECT id FROM group_course WHERE course_name = '哈他瑜伽'), '身心平衡推荐', '哈他瑜伽课程，通过体式练习和呼吸控制，达到身心平衡，提升整体健康水平。', '改善身体柔韧性，增强核心力量，提升身体协调性', 11, true, 'coach_li', '2026-06-24 16:00:00', '2026-06-24 16:00:00');
+
+INSERT INTO group_course_recommend (course_id, recommend_title, recommend_content, recommend_reason, priority, is_active, create_by, created_at, updated_at) VALUES
+((SELECT id FROM group_course WHERE course_name = '午间冥想放松'), '职场减压课程', '午间冥想放松，专为职场人士设计，快速缓解工作压力，提升工作状态。', '职场减压首选，课程时间短，效果显著', 9, false, 'admin', '2026-06-24 10:00:00', '2026-06-24 10:00:00');
+
+-- ============================================================
+-- Section K: 统计说明
+-- ============================================================
+-- 今日（2026-06-24）统计预期：
+--   新增会员: 3 (1005, 1006, 1007)
+--   签到会员: 12
+--   预约总数: 12 (4001-4012)，取消: 2，出席: 8，缺席: 2
+--   签到总数: 12，成功: 11，失败: 1
+
+-- ============================================================
+-- Section L: 测试场景汇总
+-- ============================================================
+-- 1. V7 团课预约场景:
+--    - 极速燃脂单车: 明天(6/25)，0人，可预约
+--    - 清晨流瑜伽: 6月28日，5/15人，可预约
+--    - 燃脂搏击: 6月26日，满员，不可预约
+--    - 哈他瑜伽: 6/24 17:45，距开始<30min，不可预约
+--    - 周末冥想修复: 7月6日，已取消(status=1)
+--    - 蜜桃臀塑造: 6月18日，已结束(status=2)
+--    - 午间冥想放松: 6月20日，已结束(status=2)
+--
+-- 2. V10 会员卡预约资格校验:
+--    - 用户A: 无会员卡 → "无可用会员卡"
+--    - 用户B: 时长卡过期 → "会员卡已过期"
+--    - 会员C: 时长卡有效 → 可正常预约
+--    - 会员D: 次数为0 → "剩余次数不足"
+--    - 会员E: 次数充足 → 不可用次数卡预约团课（仅支持储值卡）
+--    - 会员F: 储值卡30元，课程需50元 → 余额不足
+--    - 会员G: 储值卡200元，课程需50元 → 可正常预约
+--
+-- 3. V11 取消预约:
+--    - 张三(时长卡)、李四(储值卡)、王五(储值卡) 预约了晚间瑜伽_取消测试
+--    - 取消后应恢复对应卡状态，释放课程名额
+--
+-- 4. V12 时间冲突检测:
+--    - 团课A: 6/26 13:00-15:00, 团课B: 6/26 14:00-16:00 → 时间重叠
+--    - 团课C: 6/26 10:00-12:00 → 与A/B不冲突
+--
+-- 5. V14 数据统计:
+--    - 3天签到/预约数据，覆盖今天/昨天/前天
+--
+-- 6. V18 团课推荐:
+--    - 10条推荐记录，覆盖不同优先级和启用状态

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

@@ -0,0 +1,99 @@
+-- ============================================
+-- 签到记录表（sign_in_record）
+-- ============================================
+
+-- Step 1: 创建 sign_in_record 表
+CREATE TABLE IF NOT EXISTS sign_in_record (
+    -- ========== 主键和基础字段 ==========
+    id BIGSERIAL PRIMARY KEY,                                      -- 自增主键
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,      -- 记录创建时间
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,      -- 记录更新时间
+
+    -- ========== 会员相关字段 ==========
+    member_id BIGINT NOT NULL,                                     -- 会员ID，关联member_user表
+    member_card_id BIGINT,                                         -- 签到时使用的会员卡ID
+
+    -- ========== 签到核心字段 ==========
+    sign_in_time TIMESTAMP NOT NULL,                               -- 签到入场时间
+    sign_in_type VARCHAR(20) NOT NULL,                             -- 签到方式：QR_CODE-扫码签到，MANUAL-手动签到，FACE-人脸识别
+    sign_in_status VARCHAR(20) NOT NULL DEFAULT 'SUCCESS',        -- 签到状态：SUCCESS-成功，FAILED-失败
+
+    -- ========== 验证和错误信息 ==========
+    verification_details TEXT,                                     -- JSONB格式，存储会员卡验证时的快照数据
+    fail_reason VARCHAR(500),                                      -- 失败时的具体原因文案
+
+    -- ========== 操作人信息 ==========
+    operator_id BIGINT,                                            -- 操作人ID（前台人员），自助签到时为NULL
+    operator_name VARCHAR(100),                                    -- 操作人姓名冗余
+
+    -- ========== 设备和环境信息 ==========
+    device_info VARCHAR(200),                                      -- 签到设备标识或型号
+    ip_address VARCHAR(50),                                        -- 客户端IP地址
+    source VARCHAR(20) NOT NULL,                                   -- 签到来源：MINI_PROGRAM-小程序扫码，PC_BACKEND-后台管理端
+
+    -- ========== 软删除字段 ==========
+    is_delete BOOLEAN DEFAULT FALSE                                -- 软删除标识：false-未删除，true-已删除
+);
+
+-- Step 2: 创建索引
+-- 会员ID索引（加速按会员查询签到记录）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_member_id ON sign_in_record(member_id);
+
+-- 签到时间索引（加速按时间范围查询）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_sign_in_time ON sign_in_record(sign_in_time);
+
+-- 签到状态索引（加速按状态筛选）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_sign_in_status ON sign_in_record(sign_in_status);
+
+-- 会员卡ID索引（加速按会员卡查询）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_member_card_id ON sign_in_record(member_card_id);
+
+-- 操作人ID索引（加速按操作人查询）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_operator_id ON sign_in_record(operator_id);
+
+-- 签到来源索引（加速按来源统计）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_source ON sign_in_record(source);
+
+-- 软删除索引（加速查询未删除的记录）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_is_delete ON sign_in_record(is_delete);
+
+-- 复合索引：会员ID + 签到时间（加速会员签到历史查询）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_member_time ON sign_in_record(member_id, sign_in_time);
+
+-- 复合索引：签到状态 + 签到时间（加速统计数据查询）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_status_time ON sign_in_record(sign_in_status, sign_in_time);
+
+-- 复合索引：签到日期（用于每日统计，使用表达式索引）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_sign_in_date ON sign_in_record(DATE(sign_in_time));
+
+-- Step 3: 添加外键约束（可选，根据业务需求决定）
+-- 注意：如果member_user表使用了软删除，外键约束可能需要谨慎使用
+-- ALTER TABLE sign_in_record
+--     ADD CONSTRAINT fk_sign_in_record_member
+--         FOREIGN KEY (member_id) REFERENCES member_user(id) ON DELETE SET NULL;
+
+-- Step 4: 添加注释
+COMMENT ON TABLE sign_in_record IS '会员到店签到记录表';
+
+COMMENT ON COLUMN sign_in_record.id IS '自增主键';
+COMMENT ON COLUMN sign_in_record.created_at IS '记录创建时间';
+COMMENT ON COLUMN sign_in_record.updated_at IS '记录更新时间';
+
+COMMENT ON COLUMN sign_in_record.member_id IS '会员ID，关联member_user表';
+COMMENT ON COLUMN sign_in_record.member_card_id IS '签到时使用的会员卡ID';
+
+COMMENT ON COLUMN sign_in_record.sign_in_time IS '签到入场时间';
+COMMENT ON COLUMN sign_in_record.sign_in_type IS '签到方式：QR_CODE-扫码签到，MANUAL-手动签到，FACE-人脸识别';
+COMMENT ON COLUMN sign_in_record.sign_in_status IS '签到状态：SUCCESS-成功，FAILED-失败';
+
+COMMENT ON COLUMN sign_in_record.verification_details IS 'JSON格式，存储会员卡验证时的快照数据（包含卡类型、剩余次数/金额、有效期等）';
+COMMENT ON COLUMN sign_in_record.fail_reason IS '失败时的具体原因文案';
+
+COMMENT ON COLUMN sign_in_record.operator_id IS '操作人ID（前台人员），自助签到时为NULL';
+COMMENT ON COLUMN sign_in_record.operator_name IS '操作人姓名冗余（避免关联查询）';
+
+COMMENT ON COLUMN sign_in_record.device_info IS '签到设备标识或型号';
+COMMENT ON COLUMN sign_in_record.ip_address IS '客户端IP地址';
+COMMENT ON COLUMN sign_in_record.source IS '签到来源：MINI_PROGRAM-小程序扫码，PC_BACKEND-后台管理端';
+
+COMMENT ON COLUMN sign_in_record.is_delete IS '软删除标识：false-未删除，true-已删除';

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

@@ -1,120 +0,0 @@
--- 数据统计模块测试数据
--- 用于测试会员、预约、签到统计接口
-
--- 插入测试会员数据
-INSERT INTO member_user (id, member_no, nickname, phone, created_at, updated_at, is_deleted) VALUES
-(1001, 'M20260601001', '张三', '13800138001', '2026-06-01 08:00:00', '2026-06-01 08:00:00', false),
-(1002, 'M20260601002', '李四', '13800138002', '2026-06-01 09:00:00', '2026-06-01 09:00:00', false),
-(1003, 'M20260602003', '王五', '13800138003', '2026-06-02 10:00:00', '2026-06-02 10:00:00', false),
-(1004, 'M20260603004', '赵六', '13800138004', '2026-06-03 11:00:00', '2026-06-03 11:00:00', false),
-(1005, 'M20260609005', '钱七', '13800138005', '2026-06-09 08:00:00', '2026-06-09 08:00:00', false),
-(1006, 'M20260609006', '孙八', '13800138006', '2026-06-09 09:00:00', '2026-06-09 09:00:00', false),
-(1007, 'M20260609007', '周九', '13800138007', '2026-06-09 10:00:00', '2026-06-09 10:00:00', false),
-(1008, 'M20260604008', '吴十', '13800138008', '2026-06-04 14:00:00', '2026-06-04 14:00:00', false),
-(1009, 'M20260605009', '郑十一', '13800138009', '2026-06-05 15:00:00', '2026-06-05 15:00:00', false),
-(1010, 'M20260606010', '王十二', '13800138010', '2026-06-06 16:00:00', '2026-06-06 16:00:00', false),
-(1011, 'M20260607011', '陈十三', '13800138011', '2026-06-07 17:00:00', '2026-06-07 17:00:00', false),
-(1012, 'M20260608012', '刘十四', '13800138012', '2026-06-08 18:00:00', '2026-06-08 18:00:00', false)
-ON CONFLICT (id) DO NOTHING;
-
--- 插入测试签到记录数据 (今天的数据)
-INSERT INTO sign_in_record (id, member_id, sign_in_time, sign_in_type, sign_in_status, source, is_delete) VALUES
-(2001, 1001, '2026-06-09 08:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2002, 1002, '2026-06-09 08:15:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
-(2003, 1003, '2026-06-09 08:30:00', 'FACE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2004, 1004, '2026-06-09 09:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2005, 1005, '2026-06-09 09:15:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
-(2006, 1006, '2026-06-09 09:30:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2007, 1007, '2026-06-09 10:00:00', 'FACE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2008, 1008, '2026-06-09 10:15:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2009, 1009, '2026-06-09 10:30:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
-(2010, 1010, '2026-06-09 11:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2011, 1011, '2026-06-09 11:15:00', 'FACE', 'FAIL', 'MINI_PROGRAM', false),
-(2012, 1012, '2026-06-09 11:30:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false)
-ON CONFLICT (id) DO NOTHING;
-
--- 插入测试签到记录数据 (昨天的数据)
-INSERT INTO sign_in_record (id, member_id, sign_in_time, sign_in_type, sign_in_status, source, is_delete) VALUES
-(2013, 1001, '2026-06-08 07:30:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2014, 1002, '2026-06-08 08:00:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
-(2015, 1003, '2026-06-08 08:30:00', 'FACE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2016, 1004, '2026-06-08 09:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2017, 1005, '2026-06-08 09:30:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
-(2018, 1006, '2026-06-08 10:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2019, 1007, '2026-06-08 10:30:00', 'FACE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2020, 1008, '2026-06-08 11:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false)
-ON CONFLICT (id) DO NOTHING;
-
--- 插入测试签到记录数据 (前天的数据)
-INSERT INTO sign_in_record (id, member_id, sign_in_time, sign_in_type, sign_in_status, source, is_delete) VALUES
-(2021, 1001, '2026-06-07 07:00:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2022, 1002, '2026-06-07 07:30:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false),
-(2023, 1003, '2026-06-07 08:00:00', 'FACE', 'FAIL', 'MINI_PROGRAM', false),
-(2024, 1004, '2026-06-07 08:30:00', 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', false),
-(2025, 1005, '2026-06-07 09:00:00', 'MANUAL', 'SUCCESS', 'PC_BACKEND', false)
-ON CONFLICT (id) DO NOTHING;
-
--- 插入测试团课数据
-INSERT INTO group_course (id, course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, created_at, updated_at) VALUES
-(3001, '瑜伽入门', 1, 1, '2026-06-09 08:00:00', '2026-06-09 09:00:00', 20, 15, 0, '健身房A区', 'https://example.com/yoga.jpg', '适合初学者的瑜伽课程', '2026-06-01 10:00:00', '2026-06-01 10:00:00'),
-(3002, '动感单车', 2, 2, '2026-06-09 09:30:00', '2026-06-09 10:30:00', 25, 20, 0, '健身房B区', 'https://example.com/spinning.jpg', '高强度有氧运动', '2026-06-01 11:00:00', '2026-06-01 11:00:00'),
-(3003, '普拉提', 3, 1, '2026-06-09 14:00:00', '2026-06-09 15:00:00', 15, 10, 0, '健身房C区', 'https://example.com/pilates.jpg', '核心力量训练', '2026-06-01 12:00:00', '2026-06-01 12:00:00')
-ON CONFLICT (id) DO NOTHING;
-
--- 插入测试团课预约数据 (今天的数据)
-INSERT INTO group_course_booking (id, member_id, member_card_id, course_id, booking_time, status, created_at, updated_at) VALUES
-(4001, 1001, 1, 3001, '2026-06-09 08:00:00', '2', '2026-06-08 20:00:00', '2026-06-09 08:30:00'),
-(4002, 1002, 2, 3001, '2026-06-09 08:00:00', '2', '2026-06-08 21:00:00', '2026-06-09 08:30:00'),
-(4003, 1003, 3, 3001, '2026-06-09 08:00:00', '3', '2026-06-08 22:00:00', '2026-06-09 09:00:00'),
-(4004, 1004, 4, 3002, '2026-06-09 09:30:00', '2', '2026-06-08 19:00:00', '2026-06-09 09:30:00'),
-(4005, 1005, 5, 3002, '2026-06-09 09:30:00', '1', '2026-06-08 20:30:00', '2026-06-09 09:00:00'),
-(4006, 1006, 6, 3002, '2026-06-09 09:30:00', '2', '2026-06-08 21:30:00', '2026-06-09 09:30:00'),
-(4007, 1007, 7, 3003, '2026-06-09 14:00:00', '2', '2026-06-08 22:30:00', '2026-06-09 14:00:00'),
-(4008, 1008, 8, 3003, '2026-06-09 14:00:00', '3', '2026-06-09 08:00:00', '2026-06-09 14:00:00'),
-(4009, 1009, 9, 3003, '2026-06-09 14:00:00', '2', '2026-06-09 09:00:00', '2026-06-09 14:00:00'),
-(4010, 1010, 10, 3001, '2026-06-09 08:00:00', '2', '2026-06-09 07:00:00', '2026-06-09 08:00:00'),
-(4011, 1011, 11, 3002, '2026-06-09 09:30:00', '1', '2026-06-09 08:30:00', '2026-06-09 09:00:00'),
-(4012, 1012, 12, 3003, '2026-06-09 14:00:00', '2', '2026-06-09 10:00:00', '2026-06-09 14:00:00')
-ON CONFLICT (id) DO NOTHING;
-
--- 插入测试团课预约数据 (昨天的数据)
-INSERT INTO group_course_booking (id, member_id, member_card_id, course_id, booking_time, status, created_at, updated_at) VALUES
-(4013, 1001, 1, 3001, '2026-06-08 08:00:00', '2', '2026-06-07 20:00:00', '2026-06-08 08:30:00'),
-(4014, 1002, 2, 3001, '2026-06-08 08:00:00', '2', '2026-06-07 21:00:00', '2026-06-08 08:30:00'),
-(4015, 1003, 3, 3002, '2026-06-08 09:30:00', '3', '2026-06-07 22:00:00', '2026-06-08 09:30:00'),
-(4016, 1004, 4, 3002, '2026-06-08 09:30:00', '2', '2026-06-07 19:00:00', '2026-06-08 09:30:00'),
-(4017, 1005, 5, 3003, '2026-06-08 14:00:00', '1', '2026-06-07 20:30:00', '2026-06-08 13:00:00'),
-(4018, 1006, 6, 3003, '2026-06-08 14:00:00', '2', '2026-06-07 21:30:00', '2026-06-08 14:00:00')
-ON CONFLICT (id) DO NOTHING;
-
--- 插入测试团课预约数据 (前天的数据)
-INSERT INTO group_course_booking (id, member_id, member_card_id, course_id, booking_time, status, created_at, updated_at) VALUES
-(4019, 1001, 1, 3002, '2026-06-07 09:30:00', '2', '2026-06-06 20:00:00', '2026-06-07 09:30:00'),
-(4020, 1002, 2, 3002, '2026-06-07 09:30:00', '2', '2026-06-06 21:00:00', '2026-06-07 09:30:00'),
-(4021, 1003, 3, 3003, '2026-06-07 14:00:00', '2', '2026-06-06 22:00:00', '2026-06-07 14:00:00'),
-(4022, 1004, 4, 3003, '2026-06-07 14:00:00', '3', '2026-06-06 19:00:00', '2026-06-07 14:00:00')
-ON CONFLICT (id) DO NOTHING;
-
--- 预期统计结果 (今日):
--- 会员统计:
---   新增会员: 3 (1005, 1006, 1007)
---   活跃会员: 12 (所有会员今日或近期有活动)
---   总会员数: 12
---   签到会员: 12
---   预约会员: 9
---   取消会员: 2
-
--- 预约统计:
---   总预约: 12
---   取消: 2
---   出席: 8
---   缺席: 2
---   出席率: 8/10 = 80%
---   取消率: 2/12 = 16.67%
-
--- 签到统计:
---   总签到: 12
---   成功: 11
---   失败: 1
---   成功率: 11/12 = 91.67%
---   类型分布: QR_CODE=5, MANUAL=4, FACE=3

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

@@ -0,0 +1,9 @@
+-- ============================================
+-- 为团课表添加二维码路径字段
+-- ============================================
+
+-- 添加二维码路径字段
+ALTER TABLE group_course ADD COLUMN qr_code_path VARCHAR(500);
+
+-- 添加字段注释
+COMMENT ON COLUMN group_course.qr_code_path IS '二维码图片路径';

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

@@ -0,0 +1,9 @@
+-- ============================================
+-- V20: 为 member_user 表添加 deleted_at 字段
+-- 原因：BaseEntity 已映射该字段，但 member_user 表缺失
+-- ============================================
+
+ALTER TABLE member_user
+    ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP;
+
+COMMENT ON COLUMN member_user.deleted_at IS '软删除时间';

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

@@ -0,0 +1,21 @@
+-- ============================================
+-- V20: 更新 member_user 表 - 添加阿里云号码认证字段
+-- 支持一键登录功能
+-- ============================================
+
+-- 添加阿里云号码认证相关字段
+ALTER TABLE IF EXISTS member_user
+    ADD COLUMN IF NOT EXISTS dypns_open_id VARCHAR(100),
+    ADD COLUMN IF NOT EXISTS id_card VARCHAR(50),
+    ADD COLUMN IF NOT EXISTS real_name VARCHAR(50),
+    ADD COLUMN IF NOT EXISTS register_channel VARCHAR(50) DEFAULT 'SMS';
+
+-- 创建索引
+CREATE INDEX IF NOT EXISTS idx_member_user_dypns_open_id ON member_user(dypns_open_id);
+CREATE INDEX IF NOT EXISTS idx_member_user_register_channel ON member_user(register_channel);
+
+-- 添加字段注释
+COMMENT ON COLUMN member_user.dypns_open_id IS '阿里云号码认证OpenID（一键登录用户唯一标识）';
+COMMENT ON COLUMN member_user.id_card IS '身份证号码（AES加密存储）';
+COMMENT ON COLUMN member_user.real_name IS '真实姓名（AES加密存储）';
+COMMENT ON COLUMN member_user.register_channel IS '注册渠道：SMS-短信验证码，ONE_CLICK-一键登录，WECHAT-微信授权';

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

@@ -0,0 +1,9 @@
+-- ============================================
+-- V21: 为 member_card_transactions 表添加 updated_at 字段
+-- 原因：MemberCardTransaction 继承 BaseEntity 已映射该字段，但表缺失
+-- ============================================
+
+ALTER TABLE member_card_transactions
+    ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP;
+
+COMMENT ON COLUMN member_card_transactions.updated_at IS '更新时间';

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

@@ -0,0 +1,100 @@
+-- ============================================
+-- V22: 新增业务模块权限
+-- 描述: 为会员、会员卡、团课、签到、数据统计、员工管理等业务模块创建权限
+-- ============================================
+
+-- ============================================
+-- 会员管理权限
+-- ============================================
+INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status, create_by, update_by, created_at, updated_at) VALUES
+('会员查看', 'business:member:view', '/api/admin/members', 'GET', '查看会员列表及详情', 1, 'system', 'system', NOW(), NOW()),
+('会员编辑', 'business:member:edit', '/api/admin/member', 'PUT', '编辑会员信息', 1, 'system', 'system', NOW(), NOW()),
+('会员手机修改', 'business:member:phone', '/api/admin/member/phone', 'POST', '管理员修改会员手机号', 1, 'system', 'system', NOW(), NOW());
+
+-- ============================================
+-- 会员卡管理权限
+-- ============================================
+INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status, create_by, update_by, created_at, updated_at) VALUES
+('会员卡查看', 'business:memberCard:view', '/api/member-cards', 'GET', '查看会员卡列表及详情', 1, 'system', 'system', NOW(), NOW()),
+('会员卡创建', 'business:memberCard:create', '/api/member-cards', 'POST', '创建会员卡类型', 1, 'system', 'system', NOW(), NOW()),
+('会员卡编辑', 'business:memberCard:edit', '/api/member-cards', 'PUT', '编辑会员卡类型', 1, 'system', 'system', NOW(), NOW()),
+('会员卡删除', 'business:memberCard:delete', '/api/member-cards', 'DELETE', '删除会员卡类型', 1, 'system', 'system', NOW(), NOW()),
+('会员卡购买', 'business:memberCard:purchase', '/api/member-card-records/purchase', 'POST', '为会员购买/绑定会员卡', 1, 'system', 'system', NOW(), NOW()),
+('会员卡退卡', 'business:memberCard:refund', '/api/member-card-records/refund', 'POST', '会员卡退卡/解绑', 1, 'system', 'system', NOW(), NOW());
+
+-- ============================================
+-- 团课管理权限
+-- ============================================
+INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status, create_by, update_by, created_at, updated_at) VALUES
+('团课查看', 'business:groupCourse:view', '/api/groupCourse', 'GET', '查看团课列表及详情', 1, 'system', 'system', NOW(), NOW()),
+('团课创建', 'business:groupCourse:create', '/api/groupCourse', 'POST', '创建团课', 1, 'system', 'system', NOW(), NOW()),
+('团课编辑', 'business:groupCourse:edit', '/api/groupCourse', 'PUT', '编辑团课信息', 1, 'system', 'system', NOW(), NOW()),
+('团课删除', 'business:groupCourse:delete', '/api/groupCourse', 'DELETE', '删除团课', 1, 'system', 'system', NOW(), NOW()),
+('团课取消', 'business:groupCourse:cancel', '/api/groupCourse/cancel', 'POST', '取消团课', 1, 'system', 'system', NOW(), NOW());
+
+-- ============================================
+-- 团课类型管理权限
+-- ============================================
+INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status, create_by, update_by, created_at, updated_at) VALUES
+('团课类型查看', 'business:groupCourseType:view', '/api/groupCourse/types', 'GET', '查看团课类型列表', 1, 'system', 'system', NOW(), NOW()),
+('团课类型创建', 'business:groupCourseType:create', '/api/groupCourse/types', 'POST', '创建团课类型', 1, 'system', 'system', NOW(), NOW()),
+('团课类型编辑', 'business:groupCourseType:edit', '/api/groupCourse/types', 'PUT', '编辑团课类型', 1, 'system', 'system', NOW(), NOW()),
+('团课类型删除', 'business:groupCourseType:delete', '/api/groupCourse/types', 'DELETE', '删除团课类型', 1, 'system', 'system', NOW(), NOW());
+
+-- ============================================
+-- 团课推荐管理权限
+-- ============================================
+INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status, create_by, update_by, created_at, updated_at) VALUES
+('团课推荐查看', 'business:groupCourseRecommend:view', '/api/groupCourse/recommend', 'GET', '查看推荐团课列表', 1, 'system', 'system', NOW(), NOW()),
+('团课推荐创建', 'business:groupCourseRecommend:create', '/api/groupCourse/recommend', 'POST', '创建推荐团课', 1, 'system', 'system', NOW(), NOW()),
+('团课推荐编辑', 'business:groupCourseRecommend:edit', '/api/groupCourse/recommend', 'PUT', '编辑推荐团课', 1, 'system', 'system', NOW(), NOW()),
+('团课推荐删除', 'business:groupCourseRecommend:delete', '/api/groupCourse/recommend', 'DELETE', '删除推荐团课', 1, 'system', 'system', NOW(), NOW());
+
+-- ============================================
+-- 团课预约管理权限
+-- ============================================
+INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status, create_by, update_by, created_at, updated_at) VALUES
+('团课预约查看', 'business:groupCourseBooking:view', '/api/groupCourse/bookings', 'GET', '查看团课预约记录', 1, 'system', 'system', NOW(), NOW()),
+('团课预约创建', 'business:groupCourseBooking:create', '/api/groupCourse/book', 'POST', '预约团课', 1, 'system', 'system', NOW(), NOW()),
+('团课预约取消', 'business:groupCourseBooking:cancel', '/api/groupCourse/booking/cancel', 'POST', '取消团课预约', 1, 'system', 'system', NOW(), NOW());
+
+-- ============================================
+-- 签到管理权限
+-- ============================================
+INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status, create_by, update_by, created_at, updated_at) VALUES
+('签到查看', 'business:checkIn:view', '/api/checkIn/records', 'GET', '查看签到记录', 1, 'system', 'system', NOW(), NOW()),
+('签到操作', 'business:checkIn:create', '/api/checkIn', 'POST', '执行签到操作', 1, 'system', 'system', NOW(), NOW()),
+('签到导出', 'business:checkIn:export', '/api/checkIn/records/export', 'GET', '导出签到记录', 1, 'system', 'system', NOW(), NOW());
+
+-- ============================================
+-- 数据统计权限
+-- ============================================
+INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status, create_by, update_by, created_at, updated_at) VALUES
+('数据统计查看', 'business:dataCount:view', '/api/datacount', 'GET', '查看数据统计报表', 1, 'system', 'system', NOW(), NOW()),
+('数据统计导出', 'business:dataCount:export', '/api/datacount/export', 'GET', '导出统计报表', 1, 'system', 'system', NOW(), NOW());
+
+-- ============================================
+-- 员工管理权限
+-- ============================================
+INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status, create_by, update_by, created_at, updated_at) VALUES
+('员工查看', 'business:employee:view', '/api/employees/page', 'GET', '查看员工列表', 1, 'system', 'system', NOW(), NOW()),
+('员工创建', 'business:employee:create', '/api/users', 'POST', '创建员工账号', 1, 'system', 'system', NOW(), NOW()),
+('员工编辑', 'business:employee:edit', '/api/users', 'PUT', '编辑员工信息', 1, 'system', 'system', NOW(), NOW()),
+('员工删除', 'business:employee:delete', '/api/users', 'DELETE', '删除/禁用员工账号', 1, 'system', 'system', NOW(), NOW()),
+('员工分配角色', 'business:employee:assignRole', '/api/users/roles', 'POST', '为员工分配角色', 1, 'system', 'system', NOW(), NOW());
+
+-- ============================================
+-- 为超级管理员角色分配所有业务权限
+-- ============================================
+INSERT INTO sys_role_permission (role_id, permission_id, create_by, update_by, created_at, updated_at)
+SELECT 1, id, 'system', 'system', NOW(), NOW()
+FROM sys_permission
+WHERE permission_code LIKE 'business:%'
+  AND status = 1
+  AND id NOT IN (SELECT permission_id FROM sys_role_permission WHERE role_id = 1);
+
+-- ============================================
+-- 重置序列值
+-- ============================================
+SELECT setval('sys_permission_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_permission));
+SELECT setval('sys_role_permission_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_role_permission));

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

@@ -0,0 +1,93 @@
+-- ============================================================
+-- V23: 教练账号测试数据
+-- 描述: 创建教练角色、教练用户及相关团课测试数据
+-- 日期: 2026-06-22
+-- ============================================================
+
+-- ============================================================
+-- 1. 新增教练专属权限
+--    教练只能查看自己教授的团课/预约/签到信息，不能修改数据库
+-- ============================================================
+INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status, create_by, update_by, created_at, updated_at) VALUES
+('查看自己的团课',   'coach:course:view',   '/api/coach/courses',   'GET',  '查看教练自己教授的团课列表及详情',    1, 'system', 'system', NOW(), NOW()),
+('查看自己团课的预约', 'coach:booking:view',  '/api/coach/bookings',  'GET',  '查看教练自己团课的会员预约记录',      1, 'system', 'system', NOW(), NOW()),
+('查看自己团课的签到', 'coach:signIn:view',   '/api/coach/signins',   'GET',  '查看教练自己团课的会员签到记录',      1, 'system', 'system', NOW(), NOW()),
+('教练执行签到',      'coach:signIn:create', '/api/coach/signins',   'POST', '教练为自己团课的会员执行签到操作',    1, 'system', 'system', NOW(), NOW())
+ON CONFLICT (permission_code) DO NOTHING;
+
+-- ============================================================
+-- 2. 教练角色
+-- ============================================================
+INSERT INTO sys_role (id, role_name, role_key, role_sort, status, create_by, update_by, created_at, updated_at)
+VALUES (5, '教练', 'coach', 5, 1, 'system', 'system', NOW(), NOW())
+ON CONFLICT (role_key) DO NOTHING;
+
+-- ============================================================
+-- 3. 教练用户（密码: Test@123）
+-- ============================================================
+INSERT INTO sys_user (id, username, password, email, phone, nickname, status, create_by, update_by, created_at, updated_at)
+VALUES (20, 'coach', '$2a$12$nZ1EMUpZQljbnEdIKzH72eHlDJKUmHmHppnTTVth/SlHs5VpSAr8C', 'coach@novalon.com', '13900000001', '张教练', 1, 'system', 'system', NOW(), NOW())
+ON CONFLICT (username) DO NOTHING;
+
+-- ============================================================
+-- 4. 教练角色关联
+-- ============================================================
+INSERT INTO user_role (user_id, role_id, created_by, created_at)
+VALUES (20, 5, 'system', NOW())
+ON CONFLICT (user_id, role_id) DO NOTHING;
+
+-- ============================================================
+-- 5. 为教练角色分配有限权限
+--    教练只能查看自己教授的团课、查看自己团课的预约/签到信息、为自己团课的会员签到
+--    不能对数据库进行写操作（签到属于业务操作，非数据库直接写入）
+-- ============================================================
+INSERT INTO sys_role_permission (role_id, permission_id, create_by, update_by, created_at, updated_at)
+SELECT 5, id, 'system', 'system', NOW(), NOW()
+FROM sys_permission
+WHERE permission_code IN (
+    'coach:course:view',      -- 查看自己的团课
+    'coach:booking:view',     -- 查看自己团课的预约信息
+    'coach:signIn:view',      -- 查看自己团课的签到信息
+    'coach:signIn:create',    -- 为自己团课的会员签到
+    'system:notice:view'      -- 查看系统公告
+)
+AND NOT EXISTS (
+    SELECT 1 FROM sys_role_permission WHERE role_id = 5 AND permission_id = sys_permission.id
+);
+
+-- ============================================================
+-- 6. 为教练分配今天的测试团课
+-- ============================================================
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, stored_value_amount, create_by, created_at, updated_at)
+VALUES
+('核心力量训练', 20, (SELECT id FROM group_course_type WHERE type_name = '核心训练' LIMIT 1), 
+ CURRENT_DATE + TIME '08:00', CURRENT_DATE + TIME '09:00', 15, 3, '0', '健身房B区', '针对核心肌群的专项训练，适合所有水平学员', 50.00, 'system', NOW(), NOW()),
+
+('瑜伽入门', 20, (SELECT id FROM group_course_type WHERE type_name = '瑜伽入门' LIMIT 1),
+ CURRENT_DATE + TIME '10:00', CURRENT_DATE + TIME '11:00', 12, 5, '0', '瑜伽教室', '基础的瑜伽体式教学，新课上线欢迎参加', 50.00, 'system', NOW(), NOW()),
+
+('动感单车', 20, (SELECT id FROM group_course_type WHERE type_name = '动感单车' LIMIT 1),
+ CURRENT_DATE + TIME '14:00', CURRENT_DATE + TIME '15:00', 20, 8, '0', '单车房', '高强度燃脂骑行，动感音乐带你飞', 50.00, 'system', NOW(), NOW()),
+
+('晚间普拉提', 20, (SELECT id FROM group_course_type WHERE type_name = '普拉提' LIMIT 1),
+ CURRENT_DATE + TIME '18:00', CURRENT_DATE + TIME '19:00', 10, 2, '0', '普拉提教室', '注重核心力量和身体控制，放松一天疲劳', 50.00, 'system', NOW(), NOW());
+
+-- ============================================================
+-- 7. 为教练创建一个未来的团课（方便测试时间表）
+-- ============================================================
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, stored_value_amount, create_by, created_at, updated_at)
+VALUES
+('HIIT燃脂训练', 20, (SELECT id FROM group_course_type WHERE type_name = 'HIIT训练' LIMIT 1),
+ CURRENT_DATE + INTERVAL '1 day' + TIME '08:00', CURRENT_DATE + INTERVAL '1 day' + TIME '09:00',
+ 15, 0, '0', '综合训练区', '高强度间歇训练，挑战心肺极限', 50.00, 'system', NOW(), NOW()),
+
+('周末瑜伽', 20, (SELECT id FROM group_course_type WHERE type_name = '瑜伽进阶' LIMIT 1),
+ CURRENT_DATE + INTERVAL '3 days' + TIME '09:00', CURRENT_DATE + INTERVAL '3 days' + TIME '10:30',
+ 12, 0, '0', '瑜伽教室', '针对有基础的进阶瑜伽课程', 50.00, 'system', NOW(), NOW());
+
+-- ============================================================
+-- 8. 重置序列值
+-- ============================================================
+SELECT setval('sys_role_id_seq', GREATEST((SELECT COALESCE(MAX(id), 0) FROM sys_role), 5));
+SELECT setval('sys_user_id_seq', GREATEST((SELECT COALESCE(MAX(id), 0) FROM sys_user), 20));
+SELECT setval('group_course_id_seq', (SELECT COALESCE(MAX(id), 0) FROM group_course));

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

@@ -0,0 +1,50 @@
+-- ============================================================
+-- V24: 新增第二个测试教练账号（李教练）
+-- 描述: 
+--   1. 新增测试教练用户 coachli（李教练）
+--   2. 为李教练分配教练角色（继承教练的有限权限）
+--   3. 为李教练分配未来一周的测试团课
+-- 日期: 2026-06-22
+-- ============================================================
+
+-- ============================================================
+-- 1. 第二个测试教练账号（密码: Test@123）
+-- ============================================================
+INSERT INTO sys_user (id, username, password, email, phone, nickname, status, create_by, update_by, created_at, updated_at)
+VALUES (21, 'coachli', '$2a$12$nZ1EMUpZQljbnEdIKzH72eHlDJKUmHmHppnTTVth/SlHs5VpSAr8C', 'coachli@novalon.com', '13900000002', '李教练', 1, 'system', 'system', NOW(), NOW())
+ON CONFLICT (username) DO NOTHING;
+
+-- ============================================================
+-- 2. 为李教练分配教练角色（role_id=5）
+--    继承教练角色的所有有限权限
+-- ============================================================
+INSERT INTO user_role (user_id, role_id, created_by, created_at)
+VALUES (21, 5, 'system', NOW())
+ON CONFLICT (user_id, role_id) DO NOTHING;
+
+-- ============================================================
+-- 3. 为李教练分配测试团课（未来一周的课程）
+-- ============================================================
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, description, stored_value_amount, create_by, created_at, updated_at)
+VALUES
+('入门瑜伽', 21, (SELECT id FROM group_course_type WHERE type_name = '瑜伽入门' LIMIT 1),
+ CURRENT_DATE + INTERVAL '2 days' + TIME '09:00', CURRENT_DATE + INTERVAL '2 days' + TIME '10:00',
+ 15, 0, '0', '瑜伽教室', '适合零基础学员的入门瑜伽课程', 50.00, 'system', NOW(), NOW()),
+
+('燃脂搏击', 21, (SELECT id FROM group_course_type WHERE type_name = '动感单车' LIMIT 1),
+ CURRENT_DATE + INTERVAL '2 days' + TIME '15:00', CURRENT_DATE + INTERVAL '2 days' + TIME '16:00',
+ 20, 0, '0', '综合训练区', '高强度搏击操，燃烧卡路里', 50.00, 'system', NOW(), NOW()),
+
+('肩颈理疗', 21, (SELECT id FROM group_course_type WHERE type_name = '普拉提' LIMIT 1),
+ CURRENT_DATE + INTERVAL '4 days' + TIME '10:00', CURRENT_DATE + INTERVAL '4 days' + TIME '11:00',
+ 12, 0, '0', '普拉提教室', '针对久坐人群的肩颈放松课程', 50.00, 'system', NOW(), NOW()),
+
+('晨间有氧', 21, (SELECT id FROM group_course_type WHERE type_name = 'HIIT训练' LIMIT 1),
+ CURRENT_DATE + INTERVAL '5 days' + TIME '07:00', CURRENT_DATE + INTERVAL '5 days' + TIME '08:00',
+ 20, 0, '0', '有氧区', '清晨燃脂有氧训练，开启活力一天', 50.00, 'system', NOW(), NOW());
+
+-- ============================================================
+-- 4. 重置序列值
+-- ============================================================
+SELECT setval('sys_user_id_seq', GREATEST((SELECT COALESCE(MAX(id), 0) FROM sys_user), 21));
+SELECT setval('group_course_id_seq', (SELECT COALESCE(MAX(id), 0) FROM group_course));

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

@@ -13,10 +13,11 @@ CREATE TABLE IF NOT EXISTS group_course (
     max_members INTEGER DEFAULT 20,
     current_members INTEGER DEFAULT 0,
     status VARCHAR(1) DEFAULT '0',
+    actual_start_time TIMESTAMP,
+    actual_end_time TIMESTAMP,
     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),
@@ -50,11 +51,12 @@ 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.status IS '状态（0正常 1已取消 2已结束 3进行中 4超时）';
+COMMENT ON COLUMN group_course.actual_start_time IS '实际开课时间（教练点击开课时记录）';
+COMMENT ON COLUMN group_course.actual_end_time IS '实际结课时间（教练点击结课时记录）';
 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 '更新人';