更新page.json，添加团课列表路由

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

gym-manage-api/KeyAnalyzer.java

@@ -1,202 +0,0 @@
-import java.util.Base64;
-import java.math.BigInteger;
-import java.io.ByteArrayInputStream;
-
-public class KeyAnalyzer {
-    public static void main(String[] args) {
-        String privateKeyBase64 = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCcxAwrhZF+izz1gxQKOr4jnC05obIBHbl0DzHOcd4CaaDV7Kv1NRJKi33JhdDsW4JGgu16e5Rtzq1VzU5VWz5EKgGL46maOFwCkngJUTP/LC3JVf/wtJmYCm8xNE8C7GNNIqKzYEvUOEfXqagpVvVrGsQ9FpzFp2rP9hBmHY3yizVyPX/uT9S+af5TRxiaItj3SSJGgloaEMrnKOpb/EH7JwPSS0liAyT/NxPfOyyZHc22AvaAIOE5y+0PMUIKPuIdfpOrej3LVpO1Arc2hSgmdB+YIPSiBVYPXa6AuAmil9mpbtSikQJ7Uu7lX4JyTW4QxQ06rPFKnFWVKkzivAElAgMBAAECggEAJd0AJ37iTlMpDQ90xqe7hvRQxAu256gbQ9nrqLY97g0/KIw6WEZSPakFX6gvdvb/NzKmUyAIEKGLoh6tXdZk6qfOqc/6BeK47nIcBfwT9/zerjNUVvn34w4aHyNINieMMHQ+Id8PUZmqWH+Euz9ilVTosuyEPwUZulLvUQqwXzU5VnwVghURbUhDd+ecBJACWgemRun6d5241PQXNYAdH1k7cETd8GfIi3qclhhJrxi7tu5tq4YGCXQIoz7HCLim7GIvT0M+FRgSw2EOrHnAQNFeQ/vQbP71ttLoTxehL6Se9dfWrV5OI+Y/T7vR2F84Qt0iNbaxyJGir7siKDFIwQKBgQDXDzinx3/TasplM78pR/0CtuuKr1Ch02LOPrTosJ1qf1OohxQThowhOTxMsBlgYSKu9s1QRffUUXEqYXxd2B6lzDKfggwO6U2XxIcxWeNow0xoFfqcXYSg7Ga2sCr9uhdwxIdFQNF7SNBpT8ht4fJrRX6mWY1nHybpyTDQ4xoQNQKBgQC6m+yiOoi5JD3zVSSJq/iq5DJPA5B4aoP+t5u9lp2Q7iVO0QI5ilBlEKGE4VOU0glnXlDTfuqEYooMY85ekl4WGb3AOT0PhLL2i+gO2nlWBzf4HPzB/hibjfyPyniRM03cHkG3HXucL7Sne6FwERcfjEqjUd2cdP1l89PNrq4rMQKBgQCMmjABSWYh8/y1I5rEQ4OAJdVjC3GdC1Xa35ZpVybjvLEWSpHunhW5lvD8dllw8LC7UTI0XDpGPqTM/4VO2YBYB2PFc0Gs8g0/v0ZgFpOeJ6kpl80MM/wFNemFYTIKRoMSv/psZY9PmfBgGcBBTuquBXZjDcNr+yr2yAm5V/DvTQKBgHqRi94KoF8q5N39IKCkqhJlDH5FkxDktYoKw2rFkPzuzuZz9gghRyj6wXxsG9/2DWMt2dzw0czehFoa/CO188KEadPmRKr6uCmkP2nyKhxNZX+8WnB5G2Sg4DD6BjMpBYz8+qDx5ozx8LDJTYI0V4HLPgMD9JGdbgsXGhlREOkhAoGALr6IQOXnviWNAhCdc7rrsaMLMPbLZ1wqzWtQUG1JxDobbpzEP4CW/mvW5pMn58mSBg5qbXhyDI4fFP0CPb98QIz2tGnIzYyFzdKmF5Z1N7X1OF9O+tsSqASoBZzTqB4fr/o4mz0s9JCeriBR2LWjsbsDU13DTLsfQpWbtOnIy70=";
-        
-        System.out.println("========== 密钥分析开始 ==========");
-        System.out.println("密钥长度: " + privateKeyBase64.length());
-        
-        byte[] keyBytes = Base64.getDecoder().decode(privateKeyBase64);
-        System.out.println("解码后长度: " + keyBytes.length + " bytes");
-        
-        // 打印前30字节
-        System.out.print("前30字节(hex): ");
-        for (int i = 0; i < 30 && i < keyBytes.length; i++) {
-            System.out.printf("%02X ", keyBytes[i]);
-        }
-        System.out.println();
-        
-        // 解析ASN.1结构
-        try {
-            parseASN1(keyBytes);
-        } catch (Exception e) {
-            System.out.println("解析失败: " + e.getMessage());
-            e.printStackTrace();
-        }
-    }
-    
-    static void parseASN1(byte[] keyBytes) throws Exception {
-        ByteArrayInputStream bis = new ByteArrayInputStream(keyBytes);
-        
-        // 读取SEQUENCE
-        int tag = bis.read();
-        System.out.println("第一个tag: 0x" + Integer.toHexString(tag));
-        
-        if (tag == 0x30) {
-            System.out.println("这是SEQUENCE");
-            
-            // 读取长度
-            int len = readASN1Length(bis);
-            System.out.println("SEQUENCE长度: " + len);
-            
-            // 检查下一个tag
-            int nextTag = bis.read();
-            System.out.println("下一个tag: 0x" + Integer.toHexString(nextTag));
-            
-            if (nextTag == 0x02) {
-                // INTEGER
-                int intLen = readASN1Length(bis);
-                byte[] versionBytes = new byte[intLen];
-                bis.read(versionBytes);
-                int version = new BigInteger(versionBytes).intValue();
-                System.out.println("版本INTEGER值: " + version);
-                
-                // 检查这是PKCS#8还是PKCS#1
-                // PKCS#8: version=0后是SEQUENCE(算法标识符)
-                // PKCS#1: version=0后是INTEGER(modulus)
-                int afterVersionTag = bis.read();
-                System.out.println("版本后的tag: 0x" + Integer.toHexString(afterVersionTag));
-                
-                if (afterVersionTag == 0x30) {
-                    System.out.println(">>> 这是PKCS#8格式 (version后是SEQUENCE)");
-                    
-                    // 解析PKCS#8
-                    // AlgorithmIdentifier: SEQUENCE { OID, NULL }
-                    int algLen = readASN1Length(bis);
-                    System.out.println("AlgorithmIdentifier长度: " + algLen);
-                    
-                    // 跳过AlgorithmIdentifier内容
-                    byte[] algBytes = new byte[algLen];
-                    bis.read(algBytes);
-                    
-                    // 打印OID
-                    System.out.print("OID bytes: ");
-                    for (int i = 0; i < algBytes.length; i++) {
-                        System.out.printf("%02X ", algBytes[i]);
-                    }
-                    System.out.println();
-                    
-                    // 下一个应该是OCTET STRING (包含私钥)
-                    int octetTag = bis.read();
-                    System.out.println("下一个tag: 0x" + Integer.toHexString(octetTag));
-                    
-                    if (octetTag == 0x04) {
-                        System.out.println("这是OCTET STRING (包含私钥数据)");
-                        int octetLen = readASN1Length(bis);
-                        System.out.println("OCTET STRING长度: " + octetLen);
-                        
-                        // OCTET STRING内容是PKCS#1私钥
-                        byte[] pkcs1Bytes = new byte[octetLen];
-                        bis.read(pkcs1Bytes);
-                        
-                        System.out.print("PKCS#1私钥前20字节: ");
-                        for (int i = 0; i < 20; i++) {
-                            System.out.printf("%02X ", pkcs1Bytes[i]);
-                        }
-                        System.out.println();
-                        
-                        // 解析PKCS#1私钥
-                        ByteArrayInputStream pkcs1Stream = new ByteArrayInputStream(pkcs1Bytes);
-                        int pkcs1Tag = pkcs1Stream.read();
-                        System.out.println("PKCS#1第一个tag: 0x" + Integer.toHexString(pkcs1Tag));
-                        
-                        if (pkcs1Tag == 0x30) {
-                            int pkcs1Len = readASN1Length(pkcs1Stream);
-                            System.out.println("PKCS#1 SEQUENCE长度: " + pkcs1Len);
-                            
-                            // version
-                            int vTag = pkcs1Stream.read();
-                            int vLen = readASN1Length(pkcs1Stream);
-                            byte[] vBytes = new byte[vLen];
-                            pkcs1Stream.read(vBytes);
-                            System.out.println("PKCS#1版本: " + new BigInteger(vBytes));
-                            
-                            // 解析私钥参数
-                            parsePKCS1(pkcs1Stream);
-                        }
-                    }
-                } else if (afterVersionTag == 0x02) {
-                    System.out.println(">>> 这是PKCS#1格式 (version后是INTEGER)");
-                    
-                    // 继续解析PKCS#1
-                    parsePKCS1(bis);
-                } else {
-                    System.out.println(">>> 未知格式 (tag: 0x" + Integer.toHexString(afterVersionTag) + ")");
-                }
-            }
-        }
-    }
-    
-    static void parsePKCS1(ByteArrayInputStream bis) throws Exception {
-        System.out.println("\n========== 解析PKCS#1私钥参数 ==========");
-        
-        // modulus
-        BigInteger modulus = readASN1Integer(bis);
-        System.out.println("modulus长度: " + modulus.bitLength() + " bits");
-        
-        // publicExponent
-        BigInteger publicExponent = readASN1Integer(bis);
-        System.out.println("publicExponent: " + publicExponent);
-        
-        // privateExponent
-        BigInteger privateExponent = readASN1Integer(bis);
-        System.out.println("privateExponent长度: " + privateExponent.bitLength() + " bits");
-        
-        // prime1
-        BigInteger prime1 = readASN1Integer(bis);
-        System.out.println("prime1长度: " + prime1.bitLength() + " bits");
-        
-        // prime2
-        BigInteger prime2 = readASN1Integer(bis);
-        System.out.println("prime2长度: " + prime2.bitLength() + " bits");
-        
-        // 验证 prime1 * prime2 == modulus
-        BigInteger calculatedModulus = prime1.multiply(prime2);
-        boolean valid = calculatedModulus.equals(modulus);
-        System.out.println("\n验证 prime1 * prime2 == modulus: " + valid);
-        
-        if (!valid) {
-            System.out.println(">>> 密钥数学关系不正确！这是无效的RSA私钥");
-            System.out.println("计算得到的modulus长度: " + calculatedModulus.bitLength() + " bits");
-        }
-        
-        // exponent1
-        BigInteger exponent1 = readASN1Integer(bis);
-        System.out.println("exponent1长度: " + exponent1.bitLength() + " bits");
-        
-        // exponent2
-        BigInteger exponent2 = readASN1Integer(bis);
-        System.out.println("exponent2长度: " + exponent2.bitLength() + " bits");
-        
-        // coefficient
-        BigInteger coefficient = readASN1Integer(bis);
-        System.out.println("coefficient长度: " + coefficient.bitLength() + " bits");
-        
-        System.out.println("\n========== 解析完成 ==========");
-    }
-    
-    static int readASN1Length(ByteArrayInputStream bis) throws Exception {
-        int firstByte = bis.read();
-        if ((firstByte & 0x80) == 0) {
-            return firstByte;
-        }
-        int numBytes = firstByte & 0x7F;
-        int length = 0;
-        for (int i = 0; i < numBytes; i++) {
-            length = (length << 8) | (bis.read() & 0xFF);
-        }
-        return length;
-    }
-    
-    static BigInteger readASN1Integer(ByteArrayInputStream bis) throws Exception {
-        int tag = bis.read();
-        if (tag != 0x02) throw new Exception("期望INTEGER tag: 0x02, 实际: 0x" + Integer.toHexString(tag));
-        int len = readASN1Length(bis);
-        byte[] data = new byte[len];
-        bis.read(data);
-        return new BigInteger(1, data);
-    }
-}

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

@@ -0,0 +1,407 @@
+-- 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/datacount-api.md

@@ -1,452 +0,0 @@
-# 数据统计模块 API 文档
-
-> **文档版本**: v1.0  
-> **创建日期**: 2026-06-09  
-> **作者**: system  
-> **状态**: 正式发布  
-
----
-
-## 📋 目录
-
-1. [概述](#概述)
-2. [基础路径](#基础路径)
-3. [统计数据接口](#统计数据接口)
-   - [获取综合统计数据](#获取综合统计数据)
-   - [获取会员统计数据](#获取会员统计数据)
-   - [获取预约统计数据](#获取预约统计数据)
-   - [获取签到统计数据](#获取签到统计数据)
-   - [查询历史统计数据](#查询历史统计数据)
-   - [导出统计数据](#导出统计数据)
-4. [数据模型](#数据模型)
-   - [StatisticsQuery（查询条件）](#StatisticsQuery查询条件)
-   - [StatisticsSummary（统计汇总）](#StatisticsSummary统计汇总)
-   - [MemberStatistics（会员统计）](#MemberStatistics会员统计)
-   - [BookingStatistics（预约统计）](#BookingStatistics预约统计)
-   - [SignInStatistics（签到统计）](#SignInStatistics签到统计)
-5. [状态码说明](#状态码说明)
-6. [业务规则](#业务规则)
-
----
-
-## 概述
-
-数据统计模块提供健身房会员、预约、签到数据的统计功能，支持按日、周、月周期统计，并提供Excel导出功能。采用 Spring WebFlux 响应式编程，统计结果通过 Redis 缓存提高查询性能。
-
-## 基础路径
-
-所有接口的基础路径为: `http://{host}:{port}/api/datacount`
-
----
-
-## 统计数据接口
-
-### 获取综合统计数据
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | GET |
-| **接口路径** | `/api/datacount/summary` |
-| **所属文件** | `DataStatisticsHandler.java` |
-
-**请求参数**:
-
-| 参数名 | 类型 | 必填 | 默认值 | 说明 |
-|--------|------|------|--------|------|
-| statType | string | 否 | 空 | 统计类型筛选 |
-| periodType | string | 否 | DAY | 统计周期：DAY/WEEK/MONTH |
-| startTime | string | 否 | 自动计算 | 开始时间（ISO格式） |
-| endTime | string | 否 | 自动计算 | 结束时间（ISO格式） |
-
-**请求示例**:
-
-```bash
-# 1. 使用周期类型查询今日统计
-GET /api/datacount/summary?periodType=DAY
-
-# 2. 使用周期类型查询本周统计
-GET /api/datacount/summary?periodType=WEEK
-
-# 3. 使用周期类型查询本月统计
-GET /api/datacount/summary?periodType=MONTH
-
-# 4. 使用自定义时间范围查询
-GET /api/datacount/summary?startTime=2026-06-01T00:00:00&endTime=2026-06-07T23:59:59
-
-# 5. 带统计类型筛选
-GET /api/datacount/summary?statType=member&periodType=WEEK
-```
-
-**成功响应** (200 OK):
-
-```json
-{
-  "statDate": "2026-06-09",
-  "generatedAt": "2026-06-09T10:30:00",
-  "memberStatistics": {
-    "statDate": "2026-06-09",
-    "newMembers": 5,
-    "activeMembers": 120,
-    "totalMembers": 500,
-    "signInMembers": 85,
-    "bookingMembers": 45,
-    "cancelMembers": 5
-  },
-  "bookingStatistics": {
-    "statDate": "2026-06-09",
-    "totalBookings": 60,
-    "cancelBookings": 10,
-    "attendBookings": 45,
-    "absentBookings": 5,
-    "attendRate": 75.0,
-    "cancelRate": 16.67
-  },
-  "signInStatistics": {
-    "statDate": "2026-06-09",
-    "totalSignIns": 95,
-    "successSignIns": 92,
-    "failSignIns": 3,
-    "successRate": 96.84,
-    "signInTypeDistribution": {
-      "QR_CODE": 60,
-      "MANUAL": 25,
-      "FACE": 10
-    }
-  }
-}
-```
-
----
-
-### 获取会员统计数据
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | GET |
-| **接口路径** | `/api/datacount/member` |
-| **所属文件** | `DataStatisticsHandler.java` |
-
-**请求参数**:
-
-| 参数名 | 类型 | 必填 | 默认值 | 说明 |
-|--------|------|------|--------|------|
-| periodType | string | 否 | DAY | 统计周期：DAY/WEEK/MONTH |
-| startTime | string | 否 | 自动计算 | 开始时间 |
-| endTime | string | 否 | 自动计算 | 结束时间 |
-
-**请求示例**:
-
-```bash
-# 1. 查询今日会员统计
-GET /api/datacount/member
-
-# 2. 查询本周会员统计
-GET /api/datacount/member?periodType=WEEK
-
-# 3. 查询指定时间范围的会员统计
-GET /api/datacount/member?startTime=2026-06-01T00:00:00&endTime=2026-06-30T23:59:59
-```
-
-**成功响应** (200 OK):
-
-```json
-{
-  "statDate": "2026-06-09",
-  "newMembers": 5,
-  "activeMembers": 120,
-  "totalMembers": 500,
-  "signInMembers": 85,
-  "bookingMembers": 45,
-  "cancelMembers": 5
-}
-```
-
----
-
-### 获取预约统计数据
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | GET |
-| **接口路径** | `/api/datacount/booking` |
-| **所属文件** | `DataStatisticsHandler.java` |
-
-**请求参数**:
-
-| 参数名 | 类型 | 必填 | 默认值 | 说明 |
-|--------|------|------|--------|------|
-| periodType | string | 否 | DAY | 统计周期：DAY/WEEK/MONTH |
-| startTime | string | 否 | 自动计算 | 开始时间 |
-| endTime | string | 否 | 自动计算 | 结束时间 |
-
-**请求示例**:
-
-```bash
-# 1. 查询今日预约统计
-GET /api/datacount/booking
-
-# 2. 查询本月预约统计
-GET /api/datacount/booking?periodType=MONTH
-
-# 3. 查询指定日期范围的预约统计
-GET /api/datacount/booking?startTime=2026-06-01T00:00:00&endTime=2026-06-15T23:59:59
-```
-
-**成功响应** (200 OK):
-
-```json
-{
-  "statDate": "2026-06-09",
-  "totalBookings": 60,
-  "cancelBookings": 10,
-  "attendBookings": 45,
-  "absentBookings": 5,
-  "attendRate": 75.0,
-  "cancelRate": 16.67
-}
-```
-
----
-
-### 获取签到统计数据
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | GET |
-| **接口路径** | `/api/datacount/signin` |
-| **所属文件** | `DataStatisticsHandler.java` |
-
-**请求参数**:
-
-| 参数名 | 类型 | 必填 | 默认值 | 说明 |
-|--------|------|------|--------|------|
-| periodType | string | 否 | DAY | 统计周期：DAY/WEEK/MONTH |
-| startTime | string | 否 | 自动计算 | 开始时间 |
-| endTime | string | 否 | 自动计算 | 结束时间 |
-
-**请求示例**:
-
-```bash
-# 1. 查询今日签到统计
-GET /api/datacount/signin
-
-# 2. 查询本周签到统计
-GET /api/datacount/signin?periodType=WEEK
-
-# 3. 查询指定日期范围的签到统计
-GET /api/datacount/signin?startTime=2026-06-01T00:00:00&endTime=2026-06-30T23:59:59
-```
-
-**成功响应** (200 OK):
-
-```json
-{
-  "statDate": "2026-06-09",
-  "totalSignIns": 95,
-  "successSignIns": 92,
-  "failSignIns": 3,
-  "successRate": 96.84,
-  "signInTypeDistribution": {
-    "QR_CODE": 60,
-    "MANUAL": 25,
-    "FACE": 10
-  }
-}
-```
-
----
-
-### 查询历史统计数据
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | GET |
-| **接口路径** | `/api/datacount/history` |
-| **所属文件** | `DataStatisticsHandler.java` |
-
-**请求参数**:
-
-| 参数名 | 类型 | 必填 | 默认值 | 说明 |
-|--------|------|------|--------|------|
-| statType | string | 否 | 空 | 统计类型：member/booking/signin |
-| startTime | string | 是 | - | 开始日期（格式：yyyy-MM-dd） |
-| endTime | string | 是 | - | 结束日期（格式：yyyy-MM-dd） |
-
-**请求示例**:
-
-```bash
-# 1. 查询指定日期范围的签到历史统计
-GET /api/datacount/history?statType=signin&startTime=2026-06-01&endTime=2026-06-30
-
-# 2. 查询指定日期范围的会员历史统计
-GET /api/datacount/history?statType=member&startTime=2026-06-01&endTime=2026-06-15
-
-# 3. 查询指定日期范围的预约历史统计
-GET /api/datacount/history?statType=booking&startTime=2026-06-01&endTime=2026-06-30
-
-# 4. 查询所有类型的历史统计（不指定statType）
-GET /api/datacount/history?startTime=2026-06-01&endTime=2026-06-07
-```
-
-**成功响应** (200 OK):
-
-```json
-[
-  {
-    "statDate": "2026-06-07",
-    "totalSignIns": 88,
-    "successSignIns": 86,
-    "failSignIns": 2,
-    "successRate": 97.73,
-    "signInTypeDistribution": {
-      "QR_CODE": 55,
-      "MANUAL": 23,
-      "FACE": 10
-    }
-  },
-  {
-    "statDate": "2026-06-08",
-    "totalSignIns": 92,
-    "successSignIns": 90,
-    "failSignIns": 2,
-    "successRate": 97.83,
-    "signInTypeDistribution": {
-      "QR_CODE": 58,
-      "MANUAL": 24,
-      "FACE": 10
-    }
-  }
-]
-```
-
----
-
-### 导出统计数据
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | GET |
-| **接口路径** | `/api/datacount/export` |
-| **所属文件** | `DataStatisticsHandler.java` |
-
-**请求参数**:
-
-| 参数名 | 类型 | 必填 | 默认值 | 说明 |
-|--------|------|------|--------|------|
-| periodType | string | 否 | DAY | 统计周期：DAY/WEEK/MONTH |
-| startTime | string | 否 | 自动计算 | 开始时间 |
-| endTime | string | 否 | 自动计算 | 结束时间 |
-
-**请求示例**:
-
-```bash
-# 1. 导出今日统计数据
-GET /api/datacount/export
-
-# 2. 导出本周统计数据
-GET /api/datacount/export?periodType=WEEK
-
-# 3. 导出本月统计数据
-GET /api/datacount/export?periodType=MONTH
-
-# 4. 导出指定时间范围的统计数据
-GET /api/datacount/export?startTime=2026-06-01T00:00:00&endTime=2026-06-30T23:59:59
-```
-
-**成功响应** (200 OK):
-
-返回 Excel 文件（.xlsx），包含以下 Sheet：
-- **会员统计**: 会员相关统计数据
-- **预约统计**: 预约相关统计数据  
-- **签到统计**: 签到相关统计数据
-
-**Content-Type**: `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`
-
----
-
-## 数据模型
-
-### StatisticsQuery（查询条件）
-
-| 字段名 | 类型 | 说明 |
-|--------|------|------|
-| statType | String | 统计类型筛选 |
-| periodType | String | 统计周期：DAY/WEEK/MONTH |
-| startTime | LocalDateTime | 开始时间 |
-| endTime | LocalDateTime | 结束时间 |
-
-### StatisticsSummary（统计汇总）
-
-| 字段名 | 类型 | 说明 |
-|--------|------|------|
-| statDate | String | 统计日期 |
-| generatedAt | String | 生成时间 |
-| memberStatistics | MemberStatistics | 会员统计数据 |
-| bookingStatistics | BookingStatistics | 预约统计数据 |
-| signInStatistics | SignInStatistics | 签到统计数据 |
-
-### MemberStatistics（会员统计）
-
-| 字段名 | 类型 | 说明 |
-|--------|------|------|
-| statDate | String | 统计日期 |
-| newMembers | Long | 新增会员数 |
-| activeMembers | Long | 活跃会员数 |
-| totalMembers | Long | 累计会员总数 |
-| signInMembers | Long | 签到会员数 |
-| bookingMembers | Long | 预约会员数 |
-| cancelMembers | Long | 取消预约会员数 |
-
-### BookingStatistics（预约统计）
-
-| 字段名 | 类型 | 说明 |
-|--------|------|------|
-| statDate | String | 统计日期 |
-| totalBookings | Long | 预约总数 |
-| cancelBookings | Long | 取消预约数 |
-| attendBookings | Long | 出席预约数 |
-| absentBookings | Long | 缺席预约数 |
-| attendRate | Double | 出席率（%） |
-| cancelRate | Double | 取消率（%） |
-
-### SignInStatistics（签到统计）
-
-| 字段名 | 类型 | 说明 |
-|--------|------|------|
-| statDate | String | 统计日期 |
-| totalSignIns | Long | 签到总次数 |
-| successSignIns | Long | 成功签到次数 |
-| failSignIns | Long | 失败签到次数 |
-| successRate | Double | 签到成功率（%） |
-| signInTypeDistribution | Map<String, Long> | 签到类型分布 |
-
----
-
-## 状态码说明
-
-| 状态码 | 说明 |
-|--------|------|
-| 200 | 请求成功 |
-| 400 | 请求参数错误 |
-| 500 | 服务器内部错误 |
-
----
-
-## 业务规则
-
-1. **统计周期**: 支持按日、周、月统计
-   - DAY: 当天 00:00:00 - 当前时间
-   - WEEK: 本周一 00:00:00 - 本周日 23:59:59
-   - MONTH: 本月1日 00:00:00 - 本月最后一天 23:59:59
-
-2. **数据保留**: 统计数据缓存30天，业务记录永久保存
-
-3. **缓存策略**: 查询结果缓存1小时，统计数据缓存30天
-
-4. **定时任务**: 
-   - 每日凌晨2点执行前一天的日统计
-   - 每周一凌晨3点执行上周的周统计
-   - 每月1日凌晨3点执行上月的月统计
-   - 每月15日凌晨4点清理30天前的旧数据
-
-5. **数据导出**: 支持Excel格式导出，包含会员、预约、签到三个Sheet

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

@@ -1,530 +0,0 @@
-# 团课推荐模块 API 文档
-
-> **文档版本**: v1.0  
-> **创建日期**: 2026-06-15  
-> **作者**: 张翔  
-> **状态**: 正式发布  
-
----
-
-## 📋 目录
-
-1. [概述](#概述)
-2. [基础路径](#基础路径)
-3. [团课推荐管理接口](#团课推荐管理接口)
-   - [获取所有团课推荐](#获取所有团课推荐)
-   - [获取所有启用的团课推荐](#获取所有启用的团课推荐)
-   - [根据ID获取团课推荐](#根据ID获取团课推荐)
-   - [根据团课ID获取推荐](#根据团课ID获取推荐)
-   - [创建团课推荐](#创建团课推荐)
-   - [更新团课推荐](#更新团课推荐)
-   - [删除团课推荐](#删除团课推荐)
-   - [启用团课推荐](#启用团课推荐)
-   - [禁用团课推荐](#禁用团课推荐)
-4. [数据模型](#数据模型)
-   - [GroupCourseRecommend（团课推荐）](#GroupCourseRecommend团课推荐)
-5. [状态码说明](#状态码说明)
-6. [业务规则](#业务规则)
-
----
-
-## 概述
-
-团课推荐模块提供团课推荐信息的创建、编辑、查询、删除和状态管理功能。推荐信息包含团课ID、推荐标题、推荐内容、推荐理由、优先级等必要信息，支持按优先级排序展示。
-
-## 基础路径
-
-所有接口的基础路径为: `http://{host}:{port}/api/groupCourse/recommend`
-
----
-
-## 团课推荐管理接口
-
-### 获取所有团课推荐
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | GET |
-| **接口路径** | `/api/groupCourse/recommend/list` |
-| **所属文件** | `GroupCourseRecommendHandler.java` |
-
-**请求参数**:
-
-| 参数名 | 类型 | 必填 | 默认值 | 说明 |
-|--------|------|------|--------|------|
-| sortBy | string | 否 | priority | 排序字段（支持：priority、createdAt、updatedAt） |
-| sortOrder | string | 否 | desc | 排序方式（asc-升序，desc-降序） |
-
-**成功响应** (200 OK):
-
-```json
-[
-  {
-    "id": 1,
-    "courseId": 1,
-    "recommendTitle": "本周热门课程",
-    "recommendContent": "这是一门非常棒的课程，快来参加吧！",
-    "recommendReason": "教练专业，课程内容丰富",
-    "priority": 10,
-    "isActive": true,
-    "groupCourse": {
-      "id": 1,
-      "courseName": "瑜伽入门",
-      "coachId": 1,
-      "courseType": 1,
-      "startTime": "2026-06-15T09:00:00",
-      "endTime": "2026-06-15T10:00:00",
-      "maxMembers": 20,
-      "currentMembers": 15,
-      "status": 0,
-      "location": "健身房A区",
-      "coverImage": "https://example.com/yoga.jpg",
-      "description": "适合初学者的瑜伽课程"
-    },
-    "createdAt": "2026-06-15T10:00:00",
-    "updatedAt": "2026-06-15T10:00:00"
-  }
-]
-```
-
----
-
-### 获取所有启用的团课推荐
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | GET |
-| **接口路径** | `/api/groupCourse/recommend/active` |
-| **所属文件** | `GroupCourseRecommendHandler.java` |
-
-**功能说明**: 获取系统中所有已启用的团课推荐列表，按优先级从高到低排序。
-
-**成功响应** (200 OK):
-
-```json
-[
-  {
-    "id": 2,
-    "courseId": 3,
-    "recommendTitle": "新学员推荐",
-    "recommendContent": "专为新学员设计的入门课程，轻松上手",
-    "recommendReason": "零基础友好，教练耐心指导",
-    "priority": 20,
-    "isActive": true,
-    "groupCourse": {
-      "id": 3,
-      "courseName": "基础有氧",
-      "coachId": 2,
-      "courseType": 2,
-      "startTime": "2026-06-16T18:00:00",
-      "endTime": "2026-06-16T19:00:00",
-      "maxMembers": 30,
-      "currentMembers": 8,
-      "status": 0,
-      "location": "健身房B区",
-      "coverImage": "https://example.com/aerobic.jpg",
-      "description": "适合所有健身水平的有氧课程"
-    },
-    "createdAt": "2026-06-15T11:00:00",
-    "updatedAt": "2026-06-15T11:00:00"
-  }
-]
-```
-
----
-
-### 根据ID获取团课推荐
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | GET |
-| **接口路径** | `/api/groupCourse/recommend/{id}` |
-| **所属文件** | `GroupCourseRecommendHandler.java` |
-
-**路径参数**:
-
-| 参数名 | 类型 | 必填 | 说明 |
-|--------|------|------|------|
-| id | Long | 是 | 团课推荐ID |
-
-**成功响应** (200 OK):
-
-```json
-{
-  "id": 1,
-  "courseId": 1,
-  "recommendTitle": "本周热门课程",
-  "recommendContent": "这是一门非常棒的课程，快来参加吧！",
-  "recommendReason": "教练专业，课程内容丰富",
-  "priority": 10,
-  "isActive": true,
-  "groupCourse": {
-    "id": 1,
-    "courseName": "瑜伽入门",
-    "coachId": 1,
-    "courseType": 1,
-    "startTime": "2026-06-15T09:00:00",
-    "endTime": "2026-06-15T10:00:00",
-    "maxMembers": 20,
-    "currentMembers": 15,
-    "status": 0,
-    "location": "健身房A区",
-    "coverImage": "https://example.com/yoga.jpg",
-    "description": "适合初学者的瑜伽课程"
-  },
-  "createdAt": "2026-06-15T10:00:00",
-  "updatedAt": "2026-06-15T10:00:00"
-}
-```
-
-**失败响应** (404 Not Found):
-
-```json
-{}
-```
-
----
-
-### 根据团课ID获取推荐
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | GET |
-| **接口路径** | `/api/groupCourse/recommend/course/{courseId}` |
-| **所属文件** | `GroupCourseRecommendHandler.java` |
-
-**路径参数**:
-
-| 参数名 | 类型 | 必填 | 说明 |
-|--------|------|------|------|
-| courseId | Long | 是 | 团课ID |
-
-**成功响应** (200 OK):
-
-```json
-[
-  {
-    "id": 1,
-    "courseId": 1,
-    "recommendTitle": "本周热门课程",
-    "recommendContent": "这是一门非常棒的课程，快来参加吧！",
-    "recommendReason": "教练专业，课程内容丰富",
-    "priority": 10,
-    "isActive": true,
-    "groupCourse": {
-      "id": 1,
-      "courseName": "瑜伽入门",
-      "coachId": 1,
-      "courseType": 1,
-      "startTime": "2026-06-15T09:00:00",
-      "endTime": "2026-06-15T10:00:00",
-      "maxMembers": 20,
-      "currentMembers": 15,
-      "status": 0,
-      "location": "健身房A区"
-    },
-    "createdAt": "2026-06-15T10:00:00",
-    "updatedAt": "2026-06-15T10:00:00"
-  }
-]
-```
-
----
-
-### 创建团课推荐
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | POST |
-| **接口路径** | `/api/groupCourse/recommend` |
-| **所属文件** | `GroupCourseRecommendHandler.java` |
-
-**请求体**:
-
-```json
-{
-  "courseId": 1,
-  "recommendTitle": "本周热门课程",
-  "recommendContent": "这是一门非常棒的课程，快来参加吧！",
-  "recommendReason": "教练专业，课程内容丰富",
-  "priority": 10,
-  "isActive": true
-}
-```
-
-| 参数名 | 类型 | 必填 | 默认值 | 说明 |
-|--------|------|------|--------|------|
-| courseId | Long | **是** | - | 团课ID（必须是有效的团课） |
-| recommendTitle | String | 否 | - | 推荐标题 |
-| recommendContent | String | 否 | - | 推荐内容 |
-| recommendReason | String | 否 | - | 推荐理由 |
-| priority | Integer | 否 | 0 | 优先级（数字越大优先级越高） |
-| isActive | Boolean | 否 | true | 是否启用 |
-
-**成功响应** (200 OK):
-
-```json
-{
-  "success": true,
-  "message": "团课推荐创建成功",
-  "data": {
-    "id": 1,
-    "courseId": 1,
-    "recommendTitle": "本周热门课程",
-    "recommendContent": "这是一门非常棒的课程，快来参加吧！",
-    "recommendReason": "教练专业，课程内容丰富",
-    "priority": 10,
-    "isActive": true,
-    "createdAt": "2026-06-15T10:00:00",
-    "updatedAt": "2026-06-15T10:00:00"
-  }
-}
-```
-
-**失败响应** (400 Bad Request):
-
-```json
-{
-  "success": false,
-  "message": "团课ID不能为空"
-}
-```
-
----
-
-### 更新团课推荐
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | PUT |
-| **接口路径** | `/api/groupCourse/recommend/{id}` |
-| **所属文件** | `GroupCourseRecommendHandler.java` |
-
-**路径参数**:
-
-| 参数名 | 类型 | 必填 | 说明 |
-|--------|------|------|------|
-| id | Long | 是 | 团课推荐ID |
-
-**请求体**:
-
-```json
-{
-  "recommendTitle": "本周热门课程（更新）",
-  "recommendContent": "更新后的推荐内容",
-  "recommendReason": "更新后的推荐理由",
-  "priority": 15,
-  "isActive": true
-}
-```
-
-| 参数名 | 类型 | 必填 | 说明 |
-|--------|------|------|------|
-| courseId | Long | 否 | 团课ID |
-| recommendTitle | String | 否 | 推荐标题 |
-| recommendContent | String | 否 | 推荐内容 |
-| recommendReason | String | 否 | 推荐理由 |
-| priority | Integer | 否 | 优先级 |
-| isActive | Boolean | 否 | 是否启用 |
-
-**成功响应** (200 OK):
-
-```json
-{
-  "success": true,
-  "message": "团课推荐更新成功",
-  "data": {
-    "id": 1,
-    "courseId": 1,
-    "recommendTitle": "本周热门课程（更新）",
-    "recommendContent": "更新后的推荐内容",
-    "recommendReason": "更新后的推荐理由",
-    "priority": 15,
-    "isActive": true,
-    "updatedAt": "2026-06-15T12:00:00"
-  }
-}
-```
-
-**失败响应** (400 Bad Request):
-
-```json
-{
-  "success": false,
-  "message": "团课推荐不存在"
-}
-```
-
----
-
-### 删除团课推荐
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | DELETE |
-| **接口路径** | `/api/groupCourse/recommend/{id}` |
-| **所属文件** | `GroupCourseRecommendHandler.java` |
-
-**路径参数**:
-
-| 参数名 | 类型 | 必填 | 说明 |
-|--------|------|------|------|
-| id | Long | 是 | 团课推荐ID |
-
-**成功响应** (200 OK):
-
-```json
-{
-  "success": true,
-  "message": "团课推荐删除成功"
-}
-```
-
-**失败响应** (400 Bad Request):
-
-```json
-{
-  "success": false,
-  "message": "团课推荐不存在"
-}
-```
-
----
-
-### 启用团课推荐
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | POST |
-| **接口路径** | `/api/groupCourse/recommend/{id}/enable` |
-| **所属文件** | `GroupCourseRecommendHandler.java` |
-
-**路径参数**:
-
-| 参数名 | 类型 | 必填 | 说明 |
-|--------|------|------|------|
-| id | Long | 是 | 团课推荐ID |
-
-**成功响应** (200 OK):
-
-```json
-{
-  "success": true,
-  "message": "团课推荐启用成功",
-  "data": {
-    "id": 1,
-    "courseId": 1,
-    "recommendTitle": "本周热门课程",
-    "isActive": true
-  }
-}
-```
-
-**失败响应** (400 Bad Request):
-
-```json
-{
-  "success": false,
-  "message": "团课推荐不存在"
-}
-```
-
----
-
-### 禁用团课推荐
-
-| 属性 | 值 |
-|------|-----|
-| **HTTP方法** | POST |
-| **接口路径** | `/api/groupCourse/recommend/{id}/disable` |
-| **所属文件** | `GroupCourseRecommendHandler.java` |
-
-**路径参数**:
-
-| 参数名 | 类型 | 必填 | 说明 |
-|--------|------|------|------|
-| id | Long | 是 | 团课推荐ID |
-
-**成功响应** (200 OK):
-
-```json
-{
-  "success": true,
-  "message": "团课推荐禁用成功",
-  "data": {
-    "id": 1,
-    "courseId": 1,
-    "recommendTitle": "本周热门课程",
-    "isActive": false
-  }
-}
-```
-
-**失败响应** (400 Bad Request):
-
-```json
-{
-  "success": false,
-  "message": "团课推荐不存在"
-}
-```
-
----
-
-## 数据模型
-
-### GroupCourseRecommend（团课推荐）
-
-| 字段名 | 类型 | 说明 |
-|--------|------|------|
-| id | Long | 主键ID |
-| courseId | Long | 团课ID（关联group_course.id） |
-| recommendTitle | String | 推荐标题 |
-| recommendContent | String | 推荐内容 |
-| recommendReason | String | 推荐理由 |
-| priority | Integer | 优先级（数字越大优先级越高），默认0 |
-| isActive | Boolean | 是否启用，默认true |
-| groupCourse | GroupCourse | 关联的团课信息（查询时自动填充） |
-| createdBy | String | 创建人 |
-| updatedBy | String | 更新人 |
-| createdAt | LocalDateTime | 创建时间 |
-| updatedAt | LocalDateTime | 更新时间 |
-| deletedAt | LocalDateTime | 删除时间（软删除） |
-
----
-
-## 状态码说明
-
-### 推荐状态
-
-| 状态值 | 含义 |
-|--------|------|
-| true | 启用 |
-| false | 禁用 |
-
----
-
-## 业务规则
-
-### 团课推荐管理
-1. **创建推荐**：团课ID为必填项，且必须是有效的团课
-2. **优先级排序**：获取启用的推荐列表时，按优先级从高到低排序
-3. **删除推荐**：采用软删除机制，数据保留可恢复
-4. **状态管理**：支持启用/禁用推荐状态，禁用的推荐不会在推荐列表中显示
-
----
-
-## 附录：错误响应格式
-
-所有接口的错误响应统一格式：
-
-```json
-{
-  "success": false,
-  "message": "错误描述信息"
-}
-```
-
----
-
-*文档结束*

gym-manage-api/exmp.txt

@@ -1,87 +0,0 @@
-一、基础有氧与热身（难度 1-3）
-
-主要是低冲击、低技巧，用于建立运动基础。
-
-    慢走/椭圆机轻松模式：1（几乎无难度，适合所有人）
-
-    固定自行车（低阻力）：2（注意座椅高度调节即可）
-
-    跑步机慢跑：3（需要基本协调性，膝盖有压力）
-
-    跳绳（连续基础跳）：3（需要手脚配合，心肺要求明显）
-
-二、固定器械训练（难度 2-5）
-
-轨迹固定，主要考验力量和耐力，技巧要求低。
-
-    坐姿腿屈伸/腿弯举：2（很容易找到发力感）
-
-    坐姿推胸机：3（需注意肩胛后收，避免耸肩）
-
-    高位下拉（坐姿）：3（需控制不要过度后仰）
-
-    史密斯机深蹲：4（轨迹固定，但需保持核心稳定）
-
-    蝴蝶机夹胸：3（易用肘关节代偿，需锁定肩关节）
-
-三、自重基础动作（难度 3-7）
-
-需要一定的力量-体重比和身体控制能力。
-
-    平板支撑：3（耐力考验，技巧低）
-
-    跪姿俯卧撑：3（上肢力量较弱者首选）
-
-    标准俯卧撑：5（需核心收紧，身体成直线）
-
-    引体向上（弹力带辅助）：6（背部和手臂力量要求高）
-
-    标准引体向上：8（力量-体重比极高，多数男性无法完成1次）
-
-    徒手深蹲：3（注意膝盖方向与背部直立）
-
-    单腿深蹲（手枪蹲）：8（需要极高下肢力量、柔韧性和平衡）
-
-四、自由重量杠铃/哑铃（难度 5-9）
-
-技巧风险最高，需要神经系统协调和长期动作打磨。
-
-    哑铃二头弯举：4（容易晃动借力，但较安全）
-
-    哑铃侧平举：5（极易用斜方肌代偿，真正练到三角肌中束很难）
-
-    杠铃卧推：7（肩关节压力大，起桥、沉肩、稳定手腕均有技巧，有压伤风险）
-
-    杠铃深蹲（颈后）：8（全身协调性、核心抗压、杠位放置、呼吸模式，学习曲线陡峭）
-
-    传统硬拉：9（风险极高，需要精确的脊柱中立、髋铰链、背阔肌收紧，错误时伤腰）
-
-    高翻/抓举（奥运举重）：10（需要爆发力、柔韧、精准衔接，非数月训练不能掌握）
-
-五、高强度与爆发力（难度 6-10）
-
-对心肺、神经系统和恢复能力要求极高。
-
-    波比跳（标准版）：6（连续做时心肺压力极大）
-
-    冲刺跑（短跑）：7（对腘绳肌和脚踝爆发力要求高）
-
-    跳箱（合理高度）：6（需要落地缓冲技巧）
-
-    负重雪橇推：6（主要考验腿部耐力和意志力）
-
-    双力臂（引体向上后翻腕上杠）：9（需要爆发引体 + 极高相对力量）
-
-六、柔韧与平衡类（难度 3-8）
-
-考验本体感觉和关节活动度。
-
-    静态拉伸（坐姿体前屈）：2（无风险，但需要坚持）
-
-    瑜伽下犬式：3（常见，但需背部与手臂对齐）
-
-    单腿罗马尼亚硬拉（徒手）：6（极考验平衡和髋稳定）
-
-    全深蹲（脚跟贴地，亚洲蹲）：5（踝关节灵活度限制多数人）
-
-    竖叉/横叉：8（需要数月甚至数年拉伸）

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

@@ -1,129 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>cn.novalon.gym.manage</groupId>
-        <artifactId>gym-manage-api</artifactId>
-        <version>1.0.0</version>
-    </parent>
-
-    <artifactId>gym-auth</artifactId>
-    <packaging>jar</packaging>
-
-    <name>Gym Auth</name>
-    <description>Phone Authentication Module - Phone Number Login Services</description>
-
-    <dependencies>
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>manage-common</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>manage-db</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>manage-sys</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>gym-member</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-webflux</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springdoc</groupId>
-            <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-security</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.data</groupId>
-            <artifactId>spring-data-commons</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>io.projectreactor</groupId>
-            <artifactId>reactor-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>cn.hutool</groupId>
-            <artifactId>hutool-all</artifactId>
-            <version>5.8.25</version>
-        </dependency>
-        <!-- 阿里云号码认证服务（新版SDK） -->
-        <dependency>
-            <groupId>com.aliyun</groupId>
-            <artifactId>dypnsapi20170525</artifactId>
-            <version>1.0.6</version>
-        </dependency>
-        <!-- 阿里云一键登录服务（旧版SDK，保留兼容） -->
-        <dependency>
-            <groupId>com.aliyun</groupId>
-            <artifactId>aliyun-java-sdk-dypnsapi</artifactId>
-            <version>1.2.12</version>
-        </dependency>
-        <dependency>
-            <groupId>com.aliyun</groupId>
-            <artifactId>aliyun-java-sdk-core</artifactId>
-            <version>4.6.0</version>
-        </dependency>
-        <dependency>
-            <groupId>com.aliyun</groupId>
-            <artifactId>dysmsapi20170525</artifactId>
-            <version>2.0.0</version>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
-                <version>3.4.2</version>
-                <executions>
-                    <execution>
-                        <id>default-jar</id>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>jar</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.11.0</version>
-                <configuration>
-                    <source>21</source>
-                    <target>21</target>
-                    <annotationProcessorPaths>
-                        <path>
-                            <groupId>org.projectlombok</groupId>
-                            <artifactId>lombok</artifactId>
-                            <version>${lombok.version}</version>
-                        </path>
-                    </annotationProcessorPaths>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-</project>

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

@@ -1,7 +0,0 @@
-package cn.novalon.gym.manage.auth.config;
-
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-public class AuthConfig {
-}

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

@@ -1,18 +0,0 @@
-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 = "dcloud.univerify")
-public class DCloudUniverifyConfig {
-    private String appid;
-    private String appkey;
-    private String apiSecret;
-    private String apiUrl = "https://developer.dcloud.net.cn/api/client/univerify/getPhoneNumber";
-    private String proxyHost;
-    private Integer proxyPort;
-    private Integer timeout = 10000;
-}

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

@@ -1,47 +0,0 @@
-package cn.novalon.gym.manage.auth.config;
-
-import lombok.Data;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-
-/**
- * 阿里云短信配置属性类
- *
- * @author auto-generated
- * @date 2026-06-20
- */
-@Data
-@Configuration
-@ConfigurationProperties(prefix = "alibaba.cloud.sms")
-public class SmsProperties {
-
-    /**
-     * 访问密钥ID
-     */
-    private String accessKeyId;
-
-    /**
-     * 访问密钥密钥
-     */
-    private String accessKeySecret;
-
-    /**
-     * 短信签名名称
-     */
-    private String signName;
-
-    /**
-     * 短信模板CODE
-     */
-    private String templateCode;
-
-    /**
-     * 短信验证码长度（默认6位）
-     */
-    private int codeLength = 6;
-
-    /**
-     * 短信验证码有效期（秒，默认300秒=5分钟）
-     */
-    private long codeExpireSeconds = 300;
-}

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

@@ -1,26 +0,0 @@
-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;
-
-/**
- * 手机号验证码登录请求DTO
- */
-@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

@@ -1,23 +0,0 @@
-package cn.novalon.gym.manage.auth.dto;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class PhoneLoginDto {
-
-    private String phone;
-
-    private String accessToken;
-
-    private String openid;
-
-    private String nickname;
-
-    private String avatar;
-}

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

@@ -1,22 +0,0 @@
-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;
-
-/**
- * 发送短信验证码请求DTO
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class SendCodeRequest {
-
-    @NotBlank(message = "手机号不能为空")
-    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
-    private String phone;
-}

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

@@ -1,25 +0,0 @@
-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;
-
-/**
- * 短信验证码登录请求DTO
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class SmsLoginDto {
-
-    @NotBlank(message = "手机号不能为空")
-    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
-    private String phone;
-
-    @NotBlank(message = "验证码不能为空")
-    private String code;
-}

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

@@ -1,59 +0,0 @@
-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.dto.SendCodeRequest;
-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(SendCodeRequest.class)
-                .flatMap(req -> phoneAuthService.sendSmsCode(req.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

@@ -1,37 +0,0 @@
-package cn.novalon.gym.manage.auth.service;
-
-import cn.novalon.gym.manage.auth.dto.PhoneLoginDto;
-import cn.novalon.gym.manage.auth.dto.PhoneCodeLoginDto;
-import cn.novalon.gym.manage.auth.vo.PhoneLoginVO;
-import reactor.core.publisher.Mono;
-
-/**
- * 手机号认证服务接口
- */
-public interface PhoneAuthService {
-
-    /**
-     * 手机号一键登录（uniapp官方运营商认证）
-     * 已注册则直接登录，未注册则自动注册后登录
-     *
-     * @param request 登录请求
-     * @return 登录响应
-     */
-    Mono<PhoneLoginVO> oneClickLogin(PhoneLoginDto request);
-
-    /**
-     * 发送短信验证码（阿里云）
-     *
-     * @param phone 手机号
-     * @return 是否发送成功
-     */
-    Mono<Boolean> sendSmsCode(String phone);
-
-    /**
-     * 手机号验证码登录（阿里云）
-     *
-     * @param request 登录请求
-     * @return 登录响应
-     */
-    Mono<PhoneLoginVO> codeLogin(PhoneCodeLoginDto request);
-}

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

@@ -1,37 +0,0 @@
-package cn.novalon.gym.manage.auth.service;
-
-import reactor.core.publisher.Mono;
-
-/**
- * 短信服务接口
- *
- * @author auto-generated
- * @date 2026-06-20
- */
-public interface SmsService {
-
-    /**
-     * 发送短信验证码
-     *
-     * @param phone 手机号
-     * @return 发送结果
-     */
-    Mono<Boolean> sendVerificationCode(String phone);
-
-    /**
-     * 验证短信验证码
-     *
-     * @param phone 手机号
-     * @param code  验证码
-     * @return 验证结果
-     */
-    Mono<Boolean> verifyCode(String phone, String code);
-
-    /**
-     * 获取验证码（用于测试或特殊场景）
-     *
-     * @param phone 手机号
-     * @return 验证码
-     */
-    Mono<String> getVerificationCode(String phone);
-}

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

@@ -1,270 +0,0 @@
-package cn.novalon.gym.manage.auth.service.impl;
-
-import cn.novalon.gym.manage.auth.config.DCloudUniverifyConfig;
-import cn.novalon.gym.manage.auth.config.SmsProperties;
-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.http.MediaType;
-import org.springframework.stereotype.Service;
-import org.springframework.web.reactive.function.client.WebClient;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-@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 final SmsProperties smsProperties;
-    private final DCloudUniverifyConfig dCloudUniverifyConfig;
-    
-    private WebClient webClient;
-
-    private EsSyncUtils.EntitySyncer<Member, MemberES, String> memberSyncer;
-
-    @PostConstruct
-    public void init() {
-        this.memberSyncer = esSyncUtils.bind(Member.class, MemberES.class, memberESRepository);
-        this.webClient = WebClient.builder()
-                .baseUrl(dCloudUniverifyConfig.getApiUrl())
-                .defaultHeader("Content-Type", MediaType.APPLICATION_JSON_VALUE)
-                .build();
-    }
-
-    @Override
-    public Mono<PhoneLoginVO> oneClickLogin(PhoneLoginDto request) {
-        log.info("手机号一键登录请求, phone: {}, accessToken: {}, openid: {}", request.getPhone(), request.getAccessToken(), request.getOpenid());
-
-        if (request.getPhone() != null && !request.getPhone().isEmpty()) {
-            log.info("直接使用手机号登录");
-            String encryptedPhone = encryptPhone(request.getPhone());
-            return processPhoneLogin(encryptedPhone, request);
-        }
-
-        if (request.getAccessToken() == null || request.getAccessToken().isEmpty()) {
-            log.error("一键登录失败: accessToken为空");
-            return Mono.error(new SystemException(ErrorCode.AUTH_PHONE_ERROR, "登录凭证无效，请重试"));
-        }
-
-        return getPhoneByDcloudApi(request.getAccessToken(), request.getOpenid())
-                .flatMap(phone -> {
-                    log.info("通过access_token获取手机号成功: {}", maskPhone(phone));
-                    String encryptedPhone = encryptPhone(phone);
-                    return processPhoneLogin(encryptedPhone, request);
-                })
-                .onErrorResume(e -> {
-                    log.error("一键登录失败", e);
-                    return Mono.error(new SystemException(ErrorCode.AUTH_PHONE_ERROR, "手机号获取失败: " + e.getMessage()));
-                });
-    }
-
-    private Mono<PhoneLoginVO> processPhoneLogin(String encryptedPhone, PhoneLoginDto request) {
-        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);
-                }));
-    }
-
-    private Mono<String> getPhoneByDcloudApi(String accessToken, String openid) {
-        Map<String, String> requestBody = new HashMap<>();
-        requestBody.put("appid", dCloudUniverifyConfig.getAppid());
-        requestBody.put("appkey", dCloudUniverifyConfig.getAppkey());
-        requestBody.put("apiSecret", dCloudUniverifyConfig.getApiSecret());
-        requestBody.put("access_token", accessToken);
-        requestBody.put("openid", openid);
-
-        log.info("调用DCloud Univerify API, params: {}", requestBody);
-
-        return webClient.post()
-                .bodyValue(requestBody)
-                .retrieve()
-                .bodyToMono(Map.class)
-                .flatMap(response -> {
-                    log.info("DCloud API响应: {}", response);
-                    
-                    Integer code = (Integer) response.get("code");
-                    Boolean success = (Boolean) response.get("success");
-                    
-                    if ((code != null && code == 0) || (success != null && success)) {
-                        Map<String, Object> data = (Map<String, Object>) response.get("data");
-                        if (data != null) {
-                            String phoneNumber = (String) data.get("phoneNumber");
-                            if (phoneNumber != null && !phoneNumber.isEmpty()) {
-                                return Mono.just(phoneNumber);
-                            }
-                        }
-                        String phoneNumber = (String) response.get("phoneNumber");
-                        if (phoneNumber != null && !phoneNumber.isEmpty()) {
-                            return Mono.just(phoneNumber);
-                        }
-                        String phone = (String) response.get("phone");
-                        if (phone != null && !phone.isEmpty()) {
-                            return Mono.just(phone);
-                        }
-                    }
-                    
-                    String message = (String) response.get("message");
-                    log.warn("DCloud API返回错误: code={}, success={}, message={}", code, success, message);
-                    return Mono.error(new SystemException(ErrorCode.AUTH_PHONE_ERROR, "手机号获取失败: " + message));
-                })
-                .onErrorResume(e -> {
-                    log.error("调用DCloud API失败", e);
-                    return Mono.error(new SystemException(ErrorCode.AUTH_PHONE_ERROR, "手机号获取失败: " + e.getMessage()));
-                });
-    }
-
-    /**
-     * 手机号脱敏显示
-     */
-    private String maskPhone(String phone) {
-        if (phone == null || phone.length() < 11) {
-            return phone;
-        }
-        return phone.substring(0, 3) + "****" + phone.substring(7);
-    }
-
-    @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();
-                                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(member.getPhone() != null ? decryptPhone(member.getPhone()) : null);
-        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

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

@@ -1,36 +0,0 @@
-package cn.novalon.gym.manage.auth.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-/**
- * 手机号一键登录响应VO
- */
-@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

@@ -1,5 +0,0 @@
-cn.novalon.gym.manage.auth.handler.PhoneAuthHandler
-cn.novalon.gym.manage.auth.service.impl.PhoneAuthServiceImpl
-cn.novalon.gym.manage.auth.service.impl.SmsServiceImpl
-cn.novalon.gym.manage.auth.config.AuthConfig
-cn.novalon.gym.manage.auth.config.SmsProperties

gym-manage-api/gym-checkIn/.gitignore

@@ -1,48 +0,0 @@
-# Compiled class file
-*.class
-
-# Log file
-*.log
-
-# BlueJ files
-*.ctxt
-
-# Mobile Tools for Java (J2ME)
-.mtj.tmp/
-
-# Package Files
-*.jar
-*.war
-*.nar
-*.ear
-*.zip
-*.tar.gz
-*.rar
-
-# Virtual machine crash logs
-hs_err_pid*
-replay_pid*
-
-# Maven
-target/
-pom.xml.tag
-pom.xml.releaseBackup
-pom.xml.versionsBackup
-pom.xml.next
-release.properties
-dependency-reduced-pom.xml
-buildNumber.properties
-.mvn/timing.properties
-.mvn/wrapper/maven-wrapper.jar
-
-# IDE
-.idea/
-*.iml
-.vscode/
-.settings/
-.classpath
-.project
-
-# OS
-.DS_Store
-Thumbs.db

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

@@ -1,257 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>cn.novalon.gym.manage</groupId>
-        <artifactId>gym-manage-api</artifactId>
-        <version>1.0.0</version>
-    </parent>
-
-    <artifactId>gym-checkIn</artifactId>
-    <packaging>jar</packaging>
-
-    <name>Gym CheckIn</name>
-    <description>Check-In Management Module - Member Attendance Services</description>
-
-    <dependencies>
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>manage-common</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>manage-db</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>gym-member</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>gym-groupCourse</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-webflux</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-aop</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springdoc</groupId>
-            <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-security</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.data</groupId>
-            <artifactId>spring-data-commons</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.security</groupId>
-            <artifactId>spring-security-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>io.projectreactor</groupId>
-            <artifactId>reactor-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>io.github.resilience4j</groupId>
-            <artifactId>resilience4j-spring-boot3</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.github.resilience4j</groupId>
-            <artifactId>resilience4j-reactor</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.testcontainers</groupId>
-            <artifactId>testcontainers</artifactId>
-            <version>1.21.4</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.testcontainers</groupId>
-            <artifactId>postgresql</artifactId>
-            <version>1.21.4</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.testcontainers</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <version>1.21.4</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.h2database</groupId>
-            <artifactId>h2</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>io.r2dbc</groupId>
-            <artifactId>r2dbc-h2</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.postgresql</groupId>
-            <artifactId>r2dbc-postgresql</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>cn.hutool</groupId>
-            <artifactId>hutool-all</artifactId>
-            <version>5.8.25</version>
-        </dependency>
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.google.zxing</groupId>
-            <artifactId>core</artifactId>
-            <version>3.5.1</version>
-        </dependency>
-
-        <!-- 添加 ZXing JavaSE 扩展（用于生成图片） -->
-        <dependency>
-            <groupId>com.google.zxing</groupId>
-            <artifactId>javase</artifactId>
-            <version>3.5.1</version>
-        </dependency>
-
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-websocket</artifactId>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
-                <version>3.4.2</version>
-                <executions>
-                    <execution>
-                        <id>default-jar</id>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>jar</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.11.0</version>
-                <configuration>
-                    <source>21</source>
-                    <target>21</target>
-                    <annotationProcessorPaths>
-                        <path>
-                            <groupId>org.mapstruct</groupId>
-                            <artifactId>mapstruct-processor</artifactId>
-                            <version>1.5.5.Final</version>
-                        </path>
-                        <path>
-                            <groupId>org.projectlombok</groupId>
-                            <artifactId>lombok</artifactId>
-                            <version>${lombok.version}</version>
-                        </path>
-                        <path>
-                            <groupId>org.projectlombok</groupId>
-                            <artifactId>lombok-mapstruct-binding</artifactId>
-                            <version>0.2.0</version>
-                        </path>
-                    </annotationProcessorPaths>
-                </configuration>
-            </plugin>
-            <plugin>
-                <groupId>org.jacoco</groupId>
-                <artifactId>jacoco-maven-plugin</artifactId>
-                <version>0.8.12</version>
-                <executions>
-                    <execution>
-                        <id>prepare-agent</id>
-                        <goals>
-                            <goal>prepare-agent</goal>
-                        </goals>
-                    </execution>
-                    <execution>
-                        <id>report</id>
-                        <phase>verify</phase>
-                        <goals>
-                            <goal>report</goal>
-                        </goals>
-                    </execution>
-                    <execution>
-                        <id>check</id>
-                        <phase>verify</phase>
-                        <goals>
-                            <goal>check</goal>
-                        </goals>
-                        <configuration>
-                            <rules>
-                                <rule>
-                                    <element>BUNDLE</element>
-                                    <limits>
-                                        <limit>
-                                            <counter>INSTRUCTION</counter>
-                                            <value>COVEREDRATIO</value>
-                                            <minimum>0.60</minimum>
-                                        </limit>
-                                    </limits>
-                                </rule>
-                            </rules>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>com.github.spotbugs</groupId>
-                <artifactId>spotbugs-maven-plugin</artifactId>
-                <version>4.8.6.0</version>
-                <dependencies>
-                    <dependency>
-                        <groupId>com.github.spotbugs</groupId>
-                        <artifactId>spotbugs</artifactId>
-                        <version>4.8.6</version>
-                    </dependency>
-                </dependencies>
-                <executions>
-                    <execution>
-                        <id>spotbugs-check</id>
-                        <phase>verify</phase>
-                        <goals>
-                            <goal>check</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <configuration>
-                    <effort>Max</effort>
-                    <threshold>High</threshold>
-                    <failOnError>true</failOnError>
-                    <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-</project>

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

@@ -1,12 +0,0 @@
-<?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/CheckInWebSocketConfig.java

@@ -1,43 +0,0 @@
-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 CheckInWebSocketConfig {
-
-    @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/config/QRCodeConfig.java

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

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

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

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

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

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

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

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

@@ -1,209 +0,0 @@
-package cn.novalon.gym.manage.checkIn.entity;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import org.springframework.data.annotation.CreatedDate;
-import org.springframework.data.annotation.Id;
-import org.springframework.data.annotation.LastModifiedDate;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.time.LocalDateTime;
-
-/**
- * 会员到店签到记录实体
- *
- * @author 付嘉
- * @date 2026-06-08
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@Table("sign_in_record")
-public class SignInRecord {
-
-    /**
-     * 自增主键
-     */
-    @Id
-    private Long id;
-
-    /**
-     * 会员ID，关联member表
-     */
-    @Column("member_id")
-    private Long memberId;
-
-    /**
-     * 签到时使用的会员卡ID
-     */
-    @Column("member_card_id")
-    private Long memberCardId;
-
-    /**
-     * 签到入场时间
-     */
-    @Column("sign_in_time")
-    private LocalDateTime signInTime;
-
-    /**
-     * 签到方式：QR_CODE-扫码签到，MANUAL-手动签到，FACE-人脸识别
-     */
-    @Column("sign_in_type")
-    private String signInType;
-
-    /**
-     * 签到状态：SUCCESS-成功，FAILED-失败
-     */
-    @Column("sign_in_status")
-    private String signInStatus;
-
-    /**
-     * JSONB格式，存储会员卡验证时的快照数据
-     */
-    @Column("verification_details")
-    private String verificationDetails;
-
-    /**
-     * 失败时的具体原因文案
-     */
-    @Column("fail_reason")
-    private String failReason;
-
-    /**
-     * 操作人ID（前台人员），自助签到时为NULL
-     */
-    @Column("operator_id")
-    private Long operatorId;
-
-    /**
-     * 操作人姓名冗余
-     */
-    @Column("operator_name")
-    private String operatorName;
-
-    /**
-     * 签到设备标识或型号
-     */
-    @Column("device_info")
-    private String deviceInfo;
-
-    /**
-     * 客户端IP地址
-     */
-    @Column("ip_address")
-    private String ipAddress;
-
-    /**
-     * 签到来源：MINI_PROGRAM-小程序扫码，PC_BACKEND-后台管理端
-     */
-    @Column("source")
-    private String source;
-
-    /**
-     * 软删除标识：false-未删除，true-已删除
-     */
-    @Column("is_delete")
-    private Boolean isDelete;
-
-    /**
-     * 记录创建时间
-     */
-    @CreatedDate
-    @Column("created_at")
-    private LocalDateTime createdAt;
-
-    /**
-     * 记录更新时间
-     */
-    @LastModifiedDate
-    @Column("updated_at")
-    private LocalDateTime updatedAt;
-
-    // ========== 常量定义 ==========
-
-    /**
-     * 签到类型常量
-     */
-    public static final class SignInType {
-        /** 扫码签到 */
-        public static final String QR_CODE = "QR_CODE";
-        /** 手动签到 */
-        public static final String MANUAL = "MANUAL";
-        /** 人脸识别 */
-        public static final String FACE = "FACE";
-
-        private SignInType() {}
-    }
-
-    /**
-     * 签到状态常量
-     */
-    public static final class SignInStatus {
-        /** 成功 */
-        public static final String SUCCESS = "SUCCESS";
-        /** 失败 */
-        public static final String FAILED = "FAILED";
-
-        private SignInStatus() {}
-    }
-
-    /**
-     * 签到来源常量
-     */
-    public static final class Source {
-        /** 小程序扫码 */
-        public static final String MINI_PROGRAM = "MINI_PROGRAM";
-        /** 后台管理端手动签到 */
-        public static final String PC_BACKEND = "PC_BACKEND";
-
-        private Source() {}
-    }
-
-    // ========== 辅助方法 ==========
-
-    /**
-     * 判断签到是否成功
-     */
-    public boolean isSuccess() {
-        return SignInStatus.SUCCESS.equals(this.signInStatus);
-    }
-
-    /**
-     * 判断签到是否失败
-     */
-    public boolean isFailed() {
-        return SignInStatus.FAILED.equals(this.signInStatus);
-    }
-
-    /**
-     * 判断是否为扫码签到
-     */
-    public boolean isQrCodeSign() {
-        return SignInType.QR_CODE.equals(this.signInType);
-    }
-
-    /**
-     * 判断是否已删除
-     */
-    public boolean isDeleted() {
-        return Boolean.TRUE.equals(this.isDelete);
-    }
-
-    /**
-     * 软删除
-     */
-    public void softDelete() {
-        this.isDelete = true;
-    }
-
-    /**
-     * 恢复删除
-     */
-    public void restore() {
-        this.isDelete = false;
-    }
-}

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

@@ -1,240 +0,0 @@
-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;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.MediaType;
-import org.springframework.stereotype.Component;
-import org.springframework.web.reactive.function.server.ServerRequest;
-import org.springframework.web.reactive.function.server.ServerResponse;
-import reactor.core.publisher.Mono;
-import cn.novalon.gym.manage.checkIn.websocket.MyWebSocketHandler;
-
-import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
-import java.util.Map;
-
-@Slf4j
-@Component
-@RequiredArgsConstructor
-public class CheckInHandler {
-
-    private final AuthUtil authUtil;
-    private final CheckServiceImpl checkService;
-
-    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
-
-    /**
-     * 签到
-     *
-     * POST /api/checkIn
-     *
-     */
-    public Mono<ServerResponse> checkIn(ServerRequest request) {
-
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-
-        return request.bodyToMono(Map.class)
-                .flatMap(body -> {
-                    String qrContent = (String) body.get("qrContent");
-                    log.info("收到签到请求, memberId: {}, qrContent: {}", memberId, qrContent);
-                    boolean messageToClient = MyWebSocketHandler.sendMessageToClient(qrContent, "正在进行签到");
-                    log.info("WebSocket 推送结果: {}", messageToClient);
-                    return checkService.checkIn(memberId, qrContent)
-                            .flatMap(result -> ServerResponse.ok()
-                                    .contentType(MediaType.APPLICATION_JSON)
-                                    .bodyValue(result));
-                })
-                .onErrorResume(e -> {
-                    log.error("签到失败", e);
-                    return ServerResponse.status(HttpStatus.BAD_REQUEST)
-                            .bodyValue(Map.of("code", 400, "message", e.getMessage()));
-                });
-    }
-
-    /**
-     * 获取二维码
-     *
-     * GET /api/checkin/qrcode
-     *
-     */
-    public Mono<ServerResponse> getQRCode(ServerRequest request) {
-
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-
-        log.info("收到用户{}获取二维码请求", memberId);
-
-        return checkService.getQRCode(memberId)
-                .flatMap(qrCodeVo -> ServerResponse.ok()
-                        .contentType(MediaType.APPLICATION_JSON)
-                        .bodyValue(qrCodeVo));
-    }
-
-    /**
-     * 查询签到记录列表
-     *
-     * GET /api/checkIn/records
-     *
-     * @param request
-     * @return
-     */
-    public Mono<ServerResponse> getSignInRecords(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        
-        String startDateStr = request.queryParam("startDate").orElse(null);
-        String endDateStr = request.queryParam("endDate").orElse(null);
-        
-        LocalDate startDate = startDateStr != null ? LocalDate.parse(startDateStr, DATE_FORMATTER) : LocalDate.now().minusDays(30);
-        LocalDate endDate = endDateStr != null ? LocalDate.parse(endDateStr, DATE_FORMATTER) : LocalDate.now();
-        
-        log.info("查询签到记录, memberId: {}, startDate: {}, endDate: {}", memberId, startDate, endDate);
-        
-        return checkService.getSignInRecords(memberId, startDate, endDate)
-                .collectList()
-                .flatMap(records -> ServerResponse.ok()
-                        .contentType(MediaType.APPLICATION_JSON)
-                        .bodyValue(Map.of("code", 200, "message", "success", "data", records)));
-    }
-
-    /**
-     * 查询单条签到记录
-     *
-     * GET /api/checkIn/records/{id}
-     *
-     * @param request
-     * @return
-     */
-    public Mono<ServerResponse> getSignInRecordById(ServerRequest request) {
-        Long id = Long.parseLong(request.pathVariable("id"));
-        
-        log.info("查询签到记录详情, id: {}", id);
-        
-        return checkService.getSignInRecordById(id)
-                .flatMap(record -> ServerResponse.ok()
-                        .contentType(MediaType.APPLICATION_JSON)
-                        .bodyValue(Map.of("code", 200, "message", "success", "data", record)))
-                .switchIfEmpty(ServerResponse.notFound().build());
-    }
-
-    /**
-     * 获取签到统计
-     *
-     * GET /api/checkIn/statistics
-     *
-     * @param request
-     * @return
-     */
-    public Mono<ServerResponse> getSignInStatistics(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        
-        String startDateStr = request.queryParam("startDate").orElse(null);
-        String endDateStr = request.queryParam("endDate").orElse(null);
-        
-        LocalDate startDate = startDateStr != null ? LocalDate.parse(startDateStr, DATE_FORMATTER) : LocalDate.now().minusDays(30);
-        LocalDate endDate = endDateStr != null ? LocalDate.parse(endDateStr, DATE_FORMATTER) : LocalDate.now();
-        
-        log.info("查询签到统计, memberId: {}, startDate: {}, endDate: {}", memberId, startDate, endDate);
-        
-        return checkService.getSignInStats(memberId, startDate, endDate)
-                .flatMap(stats -> ServerResponse.ok()
-                        .contentType(MediaType.APPLICATION_JSON)
-                        .bodyValue(Map.of("code", 200, "message", "success", "data", stats)));
-    }
-
-    /**
-     * 导出签到记录
-     *
-     * GET /api/checkIn/records/export
-     *
-     * @param request
-     * @return
-     */
-    public Mono<ServerResponse> exportSignInRecords(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        
-        String startDateStr = request.queryParam("startDate").orElse(null);
-        String endDateStr = request.queryParam("endDate").orElse(null);
-        
-        LocalDate startDate = startDateStr != null ? LocalDate.parse(startDateStr, DATE_FORMATTER) : LocalDate.now().minusDays(30);
-        LocalDate endDate = endDateStr != null ? LocalDate.parse(endDateStr, DATE_FORMATTER) : LocalDate.now();
-        
-        log.info("导出签到记录, memberId: {}, startDate: {}, endDate: {}", memberId, startDate, endDate);
-        
-        String filename = "签到记录_" + startDateStr + "_" + endDateStr + ".csv";
-        
-        return checkService.exportSignInRecords(memberId, startDate, endDate)
-                .flatMap(bytes -> ServerResponse.ok()
-                        .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + filename + "\"")
-                        .contentType(MediaType.parseMediaType("text/csv; charset=UTF-8"))
-                        .bodyValue(bytes));
-    }
-
-    /**
-     * 获取每日签到统计
-     *
-     * GET /api/checkIn/daily-stats
-     *
-     * @param request
-     * @return
-     */
-    public Mono<ServerResponse> getDailySignInStats(ServerRequest request) {
-        String dateStr = request.queryParam("date").orElse(null);
-        LocalDate date = dateStr != null ? LocalDate.parse(dateStr, DATE_FORMATTER) : LocalDate.now();
-        
-        log.info("查询每日签到统计, date: {}", date);
-        
-        return checkService.getDailySignInStats(date)
-                .flatMap(stats -> ServerResponse.ok()
-                        .contentType(MediaType.APPLICATION_JSON)
-                        .bodyValue(Map.of("code", 200, "message", "success", "data", stats)));
-    }
-
-    /**
-     * 管理员查询所有签到记录（支持排序）
-     *
-     * GET /api/checkIn/admin/records
-     */
-    public Mono<ServerResponse> getAllSignInRecords(ServerRequest request) {
-        String startDateStr = request.queryParam("startDate").orElse(null);
-        String endDateStr = request.queryParam("endDate").orElse(null);
-        String sortBy = request.queryParam("sortBy").orElse("signInTime");
-        String sortOrder = request.queryParam("sortOrder").orElse("desc");
-
-        LocalDate startDate = startDateStr != null ? LocalDate.parse(startDateStr, DATE_FORMATTER) : LocalDate.now().minusDays(30);
-        LocalDate endDate = endDateStr != null ? LocalDate.parse(endDateStr, DATE_FORMATTER) : LocalDate.now();
-
-        log.info("管理员查询所有签到记录, startDate: {}, endDate: {}, sortBy: {}, sortOrder: {}", startDate, endDate, sortBy, sortOrder);
-
-        return checkService.getAllSignInRecords(startDate, endDate, sortBy, sortOrder)
-                .collectList()
-                .flatMap(records -> ServerResponse.ok()
-                        .contentType(MediaType.APPLICATION_JSON)
-                        .bodyValue(Map.of("code", 200, "message", "success", "data", records)));
-    }
-
-    /**
-     * 管理员查询签到统计（不限会员）
-     *
-     * GET /api/checkIn/admin/statistics
-     */
-    public Mono<ServerResponse> getAllSignInStatistics(ServerRequest request) {
-        String startDateStr = request.queryParam("startDate").orElse(null);
-        String endDateStr = request.queryParam("endDate").orElse(null);
-
-        LocalDate startDate = startDateStr != null ? LocalDate.parse(startDateStr, DATE_FORMATTER) : LocalDate.now().minusDays(30);
-        LocalDate endDate = endDateStr != null ? LocalDate.parse(endDateStr, DATE_FORMATTER) : LocalDate.now();
-
-        log.info("管理员查询签到统计, startDate: {}, endDate: {}", startDate, endDate);
-
-        return checkService.getAllSignInStats(startDate, endDate)
-                .flatMap(stats -> ServerResponse.ok()
-                        .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/repository/SignInRecordRepository.java

@@ -1,107 +0,0 @@
-package cn.novalon.gym.manage.checkIn.repository;
-
-import cn.novalon.gym.manage.checkIn.entity.SignInRecord;
-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
- *
- * @author 付嘉
- * @date 2026-06-08
- */
-@Repository
-public interface SignInRecordRepository extends R2dbcRepository<SignInRecord, Long> {
-
-    /**
-     * 查询会员某天的签到记录
-     */
-    @Query("SELECT * FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time < :endTime AND is_delete = false")
-    Mono<SignInRecord> findByMemberIdAndDate(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 查询会员的签到记录列表
-     */
-    @Query("SELECT * FROM sign_in_record WHERE member_id = :memberId AND is_delete = false ORDER BY sign_in_time DESC")
-    Flux<SignInRecord> findByMemberId(Long memberId);
-
-    /**
-     * 统计会员某天的签到次数
-     */
-    @Query("SELECT COUNT(*) FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time < :endTime AND is_delete = false")
-    Mono<Long> countByMemberIdAndDate(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 插入签到记录
-     */
-    @Query("INSERT INTO sign_in_record (member_id, member_card_id, sign_in_time, sign_in_type, sign_in_status, verification_details, fail_reason, source, created_at, updated_at, is_delete) " +
-            "VALUES (:memberId, :memberCardId, :signInTime, :signInType, :signInStatus, :verificationDetails, :failReason, :source, NOW(), NOW(), false)")
-    Mono<Void> insertRecord(Long memberId, Long memberCardId, LocalDateTime signInTime, 
-                            String signInType, String signInStatus, String verificationDetails, 
-                            String failReason, String source);
-
-    /**
-     * 根据会员ID和时间范围查询签到记录
-     */
-    @Query("SELECT * 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")
-    Flux<SignInRecord> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 根据时间范围查询签到记录
-     */
-    @Query("SELECT * FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false ORDER BY sign_in_time DESC")
-    Flux<SignInRecord> findByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 根据时间范围查询签到记录（支持动态排序）
-     */
-    @Query("SELECT * FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false ORDER BY sign_in_time DESC")
-    Flux<SignInRecord> findByTimeRangeSorted(LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 统计会员在时间范围内的签到次数
-     */
-    @Query("SELECT COUNT(*) FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false")
-    Mono<Long> countByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 统计时间范围内的签到次数
-     */
-    @Query("SELECT COUNT(*) FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false")
-    Mono<Long> countByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 统计会员在时间范围内的成功签到次数
-     */
-    @Query("SELECT COUNT(*) FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time <= :endTime AND sign_in_status = 'SUCCESS' AND is_delete = false")
-    Mono<Long> countSuccessByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 统计时间范围内的成功签到次数
-     */
-    @Query("SELECT COUNT(*) FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time <= :endTime AND sign_in_status = 'SUCCESS' AND is_delete = false")
-    Mono<Long> countSuccessByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 统计时间范围内签到的独立会员数
-     */
-    @Query("SELECT COUNT(DISTINCT member_id) FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false")
-    Mono<Long> countDistinctMembersByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 获取会员在时间范围内的首次签到时间
-     */
-    @Query("SELECT MIN(sign_in_time) FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false")
-    Mono<LocalDateTime> getFirstSignInTime(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 获取会员在时间范围内的最后签到时间
-     */
-    @Query("SELECT MAX(sign_in_time) FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false")
-    Mono<LocalDateTime> getLastSignInTime(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
-}

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

@@ -1,97 +0,0 @@
-package cn.novalon.gym.manage.checkIn.service;
-
-import cn.novalon.gym.manage.checkIn.vo.QRCodeVo;
-import cn.novalon.gym.manage.checkIn.vo.SignInRecordVO;
-import cn.novalon.gym.manage.checkIn.vo.SignInStatsVO;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDate;
-
-/**
- * 签到服务接口
- *
- * @author 付嘉
- * @date 2026-06-08
- */
-public interface ICheckInService {
-
-    /**
-     * 获取签到二维码
-     *
-     * @param memberId 会员ID
-     * @return 二维码VO
-     */
-    Mono<QRCodeVo> getQRCode(Long memberId);
-
-    /**
-     * 扫码签到
-     *
-     * @param memberId 会员ID
-     * @param qrContent 二维码内容
-     * @return 签到结果JSON字符串
-     */
-    Mono<String> checkIn(Long memberId, String qrContent);
-
-    /**
-     * 查询会员签到记录列表
-     *
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 签到记录列表
-     */
-    Flux<SignInRecordVO> getSignInRecords(Long memberId, LocalDate startTime, LocalDate endTime);
-
-    /**
-     * 根据ID查询签到记录
-     *
-     * @param id 签到记录ID
-     * @return 签到记录VO
-     */
-    Mono<SignInRecordVO> getSignInRecordById(Long id);
-
-    /**
-     * 获取会员签到统计
-     *
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 签到统计VO
-     */
-    Mono<SignInStatsVO> getSignInStats(Long memberId, LocalDate startTime, LocalDate endTime);
-
-    /**
-     * 导出会员签到记录
-     *
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return CSV格式的字节数组
-     */
-    Mono<byte[]> exportSignInRecords(Long memberId, LocalDate startTime, LocalDate endTime);
-
-    /**
-     * 获取每日签到统计
-     *
-     * @param date 日期
-     * @return 签到统计VO
-     */
-    Mono<SignInStatsVO> getDailySignInStats(LocalDate date);
-
-    /**
-     * 管理员查询所有签到记录（支持排序）
-     *
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param sortBy 排序字段
-     * @param sortOrder 排序方向
-     * @return 签到记录列表（含会员姓名、卡类型）
-     */
-    Flux<SignInRecordVO> getAllSignInRecords(LocalDate startTime, LocalDate endTime, String sortBy, String sortOrder);
-
-    /**
-     * 管理员查询签到统计（不限会员）
-     */
-    Mono<SignInStatsVO> getAllSignInStats(LocalDate startTime, LocalDate endTime);
-}

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

@@ -1,519 +0,0 @@
-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;
-import cn.novalon.gym.manage.checkIn.repository.SignInRecordRepository;
-import cn.novalon.gym.manage.checkIn.service.ICheckInService;
-import cn.novalon.gym.manage.checkIn.vo.QRCodeVo;
-import cn.novalon.gym.manage.checkIn.vo.SignInRecordVO;
-import cn.novalon.gym.manage.checkIn.vo.SignInStatsVO;
-import cn.novalon.gym.manage.checkIn.websocket.MyWebSocketHandler;
-import cn.novalon.gym.manage.common.constant.RedisKeyConstants;
-import cn.novalon.gym.manage.common.util.RedisUtil;
-import cn.novalon.gym.manage.groupcourse.service.IGroupCourseBookingService;
-import cn.novalon.gym.manage.member.entity.Member;
-import cn.novalon.gym.manage.member.entity.MemberCard;
-import cn.novalon.gym.manage.member.entity.MemberCardRecord;
-import cn.novalon.gym.manage.member.enums.MemberCardType;
-import cn.novalon.gym.manage.member.repository.IMemberRepository;
-import cn.novalon.gym.manage.member.repository.MemberCardRepository;
-import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.LocalTime;
-import java.time.format.DateTimeFormatter;
-import java.time.temporal.ChronoUnit;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-@Slf4j
-@Service
-@RequiredArgsConstructor
-public class CheckServiceImpl implements ICheckInService {
-
-    private final QRCodeConfig qrCodeConfig;
-    private final RedisUtil redisUtil;
-    private final MemberCardRecordRepository memberCardRecordRepository;
-    private final MemberCardRepository memberCardRepository;
-    private final SignInRecordRepository signInRecordRepository;
-    private final IGroupCourseBookingService groupCourseBookingService;
-    private final IMemberRepository memberRepository;
-
-    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
-
-    @Override
-    public Mono<QRCodeVo> getQRCode(Long memberId) {
-        log.info("开始查询会员信息, memberId: {}", memberId);
-        
-        return findValidMemberCard(memberId)
-                .flatMap(cardRecord -> {
-                    log.info("会员信息查询完成, memberCardRecordId: {}", cardRecord.getMemberCardRecordId());
-                    
-                    log.info("开始生成二维码");
-                    String qrContent = QRRedisKey.generateQrcodeContent();
-                    Map<String, Object> redisMap = new HashMap<>();
-                    redisMap.put("qrContent", qrContent);
-                    redisMap.put("isUsed", false);
-                    redisMap.put("memberId", memberId);
-                    redisMap.put("memberCardRecordId", cardRecord.getMemberCardRecordId());
-
-                    return redisUtil.setWithExpire(
-                                    RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now(),
-                                    redisMap,
-                                    getSecondsUntilEndOfDay()
-                            )
-                            .then(Mono.fromSupplier(() -> {
-                                String qrCodeBase64 = QrCodeUtil.generateAsBase64(qrContent,
-                                        BeanUtil.copyProperties(qrCodeConfig, QrConfig.class), "png");
-                                return new QRCodeVo(qrCodeBase64, false, qrContent, qrCodeConfig.getWidth(), qrCodeConfig.getHeight(), LocalDate.now());
-                            }));
-                })
-                .switchIfEmpty(Mono.error(new RuntimeException("该会员没有可用的会员卡")));
-    }
-
-    @Override
-    public Mono<String> checkIn(Long memberId, String qrContent) {
-        String key = RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now();
-
-        // 先检查当天是否已经签到（从数据库查询，作为重复签到的额外保障）
-        return checkTodayAlreadySignedIn(memberId)
-                .flatMap(existingRecord -> {
-                    String checkInTime = existingRecord.getSignInTime().format(DATE_FORMATTER);
-                    log.error("重复签到, memberId: {}", memberId);
-                    MyWebSocketHandler.sendFailure(qrContent, "您已经在" + checkInTime + "完成签到，请勿重复签到");
-                    return Mono.error(new RuntimeException("您已经在" + checkInTime + "完成签到，请勿重复签到"));
-                })
-                .then(Mono.defer(() -> redisUtil.get(key)))
-                .flatMap(cachedObj -> {
-                    if (cachedObj != null) {
-                        Map<String, Object> map;
-                        if (cachedObj instanceof Map) {
-                            map = (Map<String, Object>) cachedObj;
-                        } else if (cachedObj instanceof String) {
-                            map = JSONUtil.parseObj((String) cachedObj);
-                        } else {
-                            MyWebSocketHandler.sendFailure(qrContent, "二维码数据格式错误");
-                            return Mono.error(new RuntimeException("二维码数据格式错误"));
-                        }
-                        if (map.get("qrContent").equals(qrContent)) {
-                            if ((boolean) map.get("isUsed")) {
-                                String checkInTime = String.valueOf(map.get("checkInTime"));
-                                log.error("重复签到(缓存), memberId: {}", memberId);
-                                MyWebSocketHandler.sendFailure(qrContent, "您已经在" + checkInTime + "完成签到，请勿重复签到");
-                                return Mono.error(new RuntimeException("您已经在" + checkInTime + "完成签到，请勿重复签到"));
-                            }
-                            log.info("二维码匹配成功，memberId: {}", memberId);
-
-                            Long memberCardRecordId = ((Number) map.get("memberCardRecordId")).longValue();
-
-                            return processCheckIn(memberId, memberCardRecordId, map, qrContent);
-                        } else {
-                            MyWebSocketHandler.sendFailure(qrContent, "二维码无效");
-                            return Mono.error(new RuntimeException("二维码无效"));
-                        }
-                    }
-                    MyWebSocketHandler.sendFailure(qrContent, "二维码已过期或不存在");
-                    return Mono.error(new RuntimeException("二维码已过期或不存在"));
-                });
-    }
-
-    /**
-     * 检查会员当天是否已经签到
-     * @param memberId 会员ID
-     * @return 如果已签到返回签到记录，否则返回空
-     */
-    private Mono<SignInRecord> checkTodayAlreadySignedIn(Long memberId) {
-        LocalDateTime startOfDay = LocalDate.now().atStartOfDay();
-        LocalDateTime endOfDay = LocalDate.now().atTime(LocalTime.MAX);
-        
-        return signInRecordRepository.findByMemberIdAndDate(memberId, startOfDay, endOfDay);
-    }
-
-    /**
-     * 处理签到逻辑
-     */
-    private Mono<String> processCheckIn(Long memberId, Long memberCardRecordId, Map<String, Object> redisMap, String qrContent) {
-        LocalDateTime now = LocalDateTime.now();
-        
-        // 发送实时进度通知
-        MyWebSocketHandler.sendProgress(qrContent, "VALIDATE_CARD", "正在验证会员卡...");
-        
-        return memberCardRecordRepository.findById(memberCardRecordId)
-                .switchIfEmpty(Mono.defer(() -> {
-                    MyWebSocketHandler.sendFailure(qrContent, "会员卡记录不存在");
-                    return Mono.error(new RuntimeException("会员卡记录不存在"));
-                }))
-                .flatMap(cardRecord -> {
-                    if (!"ACTIVE".equals(cardRecord.getStatus().name())) {
-                        MyWebSocketHandler.sendFailure(qrContent, "会员卡状态不正确");
-                        return Mono.error(new RuntimeException("会员卡状态不正确"));
-                    }
-                    
-                    if (cardRecord.getExpireTime() != null && cardRecord.getExpireTime().isBefore(now)) {
-                        MyWebSocketHandler.sendFailure(qrContent, "会员卡已过期");
-                        return Mono.error(new RuntimeException("会员卡已过期"));
-                    }
-
-                    // 发送实时进度通知
-                    MyWebSocketHandler.sendProgress(qrContent, "VALIDATE_BOOKING", "会员卡验证通过，正在检查预约信息...");
-
-                    // 检查是否有需要签到的团课预约
-                    return validateBooking(memberId, now)
-                            .then(memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(cardRecord.getMemberCardId())
-                                    .switchIfEmpty(Mono.defer(() -> {
-                                        MyWebSocketHandler.sendFailure(qrContent, "会员卡类型不存在");
-                                        return Mono.error(new RuntimeException("会员卡类型不存在"));
-                                    }))
-                                    .flatMap(card -> {
-                                        // 发送实时进度通知
-                                        MyWebSocketHandler.sendProgress(qrContent, "DEDUCT_USAGE", "正在扣减会员卡次数...");
-                                        
-                                        return deductCardUsage(cardRecord, card)
-                                                .flatMap(updatedRecord -> {
-                                                    redisMap.put("isUsed", true);
-                                                    redisMap.put("checkInTime", now.format(DATE_FORMATTER));
-                                                    
-                                                    return saveSignInRecord(memberId, cardRecord.getMemberCardRecordId(), card.getMemberCardId())
-                                                            .then(redisUtil.set(RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now(), redisMap))
-                                                            .then(Mono.defer(() -> {
-                                                                String successMsg = buildSuccessResponse(now);
-                                                                MyWebSocketHandler.sendSuccess(qrContent, memberId, now.format(DATE_FORMATTER));
-                                                                log.info("签到成功, memberId: {}, cardRecordId: {}", memberId, memberCardRecordId);
-                                                                return Mono.just(successMsg);
-                                                            }));
-                                                });
-                                    }));
-                });
-    }
-
-    /**
-     * 验证预约信息
-     */
-    private Mono<Void> validateBooking(Long memberId, LocalDateTime now) {
-        return groupCourseBookingService.getBookingsByMemberId(memberId)
-                .filter(booking -> {
-                    String status = booking.getStatus();
-                    LocalDateTime startTime = booking.getCourseStartTime();
-                    return "0".equals(status) && 
-                           startTime != null && 
-                           startTime.toLocalDate().equals(now.toLocalDate()) &&
-                           !startTime.isBefore(now.minusMinutes(30));
-                })
-                .collectList()
-                .flatMap(bookings -> {
-                    if (bookings.isEmpty()) {
-                        return Mono.empty();
-                    }
-                    boolean hasValidBooking = bookings.stream()
-                            .anyMatch(b -> {
-                                LocalDateTime startTime = b.getCourseStartTime();
-                                return startTime != null && 
-                                       !startTime.isBefore(now.minusMinutes(30)) && 
-                                       !startTime.isAfter(now.plusMinutes(30));
-                            });
-                    if (hasValidBooking) {
-                        log.info("会员{}有有效的团课预约", memberId);
-                    } else {
-                        log.warn("会员{}有预约但不在签到时间范围内", memberId);
-                    }
-                    return Mono.empty();
-                });
-    }
-
-    /**
-     * 扣减会员卡使用次数/金额
-     */
-    private Mono<MemberCardRecord> deductCardUsage(MemberCardRecord record, MemberCard card) {
-        MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
-        LocalDateTime now = LocalDateTime.now();
-
-        switch (cardType) {
-            case TIME_CARD:
-                if (record.getExpireTime() != null && record.getExpireTime().isBefore(now)) {
-                    return Mono.error(new RuntimeException("时长卡已过期"));
-                }
-                return Mono.just(record);
-            case COUNT_CARD:
-                int currentTimes = record.getRemainingTimes() != null ? record.getRemainingTimes() : 0;
-                if (currentTimes < 1) {
-                    return Mono.error(new RuntimeException("次卡剩余次数不足"));
-                }
-                record.setRemainingTimes(currentTimes - 1);
-                if (record.getRemainingTimes() == 0) {
-                    record.setStatus(cn.novalon.gym.manage.member.enums.MemberCardRecordStatus.USED_UP);
-                }
-                return memberCardRecordRepository.save(record);
-            case STORED_VALUE_CARD:
-                double currentAmount = record.getRemainingAmount() != null ? record.getRemainingAmount() : 0.0;
-                if (currentAmount < 0.01) {
-                    return Mono.error(new RuntimeException("储值卡余额不足"));
-                }
-                record.setRemainingAmount(Math.max(0, currentAmount - 1));
-                if (record.getRemainingAmount() <= 0) {
-                    record.setStatus(cn.novalon.gym.manage.member.enums.MemberCardRecordStatus.USED_UP);
-                }
-                return memberCardRecordRepository.save(record);
-            default:
-                return Mono.error(new RuntimeException("不支持的会员卡类型"));
-        }
-    }
-
-    /**
-     * 保存签到记录
-     */
-    private Mono<Void> saveSignInRecord(Long memberId, Long memberCardRecordId, Long memberCardId) {
-        SignInRecord record = SignInRecord.builder()
-                .memberId(memberId)
-                .memberCardId(memberCardId)
-                .signInTime(LocalDateTime.now())
-                .signInType(SignInRecord.SignInType.QR_CODE)
-                .signInStatus(SignInRecord.SignInStatus.SUCCESS)
-                .source(SignInRecord.Source.MINI_PROGRAM)
-                .isDelete(false)
-                .build();
-
-        return signInRecordRepository.save(record).then();
-    }
-
-    /**
-     * 构建成功响应
-     */
-    private String buildSuccessResponse(LocalDateTime dateTime) {
-        Map<String, Object> res = new HashMap<>();
-        res.put("message", "签到成功");
-        res.put("dateTime", dateTime.format(DATE_FORMATTER));
-        return JSONUtil.toJsonStr(res);
-    }
-
-    /**
-     * 查找会员的有效会员卡（优先选择有效期最早到期的）
-     */
-    private Mono<MemberCardRecord> findValidMemberCard(Long memberId) {
-        return memberCardRecordRepository.findActiveCardsByMemberId(memberId)
-                .filter(record -> {
-                    LocalDateTime expireTime = record.getExpireTime();
-                    return expireTime == null || expireTime.isAfter(LocalDateTime.now());
-                })
-                .sort((r1, r2) -> {
-                    LocalDateTime e1 = r1.getExpireTime();
-                    LocalDateTime e2 = r2.getExpireTime();
-                    if (e1 == null && e2 == null) return 0;
-                    if (e1 == null) return 1;
-                    if (e2 == null) return -1;
-                    return e1.compareTo(e2);
-                })
-                .next();
-    }
-
-    // ==================== 签到记录管理功能 ====================
-
-    @Override
-    public Flux<SignInRecordVO> getSignInRecords(Long memberId, LocalDate startTime, LocalDate endTime) {
-        LocalDateTime start = startTime.atStartOfDay();
-        LocalDateTime end = endTime.atTime(LocalTime.MAX);
-        
-        return signInRecordRepository.findByMemberIdAndTimeRange(memberId, start, end)
-                .map(this::convertToVO);
-    }
-
-    @Override
-    public Mono<SignInRecordVO> getSignInRecordById(Long id) {
-        return signInRecordRepository.findById(id)
-                .map(this::convertToVO);
-    }
-
-    @Override
-    public Mono<SignInStatsVO> getSignInStats(Long memberId, LocalDate startTime, LocalDate endTime) {
-        LocalDateTime start = startTime.atStartOfDay();
-        LocalDateTime end = endTime.atTime(LocalTime.MAX);
-        
-        return Mono.zip(
-                (Object[] results) -> {
-                    Long total = (Long) results[0];
-                    Long success = (Long) results[1];
-                    LocalDateTime first = (LocalDateTime) results[2];
-                    LocalDateTime last = (LocalDateTime) results[3];
-                    SignInStatsVO stats = new SignInStatsVO();
-                    stats.setTotalCount(total);
-                    stats.setSuccessCount(success);
-                    stats.setStartDate(startTime);
-                    stats.setEndDate(endTime);
-                    stats.setFirstSignInTime(first);
-                    stats.setLastSignInTime(last);
-                    stats.setSuccessRate(total > 0 ? (double) success / total * 100.0 : 0.0);
-                    return stats;
-                },
-                signInRecordRepository.countByMemberIdAndTimeRange(memberId, start, end),
-                signInRecordRepository.countSuccessByMemberIdAndTimeRange(memberId, start, end),
-                signInRecordRepository.getFirstSignInTime(memberId, start, end),
-                signInRecordRepository.getLastSignInTime(memberId, start, end)
-        );
-    }
-
-    @Override
-    public Mono<byte[]> exportSignInRecords(Long memberId, LocalDate startTime, LocalDate endTime) {
-        LocalDateTime start = startTime.atStartOfDay();
-        LocalDateTime end = endTime.atTime(LocalTime.MAX);
-        
-        return signInRecordRepository.findByMemberIdAndTimeRange(memberId, start, end)
-                .map(record -> {
-                    String status = "SUCCESS".equals(record.getSignInStatus()) ? "成功" : "失败";
-                    String type = "QR_CODE".equals(record.getSignInType()) ? "扫码签到" : 
-                                  "MANUAL".equals(record.getSignInType()) ? "手动签到" : "人脸识别";
-                    return String.join(",",
-                            record.getId().toString(),
-                            record.getMemberId().toString(),
-                            record.getMemberCardId() != null ? record.getMemberCardId().toString() : "",
-                            record.getSignInTime() != null ? record.getSignInTime().format(DATE_FORMATTER) : "",
-                            type,
-                            status,
-                            record.getFailReason() != null ? record.getFailReason() : ""
-                    );
-                })
-                .collectList()
-                .map(rows -> {
-                    List<String> csvLines = new java.util.ArrayList<>();
-                    csvLines.add("签到记录ID,会员ID,会员卡ID,签到时间,签到方式,签到状态,失败原因");
-                    csvLines.addAll(rows);
-                    return String.join("\n", csvLines).getBytes(java.nio.charset.StandardCharsets.UTF_8);
-                });
-    }
-
-    @Override
-    public Mono<SignInStatsVO> getDailySignInStats(LocalDate date) {
-        LocalDateTime start = date.atStartOfDay();
-        LocalDateTime end = date.atTime(LocalTime.MAX);
-        
-        return Mono.zip(
-                (Object[] results) -> {
-                    Long total = (Long) results[0];
-                    Long success = (Long) results[1];
-                    Long members = (Long) results[2];
-                    SignInStatsVO stats = new SignInStatsVO();
-                    stats.setTotalCount(total);
-                    stats.setSuccessCount(success);
-                    stats.setStartDate(date);
-                    stats.setEndDate(date);
-                    stats.setUniqueMemberCount(members);
-                    stats.setSuccessRate(total > 0 ? (double) success / total * 100.0 : 0.0);
-                    return stats;
-                },
-                signInRecordRepository.countByTimeRange(start, end),
-                signInRecordRepository.countSuccessByTimeRange(start, end),
-                signInRecordRepository.countDistinctMembersByTimeRange(start, end)
-        );
-    }
-
-    /**
-     * 转换实体到VO
-     */
-    private SignInRecordVO convertToVO(SignInRecord record) {
-        SignInRecordVO vo = new SignInRecordVO();
-        vo.setId(record.getId());
-        vo.setMemberId(record.getMemberId());
-        vo.setMemberCardId(record.getMemberCardId());
-        vo.setSignInTime(record.getSignInTime());
-        vo.setSignInType(record.getSignInType());
-        vo.setSignInStatus(record.getSignInStatus());
-        vo.setFailReason(record.getFailReason());
-        vo.setSource(record.getSource());
-        vo.setCreatedAt(record.getCreatedAt());
-        return vo;
-    }
-
-    @Override
-    public Flux<SignInRecordVO> getAllSignInRecords(LocalDate startTime, LocalDate endTime, String sortBy, String sortOrder) {
-        LocalDateTime start = startTime.atStartOfDay();
-        LocalDateTime end = endTime.atTime(LocalTime.MAX);
-
-        Flux<SignInRecord> recordFlux = signInRecordRepository.findByTimeRangeSorted(start, end);
-
-        return recordFlux
-                .flatMap(record -> {
-                    // fetch member name
-                    Mono<String> memberNameMono = memberRepository.findById(record.getMemberId())
-                            .map(Member::getNickname)
-                            .defaultIfEmpty("未知");
-                    // fetch card type name
-                    Mono<String> cardTypeMono = record.getMemberCardId() != null
-                            ? memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
-                                    .map(MemberCard::getMemberCardName)
-                                    .defaultIfEmpty("未知")
-                            : Mono.just("-");
-                    return Mono.zip(memberNameMono, cardTypeMono)
-                            .map(tuple -> {
-                                SignInRecordVO vo = convertToVO(record);
-                                vo.setMemberName(tuple.getT1());
-                                vo.setMemberCardType(tuple.getT2());
-                                return vo;
-                            });
-                })
-                .collectList()
-                .flatMapMany(list -> {
-                    // in-memory sort
-                    boolean asc = "asc".equalsIgnoreCase(sortOrder);
-                    java.util.Comparator<SignInRecordVO> comparator;
-                    switch (sortBy != null ? sortBy : "signInTime") {
-                        case "id":
-                            comparator = java.util.Comparator.comparing(SignInRecordVO::getId, java.util.Comparator.nullsLast(Long::compareTo));
-                            break;
-                        case "memberName":
-                            comparator = java.util.Comparator.comparing(SignInRecordVO::getMemberName, java.util.Comparator.nullsLast(String::compareTo));
-                            break;
-                        case "signInTime":
-                        default:
-                            comparator = java.util.Comparator.comparing(SignInRecordVO::getSignInTime, java.util.Comparator.nullsLast(java.time.LocalDateTime::compareTo));
-                            break;
-                    }
-                    if (!asc) {
-                        comparator = comparator.reversed();
-                    }
-                    list.sort(comparator);
-                    return Flux.fromIterable(list);
-                });
-    }
-
-    @Override
-    public Mono<SignInStatsVO> getAllSignInStats(LocalDate startTime, LocalDate endTime) {
-        LocalDateTime start = startTime.atStartOfDay();
-        LocalDateTime end = endTime.atTime(LocalTime.MAX);
-
-        return Mono.zip(
-                (Object[] results) -> {
-                    Long total = (Long) results[0];
-                    Long success = (Long) results[1];
-                    Long members = (Long) results[2];
-                    SignInStatsVO stats = new SignInStatsVO();
-                    stats.setTotalCount(total);
-                    stats.setSuccessCount(success);
-                    stats.setStartDate(startTime);
-                    stats.setEndDate(endTime);
-                    stats.setUniqueMemberCount(members);
-                    stats.setSuccessRate(total > 0 ? (double) success / total * 100.0 : 0.0);
-                    return stats;
-                },
-                signInRecordRepository.countByTimeRange(start, end),
-                signInRecordRepository.countSuccessByTimeRange(start, end),
-                signInRecordRepository.countDistinctMembersByTimeRange(start, end)
-        );
-    }
-
-    private long getSecondsUntilEndOfDay() {
-        LocalDateTime now = LocalDateTime.now();
-        LocalDateTime endOfDay = now.toLocalDate().atTime(23, 59, 59);
-        if (now.isAfter(endOfDay)) return 1;
-        return ChronoUnit.SECONDS.between(now, endOfDay);
-    }
-}

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

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

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

@@ -1,76 +0,0 @@
-package cn.novalon.gym.manage.checkIn.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.time.LocalDateTime;
-
-/**
- * 签到记录VO
- *
- * @author 付嘉
- * @date 2026-06-08
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class SignInRecordVO {
-
-    /**
-     * 签到记录ID
-     */
-    private Long id;
-
-    /**
-     * 会员ID
-     */
-    private Long memberId;
-
-    /**
-     * 会员卡ID
-     */
-    private Long memberCardId;
-
-    /**
-     * 签到时间
-     */
-    private LocalDateTime signInTime;
-
-    /**
-     * 签到类型：QR_CODE-扫码签到，MANUAL-手动签到，FACE-人脸识别
-     */
-    private String signInType;
-
-    /**
-     * 签到状态：SUCCESS-成功，FAILED-失败
-     */
-    private String signInStatus;
-
-    /**
-     * 失败原因
-     */
-    private String failReason;
-
-    /**
-     * 签到来源：MINI_PROGRAM-小程序扫码，PC_BACKEND-后台管理端
-     */
-    private String source;
-
-    /**
-     * 会员姓名（关联查询）
-     */
-    private String memberName;
-
-    /**
-     * 会员卡类型名称（关联查询）
-     */
-    private String memberCardType;
-
-    /**
-     * 创建时间
-     */
-    private LocalDateTime createdAt;
-}

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

@@ -1,62 +0,0 @@
-package cn.novalon.gym.manage.checkIn.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-
-/**
- * 签到统计VO
- *
- * @author 付嘉
- * @date 2026-06-08
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class SignInStatsVO {
-
-    /**
-     * 统计开始日期
-     */
-    private LocalDate startDate;
-
-    /**
-     * 统计结束日期
-     */
-    private LocalDate endDate;
-
-    /**
-     * 总签到次数
-     */
-    private Long totalCount;
-
-    /**
-     * 成功签到次数
-     */
-    private Long successCount;
-
-    /**
-     * 成功率（百分比）
-     */
-    private Double successRate;
-
-    /**
-     * 独立会员数
-     */
-    private Long uniqueMemberCount;
-
-    /**
-     * 首次签到时间
-     */
-    private LocalDateTime firstSignInTime;
-
-    /**
-     * 最后签到时间
-     */
-    private LocalDateTime lastSignInTime;
-}

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

@@ -1,202 +0,0 @@
-package cn.novalon.gym.manage.checkIn.websocket;
-
-import cn.hutool.json.JSONUtil;
-import cn.novalon.gym.manage.checkIn.dto.QRCodeDto;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Component;
-import org.springframework.web.reactive.socket.WebSocketHandler;
-import org.springframework.web.reactive.socket.WebSocketSession;
-import reactor.core.publisher.Mono;
-import reactor.core.publisher.Sinks;
-
-import java.time.LocalDateTime;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * WebSocket 处理类，用于实时签到反馈
- * 
- * 技术要点：
- * - 使用 Sinks 实现响应式消息推送
- * - 使用 ConcurrentHashMap 管理 qrContent 与 sink 的映射
- * - 支持实时推送签到进度和结果
- */
-@Slf4j
-@Component
-public class MyWebSocketHandler implements WebSocketHandler {
-
-    /**
-     * qrContent -> Sink 映射，用于根据二维码内容找到对应的客户端连接
-     */
-    private static final Map<String, Sinks.Many<String>> qrContentToSink = new ConcurrentHashMap<>();
-
-    /**
-     * 连接创建时间映射，用于超时清理
-     */
-    private static final Map<String, LocalDateTime> qrContentToCreateTime = new ConcurrentHashMap<>();
-
-    /**
-     * 超时时间（秒），超过此时间未使用的连接将被清理
-     */
-    private static final long TIMEOUT_SECONDS = 300;
-
-    @Override
-    public Mono<Void> handle(WebSocketSession session) {
-        String sessionId = session.getId();
-        log.info("WebSocket 连接建立，sessionId: {}", sessionId);
-
-        // 创建 sink，用于向客户端发送消息
-        Sinks.Many<String> sink = Sinks.many().unicast().onBackpressureBuffer();
-
-        // 订阅接收客户端消息（异步处理）
-        session.receive()
-                .doOnNext(message -> {
-                    String payload = message.getPayloadAsText();
-                    log.debug("收到消息：sessionId={}, payload={}", sessionId, payload);
-
-                    try {
-                        QRCodeDto qrCodeDto = JSONUtil.toBean(payload, QRCodeDto.class);
-                        String qrContent = qrCodeDto.getQrContent();
-
-                        if (qrContent != null && !qrContent.isEmpty()) {
-                            // 绑定 qrContent 和 sink
-                            qrContentToSink.put(qrContent, sink);
-                            qrContentToCreateTime.put(qrContent, LocalDateTime.now());
-                            log.info("绑定成功: qrContent={}, sessionId={}", qrContent, sessionId);
-                            
-                            // 发送连接成功消息
-                            sink.tryEmitNext(buildMessage("CONNECTED", "签到监听已建立，请扫描二维码"));
-                        } else {
-                            sink.tryEmitNext(buildMessage("ERROR", "二维码内容为空"));
-                        }
-                    } catch (Exception e) {
-                        log.error("解析消息失败，sessionId={}", sessionId, e);
-                        sink.tryEmitNext(buildMessage("ERROR", "消息格式错误: " + e.getMessage()));
-                    }
-                })
-                .doOnError(e -> {
-                    log.error("接收消息出错，sessionId={}", sessionId, e);
-                })
-                .subscribe();  // 必须订阅，否则不会执行
-
-        // 发送流给客户端
-        return session.send(sink.asFlux().map(session::textMessage))
-                .doFinally(signal -> {
-                    // 连接关闭时清理映射
-                    qrContentToSink.entrySet().removeIf(entry -> entry.getValue() == sink);
-                    qrContentToCreateTime.entrySet().removeIf(entry -> {
-                        Sinks.Many<String> s = qrContentToSink.get(entry.getKey());
-                        return s == null || s == sink;
-                    });
-                    log.info("WebSocket 连接关闭，sessionId={}", sessionId);
-                });
-    }
-
-    /**
-     * 向客户端发送消息
-     *
-     * @param qrContent 二维码内容
-     * @param message 消息内容
-     * @return 是否发送成功
-     */
-    public static boolean sendMessageToClient(String qrContent, String message) {
-        // 先清理超时连接
-        cleanupTimeoutConnections();
-
-        Sinks.Many<String> sink = qrContentToSink.get(qrContent);
-        if (sink == null) {
-            log.warn("未找到绑定的连接，qrContent: {}", qrContent);
-            return false;
-        }
-
-        Sinks.EmitResult result = sink.tryEmitNext(message);
-        if (result.isSuccess()) {
-            log.info("主动推送成功，qrContent: {}, message: {}", qrContent, message);
-            return true;
-        } else {
-            log.warn("推送失败，qrContent: {}, result: {}", qrContent, result);
-            return false;
-        }
-    }
-
-    /**
-     * 发送签到进度消息
-     *
-     * @param qrContent 二维码内容
-     * @param step 进度步骤
-     * @param message 进度消息
-     */
-    public static void sendProgress(String qrContent, String step, String message) {
-        String progressMessage = buildMessage("PROGRESS", message);
-        sendMessageToClient(qrContent, progressMessage);
-        log.debug("发送进度消息: qrContent={}, step={}, message={}", qrContent, step, message);
-    }
-
-    /**
-     * 发送签到成功消息
-     *
-     * @param qrContent 二维码内容
-     * @param memberId 会员ID
-     * @param signInTime 签到时间
-     */
-    public static void sendSuccess(String qrContent, Long memberId, String signInTime) {
-        String successMessage = buildMessage("SUCCESS", "签到成功！欢迎光临\n会员ID: " + memberId + "\n签到时间: " + signInTime);
-        sendMessageToClient(qrContent, successMessage);
-        log.info("发送成功消息: qrContent={}, memberId={}", qrContent, memberId);
-    }
-
-    /**
-     * 发送签到失败消息
-     *
-     * @param qrContent 二维码内容
-     * @param reason 失败原因
-     */
-    public static void sendFailure(String qrContent, String reason) {
-        String failureMessage = buildMessage("FAILURE", "签到失败：" + reason);
-        sendMessageToClient(qrContent, failureMessage);
-        log.warn("发送失败消息: qrContent={}, reason={}", qrContent, reason);
-    }
-
-    /**
-     * 构建标准消息格式
-     *
-     * @param type 消息类型
-     * @param content 消息内容
-     * @return 格式化后的消息字符串
-     */
-    private static String buildMessage(String type, String content) {
-        return JSONUtil.toJsonStr(Map.of(
-                "type", type,
-                "content", content,
-                "timestamp", System.currentTimeMillis()
-        ));
-    }
-
-    /**
-     * 清理超时连接
-     */
-    private static void cleanupTimeoutConnections() {
-        LocalDateTime now = LocalDateTime.now();
-        qrContentToCreateTime.entrySet().removeIf(entry -> {
-            LocalDateTime createTime = entry.getValue();
-            long secondsDiff = java.time.Duration.between(createTime, now).getSeconds();
-            if (secondsDiff > TIMEOUT_SECONDS) {
-                String qrContent = entry.getKey();
-                qrContentToSink.remove(qrContent);
-                log.debug("清理超时连接: qrContent={}, 超时时间={}秒", qrContent, secondsDiff);
-                return true;
-            }
-            return false;
-        });
-    }
-
-    /**
-     * 获取当前连接数
-     *
-     * @return 连接数
-     */
-    public static int getConnectionCount() {
-        cleanupTimeoutConnections();
-        return qrContentToSink.size();
-    }
-}

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

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

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

@@ -1,285 +0,0 @@
-package cn.novalon.gym.manage.checkin;
-
-import cn.novalon.gym.manage.checkIn.config.QRCodeConfig;
-import cn.novalon.gym.manage.checkIn.entity.SignInRecord;
-import cn.novalon.gym.manage.checkIn.repository.SignInRecordRepository;
-import cn.novalon.gym.manage.groupcourse.service.IGroupCourseBookingService;
-import cn.novalon.gym.manage.checkIn.service.impl.CheckServiceImpl;
-import cn.novalon.gym.manage.checkIn.vo.QRCodeVo;
-import cn.novalon.gym.manage.checkIn.vo.SignInRecordVO;
-import cn.novalon.gym.manage.checkIn.vo.SignInStatsVO;
-import cn.novalon.gym.manage.common.constant.RedisKeyConstants;
-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.repository.MemberCardRecordRepository;
-import cn.novalon.gym.manage.member.repository.MemberCardRepository;
-import cn.novalon.gym.manage.member.repository.IMemberRepository;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-import reactor.test.StepVerifier;
-
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.LocalTime;
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-
-/**
- * 签到模块接口测试类
- * 测试模块三（gym-checkIn）的所有接口
- */
-class CheckInModuleTest {
-
-    @Mock
-    private QRCodeConfig qrCodeConfig;
-
-    @Mock
-    private RedisUtil redisUtil;
-
-    @Mock
-    private MemberCardRecordRepository memberCardRecordRepository;
-
-    @Mock
-    private MemberCardRepository memberCardRepository;
-
-    @Mock
-    private SignInRecordRepository signInRecordRepository;
-
-    @Mock
-    private IGroupCourseBookingService groupCourseBookingService;
-
-    @Mock
-    private IMemberRepository memberRepository;
-
-    @Mock
-    private MemberCard mockMemberCard;
-
-    @Mock
-    private SignInRecord mockSignInRecord;
-
-    @Mock
-    private MemberCardRecord mockMemberCardRecord;
-
-    private CheckServiceImpl checkService;
-
-    @BeforeEach
-    void setUp() {
-        MockitoAnnotations.openMocks(this);
-        checkService = new CheckServiceImpl(qrCodeConfig, redisUtil, memberCardRecordRepository, 
-                memberCardRepository, signInRecordRepository, groupCourseBookingService, memberRepository);
-
-        when(mockMemberCard.getId()).thenReturn(1L);
-        when(mockMemberCard.getMemberCardType()).thenReturn("TIME_CARD");
-
-        when(mockSignInRecord.getId()).thenReturn(1L);
-        when(mockSignInRecord.getMemberId()).thenReturn(1L);
-        when(mockSignInRecord.getMemberCardId()).thenReturn(1L);
-        when(mockSignInRecord.getSignInTime()).thenReturn(LocalDateTime.now());
-        when(mockSignInRecord.getSignInType()).thenReturn("QR_CODE");
-        when(mockSignInRecord.getSignInStatus()).thenReturn("SUCCESS");
-        when(mockSignInRecord.getSource()).thenReturn("MINI_PROGRAM");
-
-        when(mockMemberCardRecord.getMemberCardRecordId()).thenReturn(1L);
-        when(mockMemberCardRecord.getMemberCardId()).thenReturn(1L);
-        when(mockMemberCardRecord.getRemainingTimes()).thenReturn(10);
-        when(mockMemberCardRecord.getRemainingAmount()).thenReturn(100.0);
-        when(mockMemberCardRecord.getExpireTime()).thenReturn(LocalDateTime.now().plusDays(30));
-        when(mockMemberCardRecord.getStatus()).thenReturn(cn.novalon.gym.manage.member.enums.MemberCardRecordStatus.ACTIVE);
-    }
-
-    @Test
-    @DisplayName("测试1: 获取二维码 - getQRCode")
-    void testGetQRCode() {
-        when(memberCardRecordRepository.findActiveCardsByMemberId(1L))
-                .thenReturn(Flux.just(mockMemberCardRecord));
-        when(redisUtil.setWithExpire(any(String.class), any(Map.class), any(Long.class)))
-                .thenReturn(Mono.just(true));
-
-        Mono<QRCodeVo> result = checkService.getQRCode(1L);
-
-        StepVerifier.create(result)
-                .expectNextMatches(qrCodeVo -> {
-                    org.junit.jupiter.api.Assertions.assertNotNull(qrCodeVo);
-                    org.junit.jupiter.api.Assertions.assertNotNull(qrCodeVo.getQrContent());
-                    return true;
-                })
-                .verifyComplete();
-    }
-
-    @Test
-    @DisplayName("测试2: 签到 - checkIn")
-    void testCheckIn() {
-        Long memberId = 1L;
-        Map<String, Object> qrData = new HashMap<>();
-        qrData.put("qrContent", "test-qr-content");
-        qrData.put("memberId", memberId);
-        qrData.put("memberCardRecordId", 1L);
-        qrData.put("isUsed", false);
-        qrData.put("expireTime", System.currentTimeMillis() + 3600000);
-        
-        String key = RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now();
-        
-        when(redisUtil.get(eq(key))).thenReturn(Mono.just(qrData));
-        when(memberCardRecordRepository.findById(1L)).thenReturn(Mono.just(mockMemberCardRecord));
-        when(memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(mockMemberCard));
-        when(signInRecordRepository.save(any(SignInRecord.class))).thenReturn(Mono.just(mockSignInRecord));
-        when(redisUtil.set(any(String.class), any(Map.class))).thenReturn(Mono.just(true));
-        when(groupCourseBookingService.getBookingsByMemberId(memberId)).thenReturn(Flux.empty());
-        when(signInRecordRepository.findByMemberIdAndDate(eq(memberId), any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Mono.empty());
-
-        Mono<String> result = checkService.checkIn(memberId, "test-qr-content");
-
-        StepVerifier.create(result)
-                .expectNextMatches(response -> response.contains("签到成功"))
-                .verifyComplete();
-    }
-
-    @Test
-    @DisplayName("测试3: 查询签到记录列表 - getSignInRecords")
-    void testGetSignInRecords() {
-        when(signInRecordRepository.findByMemberIdAndTimeRange(
-                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Flux.just(mockSignInRecord));
-
-        Flux<SignInRecordVO> result = checkService.getSignInRecords(1L, 
-                LocalDate.now().minusDays(30), LocalDate.now());
-
-        StepVerifier.create(result)
-                .expectNextCount(1)
-                .verifyComplete();
-    }
-
-    @Test
-    @DisplayName("测试4: 查询单条签到记录 - getSignInRecordById")
-    void testGetSignInRecordById() {
-        when(signInRecordRepository.findById(1L))
-                .thenReturn(Mono.just(mockSignInRecord));
-
-        Mono<SignInRecordVO> result = checkService.getSignInRecordById(1L);
-
-        StepVerifier.create(result)
-                .expectNextMatches(vo -> vo.getId() == 1L)
-                .verifyComplete();
-    }
-
-    @Test
-    @DisplayName("测试5: 查询签到记录 - 记录不存在")
-    void testGetSignInRecordById_NotFound() {
-        when(signInRecordRepository.findById(999L))
-                .thenReturn(Mono.empty());
-
-        Mono<SignInRecordVO> result = checkService.getSignInRecordById(999L);
-
-        StepVerifier.create(result)
-                .verifyComplete();
-    }
-
-    @Test
-    @DisplayName("测试6: 获取签到统计 - getSignInStats")
-    void testGetSignInStats() {
-        when(signInRecordRepository.countByMemberIdAndTimeRange(
-                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Mono.just(10L));
-        when(signInRecordRepository.countSuccessByMemberIdAndTimeRange(
-                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Mono.just(8L));
-        when(signInRecordRepository.getFirstSignInTime(
-                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Mono.just(LocalDateTime.now().minusDays(29)));
-        when(signInRecordRepository.getLastSignInTime(
-                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Mono.just(LocalDateTime.now()));
-
-        Mono<SignInStatsVO> result = checkService.getSignInStats(1L, 
-                LocalDate.now().minusDays(30), LocalDate.now());
-
-        StepVerifier.create(result)
-                .expectNextMatches(stats -> {
-                    org.junit.jupiter.api.Assertions.assertEquals(10L, stats.getTotalCount());
-                    org.junit.jupiter.api.Assertions.assertEquals(8L, stats.getSuccessCount());
-                    return true;
-                })
-                .verifyComplete();
-    }
-
-    @Test
-    @DisplayName("测试7: 获取每日签到统计 - getDailySignInStats")
-    void testGetDailySignInStats() {
-        when(signInRecordRepository.countByTimeRange(any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Mono.just(50L));
-        when(signInRecordRepository.countSuccessByTimeRange(
-                any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Mono.just(45L));
-        when(signInRecordRepository.countDistinctMembersByTimeRange(
-                any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Mono.just(30L));
-
-        Mono<SignInStatsVO> result = checkService.getDailySignInStats(LocalDate.now());
-
-        StepVerifier.create(result)
-                .expectNextMatches(stats -> {
-                    org.junit.jupiter.api.Assertions.assertEquals(50L, stats.getTotalCount());
-                    org.junit.jupiter.api.Assertions.assertEquals(45L, stats.getSuccessCount());
-                    org.junit.jupiter.api.Assertions.assertEquals(30L, stats.getUniqueMemberCount());
-                    return true;
-                })
-                .verifyComplete();
-    }
-
-    @Test
-    @DisplayName("测试8: 导出签到记录 - exportSignInRecords")
-    void testExportSignInRecords() {
-        when(signInRecordRepository.findByMemberIdAndTimeRange(
-                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Flux.just(mockSignInRecord));
-
-        Mono<byte[]> result = checkService.exportSignInRecords(1L, 
-                LocalDate.now().minusDays(7), LocalDate.now());
-
-        StepVerifier.create(result)
-                .expectNextMatches(bytes -> bytes.length > 0)
-                .verifyComplete();
-    }
-
-    @Test
-    @DisplayName("测试9: 签到失败 - 二维码无效")
-    void testCheckIn_QRCodeInvalid() {
-        Long memberId = 1L;
-        String key = RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now();
-        when(redisUtil.get(eq(key))).thenReturn(Mono.just(new HashMap<>()));
-        when(signInRecordRepository.findByMemberIdAndDate(eq(memberId), any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Mono.empty());
-
-        Mono<String> result = checkService.checkIn(memberId, "invalid-qr");
-
-        StepVerifier.create(result)
-                .expectError(RuntimeException.class)
-                .verify();
-    }
-
-    @Test
-    @DisplayName("测试10: 签到失败 - 二维码不存在")
-    void testCheckIn_QRCodeNotFound() {
-        Long memberId = 1L;
-        String key = RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now();
-        when(redisUtil.get(eq(key))).thenReturn(Mono.empty());
-        when(signInRecordRepository.findByMemberIdAndDate(eq(memberId), any(LocalDateTime.class), any(LocalDateTime.class)))
-                .thenReturn(Mono.empty());
-
-        Mono<String> result = checkService.checkIn(memberId, "not-exist");
-
-        StepVerifier.create(result)
-                .verifyComplete();
-    }
-}

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

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

gym-manage-api/gym-dataCount/.gitignore

@@ -1,33 +0,0 @@
-HELP.md
-target/
-.mvn/wrapper/maven-wrapper.jar
-!**/src/main/**/target/
-!**/src/test/**/target/
-
-### STS ###
-.apt_generated
-.classpath
-.factorypath
-.project
-.settings
-.springBeans
-.sts4-cache
-
-### IntelliJ IDEA ###
-.idea
-*.iws
-*.iml
-*.ipr
-
-### NetBeans ###
-/nbproject/private/
-/nbbuild/
-/dist/
-/nbdist/
-/.nb-gradle/
-build/
-!**/src/main/**/build/
-!**/src/test/**/build/
-
-### VS Code ###
-.vscode/

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

@@ -1,3 +0,0 @@
-wrapperVersion=3.3.4
-distributionType=only-script
-distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.16/apache-maven-3.9.16-bin.zip

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

@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <parent>
-        <groupId>cn.novalon.gym.manage</groupId>
-        <artifactId>gym-manage-api</artifactId>
-        <version>1.0.0</version>
-        <relativePath>../pom.xml</relativePath>
-    </parent>
-    <groupId>cn.novalon.gym.manage</groupId>
-    <artifactId>gym-dataCount</artifactId>
-    <version>1.0.0</version>
-    <name>gym-dataCount</name>
-    <description>Data Statistics Module for Gym Management</description>
-
-    <properties>
-        <java.version>21</java.version>
-    </properties>
-
-    <dependencies>
-        <!-- Common模块 -->
-        <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>
-
-        <!-- WebFlux -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-webflux</artifactId>
-        </dependency>
-
-        <!-- R2dbc -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-r2dbc</artifactId>
-        </dependency>
-
-        <!-- Redis -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-redis</artifactId>
-        </dependency>
-
-        <!-- Validation -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-validation</artifactId>
-        </dependency>
-
-        <!-- Swagger -->
-        <dependency>
-            <groupId>org.springdoc</groupId>
-            <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
-        </dependency>
-
-        <!-- POI for Excel export -->
-        <dependency>
-            <groupId>org.apache.poi</groupId>
-            <artifactId>poi-ooxml</artifactId>
-            <version>5.2.5</version>
-        </dependency>
-
-        <!-- Gym Modules -->
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>gym-member</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>gym-groupCourse</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>gym-checkIn</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-
-        <!-- Test -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.11.0</version>
-                <configuration>
-                    <source>21</source>
-                    <target>21</target>
-                    <annotationProcessorPaths>
-                        <path>
-                            <groupId>org.projectlombok</groupId>
-                            <artifactId>lombok</artifactId>
-                            <version>${lombok.version}</version>
-                        </path>
-                    </annotationProcessorPaths>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-</project>

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/config/DataCountAutoConfiguration.java

@@ -1,15 +0,0 @@
-package cn.novalon.gym.manage.datacount.config;
-
-import org.springframework.boot.autoconfigure.AutoConfiguration;
-import org.springframework.context.annotation.ComponentScan;
-
-/**
- * 数据统计模块自动配置
- *
- * @author system
- * @date 2026-06-09
- */
-@AutoConfiguration
-@ComponentScan(basePackages = "cn.novalon.gym.manage.datacount")
-public class DataCountAutoConfiguration {
-}

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/dao/DataStatisticsDao.java

@@ -1,183 +0,0 @@
-package cn.novalon.gym.manage.datacount.dao;
-
-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;
-
-/**
- * 数据统计 DAO - 使用 DatabaseClient 执行跨表聚合查询
- *
- * @author system
- * @date 2026-06-09
- */
-@Repository
-public class DataStatisticsDao {
-
-    private final DatabaseClient databaseClient;
-
-    public DataStatisticsDao(DatabaseClient databaseClient) {
-        this.databaseClient = databaseClient;
-    }
-
-    /**
-     * 统计指定时间范围内新增会员数
-     */
-    public Mono<Long> countNewMembers(LocalDateTime startTime, LocalDateTime endTime) {
-        return databaseClient.sql("SELECT COUNT(*) FROM member_user WHERE created_at >= :startTime AND created_at < :endTime AND deleted_at IS NULL")
-                .bind("startTime", startTime)
-                .bind("endTime", endTime)
-                .map(row -> row.get(0, Long.class))
-                .one();
-    }
-
-    /**
-     * 统计总会员数
-     */
-    public Mono<Long> countTotalMembers() {
-        return databaseClient.sql("SELECT COUNT(*) FROM member_user WHERE deleted_at IS NULL")
-                .map(row -> row.get(0, Long.class))
-                .one();
-    }
-
-    /**
-     * 统计指定时间范围内的签到次数
-     */
-    public Mono<Long> countSignIns(LocalDateTime startTime, LocalDateTime endTime) {
-        return databaseClient.sql("SELECT COUNT(*) FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time < :endTime AND is_delete = false")
-                .bind("startTime", startTime)
-                .bind("endTime", endTime)
-                .map(row -> row.get(0, Long.class))
-                .one();
-    }
-
-    /**
-     * 统计指定时间范围内的成功签到次数
-     */
-    public Mono<Long> countSuccessSignIns(LocalDateTime startTime, LocalDateTime endTime) {
-        return databaseClient.sql("SELECT COUNT(*) FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time < :endTime AND sign_in_status = 'SUCCESS' AND is_delete = false")
-                .bind("startTime", startTime)
-                .bind("endTime", endTime)
-                .map(row -> row.get(0, Long.class))
-                .one();
-    }
-
-    /**
-     * 统计指定时间范围内签到的独立会员数
-     */
-    public Mono<Long> countDistinctSignInMembers(LocalDateTime startTime, LocalDateTime endTime) {
-        return databaseClient.sql("SELECT COUNT(DISTINCT member_id) FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time < :endTime AND is_delete = false")
-                .bind("startTime", startTime)
-                .bind("endTime", endTime)
-                .map(row -> row.get(0, Long.class))
-                .one();
-    }
-
-    /**
-     * 统计指定时间范围内的预约数
-     */
-    public Mono<Long> countBookings(LocalDateTime startTime, LocalDateTime endTime) {
-        return databaseClient.sql("SELECT COUNT(*) FROM group_course_booking WHERE booking_time >= :startTime AND booking_time < :endTime AND deleted_at IS NULL")
-                .bind("startTime", startTime)
-                .bind("endTime", endTime)
-                .map(row -> row.get(0, Long.class))
-                .one();
-    }
-
-    /**
-     * 统计指定时间范围内的取消预约数
-     */
-    public Mono<Long> countCancelBookings(LocalDateTime startTime, LocalDateTime endTime) {
-        return databaseClient.sql("SELECT COUNT(*) FROM group_course_booking WHERE booking_time >= :startTime AND booking_time < :endTime AND status = '1' AND deleted_at IS NULL")
-                .bind("startTime", startTime)
-                .bind("endTime", endTime)
-                .map(row -> row.get(0, Long.class))
-                .one();
-    }
-
-    /**
-     * 统计指定时间范围内的出席预约数
-     */
-    public Mono<Long> countAttendBookings(LocalDateTime startTime, LocalDateTime endTime) {
-        return databaseClient.sql("SELECT COUNT(*) FROM group_course_booking WHERE booking_time >= :startTime AND booking_time < :endTime AND status = '2' AND deleted_at IS NULL")
-                .bind("startTime", startTime)
-                .bind("endTime", endTime)
-                .map(row -> row.get(0, Long.class))
-                .one();
-    }
-
-    /**
-     * 统计指定时间范围内的缺席预约数
-     */
-    public Mono<Long> countAbsentBookings(LocalDateTime startTime, LocalDateTime endTime) {
-        return databaseClient.sql("SELECT COUNT(*) FROM group_course_booking WHERE booking_time >= :startTime AND booking_time < :endTime AND status = '3' AND deleted_at IS NULL")
-                .bind("startTime", startTime)
-                .bind("endTime", endTime)
-                .map(row -> row.get(0, Long.class))
-                .one();
-    }
-
-    /**
-     * 统计指定时间范围内有预约的独立会员数
-     */
-    public Mono<Long> countDistinctBookingMembers(LocalDateTime startTime, LocalDateTime endTime) {
-        return databaseClient.sql("SELECT COUNT(DISTINCT member_id) FROM group_course_booking WHERE booking_time >= :startTime AND booking_time < :endTime AND deleted_at IS NULL")
-                .bind("startTime", startTime)
-                .bind("endTime", endTime)
-                .map(row -> row.get(0, Long.class))
-                .one();
-    }
-
-    /**
-     * 统计指定时间范围内取消预约的独立会员数
-     */
-    public Mono<Long> countDistinctCancelMembers(LocalDateTime startTime, LocalDateTime endTime) {
-        return databaseClient.sql("SELECT COUNT(DISTINCT member_id) FROM group_course_booking WHERE booking_time >= :startTime AND booking_time < :endTime AND status = '1' AND deleted_at IS NULL")
-                .bind("startTime", startTime)
-                .bind("endTime", endTime)
-                .map(row -> row.get(0, Long.class))
-                .one();
-    }
-
-    /**
-     * 按签到类型统计次数
-     */
-    public Flux<SignInTypeCount> countSignInsByType(LocalDateTime startTime, LocalDateTime endTime) {
-        return databaseClient.sql("SELECT sign_in_type as type, COUNT(*) as count FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time < :endTime AND is_delete = false GROUP BY sign_in_type")
-                .bind("startTime", startTime)
-                .bind("endTime", endTime)
-                .map(row -> {
-                    SignInTypeCount result = new SignInTypeCount();
-                    result.setType(row.get("type", String.class));
-                    result.setCount(row.get("count", Long.class));
-                    return result;
-                })
-                .all();
-    }
-
-    /**
-     * 签到类型计数结果
-     */
-    public static class SignInTypeCount {
-        private String type;
-        private Long count;
-
-        public String getType() {
-            return type;
-        }
-
-        public void setType(String type) {
-            this.type = type;
-        }
-
-        public Long getCount() {
-            return count;
-        }
-
-        public void setCount(Long count) {
-            this.count = count;
-        }
-    }
-}

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/domain/BookingStatistics.java

@@ -1,64 +0,0 @@
-package cn.novalon.gym.manage.datacount.domain;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-/**
- * 预约数据统计结果
- *
- * @author system
- * @date 2026-06-09
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class BookingStatistics {
-
-    /**
-     * 统计日期
-     */
-    private String statDate;
-
-    /**
-     * 新增预约数
-     */
-    private Long newBookings;
-
-    /**
-     * 取消预约数
-     */
-    private Long cancelBookings;
-
-    /**
-     * 出席预约数
-     */
-    private Long attendBookings;
-
-    /**
-     * 缺席预约数
-     */
-    private Long absentBookings;
-
-    /**
-     * 预约出席率
-     */
-    private Double attendanceRate;
-
-    /**
-     * 取消率
-     */
-    private Double cancelRate;
-
-    /**
-     * 预约人数（独立会员数）
-     */
-    private Long bookingMembers;
-
-    /**
-     * 取消人数（独立会员数）
-     */
-    private Long cancelMembers;
-}

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/domain/DataStatistics.java

@@ -1,79 +0,0 @@
-package cn.novalon.gym.manage.datacount.domain;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.time.LocalDateTime;
-
-/**
- * 数据统计结果域对象
- *
- * @author system
- * @date 2026-06-09
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class DataStatistics {
-
-    /**
-     * 统计类型：MEMBER-会员统计，BOOKING-预约统计，SIGN_IN-签到统计
-     */
-    private String statType;
-
-    /**
-     * 统计周期：DAY-日统计，WEEK-周统计，MONTH-月统计
-     */
-    private String periodType;
-
-    /**
-     * 统计日期（DAY时为具体日期，WEEK时为周开始日期，MONTH时为月份第一天）
-     */
-    private LocalDateTime statDate;
-
-    /**
-     * 统计数据值
-     */
-    private Long count;
-
-    /**
-     * 关联ID（如会员ID等）
-     */
-    private Long relatedId;
-
-    /**
-     * 扩展数据（JSON格式存储额外信息）
-     */
-    private String extraData;
-
-    /**
-     * 统计周期常量
-     */
-    public static final class PeriodType {
-        /** 日统计 */
-        public static final String DAY = "DAY";
-        /** 周统计 */
-        public static final String WEEK = "WEEK";
-        /** 月统计 */
-        public static final String MONTH = "MONTH";
-
-        private PeriodType() {}
-    }
-
-    /**
-     * 统计类型常量
-     */
-    public static final class StatType {
-        /** 会员统计 */
-        public static final String MEMBER = "MEMBER";
-        /** 预约统计 */
-        public static final String BOOKING = "BOOKING";
-        /** 签到统计 */
-        public static final String SIGN_IN = "SIGN_IN";
-
-        private StatType() {}
-    }
-}

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/domain/MemberStatistics.java

@@ -1,54 +0,0 @@
-package cn.novalon.gym.manage.datacount.domain;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-/**
- * 会员数据统计结果
- *
- * @author system
- * @date 2026-06-09
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class MemberStatistics {
-
-    /**
-     * 统计日期
-     */
-    private String statDate;
-
-    /**
-     * 新增会员数
-     */
-    private Long newMembers;
-
-    /**
-     * 活跃会员数（当天有签到或预约的会员）
-     */
-    private Long activeMembers;
-
-    /**
-     * 累计会员总数
-     */
-    private Long totalMembers;
-
-    /**
-     * 今日签到会员数
-     */
-    private Long signInMembers;
-
-    /**
-     * 今日预约会员数
-     */
-    private Long bookingMembers;
-
-    /**
-     * 今日取消预约会员数
-     */
-    private Long cancelBookingMembers;
-}

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/domain/SignInStatistics.java

@@ -1,64 +0,0 @@
-package cn.novalon.gym.manage.datacount.domain;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-/**
- * 签到数据统计结果
- *
- * @author system
- * @date 2026-06-09
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class SignInStatistics {
-
-    /**
-     * 统计日期
-     */
-    private String statDate;
-
-    /**
-     * 签到总次数
-     */
-    private Long totalSignIns;
-
-    /**
-     * 成功签到次数
-     */
-    private Long successSignIns;
-
-    /**
-     * 失败签到次数
-     */
-    private Long failedSignIns;
-
-    /**
-     * 签到成功率
-     */
-    private Double successRate;
-
-    /**
-     * 签到人数（独立会员数）
-     */
-    private Long signInMembers;
-
-    /**
-     * 扫码签到次数
-     */
-    private Long qrCodeSignIns;
-
-    /**
-     * 手动签到次数
-     */
-    private Long manualSignIns;
-
-    /**
-     * 人脸识别签到次数
-     */
-    private Long faceSignIns;
-}

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/domain/StatisticsQuery.java

@@ -1,52 +0,0 @@
-package cn.novalon.gym.manage.datacount.domain;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.time.LocalDateTime;
-
-/**
- * 统计数据查询请求
- *
- * @author system
- * @date 2026-06-09
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class StatisticsQuery {
-
-    /**
-     * 统计类型：MEMBER-会员统计，BOOKING-预约统计，SIGN_IN-签到统计
-     * 空表示所有类型
-     */
-    private String statType;
-
-    /**
-     * 统计周期：DAY-日统计，WEEK-周统计，MONTH-月统计
-     */
-    private String periodType;
-
-    /**
-     * 开始时间
-     */
-    private LocalDateTime startTime;
-
-    /**
-     * 结束时间
-     */
-    private LocalDateTime endTime;
-
-    /**
-     * 分页页码
-     */
-    private Integer page;
-
-    /**
-     * 每页大小
-     */
-    private Integer size;
-}

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/domain/StatisticsSummary.java

@@ -1,44 +0,0 @@
-package cn.novalon.gym.manage.datacount.domain;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-/**
- * 统计数据汇总
- *
- * @author system
- * @date 2026-06-09
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class StatisticsSummary {
-
-    /**
-     * 统计日期
-     */
-    private String statDate;
-
-    /**
-     * 会员统计数据
-     */
-    private MemberStatistics memberStatistics;
-
-    /**
-     * 预约统计数据
-     */
-    private BookingStatistics bookingStatistics;
-
-    /**
-     * 签到统计数据
-     */
-    private SignInStatistics signInStatistics;
-
-    /**
-     * 统计数据生成时间
-     */
-    private String generatedAt;
-}

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/handler/DataStatisticsHandler.java

@@ -1,130 +0,0 @@
-package cn.novalon.gym.manage.datacount.handler;
-
-import cn.novalon.gym.manage.datacount.domain.*;
-import cn.novalon.gym.manage.datacount.service.IDataStatisticsService;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.HttpHeaders;
-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.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-
-/**
- * 数据统计 Handler
- *
- * @author system
- * @date 2026-06-09
- */
-@Component
-@Tag(name = "数据统计", description = "数据统计相关操作")
-public class DataStatisticsHandler {
-
-    private static final Logger log = LoggerFactory.getLogger(DataStatisticsHandler.class);
-
-    @Autowired
-    private IDataStatisticsService dataStatisticsService;
-
-    @Operation(summary = "获取综合统计数据", description = "获取会员、预约、签到综合统计数据")
-    public Mono<ServerResponse> getStatisticsSummary(ServerRequest request) {
-        StatisticsQuery query = buildQueryFromRequest(request);
-
-        return dataStatisticsService.getStatisticsSummaryWithCache(query)
-                .flatMap(summary -> ServerResponse.ok().bodyValue(summary))
-                .onErrorResume(e -> {
-                    log.error("获取综合统计数据失败", e);
-                    StatisticsSummary errorSummary = StatisticsSummary.builder()
-                            .statDate(LocalDateTime.now().toLocalDate().toString())
-                            .generatedAt(LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME))
-                            .build();
-                    return ServerResponse.ok().bodyValue(errorSummary);
-                });
-    }
-
-    @Operation(summary = "获取会员统计数据", description = "获取会员统计数据")
-    public Mono<ServerResponse> getMemberStatistics(ServerRequest request) {
-        StatisticsQuery query = buildQueryFromRequest(request);
-
-        return dataStatisticsService.getMemberStatistics(query)
-                .flatMap(stats -> ServerResponse.ok().bodyValue(stats))
-                .onErrorResume(e -> ServerResponse.ok().bodyValue(MemberStatistics.builder().statDate(query.getStartTime() != null ? query.getStartTime().toLocalDate().toString() : LocalDateTime.now().toLocalDate().toString()).build()));
-    }
-
-    @Operation(summary = "获取预约统计数据", description = "获取预约统计数据")
-    public Mono<ServerResponse> getBookingStatistics(ServerRequest request) {
-        StatisticsQuery query = buildQueryFromRequest(request);
-
-        return dataStatisticsService.getBookingStatistics(query)
-                .flatMap(stats -> ServerResponse.ok().bodyValue(stats))
-                .onErrorResume(e -> ServerResponse.ok().bodyValue(BookingStatistics.builder().statDate(query.getStartTime() != null ? query.getStartTime().toLocalDate().toString() : LocalDateTime.now().toLocalDate().toString()).build()));
-    }
-
-    @Operation(summary = "获取签到统计数据", description = "获取签到统计数据")
-    public Mono<ServerResponse> getSignInStatistics(ServerRequest request) {
-        StatisticsQuery query = buildQueryFromRequest(request);
-
-        return dataStatisticsService.getSignInStatistics(query)
-                .flatMap(stats -> ServerResponse.ok().bodyValue(stats))
-                .onErrorResume(e -> ServerResponse.ok().bodyValue(SignInStatistics.builder().statDate(query.getStartTime() != null ? query.getStartTime().toLocalDate().toString() : LocalDateTime.now().toLocalDate().toString()).build()));
-    }
-
-    @Operation(summary = "查询历史统计数据", description = "查询历史统计数据")
-    public Mono<ServerResponse> queryHistoricalStatistics(ServerRequest request) {
-        StatisticsQuery query = buildQueryFromRequest(request);
-
-        return dataStatisticsService.queryHistoricalStatistics(query)
-                .collectList()
-                .flatMap(stats -> ServerResponse.ok().bodyValue(stats));
-    }
-
-    @Operation(summary = "导出统计数据", description = "导出统计数据为Excel文件")
-    public Mono<ServerResponse> exportStatistics(ServerRequest request) {
-        StatisticsQuery query = buildQueryFromRequest(request);
-
-        return dataStatisticsService.exportStatistics(query)
-                .flatMap(bytes -> {
-                    String filename = "statistics_" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss")) + ".xlsx";
-                    return ServerResponse.ok()
-                            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + filename + "\"")
-                            .contentType(MediaType.parseMediaType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"))
-                            .bodyValue(bytes);
-                })
-                .onErrorResume(e -> ServerResponse.ok().bodyValue("导出失败: " + e.getMessage()));
-    }
-
-    private StatisticsQuery buildQueryFromRequest(ServerRequest request) {
-        StatisticsQuery.StatisticsQueryBuilder builder = StatisticsQuery.builder();
-
-        request.queryParam("statType").ifPresent(builder::statType);
-        request.queryParam("periodType").ifPresent(builder::periodType);
-        request.queryParam("startTime").ifPresent(startTimeStr -> {
-            try {
-                builder.startTime(LocalDateTime.parse(startTimeStr, DateTimeFormatter.ISO_LOCAL_DATE_TIME));
-            } catch (Exception e) {
-                try {
-                    builder.startTime(LocalDateTime.parse(startTimeStr));
-                } catch (Exception ignored) {
-                }
-            }
-        });
-        request.queryParam("endTime").ifPresent(endTimeStr -> {
-            try {
-                builder.endTime(LocalDateTime.parse(endTimeStr, DateTimeFormatter.ISO_LOCAL_DATE_TIME));
-            } catch (Exception e) {
-                try {
-                    builder.endTime(LocalDateTime.parse(endTimeStr));
-                } catch (Exception ignored) {
-                }
-            }
-        });
-
-        return builder.build();
-    }
-}

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/scheduler/DataStatisticsScheduler.java

@@ -1,109 +0,0 @@
-package cn.novalon.gym.manage.datacount.scheduler;
-
-import cn.novalon.gym.manage.datacount.domain.DataStatistics;
-import cn.novalon.gym.manage.datacount.service.IDataStatisticsService;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.scheduling.annotation.Scheduled;
-import org.springframework.stereotype.Component;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDate;
-
-/**
- * 数据统计定时任务
- * 每日凌晨执行统计数据更新
- *
- * @author system
- * @date 2026-06-09
- */
-@Component
-public class DataStatisticsScheduler {
-
-    private static final Logger log = LoggerFactory.getLogger(DataStatisticsScheduler.class);
-
-    @Autowired
-    private IDataStatisticsService dataStatisticsService;
-
-    /**
-     * 每日凌晨2点执行前一天的日统计数据
-     * 使用cron表达式: 0 0 2 * * ?
-     */
-    @Scheduled(cron = "0 0 2 * * ?")
-    public void executeDailyStatistics() {
-        LocalDate yesterday = LocalDate.now().minusDays(1);
-        log.info("Starting daily statistics task for date: {}", yesterday);
-
-        dataStatisticsService.executeDailyStatistics(yesterday)
-                .subscribe(
-                        null,
-                        error -> log.error("Daily statistics task failed for date: {}", yesterday, error),
-                        () -> log.info("Daily statistics task completed for date: {}", yesterday)
-                );
-    }
-
-    /**
-     * 每周一凌晨3点执行上周的周统计数据
-     * 使用cron表达式: 0 0 3 ? * MON
-     */
-    @Scheduled(cron = "0 0 3 ? * MON")
-    public void executeWeeklyStatistics() {
-        LocalDate lastWeek = LocalDate.now().minusWeeks(1);
-        log.info("Starting weekly statistics task for week of: {}", lastWeek);
-
-        // 执行上周每天的统计数据汇总
-        LocalDate weekStart = lastWeek.with(java.time.temporal.TemporalAdjusters.previousOrSame(java.time.DayOfWeek.MONDAY));
-        LocalDate weekEnd = lastWeek.with(java.time.temporal.TemporalAdjusters.nextOrSame(java.time.DayOfWeek.SUNDAY));
-
-        for (LocalDate date = weekStart; !date.isAfter(weekEnd); date = date.plusDays(1)) {
-            final LocalDate statDate = date;
-            dataStatisticsService.executeDailyStatistics(statDate)
-                    .block();
-        }
-
-        log.info("Weekly statistics task completed for week: {} - {}", weekStart, weekEnd);
-    }
-
-    /**
-     * 每月1日凌晨3点执行上个月的月统计数据
-     * 使用cron表达式: 0 0 3 1 * ?
-     */
-    @Scheduled(cron = "0 0 3 1 * ?")
-    public void executeMonthlyStatistics() {
-        LocalDate lastMonth = LocalDate.now().minusMonths(1);
-        log.info("Starting monthly statistics task for month: {}", lastMonth.getMonth());
-
-        // 执行上个月每天的统计数据补全
-        LocalDate startOfMonth = lastMonth.withDayOfMonth(1);
-        LocalDate endOfMonth = lastMonth.with(java.time.temporal.TemporalAdjusters.lastDayOfMonth());
-
-        for (LocalDate date = startOfMonth; !date.isAfter(endOfMonth); date = date.plusDays(1)) {
-            final LocalDate statDate = date;
-            dataStatisticsService.executeDailyStatistics(statDate)
-                    .block();
-        }
-
-        log.info("Monthly statistics task completed for month: {}", lastMonth.getMonth());
-    }
-
-    /**
-     * 每月15日凌晨4点清理30天前的旧统计数据
-     * 使用cron表达式: 0 0 4 15 * ?
-     */
-    @Scheduled(cron = "0 0 4 15 * ?")
-    public void cleanupOldStatistics() {
-        LocalDate cutoffDate = LocalDate.now().minusDays(30);
-        log.info("Starting cleanup old statistics task, removing data before: {}", cutoffDate);
-
-        // 清理Redis中的旧统计数据
-        String pattern = "datacount:statistics:*:" + cutoffDate.toString();
-        cn.novalon.gym.manage.common.util.RedisUtil redisUtil = null;
-        try {
-            // 这里可以通过注入的service来清理，但当前实现使用Redis缓存30天自动过期
-            log.info("Old statistics cleanup completed, cutoff date: {}", cutoffDate);
-        } catch (Exception e) {
-            log.error("Failed to cleanup old statistics", e);
-        }
-    }
-}

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/service/IDataStatisticsService.java

@@ -1,78 +0,0 @@
-package cn.novalon.gym.manage.datacount.service;
-
-import cn.novalon.gym.manage.datacount.domain.*;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-/**
- * 数据统计服务接口
- *
- * @author system
- * @date 2026-06-09
- */
-public interface IDataStatisticsService {
-
-    /**
-     * 获取会员统计数据
-     *
-     * @param query 查询条件
-     * @return 会员统计数据
-     */
-    Mono<MemberStatistics> getMemberStatistics(StatisticsQuery query);
-
-    /**
-     * 获取预约统计数据
-     *
-     * @param query 查询条件
-     * @return 预约统计数据
-     */
-    Mono<BookingStatistics> getBookingStatistics(StatisticsQuery query);
-
-    /**
-     * 获取签到统计数据
-     *
-     * @param query 查询条件
-     * @return 签到统计数据
-     */
-    Mono<SignInStatistics> getSignInStatistics(StatisticsQuery query);
-
-    /**
-     * 获取综合统计数据（包含会员、预约、签到）
-     *
-     * @param query 查询条件
-     * @return 综合统计数据
-     */
-    Mono<StatisticsSummary> getStatisticsSummary(StatisticsQuery query);
-
-    /**
-     * 查询历史统计数据
-     *
-     * @param query 查询条件
-     * @return 历史统计数据列表
-     */
-    Flux<DataStatistics> queryHistoricalStatistics(StatisticsQuery query);
-
-    /**
-     * 执行每日统计数据更新（定时任务调用）
-     *
-     * @param statDate 统计日期
-     * @return 更新结果
-     */
-    Mono<Void> executeDailyStatistics(java.time.LocalDate statDate);
-
-    /**
-     * 导出统计数据为Excel
-     *
-     * @param query 查询条件
-     * @return Excel文件的字节数组
-     */
-    Mono<byte[]> exportStatistics(StatisticsQuery query);
-
-    /**
-     * 获取统计数据（带缓存）
-     *
-     * @param query 查询条件
-     * @return 统计数据
-     */
-    Mono<StatisticsSummary> getStatisticsSummaryWithCache(StatisticsQuery query);
-}

gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/service/impl/DataStatisticsServiceImpl.java

@@ -1,586 +0,0 @@
-package cn.novalon.gym.manage.datacount.service.impl;
-
-import cn.novalon.gym.manage.checkIn.entity.SignInRecord;
-import cn.novalon.gym.manage.common.util.RedisUtil;
-import cn.novalon.gym.manage.datacount.dao.DataStatisticsDao;
-import cn.novalon.gym.manage.datacount.domain.*;
-import cn.novalon.gym.manage.datacount.service.IDataStatisticsService;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.apache.poi.ss.usermodel.*;
-import org.apache.poi.xssf.usermodel.XSSFWorkbook;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.stereotype.Service;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.io.ByteArrayOutputStream;
-import java.time.DayOfWeek;
-import java.time.Duration;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-import java.time.temporal.TemporalAdjusters;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 数据统计服务实现类
- *
- * @author system
- * @date 2026-06-09
- */
-@Service
-public class DataStatisticsServiceImpl implements IDataStatisticsService {
-
-    private static final Logger log = LoggerFactory.getLogger(DataStatisticsServiceImpl.class);
-
-    private static final String CACHE_KEY_PREFIX = "datacount:statistics:";
-    private static final long CACHE_EXPIRE_SECONDS = 3600; // 1小时
-
-    @Autowired
-    private DataStatisticsDao dataStatisticsDao;
-
-    @Autowired
-    private RedisUtil redisUtil;
-
-    @Autowired
-    private ObjectMapper objectMapper;
-
-    @Value("${datacount.cache.expire-seconds:3600}")
-    private long cacheExpireSeconds = 3600;
-
-    @Override
-    public Mono<MemberStatistics> getMemberStatistics(StatisticsQuery query) {
-        LocalDateTime startTime = getStartTime(query);
-        LocalDateTime endTime = getEndTime(query);
-
-        Mono<Long> newMembersMono = dataStatisticsDao.countNewMembers(startTime, endTime);
-        Mono<Long> totalMembersMono = dataStatisticsDao.countTotalMembers();
-        Mono<Long> signInMembersMono = dataStatisticsDao.countDistinctSignInMembers(startTime, endTime);
-        Mono<Long> bookingMembersMono = dataStatisticsDao.countDistinctBookingMembers(startTime, endTime);
-        Mono<Long> cancelMembersMono = dataStatisticsDao.countDistinctCancelMembers(startTime, endTime);
-
-        return Mono.zip(newMembersMono, totalMembersMono, signInMembersMono, bookingMembersMono, cancelMembersMono)
-                .map(tuple -> {
-                    long newMembers = tuple.getT1() != null ? tuple.getT1() : 0L;
-                    long totalMembers = tuple.getT2() != null ? tuple.getT2() : 0L;
-                    long signInMembers = tuple.getT3() != null ? tuple.getT3() : 0L;
-                    long bookingMembers = tuple.getT4() != null ? tuple.getT4() : 0L;
-                    long cancelMembers = tuple.getT5() != null ? tuple.getT5() : 0L;
-
-                    // 活跃会员数 = 有签到的 + 有预约的（去重后大概值）
-                    long activeMembers = signInMembers + bookingMembers;
-
-                    return MemberStatistics.builder()
-                            .statDate(startTime.toLocalDate().toString())
-                            .newMembers(newMembers)
-                            .activeMembers(activeMembers)
-                            .totalMembers(totalMembers)
-                            .signInMembers(signInMembers)
-                            .bookingMembers(bookingMembers)
-                            .cancelBookingMembers(cancelMembers)
-                            .build();
-                });
-    }
-
-    @Override
-    public Mono<BookingStatistics> getBookingStatistics(StatisticsQuery query) {
-        LocalDateTime startTime = getStartTime(query);
-        LocalDateTime endTime = getEndTime(query);
-
-        Mono<Long> totalMono = dataStatisticsDao.countBookings(startTime, endTime);
-        Mono<Long> cancelMono = dataStatisticsDao.countCancelBookings(startTime, endTime);
-        Mono<Long> attendMono = dataStatisticsDao.countAttendBookings(startTime, endTime);
-        Mono<Long> absentMono = dataStatisticsDao.countAbsentBookings(startTime, endTime);
-        Mono<Long> bookingMembersMono = dataStatisticsDao.countDistinctBookingMembers(startTime, endTime);
-        Mono<Long> cancelMembersMono = dataStatisticsDao.countDistinctCancelMembers(startTime, endTime);
-
-        return Mono.zip(totalMono, cancelMono, attendMono, absentMono, bookingMembersMono, cancelMembersMono)
-                .map(tuple -> {
-                    long total = tuple.getT1() != null ? tuple.getT1() : 0L;
-                    long cancel = tuple.getT2() != null ? tuple.getT2() : 0L;
-                    long attend = tuple.getT3() != null ? tuple.getT3() : 0L;
-                    long absent = tuple.getT4() != null ? tuple.getT4() : 0L;
-                    long bookingMembers = tuple.getT5() != null ? tuple.getT5() : 0L;
-                    long cancelMembers = tuple.getT6() != null ? tuple.getT6() : 0L;
-
-                    double attendanceRate = total > 0 ? (double) attend / total * 100 : 0;
-                    double cancelRate = total > 0 ? (double) cancel / total * 100 : 0;
-
-                    return BookingStatistics.builder()
-                            .statDate(startTime.toLocalDate().toString())
-                            .newBookings(total)
-                            .cancelBookings(cancel)
-                            .attendBookings(attend)
-                            .absentBookings(absent)
-                            .attendanceRate(Math.round(attendanceRate * 100.0) / 100.0)
-                            .cancelRate(Math.round(cancelRate * 100.0) / 100.0)
-                            .bookingMembers(bookingMembers)
-                            .cancelMembers(cancelMembers)
-                            .build();
-                });
-    }
-
-    @Override
-    public Mono<SignInStatistics> getSignInStatistics(StatisticsQuery query) {
-        LocalDateTime startTime = getStartTime(query);
-        LocalDateTime endTime = getEndTime(query);
-
-        Mono<Long> totalMono = dataStatisticsDao.countSignIns(startTime, endTime);
-        Mono<Long> successMono = dataStatisticsDao.countSuccessSignIns(startTime, endTime);
-        Mono<Long> distinctMembersMono = dataStatisticsDao.countDistinctSignInMembers(startTime, endTime);
-
-        return Mono.zip(totalMono, successMono, distinctMembersMono)
-                .flatMap(tuple -> {
-                    long total = tuple.getT1() != null ? tuple.getT1() : 0L;
-                    long success = tuple.getT2() != null ? tuple.getT2() : 0L;
-                    long distinctMembers = tuple.getT3() != null ? tuple.getT3() : 0L;
-
-                    double successRate = total > 0 ? (double) success / total * 100 : 0;
-
-                    return dataStatisticsDao.countSignInsByType(startTime, endTime)
-                            .collectMap(
-                                    DataStatisticsDao.SignInTypeCount::getType,
-                                    DataStatisticsDao.SignInTypeCount::getCount
-                            )
-                            .defaultIfEmpty(new HashMap<>())
-                            .map(typeCountMap -> {
-                                long qrCode = getCountByType(typeCountMap, SignInRecord.SignInType.QR_CODE);
-                                long manual = getCountByType(typeCountMap, SignInRecord.SignInType.MANUAL);
-                                long face = getCountByType(typeCountMap, SignInRecord.SignInType.FACE);
-
-                                return SignInStatistics.builder()
-                                        .statDate(startTime.toLocalDate().toString())
-                                        .totalSignIns(total)
-                                        .successSignIns(success)
-                                        .failedSignIns(total - success)
-                                        .successRate(Math.round(successRate * 100.0) / 100.0)
-                                        .signInMembers(distinctMembers)
-                                        .qrCodeSignIns(qrCode)
-                                        .manualSignIns(manual)
-                                        .faceSignIns(face)
-                                        .build();
-                            });
-                });
-    }
-
-    private long getCountByType(Map<String, Long> typeCountMap, String type) {
-        Long count = typeCountMap.get(type);
-        return count != null ? count : 0L;
-    }
-
-    @Override
-    public Mono<StatisticsSummary> getStatisticsSummary(StatisticsQuery query) {
-        String statDate = query.getStartTime() != null
-                ? query.getStartTime().toLocalDate().toString()
-                : LocalDateTime.now().toLocalDate().toString();
-
-        Mono<MemberStatistics> memberStatsMono = getMemberStatistics(query)
-                .onErrorResume(e -> {
-                    log.error("获取会员统计数据失败", e);
-                    return Mono.just(MemberStatistics.builder().statDate(statDate).build());
-                });
-        Mono<BookingStatistics> bookingStatsMono = getBookingStatistics(query)
-                .onErrorResume(e -> {
-                    log.error("获取预约统计数据失败", e);
-                    return Mono.just(BookingStatistics.builder().statDate(statDate).build());
-                });
-        Mono<SignInStatistics> signInStatsMono = getSignInStatistics(query)
-                .onErrorResume(e -> {
-                    log.error("获取签到统计数据失败", e);
-                    return Mono.just(SignInStatistics.builder().statDate(statDate).build());
-                });
-
-        return Mono.zip(memberStatsMono, bookingStatsMono, signInStatsMono)
-                .map(tuple -> StatisticsSummary.builder()
-                        .statDate(LocalDateTime.now().toLocalDate().toString())
-                        .memberStatistics(tuple.getT1())
-                        .bookingStatistics(tuple.getT2())
-                        .signInStatistics(tuple.getT3())
-                        .generatedAt(LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME))
-                        .build());
-    }
-
-    @Override
-    public Flux<DataStatistics> queryHistoricalStatistics(StatisticsQuery query) {
-        // 历史统计数据查询（从Redis缓存中获取）
-        String cacheKey = buildCacheKey(query);
-        return redisUtil.get(cacheKey, String.class)
-                .flatMapMany(json -> {
-                    try {
-                        List<DataStatistics> stats = objectMapper.readValue(json,
-                                objectMapper.getTypeFactory().constructCollectionType(List.class, DataStatistics.class));
-                        return Flux.fromIterable(stats);
-                    } catch (Exception e) {
-                        log.error("Failed to parse historical statistics from cache", e);
-                        return Flux.empty();
-                    }
-                })
-                .switchIfEmpty(buildLiveStatistics(query));
-    }
-
-    /**
-     * 缓存未命中时，从数据库实时构建统计数据
-     */
-    private Flux<DataStatistics> buildLiveStatistics(StatisticsQuery query) {
-        LocalDateTime startTime = getStartTime(query);
-        LocalDateTime endTime = getEndTime(query);
-        String periodType = query.getPeriodType() != null ? query.getPeriodType() : "DAY";
-        LocalDateTime statDate = endTime;
-
-        Mono<Long> memberCountMono = dataStatisticsDao.countNewMembers(startTime, endTime);
-        Mono<Long> totalMembersMono = dataStatisticsDao.countTotalMembers();
-        Mono<Long> bookingCountMono = dataStatisticsDao.countBookings(startTime, endTime);
-        Mono<Long> signInCountMono = dataStatisticsDao.countSignIns(startTime, endTime);
-
-        return Mono.zip(memberCountMono, totalMembersMono, bookingCountMono, signInCountMono)
-                .flatMapMany(tuple -> {
-                    long newMembers = tuple.getT1() != null ? tuple.getT1() : 0L;
-                    long totalMembers = tuple.getT2() != null ? tuple.getT2() : 0L;
-                    long bookings = tuple.getT3() != null ? tuple.getT3() : 0L;
-                    long signIns = tuple.getT4() != null ? tuple.getT4() : 0L;
-
-                    List<DataStatistics> list = new ArrayList<>();
-
-                    DataStatistics memberStat = DataStatistics.builder()
-                            .statType(DataStatistics.StatType.MEMBER)
-                            .periodType(periodType)
-                            .statDate(statDate)
-                            .count(totalMembers)
-                            .extraData("新增" + newMembers + "人")
-                            .build();
-                    list.add(memberStat);
-
-                    DataStatistics bookingStat = DataStatistics.builder()
-                            .statType(DataStatistics.StatType.BOOKING)
-                            .periodType(periodType)
-                            .statDate(statDate)
-                            .count(bookings)
-                            .extraData("新增" + bookings + "条预约")
-                            .build();
-                    list.add(bookingStat);
-
-                    DataStatistics signInStat = DataStatistics.builder()
-                            .statType(DataStatistics.StatType.SIGN_IN)
-                            .periodType(periodType)
-                            .statDate(statDate)
-                            .count(signIns)
-                            .extraData("新增" + signIns + "次签到")
-                            .build();
-                    list.add(signInStat);
-
-                    return Flux.fromIterable(list);
-                });
-    }
-
-    @Override
-    public Mono<Void> executeDailyStatistics(LocalDate statDate) {
-        log.info("Executing daily statistics for date: {}", statDate);
-
-        LocalDateTime dayStart = statDate.atStartOfDay();
-        LocalDateTime dayEnd = statDate.plusDays(1).atStartOfDay();
-
-        StatisticsQuery query = StatisticsQuery.builder()
-                .startTime(dayStart)
-                .endTime(dayEnd)
-                .build();
-
-        Mono<MemberStatistics> memberStatsMono = getMemberStatistics(query);
-        Mono<BookingStatistics> bookingStatsMono = getBookingStatistics(query);
-        Mono<SignInStatistics> signInStatsMono = getSignInStatistics(query);
-
-        return Mono.zip(memberStatsMono, bookingStatsMono, signInStatsMono)
-                .flatMap(tuple -> {
-                    MemberStatistics memberStats = tuple.getT1();
-                    BookingStatistics bookingStats = tuple.getT2();
-                    SignInStatistics signInStats = tuple.getT3();
-
-                    String dateStr = statDate.toString();
-                    String memberKey = CACHE_KEY_PREFIX + "member:" + dateStr;
-                    String bookingKey = CACHE_KEY_PREFIX + "booking:" + dateStr;
-                    String signInKey = CACHE_KEY_PREFIX + "signin:" + dateStr;
-
-                    try {
-                        String memberJson = objectMapper.writeValueAsString(memberStats);
-                        String bookingJson = objectMapper.writeValueAsString(bookingStats);
-                        String signInJson = objectMapper.writeValueAsString(signInStats);
-
-                        return reactor.core.publisher.Flux.merge(
-                                redisUtil.setWithExpire(memberKey, memberJson, Duration.ofDays(30).getSeconds()),
-                                redisUtil.setWithExpire(bookingKey, bookingJson, Duration.ofDays(30).getSeconds()),
-                                redisUtil.setWithExpire(signInKey, signInJson, Duration.ofDays(30).getSeconds())
-                        ).then();
-                    } catch (Exception e) {
-                        log.error("Failed to serialize statistics data", e);
-                        return Mono.empty();
-                    }
-                })
-                .then()
-                .doOnSuccess(v -> log.info("Daily statistics completed for date: {}", statDate))
-                .doOnError(e -> log.error("Failed to execute daily statistics for date: {}", statDate, e));
-    }
-
-    @Override
-    public Mono<byte[]> exportStatistics(StatisticsQuery query) {
-        return getStatisticsSummary(query)
-                .flatMap(summary -> {
-                    try (Workbook workbook = new XSSFWorkbook()) {
-                        Sheet sheet = workbook.createSheet("数据统计报表");
-
-                        CellStyle headerStyle = workbook.createCellStyle();
-                        Font headerFont = workbook.createFont();
-                        headerFont.setBold(true);
-                        headerStyle.setFont(headerFont);
-
-                        createMainSheet(sheet, summary, headerStyle);
-
-                        Sheet memberSheet = workbook.createSheet("会员统计");
-                        createMemberStatisticsSheet(memberSheet, summary.getMemberStatistics(), headerStyle);
-
-                        Sheet bookingSheet = workbook.createSheet("预约统计");
-                        createBookingStatisticsSheet(bookingSheet, summary.getBookingStatistics(), headerStyle);
-
-                        Sheet signInSheet = workbook.createSheet("签到统计");
-                        createSignInStatisticsSheet(signInSheet, summary.getSignInStatistics(), headerStyle);
-
-                        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-                        workbook.write(outputStream);
-                        return Mono.just(outputStream.toByteArray());
-                    } catch (Exception e) {
-                        log.error("Failed to export statistics", e);
-                        return Mono.error(e);
-                    }
-                });
-    }
-
-    private void createMainSheet(Sheet sheet, StatisticsSummary summary, CellStyle headerStyle) {
-        int rowNum = 0;
-        Row row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("统计项");
-        row.createCell(1).setCellValue("数值");
-
-        row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("统计日期");
-        row.createCell(1).setCellValue(summary.getStatDate());
-
-        row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("新增会员数");
-        row.createCell(1).setCellValue(summary.getMemberStatistics().getNewMembers());
-
-        row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("活跃会员数");
-        row.createCell(1).setCellValue(summary.getMemberStatistics().getActiveMembers());
-
-        row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("累计会员总数");
-        row.createCell(1).setCellValue(summary.getMemberStatistics().getTotalMembers());
-
-        row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("新增预约数");
-        row.createCell(1).setCellValue(summary.getBookingStatistics().getNewBookings());
-
-        row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("预约出席率");
-        row.createCell(1).setCellValue(summary.getBookingStatistics().getAttendanceRate() + "%");
-
-        row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("签到总次数");
-        row.createCell(1).setCellValue(summary.getSignInStatistics().getTotalSignIns());
-
-        row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("签到成功率");
-        row.createCell(1).setCellValue(summary.getSignInStatistics().getSuccessRate() + "%");
-
-        sheet.autoSizeColumn(0);
-        sheet.autoSizeColumn(1);
-    }
-
-    private void createMemberStatisticsSheet(Sheet sheet, MemberStatistics stats, CellStyle headerStyle) {
-        int rowNum = 0;
-        Row row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("统计项");
-        row.createCell(1).setCellValue("数值");
-
-        String[][] data = {
-                {"统计日期", stats.getStatDate()},
-                {"新增会员数", String.valueOf(stats.getNewMembers())},
-                {"活跃会员数", String.valueOf(stats.getActiveMembers())},
-                {"累计会员总数", String.valueOf(stats.getTotalMembers())},
-                {"今日签到会员数", String.valueOf(stats.getSignInMembers())},
-                {"今日预约会员数", String.valueOf(stats.getBookingMembers())},
-                {"今日取消预约会员数", String.valueOf(stats.getCancelBookingMembers())}
-        };
-
-        for (String[] rowData : data) {
-            row = sheet.createRow(rowNum++);
-            row.createCell(0).setCellValue(rowData[0]);
-            row.createCell(1).setCellValue(rowData[1]);
-        }
-
-        sheet.autoSizeColumn(0);
-        sheet.autoSizeColumn(1);
-    }
-
-    private void createBookingStatisticsSheet(Sheet sheet, BookingStatistics stats, CellStyle headerStyle) {
-        int rowNum = 0;
-        Row row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("统计项");
-        row.createCell(1).setCellValue("数值");
-
-        String[][] data = {
-                {"统计日期", stats.getStatDate()},
-                {"新增预约数", String.valueOf(stats.getNewBookings())},
-                {"取消预约数", String.valueOf(stats.getCancelBookings())},
-                {"出席预约数", String.valueOf(stats.getAttendBookings())},
-                {"缺席预约数", String.valueOf(stats.getAbsentBookings())},
-                {"预约出席率", stats.getAttendanceRate() + "%"},
-                {"取消率", stats.getCancelRate() + "%"},
-                {"预约人数", String.valueOf(stats.getBookingMembers())},
-                {"取消人数", String.valueOf(stats.getCancelMembers())}
-        };
-
-        for (String[] rowData : data) {
-            row = sheet.createRow(rowNum++);
-            row.createCell(0).setCellValue(rowData[0]);
-            row.createCell(1).setCellValue(rowData[1]);
-        }
-
-        sheet.autoSizeColumn(0);
-        sheet.autoSizeColumn(1);
-    }
-
-    private void createSignInStatisticsSheet(Sheet sheet, SignInStatistics stats, CellStyle headerStyle) {
-        int rowNum = 0;
-        Row row = sheet.createRow(rowNum++);
-        row.createCell(0).setCellValue("统计项");
-        row.createCell(1).setCellValue("数值");
-
-        String[][] data = {
-                {"统计日期", stats.getStatDate()},
-                {"签到总次数", String.valueOf(stats.getTotalSignIns())},
-                {"成功签到次数", String.valueOf(stats.getSuccessSignIns())},
-                {"失败签到次数", String.valueOf(stats.getFailedSignIns())},
-                {"签到成功率", stats.getSuccessRate() + "%"},
-                {"签到人数", String.valueOf(stats.getSignInMembers())},
-                {"扫码签到次数", String.valueOf(stats.getQrCodeSignIns())},
-                {"手动签到次数", String.valueOf(stats.getManualSignIns())},
-                {"人脸识别签到次数", String.valueOf(stats.getFaceSignIns())}
-        };
-
-        for (String[] rowData : data) {
-            row = sheet.createRow(rowNum++);
-            row.createCell(0).setCellValue(rowData[0]);
-            row.createCell(1).setCellValue(rowData[1]);
-        }
-
-        sheet.autoSizeColumn(0);
-        sheet.autoSizeColumn(1);
-    }
-
-    @Override
-    public Mono<StatisticsSummary> getStatisticsSummaryWithCache(StatisticsQuery query) {
-        String cacheKey = buildCacheKey(query);
-
-        return redisUtil.get(cacheKey, StatisticsSummary.class)
-                .switchIfEmpty(
-                        getStatisticsSummary(query)
-                                .flatMap(summary -> {
-                                    try {
-                                        String json = objectMapper.writeValueAsString(summary);
-                                        return redisUtil.setWithExpire(cacheKey, json, cacheExpireSeconds)
-                                                .thenReturn(summary);
-                                    } catch (Exception e) {
-                                        log.error("Failed to serialize statistics summary", e);
-                                        return Mono.just(summary);
-                                    }
-                                })
-                );
-    }
-
-    private String buildCacheKey(StatisticsQuery query) {
-        StringBuilder keyBuilder = new StringBuilder(CACHE_KEY_PREFIX);
-        keyBuilder.append("summary:");
-
-        if (query.getStartTime() != null) {
-            keyBuilder.append(query.getStartTime().toLocalDate().toString());
-        }
-        if (query.getEndTime() != null) {
-            keyBuilder.append("_").append(query.getEndTime().toLocalDate().toString());
-        }
-        if (query.getStatType() != null) {
-            keyBuilder.append("_").append(query.getStatType());
-        }
-        if (query.getPeriodType() != null) {
-            keyBuilder.append("_").append(query.getPeriodType());
-        }
-
-        return keyBuilder.toString();
-    }
-
-    private LocalDateTime getStartTime(StatisticsQuery query) {
-        if (query.getStartTime() != null) {
-            return query.getStartTime();
-        }
-
-        LocalDate today = LocalDate.now();
-        String periodType = query.getPeriodType();
-
-        if (DataStatistics.PeriodType.WEEK.equals(periodType)) {
-            // 周统计：本周一
-            return today.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY)).atStartOfDay();
-        } else if (DataStatistics.PeriodType.MONTH.equals(periodType)) {
-            // 月统计：本月第一天
-            return today.withDayOfMonth(1).atStartOfDay();
-        } else {
-            // 日统计：当天零点
-            return today.atStartOfDay();
-        }
-    }
-
-    private LocalDateTime getEndTime(StatisticsQuery query) {
-        if (query.getEndTime() != null) {
-            return query.getEndTime();
-        }
-
-        LocalDate today = LocalDate.now();
-        String periodType = query.getPeriodType();
-
-        if (DataStatistics.PeriodType.WEEK.equals(periodType)) {
-            // 周统计：本周日 23:59:59
-            return today.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY)).atTime(23, 59, 59);
-        } else if (DataStatistics.PeriodType.MONTH.equals(periodType)) {
-            // 月统计：本月最后一天 23:59:59
-            return today.with(TemporalAdjusters.lastDayOfMonth()).atTime(23, 59, 59);
-        } else {
-            // 日统计：当前时间
-            return LocalDateTime.now();
-        }
-    }
-
-    /**
-     * 根据周期类型调整时间范围
-     * 用于定时任务中的周期统计
-     */
-    private LocalDateTime[] adjustTimeRangeByPeriod(LocalDate date, String periodType) {
-        LocalDateTime startTime;
-        LocalDateTime endTime;
-
-        if (DataStatistics.PeriodType.WEEK.equals(periodType)) {
-            startTime = date.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY)).atStartOfDay();
-            endTime = date.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY)).atTime(23, 59, 59);
-        } else if (DataStatistics.PeriodType.MONTH.equals(periodType)) {
-            startTime = date.withDayOfMonth(1).atStartOfDay();
-            endTime = date.with(TemporalAdjusters.lastDayOfMonth()).atTime(23, 59, 59);
-        } else {
-            startTime = date.atStartOfDay();
-            endTime = date.plusDays(1).atStartOfDay();
-        }
-
-        return new LocalDateTime[]{startTime, endTime};
-    }
-}

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

@@ -1 +0,0 @@
-cn.novalon.gym.manage.datacount.config.DataCountAutoConfiguration

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

@@ -81,32 +81,13 @@
             <artifactId>gym-member</artifactId>
             <version>${project.version}</version>
         </dependency>
-        
-        <!-- ZXing QR Code依赖 -->
-        <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.4</version>
-        </dependency>
     </dependencies>
 
     <build>
         <plugins>
             <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
+                <groupId>org.springframework.boot</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
-                <version>3.4.2</version>
             </plugin>
         </plugins>
     </build>

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/converter/GroupCourseConverter.java

@@ -4,10 +4,8 @@ package cn.novalon.gym.manage.groupcourse.converter;
 import cn.hutool.core.bean.BeanUtil;
 import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
 import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
-import cn.novalon.gym.manage.groupcourse.domain.GroupCourseType;
 import cn.novalon.gym.manage.groupcourse.entity.GroupCourseBookingEntity;
 import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
-import cn.novalon.gym.manage.groupcourse.entity.GroupCourseTypeEntity;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 
@@ -126,33 +124,4 @@ public class GroupCourseConverter {
                 .map(this::toBookingEntity)
                 .collect(Collectors.toList());
     }
-
-    /**
-     * 将团课类型实体转换为领域模型
-     */
-    public GroupCourseType toGroupCourseType(GroupCourseTypeEntity entity){
-        if(entity == null){
-            return null;
-        }
-        GroupCourseType groupCourseType = new GroupCourseType();
-        BeanUtil.copyProperties(entity, groupCourseType);
-        log.debug("转换团课类型实体到领域模型：typeId={}", entity.getId());
-        return groupCourseType;
-    }
-
-    /**
-     * 将团课类型领域模型转换为实体
-     */
-    public GroupCourseTypeEntity toGroupCourseTypeEntity(GroupCourseType domain){
-        if(domain == null){
-            return null;
-        }
-        GroupCourseTypeEntity entity = new GroupCourseTypeEntity();
-        BeanUtil.copyProperties(domain, entity);
-        if (domain.getId() != null) {
-            entity.markNotNew();
-        }
-        log.debug("转换团课类型领域模型到实体：typeId={}", domain.getId());
-        return entity;
-    }
 }

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

@@ -1,34 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.dao;
-
-import cn.novalon.gym.manage.groupcourse.entity.BannerEntity;
-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 BannerDao extends R2dbcRepository<BannerEntity, Long> {
-
-    Mono<BannerEntity> findByIdAndDeletedAtIsNull(Long id);
-
-    Flux<BannerEntity> findAllByDeletedAtIsNull();
-
-    Flux<BannerEntity> findAllByDeletedAtIsNull(Sort sort);
-
-    Flux<BannerEntity> findByIsActiveTrueAndDeletedAtIsNull();
-
-    Flux<BannerEntity> findByIsActiveTrueAndDeletedAtIsNull(Sort sort);
-
-    @Modifying
-    @Query("UPDATE banner 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 banner SET deleted_at = :deletedAt WHERE id = :id")
-    Mono<Integer> softDelete(Long id, LocalDateTime deletedAt);
-}

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

@@ -1,27 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.dao;
-
-import cn.novalon.gym.manage.groupcourse.entity.CourseLabelEntity;
-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 CourseLabelDao extends R2dbcRepository<CourseLabelEntity, Long> {
-
-    Mono<CourseLabelEntity> findByIdIsAndDeletedAtIsNull(Long id);
-
-    Flux<CourseLabelEntity> findAllByDeletedAtIsNull();
-
-    Flux<CourseLabelEntity> findByLabelNameContainingAndDeletedAtIsNull(String labelName);
-
-    Mono<CourseLabelEntity> findByLabelNameAndDeletedAtIsNull(String labelName);
-
-    @Modifying
-    @Query("UPDATE course_label SET deleted_at = :deletedAt WHERE id = :id")
-    Mono<Integer> softDelete(Long id, LocalDateTime deletedAt);
-}

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

@@ -1,38 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.dao;
-
-import cn.novalon.gym.manage.groupcourse.entity.CourseTypeLabelEntity;
-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;
-import java.util.List;
-
-@Repository
-public interface CourseTypeLabelDao extends R2dbcRepository<CourseTypeLabelEntity, Long> {
-
-    Flux<CourseTypeLabelEntity> findByTypeIdAndDeletedAtIsNull(Long typeId);
-
-    Flux<CourseTypeLabelEntity> findByLabelIdAndDeletedAtIsNull(Long labelId);
-
-    Mono<CourseTypeLabelEntity> findByTypeIdAndLabelIdAndDeletedAtIsNull(Long typeId, Long labelId);
-
-    @Modifying
-    @Query("UPDATE course_type_label SET deleted_at = :deletedAt WHERE type_id = :typeId AND label_id = :labelId")
-    Mono<Integer> deleteByTypeIdAndLabelId(Long typeId, Long labelId, LocalDateTime deletedAt);
-
-    @Modifying
-    @Query("UPDATE course_type_label SET deleted_at = :deletedAt WHERE type_id = :typeId")
-    Mono<Integer> deleteByTypeId(Long typeId, LocalDateTime deletedAt);
-
-    @Modifying
-    @Query("DELETE FROM course_type_label WHERE type_id = :typeId AND label_id = :labelId")
-    Mono<Integer> physicalDeleteByTypeIdAndLabelId(Long typeId, Long labelId);
-
-    @Modifying
-    @Query("UPDATE course_type_label SET deleted_at = :deletedAt WHERE label_id = :labelId")
-    Mono<Integer> deleteByLabelId(Long labelId, LocalDateTime deletedAt);
-}

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

@@ -61,12 +61,6 @@ public interface GroupCourseBookingDao extends R2dbcRepository<GroupCourseBookin
      */
     Mono<Long> countByCourseIdAndStatusAndDeletedAtIsNull(Long courseId, String status);
 
-    /**
-     * 统计会员取消的预约次数
-     */
-    @org.springframework.data.r2dbc.repository.Query("SELECT COUNT(*) FROM group_course_booking WHERE member_id = :memberId AND status = '1' AND deleted_at IS NULL")
-    Mono<Long> countCancelledByMemberId(Long memberId);
-
     /**
      * 查询会员是否有时间冲突的预约（状态为已预约且未取消）
      * 时间冲突条件：新课程的开始时间 < 已预约课程的结束时间 且 新课程的结束时间 > 已预约课程的开始时间

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

@@ -1,19 +1,16 @@
+
 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> {
@@ -39,215 +36,4 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
     @Modifying
     @Query("UPDATE group_course SET deleted_at = :deletedAt WHERE id = :id")
     Mono<Integer> softDelete(Long id, LocalDateTime deletedAt);
-
+}
-    @Modifying
-    @Query("UPDATE group_course SET deleted_at = NULL, status = '1', updated_at = :updatedAt WHERE id = :id AND deleted_at IS NOT NULL")
-    Mono<Integer> restoreCourse(Long id, LocalDateTime updatedAt);
-
-    @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);
-
-    @Modifying
-    @Query("UPDATE group_course SET status = '0', current_members = 0, start_time = start_time + INTERVAL '7 days', end_time = end_time + INTERVAL '7 days', updated_at = :updatedAt WHERE is_recurring = TRUE AND status = '2' AND end_time <= NOW() AND deleted_at IS NULL")
-    Mono<Integer> renewRecurringCourses(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;
-            }
-        }
-
-        // 5. 常态化团课筛选
-        if (query.getIsRecurring() != null) {
-            conditions.add("is_recurring = :isRecurring");
-        }
-
-        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());
-        }
-        if (query.getIsRecurring() != null) {
-            spec = spec.bind("isRecurring", query.getIsRecurring());
-        }
-        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));
-            entity.setIsRecurring(row.get("is_recurring", Boolean.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;
-            }
-        }
-
-        if (query.getIsRecurring() != null) {
-            conditions.add("is_recurring = :isRecurring");
-        }
-
-        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());
-        }
-        if (query.getIsRecurring() != null) {
-            spec = spec.bind("isRecurring", query.getIsRecurring());
-        }
-
-        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

@@ -1,42 +0,0 @@
-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/dao/GroupCourseTypeDao.java

@@ -1,36 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.dao;
-
-import cn.novalon.gym.manage.groupcourse.entity.GroupCourseTypeEntity;
-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 GroupCourseTypeDao extends R2dbcRepository<GroupCourseTypeEntity, Long> {
-
-    Mono<GroupCourseTypeEntity> findByIdIsAndDeletedAtIsNull(Long id);
-
-    Flux<GroupCourseTypeEntity> findAllByDeletedAtIsNull();
-
-    Flux<GroupCourseTypeEntity> findAllByDeletedAtIsNull(Sort sort);
-
-    Flux<GroupCourseTypeEntity> findByTypeNameContainingAndDeletedAtIsNull(String typeName);
-
-    Flux<GroupCourseTypeEntity> findByCategoryAndDeletedAtIsNull(String category);
-
-    Mono<GroupCourseTypeEntity> findByTypeNameAndDeletedAtIsNull(String typeName);
-
-    @Modifying
-    @Query("UPDATE group_course_type SET deleted_at = :deletedAt WHERE id = :id")
-    Mono<Integer> softDelete(Long id, LocalDateTime deletedAt);
-
-    @Modifying
-    @Query("UPDATE group_course_type SET type_name = :typeName, base_difficulty = :baseDifficulty, description = :description, category = :category, updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
-    Mono<Integer> updateFields(Long id, String typeName, Integer baseDifficulty, String description, String category, LocalDateTime updatedAt);
-}

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

@@ -1,43 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.domain;
-
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-public class Banner extends BaseDomain {
-
-    @Schema(description = "背景图URL", example = "https://example.com/banner.jpg")
-    private String imageUrl;
-
-    @Schema(description = "主标题", example = "突破自我")
-    private String title;
-
-    @Schema(description = "副标题", example = "超越极限")
-    private String subtitle;
-
-    @Schema(description = "简介", example = "科学训练 · 遇见更好的自己")
-    private String description;
-
-    @Schema(description = "排序（数值越大越靠前）", example = "10")
-    private Integer sortOrder;
-
-    @Schema(description = "是否启用", example = "true")
-    private Boolean isActive;
-
-    public String getImageUrl() { return imageUrl; }
-    public void setImageUrl(String imageUrl) { this.imageUrl = imageUrl; }
-
-    public String getTitle() { return title; }
-    public void setTitle(String title) { this.title = title; }
-
-    public String getSubtitle() { return subtitle; }
-    public void setSubtitle(String subtitle) { this.subtitle = subtitle; }
-
-    public String getDescription() { return description; }
-    public void setDescription(String description) { this.description = description; }
-
-    public Integer getSortOrder() { return sortOrder; }
-    public void setSortOrder(Integer sortOrder) { this.sortOrder = sortOrder; }
-
-    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/domain/CourseLabel.java

@@ -1,43 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.domain;
-
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-public class CourseLabel extends BaseDomain {
-
-    //标签名称
-    @Schema(description = "标签名称", example = "适合新手")
-    private String labelName;
-
-    //标签颜色（十六进制）
-    @Schema(description = "标签颜色（十六进制）", example = "#52c41a")
-    private String color;
-
-    //标签描述
-    @Schema(description = "标签描述", example = "适合健身初学者")
-    private String description;
-
-    public String getLabelName() {
-        return labelName;
-    }
-
-    public void setLabelName(String labelName) {
-        this.labelName = labelName;
-    }
-
-    public String getColor() {
-        return color;
-    }
-
-    public void setColor(String color) {
-        this.color = color;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-}

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

@@ -52,18 +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;
-
-    //是否常态化团课
-    @Schema(description = "是否常态化团课", example = "true")
-    private Boolean isRecurring;
-
     public String getCourseName() {
         return courseName;
     }
@@ -152,6 +148,14 @@ 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;
     }
@@ -159,20 +163,4 @@ 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;
-    }
-
-    public Boolean getIsRecurring() {
-        return isRecurring;
-    }
-
-    public void setIsRecurring(Boolean isRecurring) {
-        this.isRecurring = isRecurring;
-    }
 }

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

@@ -53,10 +53,6 @@ public class GroupCourseBooking extends BaseDomain {
     @Schema(description = "上课地点", example = "健身房A区")
     private String location;
 
-    //封面图URL（非DB字段，由 Service 从 GroupCourse 填充）
-    @Schema(description = "封面图URL", example = "https://example.com/cover.jpg")
-    private String coverImage;
-
     public Long getCourseId() {
         return courseId;
     }
@@ -136,12 +132,4 @@ public class GroupCourseBooking extends BaseDomain {
     public void setLocation(String location) {
         this.location = location;
     }
-
-    public String getCoverImage() {
-        return coverImage;
-    }
-
-    public void setCoverImage(String coverImage) {
-        this.coverImage = coverImage;
-    }
 }

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

@@ -1,254 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.domain;
-
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.List;
-
-/**
- * 团课完整信息领域模型
- * 包含团课基础信息、关联的类型信息以及类型的标签信息
- */
-public class GroupCourseDetail extends BaseDomain {
-
-    // ===== 团课基础信息 =====
-    
-    @Schema(description = "课程名称", example = "瑜伽入门")
-    private String courseName;
-
-    @Schema(description = "教练ID", example = "1")
-    private Long coachId;
-
-    @Schema(description = "课程类型ID", example = "1")
-    private Long courseType;
-
-    @Schema(description = "开始时间", example = "2026-06-02T09:00:00")
-    private LocalDateTime startTime;
-
-    @Schema(description = "结束时间", example = "2026-06-02T10:00:00")
-    private LocalDateTime endTime;
-
-    @Schema(description = "最大参与人数", example = "20")
-    private Integer maxMembers;
-
-    @Schema(description = "当前参与人数", example = "15")
-    private Integer currentMembers;
-
-    @Schema(description = "课程状态", example = "0")
-    private Long status;
-
-    @Schema(description = "上课地点", example = "健身房A区")
-    private String location;
-
-    @Schema(description = "封面图URL", example = "https://example.com/yoga.jpg")
-    private String coverImage;
-
-    @Schema(description = "课程描述", example = "适合初学者的瑜伽课程")
-    private String description;
-
-    @Schema(description = "储值卡额度（消耗金额）", example = "50.00")
-    private BigDecimal storedValueAmount;
-
-    @Schema(description = "二维码路径", example = "D:\\Games\\exmp\\image\\abc123_20260618120000.png")
-    private String qrCodePath;
-
-    // ===== 关联的类型信息 =====
-
-    @Schema(description = "类型信息")
-    private GroupCourseType typeInfo;
-
-    // ===== 快捷访问属性（从类型信息派生）=====
-
-    @Schema(description = "类型名称", example = "瑜伽入门")
-    private String typeName;
-
-    @Schema(description = "类型分类", example = "柔韧与平衡类")
-    private String typeCategory;
-
-    @Schema(description = "基础难度", example = "2")
-    private Integer baseDifficulty;
-
-    @Schema(description = "难度等级描述", example = "初级")
-    private String difficultyLevel;
-
-    @Schema(description = "综合难度系数", example = "2")
-    private Integer calculatedDifficulty;
-
-    // ===== 标签信息（从类型标签派生）=====
-
-    @Schema(description = "标签列表")
-    private List<CourseLabel> labels;
-
-    // ===== Getters and Setters =====
-
-    public String getCourseName() {
-        return courseName;
-    }
-
-    public void setCourseName(String courseName) {
-        this.courseName = courseName;
-    }
-
-    public Long getCoachId() {
-        return coachId;
-    }
-
-    public void setCoachId(Long coachId) {
-        this.coachId = coachId;
-    }
-
-    public Long getCourseType() {
-        return courseType;
-    }
-
-    public void setCourseType(Long courseType) {
-        this.courseType = courseType;
-    }
-
-    public LocalDateTime getStartTime() {
-        return startTime;
-    }
-
-    public void setStartTime(LocalDateTime startTime) {
-        this.startTime = startTime;
-    }
-
-    public LocalDateTime getEndTime() {
-        return endTime;
-    }
-
-    public void setEndTime(LocalDateTime endTime) {
-        this.endTime = endTime;
-    }
-
-    public Integer getMaxMembers() {
-        return maxMembers;
-    }
-
-    public void setMaxMembers(Integer maxMembers) {
-        this.maxMembers = maxMembers;
-    }
-
-    public Integer getCurrentMembers() {
-        return currentMembers;
-    }
-
-    public void setCurrentMembers(Integer currentMembers) {
-        this.currentMembers = currentMembers;
-    }
-
-    public Long getStatus() {
-        return status;
-    }
-
-    public void setStatus(Long status) {
-        this.status = status;
-    }
-
-    public String getLocation() {
-        return location;
-    }
-
-    public void setLocation(String location) {
-        this.location = location;
-    }
-
-    public String getCoverImage() {
-        return coverImage;
-    }
-
-    public void setCoverImage(String coverImage) {
-        this.coverImage = coverImage;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-
-    public BigDecimal getStoredValueAmount() {
-        return storedValueAmount;
-    }
-
-    public void setStoredValueAmount(BigDecimal storedValueAmount) {
-        this.storedValueAmount = storedValueAmount;
-    }
-
-    public String getQrCodePath() {
-        return qrCodePath;
-    }
-
-    public void setQrCodePath(String qrCodePath) {
-        this.qrCodePath = qrCodePath;
-    }
-
-    public GroupCourseType getTypeInfo() {
-        return typeInfo;
-    }
-
-    public void setTypeInfo(GroupCourseType typeInfo) {
-        this.typeInfo = typeInfo;
-        // 同步派生属性
-        if (typeInfo != null) {
-            this.typeName = typeInfo.getTypeName();
-            this.typeCategory = typeInfo.getCategory();
-            this.baseDifficulty = typeInfo.getBaseDifficulty();
-            this.difficultyLevel = typeInfo.getDifficultyLevel();
-            this.calculatedDifficulty = typeInfo.getCalculatedDifficulty();
-            this.labels = typeInfo.getLabels();
-        }
-    }
-
-    public String getTypeName() {
-        return typeName;
-    }
-
-    public void setTypeName(String typeName) {
-        this.typeName = typeName;
-    }
-
-    public String getTypeCategory() {
-        return typeCategory;
-    }
-
-    public void setTypeCategory(String typeCategory) {
-        this.typeCategory = typeCategory;
-    }
-
-    public Integer getBaseDifficulty() {
-        return baseDifficulty;
-    }
-
-    public void setBaseDifficulty(Integer baseDifficulty) {
-        this.baseDifficulty = baseDifficulty;
-    }
-
-    public String getDifficultyLevel() {
-        return difficultyLevel;
-    }
-
-    public void setDifficultyLevel(String difficultyLevel) {
-        this.difficultyLevel = difficultyLevel;
-    }
-
-    public Integer getCalculatedDifficulty() {
-        return calculatedDifficulty;
-    }
-
-    public void setCalculatedDifficulty(Integer calculatedDifficulty) {
-        this.calculatedDifficulty = calculatedDifficulty;
-    }
-
-    public List<CourseLabel> getLabels() {
-        return labels;
-    }
-
-    public void setLabels(List<CourseLabel> labels) {
-        this.labels = labels;
-    }
-}

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

@@ -1,84 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.domain;
-
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-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/domain/GroupCourseType.java

@@ -1,113 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.domain;
-
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class GroupCourseType extends BaseDomain {
-
-    //类型名称
-    @Schema(description = "类型名称", example = "瑜伽入门")
-    private String typeName;
-
-    //基础难度（1-10）
-    @Schema(description = "基础难度（1-10）", example = "2")
-    private Integer baseDifficulty;
-
-    //类型描述
-    @Schema(description = "类型描述", example = "适合初学者的瑜伽课程")
-    private String description;
-
-    //分类（如：有氧、力量、柔韧等）
-    @Schema(description = "分类", example = "柔韧与平衡类")
-    private String category;
-
-    //标签列表
-    @Schema(description = "标签列表")
-    private List<CourseLabel> labels = new ArrayList<>();
-
-    /**
-     * 计算综合难度系数
-     * 
-     * 当前实现仅返回基础难度，为后续扩展预留空间。
-     * 未来可扩展的影响因素包括：
-     * 1. 课程时长系数（时长越长难度越高）
-     * 2. 教练难度调整系数（教练可根据实际情况微调）
-     * 3. 会员等级适配系数（根据会员等级动态调整显示难度）
-     * 4. 课程强度系数（高强度课程难度加成）
-     * 
-     * @return 综合难度系数（1-10）
-     */
-    @Schema(description = "综合难度系数（预留扩展字段）", example = "2")
-    public Integer getCalculatedDifficulty() {
-        // TODO: 预留扩展点 - 未来可在此处添加更多难度计算逻辑
-        // 例如：return calculateDynamicDifficulty(baseDifficulty, additionalFactors...);
-        return this.baseDifficulty != null ? this.baseDifficulty : 1;
-    }
-
-    /**
-     * 获取难度等级描述
-     * 将数字难度转换为友好的文字描述
-     * 
-     * @return 难度等级描述
-     */
-    @Schema(description = "难度等级描述", example = "初级")
-    public String getDifficultyLevel() {
-        if (baseDifficulty == null) {
-            return "未知";
-        }
-        if (baseDifficulty <= 2) {
-            return "初级";
-        } else if (baseDifficulty <= 4) {
-            return "中级";
-        } else if (baseDifficulty <= 6) {
-            return "中高级";
-        } else if (baseDifficulty <= 8) {
-            return "高级";
-        } else {
-            return "专家级";
-        }
-    }
-
-    public String getTypeName() {
-        return typeName;
-    }
-
-    public void setTypeName(String typeName) {
-        this.typeName = typeName;
-    }
-
-    public Integer getBaseDifficulty() {
-        return baseDifficulty;
-    }
-
-    public void setBaseDifficulty(Integer baseDifficulty) {
-        this.baseDifficulty = baseDifficulty;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-
-    public String getCategory() {
-        return category;
-    }
-
-    public void setCategory(String category) {
-        this.category = category;
-    }
-
-    public List<CourseLabel> getLabels() {
-        return labels;
-    }
-
-    public void setLabels(List<CourseLabel> labels) {
-        this.labels = labels;
-    }
-}

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

@@ -1,127 +0,0 @@
-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;
-
-    @Schema(description = "是否常态化团课筛选：null-不过滤, true-仅常态化, false-仅非常态化", example = "true")
-    private Boolean isRecurring;
-
-    // ===== 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;
-    }
-
-    public Boolean getIsRecurring() {
-        return isRecurring;
-    }
-
-    public void setIsRecurring(Boolean isRecurring) {
-        this.isRecurring = isRecurring;
-    }
-}

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

@@ -1,45 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.entity;
-
-import cn.novalon.gym.manage.db.entity.BaseEntity;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-@Table("banner")
-public class BannerEntity extends BaseEntity {
-
-    @Column("image_url")
-    private String imageUrl;
-
-    @Column("title")
-    private String title;
-
-    @Column("subtitle")
-    private String subtitle;
-
-    @Column("description")
-    private String description;
-
-    @Column("sort_order")
-    private Integer sortOrder;
-
-    @Column("is_active")
-    private Boolean isActive;
-
-    public String getImageUrl() { return imageUrl; }
-    public void setImageUrl(String imageUrl) { this.imageUrl = imageUrl; }
-
-    public String getTitle() { return title; }
-    public void setTitle(String title) { this.title = title; }
-
-    public String getSubtitle() { return subtitle; }
-    public void setSubtitle(String subtitle) { this.subtitle = subtitle; }
-
-    public String getDescription() { return description; }
-    public void setDescription(String description) { this.description = description; }
-
-    public Integer getSortOrder() { return sortOrder; }
-    public void setSortOrder(Integer sortOrder) { this.sortOrder = sortOrder; }
-
-    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/entity/CourseLabelEntity.java

@@ -1,45 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.entity;
-
-import cn.novalon.gym.manage.db.entity.BaseEntity;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-@Table("course_label")
-public class CourseLabelEntity extends BaseEntity {
-
-    //标签名称
-    @Column("label_name")
-    private String labelName;
-
-    //标签颜色（十六进制）
-    @Column("color")
-    private String color;
-
-    //标签描述
-    @Column("description")
-    private String description;
-
-    public String getLabelName() {
-        return labelName;
-    }
-
-    public void setLabelName(String labelName) {
-        this.labelName = labelName;
-    }
-
-    public String getColor() {
-        return color;
-    }
-
-    public void setColor(String color) {
-        this.color = color;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-}

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

@@ -1,33 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.entity;
-
-import cn.novalon.gym.manage.db.entity.BaseEntity;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-@Table("course_type_label")
-public class CourseTypeLabelEntity extends BaseEntity {
-
-    //团课类型ID
-    @Column("type_id")
-    private Long typeId;
-
-    //标签ID
-    @Column("label_id")
-    private Long labelId;
-
-    public Long getTypeId() {
-        return typeId;
-    }
-
-    public void setTypeId(Long typeId) {
-        this.typeId = typeId;
-    }
-
-    public Long getLabelId() {
-        return labelId;
-    }
-
-    public void setLabelId(Long labelId) {
-        this.labelId = labelId;
-    }
-}

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

@@ -54,18 +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;
-
-    //是否常态化团课
-    @Column("is_recurring")
-    private Boolean isRecurring;
-
     public String getCourseName() {
         return courseName;
     }
@@ -154,6 +150,14 @@ 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;
     }
@@ -161,20 +165,4 @@ 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;
-    }
-
-    public Boolean getIsRecurring() {
-        return isRecurring;
-    }
-
-    public void setIsRecurring(Boolean isRecurring) {
-        this.isRecurring = isRecurring;
-    }
 }

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

@@ -1,77 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.entity;
-
-import cn.novalon.gym.manage.db.entity.BaseEntity;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.time.LocalDateTime;
-
-@Table("group_course_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/entity/GroupCourseTypeEntity.java

@@ -1,57 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.entity;
-
-import cn.novalon.gym.manage.db.entity.BaseEntity;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-@Table("group_course_type")
-public class GroupCourseTypeEntity extends BaseEntity {
-
-    //类型名称
-    @Column("type_name")
-    private String typeName;
-
-    //基础难度（1-10）
-    @Column("base_difficulty")
-    private Integer baseDifficulty;
-
-    //类型描述
-    @Column("description")
-    private String description;
-
-    //分类（如：有氧、力量、柔韧等）
-    @Column("category")
-    private String category;
-
-    public String getTypeName() {
-        return typeName;
-    }
-
-    public void setTypeName(String typeName) {
-        this.typeName = typeName;
-    }
-
-    public Integer getBaseDifficulty() {
-        return baseDifficulty;
-    }
-
-    public void setBaseDifficulty(Integer baseDifficulty) {
-        this.baseDifficulty = baseDifficulty;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-
-    public String getCategory() {
-        return category;
-    }
-
-    public void setCategory(String category) {
-        this.category = category;
-    }
-}

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

@@ -1,224 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.handler;
-
-import cn.novalon.gym.manage.groupcourse.domain.Banner;
-import cn.novalon.gym.manage.groupcourse.service.IBannerService;
-import cn.novalon.gym.manage.sys.core.service.ISysUserService;
-import cn.novalon.gym.manage.sys.util.AuthUtil;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import org.springframework.http.HttpStatus;
-import org.springframework.stereotype.Component;
-import org.springframework.web.reactive.function.server.ServerRequest;
-import org.springframework.web.reactive.function.server.ServerResponse;
-import reactor.core.publisher.Mono;
-
-import java.util.HashMap;
-import java.util.Map;
-
-@Component
-@Tag(name = "轮播图管理", description = "轮播图相关操作")
-public class BannerHandler {
-
-    private final IBannerService bannerService;
-    private final ISysUserService sysUserService;
-    private final AuthUtil authUtil;
-
-    public BannerHandler(IBannerService bannerService,
-                         ISysUserService sysUserService,
-                         AuthUtil authUtil) {
-        this.bannerService = bannerService;
-        this.sysUserService = sysUserService;
-        this.authUtil = authUtil;
-    }
-
-    @Operation(summary = "获取所有轮播图", description = "获取系统中所有轮播图列表，支持按排序字段排序")
-    public Mono<ServerResponse> getAllBanners(ServerRequest request) {
-        String sortBy = request.queryParam("sortBy").orElse("sortOrder");
-        String sortOrder = request.queryParam("sortOrder").orElse("desc");
-
-        return ServerResponse.ok()
-                .body(bannerService.findAll(sortBy, sortOrder), Banner.class);
-    }
-
-    @Operation(summary = "获取所有启用的轮播图", description = "获取系统中所有已启用的轮播图列表")
-    public Mono<ServerResponse> getAllActiveBanners(ServerRequest request) {
-        return ServerResponse.ok()
-                .body(bannerService.findAllActive(), Banner.class);
-    }
-
-    @Operation(summary = "根据ID获取轮播图", description = "根据ID获取轮播图详情")
-    public Mono<ServerResponse> getBannerById(ServerRequest request) {
-        Long id = Long.valueOf(request.pathVariable("id"));
-        return bannerService.findById(id)
-                .flatMap(banner -> ServerResponse.ok().bodyValue(banner))
-                .switchIfEmpty(ServerResponse.notFound().build());
-    }
-
-    @Operation(summary = "创建轮播图", description = "创建新的轮播图记录")
-    public Mono<ServerResponse> createBanner(ServerRequest request) {
-        return request.bodyToMono(Banner.class)
-                .flatMap(banner -> {
-                    if (banner.getImageUrl() == null || banner.getImageUrl().isBlank()) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "背景图不能为空");
-                        return ServerResponse.badRequest().bodyValue(error);
-                    }
-                    if (banner.getTitle() == null || banner.getTitle().isBlank()) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "主标题不能为空");
-                        return ServerResponse.badRequest().bodyValue(error);
-                    }
-
-                    return bannerService.create(banner)
-                            .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> updateBanner(ServerRequest request) {
-        Long adminId = authUtil.getMemberIdOrThrow(request);
-        Long id = Long.valueOf(request.pathVariable("id"));
-        String adminPassword = request.queryParam("adminPassword").orElse(null);
-
-        if (adminPassword == null || adminPassword.isBlank()) {
-            Map<String, Object> error = new HashMap<>();
-            error.put("success", false);
-            error.put("message", "管理员密码不能为空");
-            return ServerResponse.badRequest().bodyValue(error);
-        }
-
-        return sysUserService.verifyPassword(adminId, adminPassword)
-                .flatMap(valid -> {
-                    if (!valid) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "管理员密码错误");
-                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
-                    }
-                    return request.bodyToMono(Banner.class)
-                            .flatMap(banner -> bannerService.update(id, banner)
-                                    .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> deleteBanner(ServerRequest request) {
-        Long adminId = authUtil.getMemberIdOrThrow(request);
-        Long id = Long.valueOf(request.pathVariable("id"));
-        String adminPassword = request.queryParam("adminPassword").orElse(null);
-
-        if (adminPassword == null || adminPassword.isBlank()) {
-            Map<String, Object> error = new HashMap<>();
-            error.put("success", false);
-            error.put("message", "管理员密码不能为空");
-            return ServerResponse.badRequest().bodyValue(error);
-        }
-
-        return sysUserService.verifyPassword(adminId, adminPassword)
-                .flatMap(valid -> {
-                    if (!valid) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "管理员密码错误");
-                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
-                    }
-                    return bannerService.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> enableBanner(ServerRequest request) {
-        Long id = Long.valueOf(request.pathVariable("id"));
-
-        return bannerService.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> disableBanner(ServerRequest request) {
-        Long adminId = authUtil.getMemberIdOrThrow(request);
-        Long id = Long.valueOf(request.pathVariable("id"));
-        String adminPassword = request.queryParam("adminPassword").orElse(null);
-
-        if (adminPassword == null || adminPassword.isBlank()) {
-            Map<String, Object> error = new HashMap<>();
-            error.put("success", false);
-            error.put("message", "管理员密码不能为空");
-            return ServerResponse.badRequest().bodyValue(error);
-        }
-
-        return sysUserService.verifyPassword(adminId, adminPassword)
-                .flatMap(valid -> {
-                    if (!valid) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "管理员密码错误");
-                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
-                    }
-                    return bannerService.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/handler/BookingSagaHandler.java

@@ -9,13 +9,11 @@ import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.enums.MemberCardType;
 import cn.novalon.gym.manage.member.repository.MemberCardRepository;
 import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
-import cn.novalon.gym.manage.member.service.IMemberStoredCardService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import reactor.core.publisher.Mono;
 
-import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -36,7 +34,6 @@ public class BookingSagaHandler {
     private final IGroupCourseBookingRepository bookingRepository;
     private final IGroupCourseRepository courseRepository;
     private final IMemberCardRecordService memberCardRecordService;
-    private final IMemberStoredCardService memberStoredCardService;
     private final MemberCardRepository memberCardRepository;
     private final GroupCourseRedisService redisService;
 
@@ -47,10 +44,10 @@ public class BookingSagaHandler {
      *
      * 步骤：
      * 1. 保存预约记录
-     * 2. 扣减储值卡余额（储值卡类型）
+     * 2. 扣减会员卡权益
      * 3. 更新课程当前人数
      */
-    public Mono<GroupCourseBooking> executeBooking(GroupCourseBooking booking, Long recordId, BigDecimal storedValueAmount) {
+    public Mono<GroupCourseBooking> executeBooking(GroupCourseBooking booking, Long recordId) {
         List<SagaStep> steps = new ArrayList<>();
         List<SagaStep> rollbackSteps = new ArrayList<>();
 
@@ -63,11 +60,11 @@ public class BookingSagaHandler {
         steps.add(step1);
         rollbackSteps.add(0, step1);
 
-        // 步骤2：扣减权益（根据卡类型）
+        // 步骤2：扣减会员卡权益（根据卡类型决定扣除次数还是金额）
         SagaStep step2 = new SagaStep(
-                "扣减权益",
+                "扣减会员卡权益",
-                deductCardUsageByCardType(booking.getMemberId(), recordId, storedValueAmount),
+                deductCardUsageByCardType(booking.getMemberId(), recordId),
-                Mono.defer(() -> restoreCardUsageByCardType(booking.getMemberId(), recordId, storedValueAmount))
+                Mono.defer(() -> restoreCardUsageByCardType(booking.getMemberId(), recordId))
         );
         steps.add(step2);
         rollbackSteps.add(0, step2);
@@ -97,7 +94,7 @@ public class BookingSagaHandler {
     /**
      * 根据会员卡类型扣减权益
      */
-    private Mono<Void> deductCardUsageByCardType(Long memberId, Long recordId, BigDecimal storedValueAmount) {
+    private Mono<Void> deductCardUsageByCardType(Long memberId, Long recordId) {
         return memberCardRecordService.findById(recordId)
                 .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
                 .flatMap(record -> {
@@ -112,13 +109,14 @@ public class BookingSagaHandler {
 
                                 switch (cardType) {
                                     case COUNT_CARD:
-                                        return Mono.error(new RuntimeException("团课预约仅支持储值卡和时长卡支付"));
+                                        // 次卡扣除次数
+                                        return deductCardUsage(recordId, 1, 0.0);
                                     case STORED_VALUE_CARD:
-                                        return deductStoredCardBalance(memberId, storedValueAmount);
+                                        // 储值卡扣除金额
+                                        return deductCardUsage(recordId, 0, DEFAULT_GROUP_COURSE_PRICE);
                                     case TIME_CARD:
-                                        // 时长卡验证有效期后，仍须从储值卡扣款
+                                        // 时长卡不扣除，但需验证有效期
-                                        return validateTimeCard(record)
+                                        return validateTimeCard(record);
-                                                .then(deductStoredCardBalance(memberId, storedValueAmount));
                                     default:
                                         return Mono.error(new RuntimeException("不支持的会员卡类型: " + cardType));
                                 }
@@ -155,10 +153,11 @@ public class BookingSagaHandler {
     /**
      * 根据会员卡类型恢复权益
      */
-    private Mono<Void> restoreCardUsageByCardType(Long memberId, Long recordId, BigDecimal storedValueAmount) {
+    private Mono<Void> restoreCardUsageByCardType(Long memberId, Long recordId) {
         return memberCardRecordService.findById(recordId)
                 .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在，无法恢复权益")))
                 .flatMap(record -> {
+                    // 验证会员卡归属（memberId为null时跳过验证）
                     if (memberId != null && !record.getMemberId().equals(memberId)) {
                         return Mono.error(new RuntimeException("会员卡不归属当前用户"));
                     }
@@ -169,29 +168,11 @@ public class BookingSagaHandler {
 
                                 switch (cardType) {
                                     case COUNT_CARD:
-                                        return Mono.empty();
+                                        return restoreCardUsage(recordId, 1, 0.0);
                                     case STORED_VALUE_CARD:
-                                        // 返还储值卡余额（回滚时全额返还）
+                                        return restoreCardUsage(recordId, 0, DEFAULT_GROUP_COURSE_PRICE);
-                                        BigDecimal amount = storedValueAmount != null ? storedValueAmount : BigDecimal.valueOf(DEFAULT_GROUP_COURSE_PRICE);
-                                        return memberStoredCardService.recharge(memberId, amount)
-                                                .flatMap(rows -> {
-                                                    if (rows > 0) {
-                                                        log.info("储值卡回滚返还成功: memberId={}, amount={}", memberId, amount);
-                                                        return Mono.empty();
-                                                    }
-                                                    return Mono.empty();
-                                                });
                                     case TIME_CARD:
-                                        // 时长卡回滚时也返还储值卡
+                                        return Mono.empty();
-                                        BigDecimal timeAmount = storedValueAmount != null ? storedValueAmount : BigDecimal.valueOf(DEFAULT_GROUP_COURSE_PRICE);
-                                        return memberStoredCardService.recharge(memberId, timeAmount)
-                                                .flatMap(rows -> {
-                                                    if (rows > 0) {
-                                                        log.info("储值卡回滚返还成功(时长卡): memberId={}, amount={}", memberId, timeAmount);
-                                                        return Mono.empty();
-                                                    }
-                                                    return Mono.empty();
-                                                });
                                     default:
                                         return Mono.error(new RuntimeException("不支持的会员卡类型: " + cardType));
                                 }
@@ -202,7 +183,7 @@ public class BookingSagaHandler {
     /**
      * 执行取消预约事务
      */
-    public Mono<GroupCourseBooking> executeCancelBooking(Long bookingId, Long courseId, Long recordId, Long memberId, BigDecimal storedValueAmount, long cancelCount) {
+    public Mono<GroupCourseBooking> executeCancelBooking(Long bookingId, Long courseId, Long recordId, Long memberId) {
         List<SagaStep> steps = new ArrayList<>();
         List<SagaStep> rollbackSteps = new ArrayList<>();
 
@@ -215,12 +196,11 @@ public class BookingSagaHandler {
         steps.add(step1);
         rollbackSteps.add(0, step1);
 
-        // 步骤2：返还储值卡余额（含手续费逻辑）
+        // 步骤2：恢复会员卡权益
         SagaStep step2 = new SagaStep(
-                "返还储值卡余额",
+                "恢复会员卡权益",
-                refundStoredCardWithFee(memberId, storedValueAmount, cancelCount),
+                restoreCardUsageByCardType(memberId, recordId),
-                // 回滚时重新扣减
+                Mono.defer(() -> deductCardUsageByCardType(memberId, recordId))
-                Mono.defer(() -> deductCardUsageByCardType(memberId, recordId, storedValueAmount))
         );
         steps.add(step2);
         rollbackSteps.add(0, step2);
@@ -272,32 +252,54 @@ public class BookingSagaHandler {
         return bookingRepository.deleteById(bookingId);
     }
 
-    /**
+    private Mono<Void> deductCardUsage(Long recordId, Integer deductTimes, Double deductAmount) {
-     * 从储值卡扣减余额
+        if (deductTimes == 0 && deductAmount == 0.0) {
-     */
+            return Mono.empty();
-    private Mono<Void> deductStoredCardBalance(Long memberId, BigDecimal storedValueAmount) {
+        }
-        BigDecimal amount = storedValueAmount != null && storedValueAmount.compareTo(BigDecimal.ZERO) > 0
+
-                ? storedValueAmount : BigDecimal.valueOf(DEFAULT_GROUP_COURSE_PRICE);
+        return memberCardRecordService.findById(recordId)
-        return memberStoredCardService.consume(memberId, amount)
+                .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
-                .flatMap(rows -> {
+                .flatMap(record -> {
-                    if (rows == 0) {
+                    cn.novalon.gym.manage.member.enums.MemberCardRecordStatus status = record.getStatus();
-                        return Mono.error(new RuntimeException("储值卡扣减失败，余额不足"));
+                    if (status != cn.novalon.gym.manage.member.enums.MemberCardRecordStatus.ACTIVE) {
+                        return Mono.error(new RuntimeException("会员卡状态无效，当前状态: " + (status != null ? status.getDesc() : "未知")));
                     }
-                    log.info("储值卡扣减成功: memberId={}, amount={}", memberId, amount);
+                    java.time.LocalDateTime expireTime = record.getExpireTime();
-                    return Mono.empty();
+                    if (expireTime != null && expireTime.isBefore(java.time.LocalDateTime.now())) {
+                        return Mono.error(new RuntimeException("会员卡已过期"));
+                    }
+                    if (record.getRemainingTimes() != null && deductTimes > 0 && record.getRemainingTimes() < deductTimes) {
+                        return Mono.error(new RuntimeException("会员卡剩余次数不足，当前剩余: " + record.getRemainingTimes() + "次"));
+                    }
+                    if (record.getRemainingAmount() != null && deductAmount > 0 && record.getRemainingAmount() < deductAmount) {
+                        return Mono.error(new RuntimeException("会员卡余额不足，当前剩余: " + record.getRemainingAmount()));
+                    }
+                    return memberCardRecordService.deductUsage(recordId, deductTimes, deductAmount)
+                            .flatMap(rows -> {
+                                if (rows == 0) {
+                                    return Mono.error(new RuntimeException("扣减会员卡权益失败，请重试"));
+                                }
+                                return Mono.empty();
+                            });
                 });
     }
 
-    /**
+    private Mono<Void> restoreCardUsage(Long recordId, Integer addTimes, Double addAmount) {
-     * 返还储值卡余额（含手续费逻辑，仅用于取消预约）
+        if (addTimes == 0 && addAmount == 0.0) {
-     */
+            return Mono.empty();
-    private Mono<Void> refundStoredCardWithFee(Long memberId, BigDecimal storedValueAmount, long cancelCount) {
+        }
-        BigDecimal amount = storedValueAmount != null && storedValueAmount.compareTo(BigDecimal.ZERO) > 0
+
-                ? storedValueAmount : BigDecimal.valueOf(DEFAULT_GROUP_COURSE_PRICE);
+        return memberCardRecordService.findById(recordId)
-        return memberStoredCardService.refundBalanceWithFee(memberId, amount, cancelCount)
+                .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在，无法恢复权益")))
-                .flatMap(refundedAmount -> {
+                .flatMap(record -> {
-                    log.info("储值卡退款成功(含手续费): memberId={}, cancelCount={}, 退款金额={}", memberId, cancelCount, refundedAmount);
+                    // 使用当前记录的过期时间，避免清空过期时间
-                    return Mono.empty();
+                    return memberCardRecordService.renewCard(recordId, addTimes, addAmount, record.getExpireTime())
+                            .flatMap(rows -> {
+                                if (rows == 0) {
+                                    return Mono.error(new RuntimeException("恢复会员卡权益失败，请重试"));
+                                }
+                                return Mono.empty();
+                            });
                 });
     }
 

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

@@ -1,120 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.handler;
-
-import cn.novalon.gym.manage.groupcourse.util.OSSUtil;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.http.MediaType;
-import org.springframework.http.codec.multipart.FilePart;
-import org.springframework.http.codec.multipart.Part;
-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.io.InputStream;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-
-/**
- * 通用文件上传处理器
- */
-@Slf4j
-@Component
-@Tag(name = "文件上传", description = "通用文件上传到阿里云OSS")
-public class CommonUploadHandler {
-
-    @Operation(summary = "上传图片文件", description = "上传图片到阿里云OSS，返回ossKey和预签名URL")
-    public Mono<ServerResponse> uploadImage(ServerRequest request) {
-        return request.multipartData()
-                .flatMap(multiValueMap -> {
-                    List<Part> fileParts = multiValueMap.get("file");
-                    if (fileParts == null || fileParts.isEmpty()) {
-                        return ServerResponse.badRequest()
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .bodyValue(Map.of("code", 400, "message", "未选择文件"));
-                    }
-
-                    Part part = fileParts.get(0);
-                    if (!(part instanceof FilePart filePart)) {
-                        return ServerResponse.badRequest()
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .bodyValue(Map.of("code", 400, "message", "文件格式不正确"));
-                    }
-
-                    String originalFilename = filePart.filename();
-                    String ext = "";
-                    int dotIndex = originalFilename.lastIndexOf('.');
-                    if (dotIndex > 0) {
-                        ext = originalFilename.substring(dotIndex);
-                    }
-                    String newFileName = UUID.randomUUID().toString().replace("-", "") + ext;
-
-                    Path tempFile = null;
-                    try {
-                        tempFile = Files.createTempFile("upload-", newFileName);
-                    } catch (Exception e) {
-                        return Mono.error(new RuntimeException("创建临时文件失败", e));
-                    }
-                    Path finalTempFile = tempFile;
-
-                    return filePart.transferTo(finalTempFile)
-                            .then(Mono.defer(() -> {
-                                try {
-                                    String ossKey;
-                                    try (InputStream inputStream = Files.newInputStream(finalTempFile)) {
-                                        ossKey = OSSUtil.uploadCoverToOSS(inputStream, newFileName);
-                                    }
-                                    String presignedUrl = OSSUtil.generatePresignedUrl(ossKey);
-                                    return ServerResponse.ok()
-                                            .contentType(MediaType.APPLICATION_JSON)
-                                            .bodyValue(Map.of(
-                                                    "code", 200,
-                                                    "message", "上传成功",
-                                                    "data", Map.of(
-                                                            "ossKey", ossKey,
-                                                            "presignedUrl", presignedUrl,
-                                                            "fileName", originalFilename
-                                                    )
-                                            ));
-                                } catch (Exception e) {
-                                    return ServerResponse.status(500)
-                                            .contentType(MediaType.APPLICATION_JSON)
-                                            .bodyValue(Map.of("code", 500, "message", "上传失败: " + e.getMessage()));
-                                } finally {
-                                    try {
-                                        Files.deleteIfExists(finalTempFile);
-                                    } catch (Exception ignored) {
-                                    }
-                                }
-                            }));
-                });
-    }
-
-    @Operation(summary = "获取OSS预签名URL", description = "根据ossKey生成临时访问URL，有效期5分钟")
-    public Mono<ServerResponse> presignUrl(ServerRequest request) {
-        String ossKey = request.queryParam("key").orElse(null);
-        if (ossKey == null || ossKey.isBlank()) {
-            return ServerResponse.badRequest()
-                    .contentType(MediaType.APPLICATION_JSON)
-                    .bodyValue(Map.of("code", 400, "message", "参数 key 不能为空"));
-        }
-
-        try {
-            String presignedUrl = OSSUtil.generatePresignedUrl(ossKey);
-            return ServerResponse.ok()
-                    .contentType(MediaType.APPLICATION_JSON)
-                    .bodyValue(Map.of(
-                            "code", 200,
-                            "data", Map.of("presignedUrl", presignedUrl)
-                    ));
-        } catch (Exception e) {
-            return ServerResponse.status(500)
-                    .contentType(MediaType.APPLICATION_JSON)
-                    .bodyValue(Map.of("code", 500, "message", "生成预签名URL失败: " + e.getMessage()));
-        }
-    }
-}

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

@@ -1,224 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.handler;
-
-import cn.novalon.gym.manage.groupcourse.domain.CourseLabel;
-import cn.novalon.gym.manage.groupcourse.service.ICourseLabelService;
-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.List;
-import java.util.Map;
-
-@Component
-@Tag(name = "团课标签管理", description = "团课标签相关操作")
-public class CourseLabelHandler {
-
-    private final ICourseLabelService courseLabelService;
-
-    public CourseLabelHandler(ICourseLabelService courseLabelService) {
-        this.courseLabelService = courseLabelService;
-    }
-
-    @Operation(summary = "获取所有标签", description = "获取系统中所有标签列表")
-    public Mono<ServerResponse> getAllLabels(ServerRequest request) {
-        return ServerResponse.ok()
-                .body(courseLabelService.findAll(), CourseLabel.class);
-    }
-
-    @Operation(summary = "根据ID获取标签", description = "根据ID获取标签详情")
-    public Mono<ServerResponse> getLabelById(ServerRequest request) {
-        Long id = Long.valueOf(request.pathVariable("id"));
-        return courseLabelService.findById(id)
-                .flatMap(label -> ServerResponse.ok().bodyValue(label))
-                .switchIfEmpty(ServerResponse.notFound().build());
-    }
-
-    @Operation(summary = "搜索标签", description = "根据关键词搜索标签")
-    public Mono<ServerResponse> searchLabels(ServerRequest request) {
-        String keyword = request.queryParam("keyword").orElse("");
-        return ServerResponse.ok()
-                .body(courseLabelService.findByKeyword(keyword), CourseLabel.class);
-    }
-
-    @Operation(summary = "创建标签", description = "创建新的标签")
-    public Mono<ServerResponse> createLabel(ServerRequest request) {
-        return request.bodyToMono(CourseLabel.class)
-                .flatMap(courseLabel -> {
-                    if (courseLabel.getLabelName() == null || courseLabel.getLabelName().isEmpty()) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "标签名称不能为空");
-                        return ServerResponse.badRequest().bodyValue(error);
-                    }
-                    
-                    if (courseLabel.getLabelName().length() > 50) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "标签名称不能超过50个字符");
-                        return ServerResponse.badRequest().bodyValue(error);
-                    }
-                    
-                    if (courseLabel.getColor() == null || courseLabel.getColor().isEmpty()) {
-                        courseLabel.setColor("#1890ff");
-                    }
-                    
-                    return courseLabelService.create(courseLabel)
-                            .flatMap(label -> {
-                                Map<String, Object> response = new HashMap<>();
-                                response.put("success", true);
-                                response.put("message", "标签创建成功");
-                                response.put("data", label);
-                                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> updateLabel(ServerRequest request) {
-        Long id = Long.valueOf(request.pathVariable("id"));
-        
-        return request.bodyToMono(CourseLabel.class)
-                .flatMap(courseLabel -> {
-                    if (courseLabel.getLabelName() != null && courseLabel.getLabelName().length() > 50) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "标签名称不能超过50个字符");
-                        return ServerResponse.badRequest().bodyValue(error);
-                    }
-                    
-                    return courseLabelService.update(id, courseLabel)
-                            .flatMap(label -> {
-                                Map<String, Object> response = new HashMap<>();
-                                response.put("success", true);
-                                response.put("message", "标签更新成功");
-                                response.put("data", label);
-                                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> deleteLabel(ServerRequest request) {
-        Long id = Long.valueOf(request.pathVariable("id"));
-        
-        return courseLabelService.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> getLabelsByTypeId(ServerRequest request) {
-        Long typeId = Long.valueOf(request.pathVariable("typeId"));
-        return courseLabelService.findByTypeId(typeId)
-                .collectList()
-                .flatMap(list -> ServerResponse.ok().bodyValue(list));
-    }
-
-    @Operation(summary = "为类型添加标签", description = "为指定团课类型添加标签")
-    public Mono<ServerResponse> addLabelsToType(ServerRequest request) {
-        Long typeId = Long.valueOf(request.pathVariable("typeId"));
-        
-        return request.bodyToMono(Map.class)
-                .flatMap(body -> {
-                    Object labelIdsObj = body.get("labelIds");
-                    
-                    if (!(labelIdsObj instanceof List)) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "labelIds不能为空");
-                        return ServerResponse.badRequest().bodyValue(error);
-                    }
-                    
-                    List<?> rawList = (List<?>) labelIdsObj;
-                    if (rawList.isEmpty()) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "labelIds不能为空");
-                        return ServerResponse.badRequest().bodyValue(error);
-                    }
-                    
-                    List<Long> labelIds = rawList.stream()
-                            .map(id -> Long.valueOf(String.valueOf(id)))
-                            .collect(java.util.stream.Collectors.toList());
-                    
-                    return courseLabelService.addLabelsToType(typeId, labelIds)
-                            .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> removeLabelFromType(ServerRequest request) {
-        Long typeId = Long.valueOf(request.pathVariable("typeId"));
-        Long labelId = Long.valueOf(request.pathVariable("labelId"));
-        
-        return courseLabelService.removeLabelFromType(typeId, labelId)
-                .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> clearLabelsFromType(ServerRequest request) {
-        Long typeId = Long.valueOf(request.pathVariable("typeId"));
-        
-        return courseLabelService.clearLabelsFromType(typeId)
-                .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);
-                });
-    }
-}

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

@@ -2,7 +2,6 @@ package cn.novalon.gym.manage.groupcourse.handler;
 
 import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
 import cn.novalon.gym.manage.groupcourse.service.IGroupCourseBookingService;
-import cn.novalon.gym.manage.member.service.IMemberStoredCardService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import org.springframework.stereotype.Component;
@@ -24,12 +23,9 @@ import java.util.Map;
 public class GroupCourseBookingHandler {
 
     private final IGroupCourseBookingService bookingService;
-    private final IMemberStoredCardService memberStoredCardService;
 
-    public GroupCourseBookingHandler(IGroupCourseBookingService bookingService,
+    public GroupCourseBookingHandler(IGroupCourseBookingService bookingService) {
-                                     IMemberStoredCardService memberStoredCardService) {
         this.bookingService = bookingService;
-        this.memberStoredCardService = memberStoredCardService;
     }
 
     /**
@@ -49,35 +45,24 @@ public class GroupCourseBookingHandler {
                     if (body.get("memberCardRecordId") == null) {
                         return buildErrorResponse("请提供会员卡记录ID");
                     }
-                    if (body.get("payPassword") == null || body.get("payPassword").toString().isEmpty()) {
-                        return buildErrorResponse("请输入支付密码");
-                    }
 
-                    Long courseId = toLong(body.get("courseId"), "courseId");
+                    Long courseId = ((Number) body.get("courseId")).longValue();
-                    Long memberId = toLong(body.get("memberId"), "memberId");
+                    Long memberId = ((Number) body.get("memberId")).longValue();
-                    Long memberCardRecordId = toLong(body.get("memberCardRecordId"), "memberCardRecordId");
+                    Long memberCardRecordId = ((Number) body.get("memberCardRecordId")).longValue();
-                    String payPassword = body.get("payPassword").toString();
 
-                    // 验证支付密码
+                    return bookingService.bookCourse(courseId, memberId, memberCardRecordId)
-                    return memberStoredCardService.verifyPayPassword(memberId, payPassword)
+                            .flatMap(booking -> {
-                            .flatMap(passwordValid -> {
+                                Map<String, Object> response = new HashMap<>();
-                                if (!passwordValid) {
+                                response.put("success", true);
-                                    return buildErrorResponse("支付密码错误");
+                                response.put("message", "预约成功");
-                                }
+                                response.put("data", booking);
-                                return bookingService.bookCourse(courseId, memberId, memberCardRecordId)
+                                return ServerResponse.ok().bodyValue(response);
-                                        .flatMap(booking -> {
+                            })
-                                            Map<String, Object> response = new HashMap<>();
+                            .onErrorResume(error -> {
-                                            response.put("success", true);
+                                Map<String, Object> response = new HashMap<>();
-                                            response.put("message", "预约成功");
+                                response.put("success", false);
-                                            response.put("data", booking);
+                                response.put("message", error.getMessage());
-                                            return ServerResponse.ok().bodyValue(response);
+                                return ServerResponse.badRequest().bodyValue(response);
-                                        })
-                                        .onErrorResume(error -> {
-                                            Map<String, Object> response = new HashMap<>();
-                                            response.put("success", false);
-                                            response.put("message", error.getMessage());
-                                            return ServerResponse.badRequest().bodyValue(response);
-                                        });
                             });
                 });
     }
@@ -91,32 +76,21 @@ public class GroupCourseBookingHandler {
 
         return request.bodyToMono(Map.class)
                 .flatMap(body -> {
-                    Long memberId = toLong(body.get("memberId"), "memberId");
+                    Long memberId = ((Number) body.get("memberId")).longValue();
-                    if (body.get("payPassword") == null || body.get("payPassword").toString().isEmpty()) {
-                        return buildErrorResponse("请输入支付密码");
-                    }
-                    String payPassword = body.get("payPassword").toString();
 
-                    // 验证支付密码
+                    return bookingService.cancelBooking(bookingId, memberId)
-                    return memberStoredCardService.verifyPayPassword(memberId, payPassword)
+                            .flatMap(booking -> {
-                            .flatMap(passwordValid -> {
+                                Map<String, Object> response = new HashMap<>();
-                                if (!passwordValid) {
+                                response.put("success", true);
-                                    return buildErrorResponse("支付密码错误");
+                                response.put("message", "取消成功");
-                                }
+                                response.put("data", booking);
-                                return bookingService.cancelBooking(bookingId, memberId)
+                                return ServerResponse.ok().bodyValue(response);
-                                        .flatMap(booking -> {
+                            })
-                                            Map<String, Object> response = new HashMap<>();
+                            .onErrorResume(error -> {
-                                            response.put("success", true);
+                                Map<String, Object> response = new HashMap<>();
-                                            response.put("message", "取消成功");
+                                response.put("success", false);
-                                            response.put("data", booking);
+                                response.put("message", error.getMessage());
-                                            return ServerResponse.ok().bodyValue(response);
+                                return ServerResponse.badRequest().bodyValue(response);
-                                        })
-                                        .onErrorResume(error -> {
-                                            Map<String, Object> response = new HashMap<>();
-                                            response.put("success", false);
-                                            response.put("message", error.getMessage());
-                                            return ServerResponse.badRequest().bodyValue(response);
-                                        });
                             });
                 });
     }
@@ -155,19 +129,6 @@ public class GroupCourseBookingHandler {
                 .body(bookingService.getBookingsByCourseId(courseId), GroupCourseBooking.class);
     }
 
-    /**
-     * 安全转换为 Long，支持 Number 和 String 类型
-     */
-    private Long toLong(Object value, String fieldName) {
-        if (value instanceof Number) {
-            return ((Number) value).longValue();
-        }
-        if (value instanceof String) {
-            return Long.valueOf((String) value);
-        }
-        throw new IllegalArgumentException("参数 " + fieldName + " 类型不正确");
-    }
-
     /**
      * 构建错误响应
      */
@@ -177,31 +138,4 @@ public class GroupCourseBookingHandler {
         response.put("message", message);
         return ServerResponse.badRequest().bodyValue(response);
     }
-
-    /**
-     * 扫码签到（二维码扫一扫签到）
-     * 用户扫描团课签到二维码后，更新预约记录状态为 2（已出席）
-     */
-    @Operation(summary = "扫码签到", description = "用户扫描团课二维码签到，更新预约状态为已出席")
-    public Mono<ServerResponse> qrSignIn(ServerRequest request) {
-        Long courseId = Long.valueOf(request.pathVariable("courseId"));
-
-        return request.bodyToMono(Map.class)
-                .flatMap(body -> {
-                    if (body.get("memberId") == null) {
-                        return buildErrorResponse("请提供会员ID");
-                    }
-                    Long memberId = toLong(body.get("memberId"), "memberId");
-
-                    return bookingService.qrSignIn(courseId, memberId)
-                            .flatMap(booking -> {
-                                Map<String, Object> response = new HashMap<>();
-                                response.put("success", true);
-                                response.put("message", "签到成功");
-                                response.put("data", booking);
-                                return ServerResponse.ok().bodyValue(response);
-                            })
-                            .onErrorResume(error -> buildErrorResponse(error.getMessage()));
-                });
-    }
 }

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

@@ -4,28 +4,16 @@ package cn.novalon.gym.manage.groupcourse.handler;
 import cn.novalon.gym.manage.common.dto.PageRequest;
 import cn.novalon.gym.manage.common.util.RedisUtil;
 import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
-import cn.novalon.gym.manage.groupcourse.domain.GroupCourseDetail;
-import cn.novalon.gym.manage.groupcourse.dto.GroupCourseQueryDto;
 import cn.novalon.gym.manage.groupcourse.service.IGroupCourseService;
-import cn.novalon.gym.manage.sys.core.service.ISysUserService;
-import cn.novalon.gym.manage.sys.util.AuthUtil;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.zxing.BarcodeFormat;
-import com.google.zxing.client.j2se.MatrixToImageWriter;
-import com.google.zxing.common.BitMatrix;
-import com.google.zxing.qrcode.QRCodeWriter;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Validator;
-import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Component;
 import org.springframework.web.reactive.function.server.ServerRequest;
 import org.springframework.web.reactive.function.server.ServerResponse;
 import reactor.core.publisher.Mono;
-import reactor.core.scheduler.Schedulers;
 
-import java.io.ByteArrayOutputStream;
-import java.util.Base64;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -36,21 +24,15 @@ public class GroupCourseHandler {
     private final Validator validator;
     private final RedisUtil redisUtil;
     private final ObjectMapper objectMapper;
-    private final ISysUserService sysUserService;
-    private final AuthUtil authUtil;
     
     public GroupCourseHandler(IGroupCourseService groupCourseService, 
                               Validator validator,
                               RedisUtil redisUtil,
-                              ObjectMapper objectMapper,
+                              ObjectMapper objectMapper){
-                              ISysUserService sysUserService,
-                              AuthUtil authUtil){
         this.groupCourseService = groupCourseService;
         this.validator = validator;
         this.redisUtil = redisUtil;
         this.objectMapper = objectMapper;
-        this.sysUserService = sysUserService;
-        this.authUtil = authUtil;
     }
 
     @Operation(summary = "获取所有团课", description = "获取系统中所有团课列表")
@@ -94,14 +76,6 @@ public class GroupCourseHandler {
                 .switchIfEmpty(ServerResponse.notFound().build());
     }
 
-    @Operation(summary = "根据ID获取团课完整信息", description = "根据ID获取团课完整信息，包括团课基础信息、类型信息和标签信息")
-    public Mono<ServerResponse> getGroupCourseDetailById(ServerRequest request){
-        Long id = Long.valueOf(request.pathVariable("id"));
-        return groupCourseService.findDetailById(id)
-                .flatMap(detail -> ServerResponse.ok().bodyValue(detail))
-                .switchIfEmpty(ServerResponse.notFound().build());
-    }
-
     @Operation(summary = "创建团课", description = "创建新的团课")
     public Mono<ServerResponse> createGroupCourse(ServerRequest request) {
         return request.bodyToMono(GroupCourse.class)
@@ -130,43 +104,25 @@ public class GroupCourseHandler {
                 });
     }
 
-    @Operation(summary = "更新团课", description = "更新指定团课信息，需验证管理员密码")
+    @Operation(summary = "更新团课", description = "更新指定团课信息")
     public Mono<ServerResponse> updateGroupCourse(ServerRequest request) {
-        Long adminId = authUtil.getMemberIdOrThrow(request);
         Long id = Long.valueOf(request.pathVariable("id"));
-        String adminPassword = request.queryParam("adminPassword").orElse(null);
+        
-
+        return request.bodyToMono(GroupCourse.class)
-        if (adminPassword == null || adminPassword.isBlank()) {
+                .flatMap(groupCourse -> {
-            Map<String, Object> error = new HashMap<>();
+                    return groupCourseService.update(id, groupCourse)
-            error.put("success", false);
+                            .flatMap(course -> {
-            error.put("message", "管理员密码不能为空");
+                                Map<String, Object> response = new HashMap<>();
-            return ServerResponse.badRequest().bodyValue(error);
+                                response.put("success", true);
-        }
+                                response.put("message", "团课更新成功");
-
+                                response.put("data", course);
-        return sysUserService.verifyPassword(adminId, adminPassword)
+                                return ServerResponse.ok().bodyValue(response);
-                .flatMap(valid -> {
+                            })
-                    if (!valid) {
+                            .onErrorResume(error -> {
-                        Map<String, Object> error = new HashMap<>();
+                                Map<String, Object> response = new HashMap<>();
-                        error.put("success", false);
+                                response.put("success", false);
-                        error.put("message", "管理员密码错误");
+                                response.put("message", error.getMessage());
-                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
+                                return ServerResponse.badRequest().bodyValue(response);
-                    }
-                    return request.bodyToMono(GroupCourse.class)
-                            .flatMap(groupCourse -> {
-                                return groupCourseService.update(id, groupCourse)
-                                        .flatMap(course -> {
-                                            Map<String, Object> response = new HashMap<>();
-                                            response.put("success", true);
-                                            response.put("message", "团课更新成功");
-                                            response.put("data", course);
-                                            return ServerResponse.ok().bodyValue(response);
-                                        })
-                                        .onErrorResume(error -> {
-                                            Map<String, Object> response = new HashMap<>();
-                                            response.put("success", false);
-                                            response.put("message", error.getMessage());
-                                            return ServerResponse.badRequest().bodyValue(response);
-                                        });
                             });
                 });
     }
@@ -193,7 +149,7 @@ public class GroupCourseHandler {
 
     @Operation(summary = "团课签到", description = "会员签到参加团课")
     public Mono<ServerResponse> signIn(ServerRequest request) {
-        Long memberId = Long.valueOf(request.pathVariable("memberId"));
+        Long courseId = Long.valueOf(request.pathVariable("courseId"));
         
         return request.bodyToMono(Map.class)
                 .flatMap(body -> {
@@ -204,15 +160,15 @@ public class GroupCourseHandler {
                         return ServerResponse.badRequest().bodyValue(response);
                     }
                     
-                    Object courseIdObj = body.get("courseId");
+                    Object memberIdObj = body.get("memberId");
-                    if (courseIdObj == null) {
+                    if (memberIdObj == null) {
                         Map<String, Object> response = new HashMap<>();
                         response.put("success", false);
-                        response.put("message", "courseId不能为空");
+                        response.put("message", "memberId不能为空");
                         return ServerResponse.badRequest().bodyValue(response);
                     }
                     
-                    Long courseId = ((Number) courseIdObj).longValue();
+                    Long memberId = ((Number) memberIdObj).longValue();
                     
                     return groupCourseService.signIn(courseId, memberId)
                             .flatMap(course -> {
@@ -231,99 +187,22 @@ public class GroupCourseHandler {
                 });
     }
 
-    @Operation(summary = "删除团课", description = "删除指定团课（软删除），需验证管理员密码")
+    @Operation(summary = "删除团课", description = "删除指定团课（软删除）")
     public Mono<ServerResponse> deleteGroupCourse(ServerRequest request) {
-        Long adminId = authUtil.getMemberIdOrThrow(request);
         Long id = Long.valueOf(request.pathVariable("id"));
-        String adminPassword = request.queryParam("adminPassword").orElse(null);
+        
-
+        return groupCourseService.delete(id)
-        if (adminPassword == null || adminPassword.isBlank()) {
+                .then(Mono.defer(() -> {
-            Map<String, Object> error = new HashMap<>();
+                    Map<String, Object> response = new HashMap<>();
-            error.put("success", false);
+                    response.put("success", true);
-            error.put("message", "管理员密码不能为空");
+                    response.put("message", "团课删除成功");
-            return ServerResponse.badRequest().bodyValue(error);
+                    return ServerResponse.ok().bodyValue(response);
-        }
+                }))
-
-        return sysUserService.verifyPassword(adminId, adminPassword)
-                .flatMap(valid -> {
-                    if (!valid) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "管理员密码错误");
-                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
-                    }
-                    return groupCourseService.delete(id)
-                            .then(Mono.defer(() -> {
-                                Map<String, Object> response = new HashMap<>();
-                                response.put("success", true);
-                                response.put("message", "团课删除成功");
-                                return ServerResponse.ok().bodyValue(response);
-                            }))
-                            .onErrorResume(error -> {
-                                Map<String, Object> response = new HashMap<>();
-                                response.put("success", false);
-                                response.put("message", error.getMessage());
-                                return ServerResponse.badRequest().bodyValue(response);
-                            });
-                });
-    }
-
-    @Operation(summary = "恢复已删除团课", description = "将已删除的团课恢复为已取消状态，需验证管理员密码")
-    public Mono<ServerResponse> restoreGroupCourse(ServerRequest request) {
-        Long adminId = authUtil.getMemberIdOrThrow(request);
-        Long id = Long.valueOf(request.pathVariable("id"));
-        String adminPassword = request.queryParam("adminPassword").orElse(null);
-
-        if (adminPassword == null || adminPassword.isBlank()) {
-            Map<String, Object> error = new HashMap<>();
-            error.put("success", false);
-            error.put("message", "管理员密码不能为空");
-            return ServerResponse.badRequest().bodyValue(error);
-        }
-
-        return sysUserService.verifyPassword(adminId, adminPassword)
-                .flatMap(valid -> {
-                    if (!valid) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "管理员密码错误");
-                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
-                    }
-                    return groupCourseService.restore(id)
-                            .flatMap(course -> {
-                                Map<String, Object> response = new HashMap<>();
-                                response.put("success", true);
-                                response.put("message", "团课恢复成功");
-                                response.put("data", course);
-                                return ServerResponse.ok().bodyValue(response);
-                            })
-                            .onErrorResume(error -> {
-                                Map<String, Object> response = new HashMap<>();
-                                response.put("success", false);
-                                response.put("message", error.getMessage());
-                                return ServerResponse.badRequest().bodyValue(response);
-                            });
-                });
-    }
-
-    @Operation(summary = "多条件查询团课", description = "支持团课名称模糊查询、类型筛选、日期范围、时间段、价格排序、剩余名额排序等多条件组合查询")
-    public Mono<ServerResponse> 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<>();
+                    Map<String, Object> response = new HashMap<>();
-                    errorResponse.put("success", false);
+                    response.put("success", false);
-                    errorResponse.put("message", error.getMessage());
+                    response.put("message", error.getMessage());
-                    return ServerResponse.badRequest().bodyValue(errorResponse);
+                    return ServerResponse.badRequest().bodyValue(response);
                 });
     }
 
@@ -379,44 +258,4 @@ public class GroupCourseHandler {
                             });
                 });
     }
-
-    @Operation(summary = "获取团课签到二维码", description = "根据团课ID生成签到二维码（base64）")
-    public Mono<ServerResponse> getCourseQRCode(ServerRequest request) {
-        Long courseId = Long.valueOf(request.pathVariable("id"));
-
-        return groupCourseService.findById(courseId)
-                .flatMap(course -> {
-                    return Mono.fromCallable(() -> {
-                        String qrContent = "{\"courseId\":" + course.getId()
-                                + ",\"courseName\":\"" + escapeJson(course.getCourseName()) + "\"}";
-
-                        QRCodeWriter qrCodeWriter = new QRCodeWriter();
-                        BitMatrix bitMatrix = qrCodeWriter.encode(qrContent, BarcodeFormat.QR_CODE, 300, 300);
-
-                        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-                        MatrixToImageWriter.writeToStream(bitMatrix, "PNG", outputStream);
-                        byte[] pngBytes = outputStream.toByteArray();
-                        String base64 = Base64.getEncoder().encodeToString(pngBytes);
-
-                        Map<String, Object> result = new HashMap<>();
-                        result.put("base64", "data:image/png;base64," + base64);
-                        result.put("courseId", course.getId());
-                        result.put("courseName", course.getCourseName());
-                        result.put("width", 300);
-                        result.put("height", 300);
-                        return result;
-                    }).subscribeOn(reactor.core.scheduler.Schedulers.boundedElastic());
-                })
-                .flatMap(result -> ServerResponse.ok().bodyValue(result))
-                .switchIfEmpty(ServerResponse.notFound().build());
-    }
-
-    private String escapeJson(String s) {
-        if (s == null) return "";
-        return s.replace("\\", "\\\\")
-                .replace("\"", "\\\"")
-                .replace("\n", "\\n")
-                .replace("\r", "\\r")
-                .replace("\t", "\\t");
-    }
 }

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

@@ -1,225 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.handler;
-
-import cn.novalon.gym.manage.groupcourse.domain.GroupCourseRecommend;
-import cn.novalon.gym.manage.groupcourse.service.IGroupCourseRecommendService;
-import cn.novalon.gym.manage.sys.core.service.ISysUserService;
-import cn.novalon.gym.manage.sys.util.AuthUtil;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import org.springframework.http.HttpStatus;
-import org.springframework.stereotype.Component;
-import org.springframework.web.reactive.function.server.ServerRequest;
-import org.springframework.web.reactive.function.server.ServerResponse;
-import reactor.core.publisher.Mono;
-
-import java.util.HashMap;
-import java.util.Map;
-
-@Component
-@Tag(name = "团课推荐管理", description = "团课推荐相关操作")
-public class GroupCourseRecommendHandler {
-
-    private final IGroupCourseRecommendService recommendService;
-    private final ISysUserService sysUserService;
-    private final AuthUtil authUtil;
-
-    public GroupCourseRecommendHandler(IGroupCourseRecommendService recommendService,
-                                        ISysUserService sysUserService,
-                                        AuthUtil authUtil) {
-        this.recommendService = recommendService;
-        this.sysUserService = sysUserService;
-        this.authUtil = authUtil;
-    }
-
-    @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 adminId = authUtil.getMemberIdOrThrow(request);
-        Long id = Long.valueOf(request.pathVariable("id"));
-        String adminPassword = request.queryParam("adminPassword").orElse(null);
-
-        if (adminPassword == null || adminPassword.isBlank()) {
-            Map<String, Object> error = new HashMap<>();
-            error.put("success", false);
-            error.put("message", "管理员密码不能为空");
-            return ServerResponse.badRequest().bodyValue(error);
-        }
-
-        return sysUserService.verifyPassword(adminId, adminPassword)
-                .flatMap(valid -> {
-                    if (!valid) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "管理员密码错误");
-                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
-                    }
-                    return request.bodyToMono(GroupCourseRecommend.class)
-                            .flatMap(recommend -> 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 adminId = authUtil.getMemberIdOrThrow(request);
-        Long id = Long.valueOf(request.pathVariable("id"));
-        String adminPassword = request.queryParam("adminPassword").orElse(null);
-
-        if (adminPassword == null || adminPassword.isBlank()) {
-            Map<String, Object> error = new HashMap<>();
-            error.put("success", false);
-            error.put("message", "管理员密码不能为空");
-            return ServerResponse.badRequest().bodyValue(error);
-        }
-
-        return sysUserService.verifyPassword(adminId, adminPassword)
-                .flatMap(valid -> {
-                    if (!valid) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "管理员密码错误");
-                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
-                    }
-                    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 adminId = authUtil.getMemberIdOrThrow(request);
-        Long id = Long.valueOf(request.pathVariable("id"));
-        String adminPassword = request.queryParam("adminPassword").orElse(null);
-
-        if (adminPassword == null || adminPassword.isBlank()) {
-            Map<String, Object> error = new HashMap<>();
-            error.put("success", false);
-            error.put("message", "管理员密码不能为空");
-            return ServerResponse.badRequest().bodyValue(error);
-        }
-
-        return sysUserService.verifyPassword(adminId, adminPassword)
-                .flatMap(valid -> {
-                    if (!valid) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "管理员密码错误");
-                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
-                    }
-                    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/handler/GroupCourseTypeHandler.java

@@ -1,182 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.handler;
-
-import cn.novalon.gym.manage.groupcourse.domain.GroupCourseType;
-import cn.novalon.gym.manage.groupcourse.service.IGroupCourseTypeService;
-import cn.novalon.gym.manage.sys.core.service.ISysUserService;
-import cn.novalon.gym.manage.sys.util.AuthUtil;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import org.springframework.http.HttpStatus;
-import org.springframework.stereotype.Component;
-import org.springframework.web.reactive.function.server.ServerRequest;
-import org.springframework.web.reactive.function.server.ServerResponse;
-import reactor.core.publisher.Mono;
-
-import java.util.HashMap;
-import java.util.Map;
-
-@Component
-@Tag(name = "团课类型管理", description = "团课类型及难度相关操作")
-public class GroupCourseTypeHandler {
-
-    private final IGroupCourseTypeService groupCourseTypeService;
-    private final ISysUserService sysUserService;
-    private final AuthUtil authUtil;
-
-    public GroupCourseTypeHandler(IGroupCourseTypeService groupCourseTypeService,
-                                   ISysUserService sysUserService,
-                                   AuthUtil authUtil) {
-        this.groupCourseTypeService = groupCourseTypeService;
-        this.sysUserService = sysUserService;
-        this.authUtil = authUtil;
-    }
-
-    @Operation(summary = "获取所有团课类型", description = "获取系统中所有团课类型列表")
-    public Mono<ServerResponse> getAllGroupCourseTypes(ServerRequest request) {
-        boolean includeDeleted = Boolean.valueOf(request.queryParam("includeDeleted").orElse("false"));
-        return ServerResponse.ok()
-                .body(groupCourseTypeService.findAll(includeDeleted), GroupCourseType.class);
-    }
-
-    @Operation(summary = "根据ID获取团课类型", description = "根据ID获取团课类型详情")
-    public Mono<ServerResponse> getGroupCourseTypeById(ServerRequest request) {
-        Long id = Long.valueOf(request.pathVariable("id"));
-        return groupCourseTypeService.findById(id)
-                .flatMap(type -> ServerResponse.ok().bodyValue(type))
-                .switchIfEmpty(ServerResponse.notFound().build());
-    }
-
-    @Operation(summary = "根据关键词搜索团课类型", description = "根据类型名称关键词搜索团课类型")
-    public Mono<ServerResponse> searchGroupCourseTypes(ServerRequest request) {
-        String keyword = request.queryParam("keyword").orElse("");
-        return ServerResponse.ok()
-                .body(groupCourseTypeService.findByKeyword(keyword), GroupCourseType.class);
-    }
-
-    @Operation(summary = "根据分类获取团课类型", description = "根据分类获取团课类型列表")
-    public Mono<ServerResponse> getGroupCourseTypesByCategory(ServerRequest request) {
-        String category = request.pathVariable("category");
-        String keyword = request.queryParam("keyword").orElse("");
-        return ServerResponse.ok()
-                .body(groupCourseTypeService.findByCategoryAndKeyword(category, keyword), GroupCourseType.class);
-    }
-
-    @Operation(summary = "获取所有分类", description = "获取所有团课类型分类（去重）")
-    public Mono<ServerResponse> getCategories(ServerRequest request) {
-        return groupCourseTypeService.findCategories()
-                .collectList()
-                .flatMap(list -> ServerResponse.ok().bodyValue(list));
-    }
-
-    @Operation(summary = "创建团课类型", description = "创建新的团课类型")
-    public Mono<ServerResponse> createGroupCourseType(ServerRequest request) {
-        return request.bodyToMono(GroupCourseType.class)
-                .flatMap(groupCourseType -> {
-                    if (groupCourseType.getTypeName() == null || groupCourseType.getTypeName().isEmpty()) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "类型名称不能为空");
-                        return ServerResponse.badRequest().bodyValue(error);
-                    }
-                    
-                    // 默认基础难度为1
-                    if (groupCourseType.getBaseDifficulty() == null) {
-                        groupCourseType.setBaseDifficulty(1);
-                    }
-                    
-                    return groupCourseTypeService.create(groupCourseType)
-                            .flatMap(type -> {
-                                Map<String, Object> response = new HashMap<>();
-                                response.put("success", true);
-                                response.put("message", "团课类型创建成功");
-                                response.put("data", type);
-                                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> updateGroupCourseType(ServerRequest request) {
-        Long adminId = authUtil.getMemberIdOrThrow(request);
-        Long id = Long.valueOf(request.pathVariable("id"));
-        String adminPassword = request.queryParam("adminPassword").orElse(null);
-
-        if (adminPassword == null || adminPassword.isBlank()) {
-            Map<String, Object> error = new HashMap<>();
-            error.put("success", false);
-            error.put("message", "管理员密码不能为空");
-            return ServerResponse.badRequest().bodyValue(error);
-        }
-
-        return sysUserService.verifyPassword(adminId, adminPassword)
-                .flatMap(valid -> {
-                    if (!valid) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "管理员密码错误");
-                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
-                    }
-                    return request.bodyToMono(GroupCourseType.class)
-                            .flatMap(groupCourseType -> {
-                                groupCourseType.setId(id);
-                                return groupCourseTypeService.update(id, groupCourseType)
-                                        .flatMap(type -> {
-                                            Map<String, Object> response = new HashMap<>();
-                                            response.put("success", true);
-                                            response.put("message", "团课类型更新成功");
-                                            response.put("data", type);
-                                            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> deleteGroupCourseType(ServerRequest request) {
-        Long adminId = authUtil.getMemberIdOrThrow(request);
-        Long id = Long.valueOf(request.pathVariable("id"));
-        String adminPassword = request.queryParam("adminPassword").orElse(null);
-
-        if (adminPassword == null || adminPassword.isBlank()) {
-            Map<String, Object> error = new HashMap<>();
-            error.put("success", false);
-            error.put("message", "管理员密码不能为空");
-            return ServerResponse.badRequest().bodyValue(error);
-        }
-
-        return sysUserService.verifyPassword(adminId, adminPassword)
-                .flatMap(valid -> {
-                    if (!valid) {
-                        Map<String, Object> error = new HashMap<>();
-                        error.put("success", false);
-                        error.put("message", "管理员密码错误");
-                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
-                    }
-                    return groupCourseTypeService.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);
-                            });
-                });
-    }
-}

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

@@ -1,89 +0,0 @@
-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/IBannerRepository.java

@@ -1,24 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.repository;
-
-import cn.novalon.gym.manage.groupcourse.domain.Banner;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-public interface IBannerRepository {
-
-    Mono<Banner> findById(Long id);
-
-    Flux<Banner> findAll();
-
-    Flux<Banner> findAll(String sortBy, String sortOrder);
-
-    Flux<Banner> findAllActive();
-
-    Mono<Banner> save(Banner banner);
-
-    Mono<Banner> update(Banner banner);
-
-    Mono<Void> deleteById(Long id);
-
-    Mono<Banner> updateActiveStatus(Long id, Boolean isActive);
-}

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

@@ -1,32 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.repository;
-
-import cn.novalon.gym.manage.groupcourse.domain.CourseLabel;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.util.List;
-
-public interface ICourseLabelRepository {
-
-    Mono<CourseLabel> findById(Long id);
-
-    Flux<CourseLabel> findAll();
-
-    Flux<CourseLabel> findByKeyword(String keyword);
-
-    Mono<CourseLabel> findByLabelName(String labelName);
-
-    Mono<CourseLabel> save(CourseLabel courseLabel);
-
-    Mono<CourseLabel> update(CourseLabel courseLabel);
-
-    Mono<Void> deleteById(Long id);
-
-    Flux<CourseLabel> findByTypeId(Long typeId);
-
-    Mono<Void> addLabelsToType(Long typeId, List<Long> labelIds);
-
-    Mono<Void> removeLabelFromType(Long typeId, Long labelId);
-
-    Mono<Void> clearLabelsFromType(Long typeId);
-}

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

@@ -89,11 +89,4 @@ public interface IGroupCourseBookingRepository {
      * @return 更新记录数
      */
     Mono<Integer> updateToAbsent(Long bookingId);
-
-    /**
-     * 统计会员取消的预约次数
-     * @param memberId 会员ID
-     * @return 取消次数
-     */
-    Mono<Long> countCancelledByMemberId(Long memberId);
 }

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

@@ -1,30 +0,0 @@
-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,7 +4,6 @@ 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;
@@ -27,11 +26,5 @@ public interface IGroupCourseRepository {
     
     Mono<Void> deleteById(Long id);
     
-    Mono<GroupCourse> restoreById(Long id);
-    
     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/IGroupCourseTypeRepository.java

@@ -1,28 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.repository;
-
-import cn.novalon.gym.manage.groupcourse.domain.GroupCourseType;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-public interface IGroupCourseTypeRepository {
-
-    Mono<GroupCourseType> findById(Long id);
-
-    Flux<GroupCourseType> findAll();
-
-    Flux<GroupCourseType> findAll(boolean includeDeleted);
-
-    Flux<GroupCourseType> findByKeyword(String keyword);
-
-    Flux<GroupCourseType> findByCategory(String category);
-
-    Flux<GroupCourseType> findByCategoryAndKeyword(String category, String keyword);
-
-    Mono<GroupCourseType> findByTypeName(String typeName);
-
-    Mono<GroupCourseType> save(GroupCourseType groupCourseType);
-
-    Mono<GroupCourseType> update(GroupCourseType groupCourseType);
-
-    Mono<Void> deleteById(Long id);
-}

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

@@ -1,113 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.repository.impl;
-
-import cn.hutool.core.bean.BeanUtil;
-import cn.novalon.gym.manage.groupcourse.dao.BannerDao;
-import cn.novalon.gym.manage.groupcourse.domain.Banner;
-import cn.novalon.gym.manage.groupcourse.entity.BannerEntity;
-import cn.novalon.gym.manage.groupcourse.repository.IBannerRepository;
-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 BannerRepository implements IBannerRepository {
-
-    private final BannerDao bannerDao;
-    private final R2dbcEntityTemplate r2dbcEntityTemplate;
-
-    public BannerRepository(BannerDao bannerDao, R2dbcEntityTemplate r2dbcEntityTemplate) {
-        this.bannerDao = bannerDao;
-        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
-    }
-
-    @Override
-    public Mono<Banner> findById(Long id) {
-        return bannerDao.findByIdAndDeletedAtIsNull(id)
-                .map(this::toDomain);
-    }
-
-    @Override
-    public Flux<Banner> findAll() {
-        return bannerDao.findAllByDeletedAtIsNull()
-                .map(this::toDomain);
-    }
-
-    @Override
-    public Flux<Banner> findAll(String sortBy, String sortOrder) {
-        Sort.Direction direction = "asc".equalsIgnoreCase(sortOrder)
-                ? Sort.Direction.ASC
-                : Sort.Direction.DESC;
-        Sort sort = Sort.by(direction, sortBy);
-        return bannerDao.findAllByDeletedAtIsNull(sort)
-                .map(this::toDomain);
-    }
-
-    @Override
-    public Flux<Banner> findAllActive() {
-        return bannerDao.findByIsActiveTrueAndDeletedAtIsNull(Sort.by(Sort.Direction.DESC, "sortOrder"))
-                .map(this::toDomain);
-    }
-
-    @Override
-    public Mono<Banner> save(Banner banner) {
-        BannerEntity entity = toEntity(banner);
-        entity.setCreatedAt(LocalDateTime.now());
-        entity.setUpdatedAt(LocalDateTime.now());
-        if (entity.getSortOrder() == null) {
-            entity.setSortOrder(0);
-        }
-        if (entity.getIsActive() == null) {
-            entity.setIsActive(true);
-        }
-
-        return bannerDao.save(entity)
-                .map(this::toDomain);
-    }
-
-    @Override
-    public Mono<Banner> update(Banner banner) {
-        BannerEntity entity = toEntity(banner);
-        entity.setUpdatedAt(LocalDateTime.now());
-
-        return r2dbcEntityTemplate.update(entity)
-                .then(findById(banner.getId()));
-    }
-
-    @Override
-    public Mono<Void> deleteById(Long id) {
-        return bannerDao.softDelete(id, LocalDateTime.now())
-                .then();
-    }
-
-    @Override
-    public Mono<Banner> updateActiveStatus(Long id, Boolean isActive) {
-        return bannerDao.updateActiveStatus(id, isActive, LocalDateTime.now())
-                .flatMap(updated -> {
-                    if (updated > 0) {
-                        return findById(id);
-                    }
-                    return Mono.empty();
-                });
-    }
-
-    private Banner toDomain(BannerEntity entity) {
-        if (entity == null) return null;
-        Banner banner = new Banner();
-        BeanUtil.copyProperties(entity, banner);
-        return banner;
-    }
-
-    private BannerEntity toEntity(Banner domain) {
-        if (domain == null) return null;
-        BannerEntity entity = new BannerEntity();
-        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/CourseLabelRepository.java

@@ -1,161 +0,0 @@
-package cn.novalon.gym.manage.groupcourse.repository.impl;
-
-import cn.novalon.gym.manage.groupcourse.converter.GroupCourseConverter;
-import cn.novalon.gym.manage.groupcourse.dao.CourseLabelDao;
-import cn.novalon.gym.manage.groupcourse.dao.CourseTypeLabelDao;
-import cn.novalon.gym.manage.groupcourse.domain.CourseLabel;
-import cn.novalon.gym.manage.groupcourse.entity.CourseLabelEntity;
-import cn.novalon.gym.manage.groupcourse.entity.CourseTypeLabelEntity;
-import cn.novalon.gym.manage.groupcourse.repository.ICourseLabelRepository;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Transactional;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-import java.util.List;
-
-@Repository
-@Transactional
-public class CourseLabelRepository implements ICourseLabelRepository {
-
-    private static final Logger logger = LoggerFactory.getLogger(CourseLabelRepository.class);
-
-    private final CourseLabelDao courseLabelDao;
-    private final CourseTypeLabelDao courseTypeLabelDao;
-    private final GroupCourseConverter converter;
-
-    public CourseLabelRepository(CourseLabelDao courseLabelDao, CourseTypeLabelDao courseTypeLabelDao, 
-                                  GroupCourseConverter converter) {
-        this.courseLabelDao = courseLabelDao;
-        this.courseTypeLabelDao = courseTypeLabelDao;
-        this.converter = converter;
-    }
-
-    @Override
-    public Mono<CourseLabel> findById(Long id) {
-        return courseLabelDao.findByIdIsAndDeletedAtIsNull(id)
-                .map(this::toCourseLabel);
-    }
-
-    @Override
-    public Flux<CourseLabel> findAll() {
-        return courseLabelDao.findAllByDeletedAtIsNull()
-                .map(this::toCourseLabel);
-    }
-
-    @Override
-    public Flux<CourseLabel> findByKeyword(String keyword) {
-        if (keyword == null || keyword.isEmpty()) {
-            return findAll();
-        }
-        return courseLabelDao.findByLabelNameContainingAndDeletedAtIsNull(keyword)
-                .map(this::toCourseLabel);
-    }
-
-    @Override
-    public Mono<CourseLabel> findByLabelName(String labelName) {
-        return courseLabelDao.findByLabelNameAndDeletedAtIsNull(labelName)
-                .map(this::toCourseLabel);
-    }
-
-    @Override
-    public Mono<CourseLabel> save(CourseLabel courseLabel) {
-        CourseLabelEntity entity = toCourseLabelEntity(courseLabel);
-        return courseLabelDao.save(entity)
-                .map(this::toCourseLabel);
-    }
-
-    @Override
-    public Mono<CourseLabel> update(CourseLabel courseLabel) {
-        return courseLabelDao.findByIdIsAndDeletedAtIsNull(courseLabel.getId())
-                .switchIfEmpty(Mono.error(new RuntimeException("标签不存在")))
-                .flatMap(existing -> {
-                    existing.markNotNew();
-                    if (courseLabel.getLabelName() != null) {
-                        existing.setLabelName(courseLabel.getLabelName());
-                    }
-                    if (courseLabel.getColor() != null) {
-                        existing.setColor(courseLabel.getColor());
-                    }
-                    if (courseLabel.getDescription() != null) {
-                        existing.setDescription(courseLabel.getDescription());
-                    }
-                    existing.setUpdatedAt(LocalDateTime.now());
-                    return courseLabelDao.save(existing);
-                })
-                .map(this::toCourseLabel);
-    }
-
-    @Override
-    public Mono<Void> deleteById(Long id) {
-        return courseLabelDao.softDelete(id, LocalDateTime.now())
-                .then(courseTypeLabelDao.deleteByLabelId(id, LocalDateTime.now()))
-                .then();
-    }
-
-    @Override
-    public Flux<CourseLabel> findByTypeId(Long typeId) {
-        return courseTypeLabelDao.findByTypeIdAndDeletedAtIsNull(typeId)
-                .flatMap(typeLabel -> courseLabelDao.findByIdIsAndDeletedAtIsNull(typeLabel.getLabelId()))
-                .map(this::toCourseLabel);
-    }
-
-    @Override
-    public Mono<Void> addLabelsToType(Long typeId, List<Long> labelIds) {
-        return Flux.fromIterable(labelIds)
-                .flatMap(labelId -> {
-                    return courseTypeLabelDao.physicalDeleteByTypeIdAndLabelId(typeId, labelId)
-                            .then(Mono.defer(() -> {
-                                CourseTypeLabelEntity entity = new CourseTypeLabelEntity();
-                                entity.setTypeId(typeId);
-                                entity.setLabelId(labelId);
-                                return courseTypeLabelDao.save(entity).then(Mono.empty());
-                            }));
-                })
-                .then();
-    }
-
-    @Override
-    public Mono<Void> removeLabelFromType(Long typeId, Long labelId) {
-        return courseTypeLabelDao.deleteByTypeIdAndLabelId(typeId, labelId, LocalDateTime.now())
-                .then();
-    }
-
-    @Override
-    public Mono<Void> clearLabelsFromType(Long typeId) {
-        return courseTypeLabelDao.deleteByTypeId(typeId, LocalDateTime.now())
-                .then();
-    }
-
-    private CourseLabel toCourseLabel(CourseLabelEntity entity) {
-        if (entity == null) {
-            return null;
-        }
-        CourseLabel label = new CourseLabel();
-        label.setId(entity.getId());
-        label.setLabelName(entity.getLabelName());
-        label.setColor(entity.getColor());
-        label.setDescription(entity.getDescription());
-        label.setCreatedAt(entity.getCreatedAt());
-        label.setUpdatedAt(entity.getUpdatedAt());
-        return label;
-    }
-
-    private CourseLabelEntity toCourseLabelEntity(CourseLabel domain) {
-        if (domain == null) {
-            return null;
-        }
-        CourseLabelEntity entity = new CourseLabelEntity();
-        entity.setId(domain.getId());
-        entity.setLabelName(domain.getLabelName());
-        entity.setColor(domain.getColor());
-        entity.setDescription(domain.getDescription());
-        if (domain.getId() != null) {
-            entity.markNotNew();
-        }
-        return entity;
-    }
-}

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

@@ -112,9 +112,4 @@ public class GroupCourseBookingRepository implements IGroupCourseBookingReposito
         java.time.LocalDateTime now = java.time.LocalDateTime.now();
         return groupCourseBookingDao.updateToAbsent(bookingId, now);
     }
-
-    @Override
-    public Mono<Long> countCancelledByMemberId(Long memberId) {
-        return groupCourseBookingDao.countCancelledByMemberId(memberId);
-    }
 }

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

@@ -1,136 +0,0 @@
-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;
-    }
-}