移除前端中的会员卡和支付相关，新增微信一键登录

# 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/groupcourse-api.md

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

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/pom.xml

@@ -118,11 +118,6 @@
             <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>

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

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

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

@@ -2,8 +2,6 @@ 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;
@@ -14,7 +12,6 @@ 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;
@@ -39,7 +36,6 @@ public class CheckInHandler {
     public Mono<ServerResponse> checkIn(ServerRequest request) {
 
         Long memberId = authUtil.getMemberIdOrThrow(request);
-
         return request.bodyToMono(Map.class)
                 .flatMap(body -> {
                     String qrContent = (String) body.get("qrContent");
@@ -194,4 +190,4 @@ public class CheckInHandler {
                         .contentType(MediaType.APPLICATION_JSON)
                         .bodyValue(Map.of("code", 200, "message", "success", "data", stats)));
     }
-}
+}

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

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

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

@@ -2,8 +2,6 @@ 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;
@@ -21,6 +19,8 @@ import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.enums.MemberCardType;
 import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
 import cn.novalon.gym.manage.member.repository.MemberCardRepository;
+import cn.hutool.extra.qrcode.QrCodeUtil;
+import cn.hutool.extra.qrcode.QrConfig;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;

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

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

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

@@ -127,7 +127,7 @@ class CheckInModuleTest {
         
         when(redisUtil.get(eq(key))).thenReturn(Mono.just(qrData));
         when(memberCardRecordRepository.findById(1L)).thenReturn(Mono.just(mockMemberCardRecord));
-        when(memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(1L)).thenReturn(Flux.just(mockMemberCard));
+        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());

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

@@ -100,20 +100,8 @@
     <build>
         <plugins>
             <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
+                <groupId>org.springframework.boot</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
-                <version>3.11.0</version>
-                <configuration>
-                    <source>21</source>
-                    <target>21</target>
-                    <annotationProcessorPaths>
-                        <path>
-                            <groupId>org.projectlombok</groupId>
-                            <artifactId>lombok</artifactId>
-                            <version>${lombok.version}</version>
-                        </path>
-                    </annotationProcessorPaths>
-                </configuration>
             </plugin>
         </plugins>
     </build>

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

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

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

@@ -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/domain/GroupCourse.java

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

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

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

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

@@ -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/dto/GroupCourseQueryDto.java

@@ -1,116 +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;
-
-    // ===== Getters and Setters =====
-
-    public String getCourseName() {
-        return courseName;
-    }
-
-    public void setCourseName(String courseName) {
-        this.courseName = courseName;
-    }
-
-    public Long getCourseType() {
-        return courseType;
-    }
-
-    public void setCourseType(Long courseType) {
-        this.courseType = courseType;
-    }
-
-    public LocalDateTime getStartDate() {
-        return startDate;
-    }
-
-    public void setStartDate(LocalDateTime startDate) {
-        this.startDate = startDate;
-    }
-
-    public LocalDateTime getEndDate() {
-        return endDate;
-    }
-
-    public void setEndDate(LocalDateTime endDate) {
-        this.endDate = endDate;
-    }
-
-    public String getTimePeriod() {
-        return timePeriod;
-    }
-
-    public void setTimePeriod(String timePeriod) {
-        this.timePeriod = timePeriod;
-    }
-
-    public String getPriceSort() {
-        return priceSort;
-    }
-
-    public void setPriceSort(String priceSort) {
-        this.priceSort = priceSort;
-    }
-
-    public Boolean getRemainingMost() {
-        return remainingMost;
-    }
-
-    public void setRemainingMost(Boolean remainingMost) {
-        this.remainingMost = remainingMost;
-    }
-
-    public Integer getPage() {
-        return page;
-    }
-
-    public void setPage(Integer page) {
-        this.page = page;
-    }
-
-    public Integer getSize() {
-        return size;
-    }
-
-    public void setSize(Integer size) {
-        this.size = size;
-    }
-}

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

@@ -54,14 +54,14 @@ public class GroupCourseEntity extends BaseEntity {
     @Column("description")
     private String description;
 
+    //点卡额度（消耗次数）
+    @Column("point_card_amount")
+    private Integer pointCardAmount;
+
     //储值卡额度（消耗金额）
     @Column("stored_value_amount")
     private java.math.BigDecimal storedValueAmount;
 
-    //二维码路径
-    @Column("qr_code_path")
-    private String qrCodePath;
-
     public String getCourseName() {
         return courseName;
     }
@@ -150,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;
     }
@@ -157,12 +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;
-    }
 }

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/handler/BookingSagaHandler.java

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

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

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

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

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

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

@@ -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/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;
@@ -30,6 +29,4 @@ public interface IGroupCourseRepository {
     Mono<GroupCourse> updateCurrentMembers(Long id, Integer delta);
     
     Flux<GroupCourse> findByCourseType(Long courseType);
-
-    Mono<PageResponse<GroupCourse>> searchGroupCourses(GroupCourseQueryDto query);
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -237,7 +237,7 @@
                 <configuration>
                     <effort>Max</effort>
                     <threshold>High</threshold>
-                    <failOnError>false</failOnError>
+                    <failOnError>true</failOnError>
                     <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
                 </configuration>
             </plugin>

gym-manage-api/gym-member/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-member/src/main/java/cn/novalon/gym/manage/member/entity/MemberCardRecord.java

@@ -4,81 +4,69 @@ import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
-import org.springframework.data.annotation.Id;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
-import org.springframework.data.annotation.Transient;
 
 import java.time.LocalDateTime;
 
+/**
+ * 会员卡记录实体（会员持有的卡）- 对应 member_card_record 表
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
 @Data
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
 @Table("member_card_record")
-public class MemberCardRecord {
+public class MemberCardRecord extends BaseEntity {
-
-    @Id
-    @Column("id")
-    private Long id;
-
-    @Column("created_at")
-    private LocalDateTime createdAt;
-
-    @Column("updated_at")
-    private LocalDateTime updatedAt;
-
-    @Column("deleted_at")
-    private LocalDateTime deletedAt;
 
+    // 会员持有卡ID
     @Column("member_card_record_id")
     private Long memberCardRecordId;
 
+    // 会员ID
     @Column("member_id")
     private Long memberId;
 
+    // 关联会员卡ID
     @Column("member_card_id")
     private Long memberCardId;
 
+    // 状态：ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款
     @Column("status")
     private MemberCardRecordStatus status;
 
+    // 剩余次数
     @Column("remaining_times")
     private Integer remainingTimes;
 
+    // 剩余金额
     @Column("remaining_amount")
     private Double remainingAmount;
 
+    // 到期时间
     @Column("expire_time")
     private LocalDateTime expireTime;
 
+    // 来源订单ID
     @Column("source_order_id")
     private Long sourceOrderId;
 
+    // 购买时间
     @Column("purchase_time")
     private LocalDateTime purchaseTime;
 
+    // 乐观锁版本号
     @Column("version")
     private Integer version;
 
+    // 卡片组成（JSON格式，用于组合卡）
     @Column("card_composition")
     private String cardComposition;
 
-    // 联表查询的会员卡信息（非持久化字段，不映射到数据库表列）
-    @Transient
-    private String memberCardName;
-
-    @Transient
-    private String memberCardType;
-
-    @Transient
-    private Double memberCardPrice;
-
-    @Transient
-    private Integer memberCardValidityDays;
-
-    @Transient
-    private Integer memberCardTotalTimes;
-
 }

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

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

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

@@ -1,42 +0,0 @@
-package cn.novalon.gym.manage.member.entity;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.NoArgsConstructor;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.math.BigDecimal;
-
-/**
- * 储值卡实体类
- * 每个会员只有一张储值卡，存储余额信息和支付密码
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@EqualsAndHashCode(callSuper = true)
-@Table("member_stored_card")
-public class MemberStoredCard extends BaseEntity {
-
-    @Column("member_id")
-    private Long memberId;
-
-    @Column("balance")
-    private BigDecimal balance;
-
-    @Column("total_recharge")
-    private BigDecimal totalRecharge;
-
-    @Column("total_consume")
-    private BigDecimal totalConsume;
-
-    @Column("pay_password")
-    private String payPassword;
-
-    @Column("is_pay_password_set")
-    private Boolean isPayPasswordSet;
-}

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

@@ -1,48 +0,0 @@
-package cn.novalon.gym.manage.member.entity;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.NoArgsConstructor;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-
-/**
- * 储值卡充值记录实体类
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@EqualsAndHashCode(callSuper = true)
-@Table("member_stored_card_recharge")
-public class MemberStoredCardRecharge extends BaseEntity {
-
-    @Column("member_id")
-    private Long memberId;
-
-    @Column("order_no")
-    private String orderNo;
-
-    @Column("recharge_amount")
-    private BigDecimal rechargeAmount;
-
-    @Column("bonus_amount")
-    private BigDecimal bonusAmount;
-
-    @Column("total_amount")
-    private BigDecimal totalAmount;
-
-    @Column("pay_amount")
-    private BigDecimal payAmount;
-
-    @Column("status")
-    private String status;
-
-    @Column("pay_time")
-    private LocalDateTime payTime;
-}

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

@@ -31,7 +31,7 @@ public class MemberCardHandler {
 
     @Operation(summary = "根据ID查询会员卡类型", description = "查询指定ID的会员卡类型详情")
     public Mono<ServerResponse> getMemberCardById(ServerRequest request) {
-        Long id = Long.valueOf(request.pathVariable("memberCardId"));
+        Long id = Long.valueOf(request.pathVariable("id"));
         return memberCardService.findByMemberCardIdAndDeletedAtIsNull(id)
                 .flatMap(card -> ServerResponse.ok().bodyValue(card))
                 .switchIfEmpty(ServerResponse.notFound().build());
@@ -97,32 +97,29 @@ public class MemberCardHandler {
     @Operation(summary = "续费会员卡", description = "为已有会员卡续费")
     public Mono<ServerResponse> renewCard(ServerRequest request) {
         Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
-        Long memberId = Long.valueOf(request.queryParam("memberId").orElseThrow());
         Integer addTimes = request.queryParam("addTimes").map(Integer::valueOf).orElse(null);
         Double addAmount = request.queryParam("addAmount").map(Double::valueOf).orElse(null);
         Integer addDays = request.queryParam("addDays").map(Integer::valueOf).orElse(null);
         Long sourceOrderId = request.queryParam("sourceOrderId").map(Long::valueOf).orElse(null);
 
-        return memberCardService.renewCard(recordId, memberId, addTimes, addAmount, addDays, sourceOrderId)
+        return memberCardService.renewCard(recordId, addTimes, addAmount, addDays, sourceOrderId)
                 .flatMap(record -> ServerResponse.ok().bodyValue(record));
     }
 
     @Operation(summary = "使用会员卡", description = "扣减会员卡次数或余额")
     public Mono<ServerResponse> useCard(ServerRequest request) {
         Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
-        Long memberId = Long.valueOf(request.queryParam("memberId").orElseThrow());
         Integer deductTimes = request.queryParam("deductTimes").map(Integer::valueOf).orElse(null);
         Double deductAmount = request.queryParam("deductAmount").map(Double::valueOf).orElse(null);
 
-        return memberCardService.useCard(recordId, memberId, deductTimes, deductAmount)
+        return memberCardService.useCard(recordId, deductTimes, deductAmount)
                 .flatMap(record -> ServerResponse.ok().bodyValue(record));
     }
 
     @Operation(summary = "退款会员卡", description = "申请会员卡退款")
     public Mono<ServerResponse> refundCard(ServerRequest request) {
         Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
-        Long memberId = Long.valueOf(request.queryParam("memberId").orElseThrow());
+        return memberCardService.refundCard(recordId)
-        return memberCardService.refundCard(recordId, memberId)
                 .then(ServerResponse.noContent().build());
     }
 

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

@@ -3,7 +3,6 @@ package cn.novalon.gym.manage.member.handler;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
 import cn.novalon.gym.manage.member.service.IMemberCardService;
-import cn.novalon.gym.manage.sys.util.AuthUtil;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.Data;
@@ -24,22 +23,18 @@ public class MemberCardRecordHandler {
 
     private final IMemberCardService memberCardService;
     private final IMemberCardRecordService memberCardRecordService;
-    private final AuthUtil authUtil;
 
     public MemberCardRecordHandler(IMemberCardService memberCardService,
-                                   IMemberCardRecordService memberCardRecordService,
+                                   IMemberCardRecordService memberCardRecordService) {
-                                   AuthUtil authUtil) {
         this.memberCardService = memberCardService;
         this.memberCardRecordService = memberCardRecordService;
-        this.authUtil = authUtil;
     }
 
     @Operation(summary = "购买会员卡", description = "支持时长卡、次卡、储值卡，自动设置到期提醒")
     public Mono<ServerResponse> purchaseCard(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
         return request.bodyToMono(PurchaseRequest.class)
                 .flatMap(body -> memberCardService.purchaseCard(
-                        memberId,
+                        body.getMemberId(),
                         body.getMemberCardId(),
                         body.getSourceOrderId()))
                 .flatMap(record -> ServerResponse.ok().bodyValue(record))
@@ -49,10 +44,8 @@ public class MemberCardRecordHandler {
     @Operation(summary = "续费会员卡", description = "累加剩余次数/余额，顺延到期日期，权益立即生效")
     public Mono<ServerResponse> renewCard(ServerRequest request) {
         Long recordId = Long.parseLong(request.pathVariable("recordId"));
-        Long memberId = authUtil.getMemberIdOrThrow(request);
         return request.bodyToMono(RenewRequest.class)
                 .flatMap(body -> memberCardService.renewCard(recordId,
-                        memberId,
                         body.getAddTimes(),
                         body.getAddAmount(),
                         body.getAddDays(),
@@ -64,10 +57,8 @@ public class MemberCardRecordHandler {
     @Operation(summary = "使用会员卡", description = "预约团课或私教成功后扣减次数或余额")
     public Mono<ServerResponse> useCard(ServerRequest request) {
         Long recordId = Long.parseLong(request.pathVariable("recordId"));
-        Long memberId = authUtil.getMemberIdOrThrow(request);
         return request.bodyToMono(UseCardRequest.class)
                 .flatMap(body -> memberCardService.useCard(recordId,
-                        memberId,
                         body.getDeductTimes(),
                         body.getDeductAmount()))
                 .flatMap(record -> ServerResponse.ok().bodyValue(record))
@@ -77,8 +68,7 @@ public class MemberCardRecordHandler {
     @Operation(summary = "退款会员卡", description = "使用Saga模式执行退款流程，保证事务一致性")
     public Mono<ServerResponse> refundCard(ServerRequest request) {
         Long recordId = Long.parseLong(request.pathVariable("recordId"));
-        Long memberId = authUtil.getMemberIdOrThrow(request);
+        return memberCardService.refundCard(recordId)
-        return memberCardService.refundCard(recordId, memberId)
                 .then(ServerResponse.ok().bodyValue("退款成功"))
                 .onErrorResume(e -> ServerResponse.badRequest().bodyValue("退款失败: " + e.getMessage()));
     }
@@ -93,34 +83,12 @@ public class MemberCardRecordHandler {
 
     @Operation(summary = "会员我的卡包", description = "查询当前会员的所有有效卡")
     public Mono<ServerResponse> getMyCards(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
+        Long memberId = Long.parseLong(request.pathVariable("memberId"));
         return ServerResponse.ok().body(
                 memberCardRecordService.findActiveCardsByMemberId(memberId),
                 MemberCardRecord.class);
     }
 
-    @Operation(summary = "会员卡包（带筛选）", description = "查询会员的所有会员卡，支持状态筛选：all-全部, active-有效, expired-已失效")
-    public Mono<ServerResponse> getMyCardsWithStatus(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        String status = request.queryParam("status").orElse("all");
-        
-        if (!status.equals("all") && !status.equals("active") && !status.equals("expired")) {
-            return ServerResponse.badRequest().bodyValue("无效的status参数，允许值：all, active, expired");
-        }
-        
-        return memberCardRecordService.findCardsByMemberIdWithStatus(memberId, status)
-                .collectList()
-                .flatMap(cards -> ServerResponse.ok().bodyValue(cards));
-    }
-
-    @Operation(summary = "获取会员主要有效卡", description = "查询当前会员的主要有效会员卡（只返回一条），优先临期卡，其次有效卡")
-    public Mono<ServerResponse> getPrimaryCard(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        return memberCardRecordService.findPrimaryActiveCardByMemberId(memberId)
-                .flatMap(card -> ServerResponse.ok().bodyValue(card))
-                .switchIfEmpty(ServerResponse.noContent().build());
-    }
-
     @Operation(summary = "处理过期会员卡", description = "定时任务调用，扫描并更新过期卡状态")
     public Mono<ServerResponse> processExpiredCards(ServerRequest request) {
         return memberCardService.processExpiredCards()
@@ -129,6 +97,7 @@ public class MemberCardRecordHandler {
 
     @Data
     public static class PurchaseRequest {
+        private Long memberId;
         private Long memberCardId;
         private Long sourceOrderId;
     }

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

@@ -109,17 +109,6 @@ public class MemberCardTransactionHandler {
                         MemberCardTransaction.class);
     }
 
-    /**
-     * 按会员卡记录ID查询流水
-     */
-    @Operation(summary = "按会员卡记录ID查询流水", description = "查看某张会员持卡记录的所有流水")
-    public Mono<ServerResponse> getTransactionsByRecordId(ServerRequest request) {
-        Long recordId = Long.parseLong(request.pathVariable("recordId"));
-        return ServerResponse.ok()
-                .body(memberCardTransactionService.findByRecordId(recordId),
-                        MemberCardTransaction.class);
-    }
-
     /**
      * 统计某卡种的总扣次数
      */

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

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

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

@@ -1,189 +0,0 @@
-package cn.novalon.gym.manage.member.handler;
-
-import cn.novalon.gym.manage.member.service.IMemberStoredCardService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Component;
-import org.springframework.web.reactive.function.server.ServerRequest;
-import org.springframework.web.reactive.function.server.ServerResponse;
-import reactor.core.publisher.Mono;
-
-import java.math.BigDecimal;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * 储值卡 Handler
- */
-@Slf4j
-@Component
-public class MemberStoredCardHandler {
-
-    private final IMemberStoredCardService memberStoredCardService;
-
-    public MemberStoredCardHandler(IMemberStoredCardService memberStoredCardService) {
-        this.memberStoredCardService = memberStoredCardService;
-    }
-
-    /**
-     * 获取会员储值卡信息
-     */
-    public Mono<ServerResponse> getStoredCardInfo(ServerRequest request) {
-        Long memberId = Long.valueOf(request.pathVariable("memberId"));
-        return memberStoredCardService.getOrCreateStoredCard(memberId)
-                .flatMap(card -> {
-                    Map<String, Object> result = new HashMap<>();
-                    result.put("memberId", card.getMemberId());
-                    result.put("balance", card.getBalance() != null ? card.getBalance() : BigDecimal.ZERO);
-                    result.put("totalRecharge", card.getTotalRecharge() != null ? card.getTotalRecharge() : BigDecimal.ZERO);
-                    result.put("totalConsume", card.getTotalConsume() != null ? card.getTotalConsume() : BigDecimal.ZERO);
-                    result.put("isPayPasswordSet", card.getIsPayPasswordSet() != null && card.getIsPayPasswordSet());
-                    return ServerResponse.ok().bodyValue(result);
-                });
-    }
-
-    /**
-     * 获取储值卡余额
-     */
-    public Mono<ServerResponse> getBalance(ServerRequest request) {
-        Long memberId = Long.valueOf(request.pathVariable("memberId"));
-        return memberStoredCardService.getStoredCard(memberId)
-                .flatMap(card -> {
-                    Map<String, Object> result = new HashMap<>();
-                    result.put("balance", card.getBalance() != null ? card.getBalance() : BigDecimal.ZERO);
-                    result.put("hasCard", true);
-                    return ServerResponse.ok().bodyValue(result);
-                })
-                .switchIfEmpty(Mono.defer(() -> {
-                    Map<String, Object> result = new HashMap<>();
-                    result.put("balance", BigDecimal.ZERO);
-                    result.put("hasCard", false);
-                    return ServerResponse.ok().bodyValue(result);
-                }));
-    }
-
-    /**
-     * 检查支付密码是否已设置
-     */
-    public Mono<ServerResponse> checkPasswordSet(ServerRequest request) {
-        Long memberId = Long.valueOf(request.pathVariable("memberId"));
-        return memberStoredCardService.isPayPasswordSet(memberId)
-                .flatMap(isSet -> {
-                    Map<String, Object> data = new HashMap<>();
-                    data.put("isSet", isSet);
-                    Map<String, Object> result = new HashMap<>();
-                    result.put("code", 200);
-                    result.put("message", "success");
-                    result.put("data", data);
-                    return ServerResponse.ok().bodyValue(result);
-                });
-    }
-
-    /**
-     * 设置支付密码
-     */
-    public Mono<ServerResponse> setPassword(ServerRequest request) {
-        Long memberId = Long.valueOf(request.pathVariable("memberId"));
-        return request.bodyToMono(Map.class)
-                .flatMap(body -> {
-                    String password = (String) body.get("password");
-                    if (password == null || password.isEmpty()) {
-                        return ServerResponse.badRequest().bodyValue(Map.of("code", 400, "message", "密码不能为空"));
-                    }
-                    return memberStoredCardService.setPayPassword(memberId, password)
-                            .flatMap(rows -> {
-                                if (rows > 0) {
-                                    return ServerResponse.ok().bodyValue(Map.of("code", 200, "message", "设置成功"));
-                                }
-                                return ServerResponse.ok().bodyValue(Map.of("code", 400, "message", "设置失败"));
-                            });
-                });
-    }
-
-    /**
-     * 验证支付密码
-     */
-    public Mono<ServerResponse> verifyPassword(ServerRequest request) {
-        Long memberId = Long.valueOf(request.pathVariable("memberId"));
-        return request.bodyToMono(Map.class)
-                .flatMap(body -> {
-                    String password = (String) body.get("password");
-                    if (password == null || password.isEmpty()) {
-                        return ServerResponse.badRequest().bodyValue(Map.of("code", 400, "message", "密码不能为空"));
-                    }
-                    return memberStoredCardService.verifyPayPassword(memberId, password)
-                            .flatMap(isValid -> {
-                                Map<String, Object> data = new HashMap<>();
-                                data.put("valid", isValid);
-                                Map<String, Object> result = new HashMap<>();
-                                result.put("code", 200);
-                                result.put("message", isValid ? "验证成功" : "密码错误");
-                                result.put("data", data);
-                                return ServerResponse.ok().bodyValue(result);
-                            });
-                });
-    }
-
-    /**
-     * 储值卡支付（验证密码并扣减余额）
-     */
-    public Mono<ServerResponse> payWithStoredCard(ServerRequest request) {
-        Long memberId = Long.valueOf(request.pathVariable("memberId"));
-        return request.bodyToMono(Map.class)
-                .flatMap(body -> {
-                    String password = (String) body.get("password");
-                    BigDecimal amount = body.get("amount") != null
-                            ? new BigDecimal(body.get("amount").toString())
-                            : null;
-                    String orderType = (String) body.get("orderType");
-                    String goodsDesc = (String) body.get("goodsDesc");
-
-                    if (password == null || password.isEmpty()) {
-                        return ServerResponse.badRequest().bodyValue(Map.of("code", 400, "message", "支付密码不能为空"));
-                    }
-                    if (amount == null) {
-                        return ServerResponse.badRequest().bodyValue(Map.of("code", 400, "message", "支付金额不能为空"));
-                    }
-
-                    return memberStoredCardService.payWithStoredCard(memberId, password, amount)
-                            .flatMap(result -> {
-                                Map<String, Object> response = new HashMap<>();
-                                if (result.isSuccess()) {
-                                    response.put("code", 200);
-                                    response.put("message", "支付成功");
-                                    response.put("balance", result.getBalance());
-                                    log.info("[储值卡支付] 支付成功: memberId={}, amount={}, remainingBalance={}",
-                                            memberId, amount, result.getBalance());
-                                } else {
-                                    response.put("code", 400);
-                                    response.put("message", result.getMessage());
-                                    log.warn("[储值卡支付] 支付失败: memberId={}, amount={}, reason={}",
-                                            memberId, amount, result.getMessage());
-                                }
-                                return ServerResponse.ok().bodyValue(response);
-                            });
-                });
-    }
-
-    /**
-     * 查询会员的充值记录列表
-     */
-    public Mono<ServerResponse> getRechargeRecords(ServerRequest request) {
-        Long memberId = Long.valueOf(request.pathVariable("memberId"));
-        int page = Integer.parseInt(request.queryParam("page").orElse("1"));
-        int size = Integer.parseInt(request.queryParam("size").orElse("20"));
-
-        log.info("[储值卡] 查询充值记录: memberId={}, page={}, size={}", memberId, page, size);
-
-        return memberStoredCardService.getRechargeRecords(memberId, page, size)
-                .collectList()
-                .zipWith(memberStoredCardService.countRechargeRecords(memberId))
-                .flatMap(tuple -> {
-                    Map<String, Object> result = new HashMap<>();
-                    result.put("list", tuple.getT1());
-                    result.put("total", tuple.getT2());
-                    result.put("page", page);
-                    result.put("size", size);
-                    return ServerResponse.ok().bodyValue(result);
-                });
-    }
-}

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

@@ -23,6 +23,7 @@ public interface MemberCardRecordRepository extends R2dbcRepository<MemberCardRe
     /**
      * 插入新的激活卡记录
      */
+    @Modifying
     @Query("INSERT INTO member_card_record (member_id, member_card_id, status, expire_time, remaining_times, remaining_amount, source_order_id, purchase_time, created_at, updated_at) " +
             "VALUES (:memberId, :memberCardId, 'ACTIVE', :expireTime, :remainingTimes, :remainingAmount, :sourceOrderId, NOW(), NOW(), NOW()) " +
             "RETURNING *")
@@ -62,19 +63,9 @@ public interface MemberCardRecordRepository extends R2dbcRepository<MemberCardRe
     Mono<Integer> updateStatus(Long recordId, String status);
 
     /**
-     * 查询会员的有效卡片（包含会员卡类型信息）
+     * 查询会员的有效卡片
      */
-    @Query("SELECT r.member_card_record_id as id, r.created_at, r.updated_at, r.deleted_at, " +
+    @Query("SELECT * FROM member_card_record WHERE member_id = :memberId AND status = 'ACTIVE' AND deleted_at IS NULL ORDER BY expire_time ASC")
-            "r.member_card_record_id, r.member_id, r.member_card_id, r.status, " +
-            "r.remaining_times, r.remaining_amount, r.expire_time, r.source_order_id, " +
-            "r.purchase_time, r.version, r.card_composition, " +
-            "mc.member_card_name as memberCardName, mc.member_card_type as memberCardType, " +
-            "mc.member_card_price as memberCardPrice, mc.member_card_validity_days as memberCardValidityDays, " +
-            "mc.member_card_total_times as memberCardTotalTimes " +
-            "FROM member_card_record r " +
-            "LEFT JOIN member_card mc ON r.member_card_id = mc.id AND mc.deleted_at IS NULL " +
-            "WHERE r.member_id = :memberId AND r.status = 'ACTIVE' AND r.deleted_at IS NULL " +
-            "ORDER BY r.expire_time ASC")
     Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
 
     /**
@@ -115,39 +106,4 @@ public interface MemberCardRecordRepository extends R2dbcRepository<MemberCardRe
      */
     @Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND deleted_at IS NULL")
     Flux<MemberCardRecord> findActiveRecords();
-
-    /**
-     * 储值卡充值 - 增加余额
-     */
-    @Modifying
-    @Query("UPDATE member_card_record SET remaining_amount = remaining_amount + :addAmount, updated_at = NOW() " +
-            "WHERE member_card_record_id = :recordId AND status = 'ACTIVE' AND deleted_at IS NULL")
-    Mono<Integer> rechargeStoredCard(Long recordId, Double addAmount);
-
-    /**
-     * 查询会员的所有卡片（按状态筛选）- 包含会员卡类型信息
-     * status: all - 所有卡, active - 有效卡, expired - 已过期/失效卡
-     * 排序规则：临期卡（30天内到期）排在最上面，然后是其他有效卡，最后是失效卡
-     */
-    @Query("SELECT r.member_card_record_id as id, r.created_at, r.updated_at, r.deleted_at, " +
-            "r.member_card_record_id, r.member_id, r.member_card_id, r.status, " +
-            "r.remaining_times, r.remaining_amount, r.expire_time, r.source_order_id, " +
-            "r.purchase_time, r.version, r.card_composition, " +
-            "mc.member_card_name as memberCardName, mc.member_card_type as memberCardType, " +
-            "mc.member_card_price as memberCardPrice, mc.member_card_validity_days as memberCardValidityDays, " +
-            "mc.member_card_total_times as memberCardTotalTimes " +
-            "FROM member_card_record r " +
-            "LEFT JOIN member_card mc ON r.member_card_id = mc.id AND mc.deleted_at IS NULL " +
-            "WHERE r.member_id = :memberId AND r.deleted_at IS NULL " +
-            "AND (" +
-            "  :status = 'all' " +
-            "  OR (:status = 'active' AND r.status = 'ACTIVE' AND (r.expire_time IS NULL OR r.expire_time > NOW())) " +
-            "  OR (:status = 'expired' AND (r.status != 'ACTIVE' OR (r.expire_time IS NOT NULL AND r.expire_time <= NOW()))) " +
-            ") " +
-            "ORDER BY " +
-            "CASE WHEN r.status = 'ACTIVE' AND r.expire_time IS NOT NULL AND r.expire_time < NOW() + INTERVAL '30 days' AND r.expire_time > NOW() THEN 0 " +
-            "     WHEN r.status = 'ACTIVE' AND (r.expire_time IS NULL OR r.expire_time > NOW()) THEN 1 " +
-            "     ELSE 2 END, " +
-            "r.expire_time ASC")
-    Flux<MemberCardRecord> findCardsByMemberIdWithStatus(Long memberId, String status);
 }

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

@@ -9,8 +9,6 @@ import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
-import java.util.List;
-
 /**
  * 会员卡类型 Repository
  * 
@@ -20,23 +18,11 @@ import java.util.List;
 @Repository
 public interface MemberCardRepository extends R2dbcRepository<MemberCard, Long> {
 
-    /**
-     * 根据主键ID查询（未删除的）- 用于前端传递的id
-     */
-    @Query("SELECT * FROM member_card WHERE id = :id AND deleted_at IS NULL")
-    Mono<MemberCard> findByIdAndDeletedAtIsNull(Long id);
-
     /**
      * 根据会员卡ID查询（未删除的）
      */
     Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
 
-    /**
-     * 批量查询会员卡（根据 member_card_id 字段）
-     */
-    @Query("SELECT * FROM member_card WHERE deleted_at IS NULL AND member_card_id IN (:memberCardIds)")
-    Flux<MemberCard> findByMemberCardIdIn(List<Long> memberCardIds);
-
     /**
      * 条件查询会员卡列表
      */

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

@@ -1,61 +0,0 @@
-package cn.novalon.gym.manage.member.repository;
-
-import cn.novalon.gym.manage.member.entity.MemberStoredCardRecharge;
-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.math.BigDecimal;
-import java.time.LocalDateTime;
-
-/**
- * 储值卡充值记录 Repository
- */
-@Repository
-public interface MemberStoredCardRechargeRepository extends R2dbcRepository<MemberStoredCardRecharge, Long> {
-
-    /**
-     * 根据订单号查询充值记录
-     */
-    @Query("SELECT * FROM member_stored_card_recharge WHERE order_no = :orderNo AND deleted_at IS NULL")
-    Mono<MemberStoredCardRecharge> findByOrderNo(String orderNo);
-
-    /**
-     * 查询会员的充值记录列表
-     */
-    @Query("SELECT * FROM member_stored_card_recharge WHERE member_id = :memberId AND deleted_at IS NULL ORDER BY created_at DESC LIMIT :limit OFFSET :offset")
-    Flux<MemberStoredCardRecharge> findByMemberId(Long memberId, int limit, int offset);
-
-    /**
-     * 创建充值记录
-     */
-    @Modifying
-    @Query("INSERT INTO member_stored_card_recharge (member_id, order_no, recharge_amount, bonus_amount, total_amount, pay_amount, status, created_at, updated_at) " +
-            "VALUES (:memberId, :orderNo, :rechargeAmount, :bonusAmount, :totalAmount, :payAmount, 'PENDING', NOW(), NOW())")
-    Mono<Integer> createRechargeRecord(Long memberId, String orderNo, BigDecimal rechargeAmount, BigDecimal bonusAmount, BigDecimal totalAmount, BigDecimal payAmount);
-
-    /**
-     * 更新充值记录为成功
-     */
-    @Modifying
-    @Query("UPDATE member_stored_card_recharge SET status = 'SUCCESS', pay_time = :payTime, updated_at = NOW() " +
-            "WHERE order_no = :orderNo AND deleted_at IS NULL")
-    Mono<Integer> markSuccess(String orderNo, LocalDateTime payTime);
-
-    /**
-     * 更新充值记录为失败
-     */
-    @Modifying
-    @Query("UPDATE member_stored_card_recharge SET status = 'FAILED', updated_at = NOW() " +
-            "WHERE order_no = :orderNo AND deleted_at IS NULL")
-    Mono<Integer> markFailed(String orderNo);
-
-    /**
-     * 查询会员充值记录总数
-     */
-    @Query("SELECT COUNT(*) FROM member_stored_card_recharge WHERE member_id = :memberId AND deleted_at IS NULL")
-    Mono<Long> countByMemberIdAndDeletedAtIsNull(Long memberId);
-}

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

@@ -1,72 +0,0 @@
-package cn.novalon.gym.manage.member.repository;
-
-import cn.novalon.gym.manage.member.entity.MemberStoredCard;
-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.Mono;
-
-import java.math.BigDecimal;
-
-/**
- * 储值卡 Repository
- */
-@Repository
-public interface MemberStoredCardRepository extends R2dbcRepository<MemberStoredCard, Long> {
-
-    /**
-     * 根据会员ID查询储值卡
-     */
-    @Query("SELECT * FROM member_stored_card WHERE member_id = :memberId AND deleted_at IS NULL")
-    Mono<MemberStoredCard> findByMemberId(Long memberId);
-
-    /**
-     * 根据会员ID查询储值卡（可删除标记）
-     */
-    Mono<MemberStoredCard> findByMemberIdAndDeletedAtIsNull(Long memberId);
-
-    /**
-     * 储值卡充值 - 增加余额
-     */
-    @Modifying
-    @Query("UPDATE member_stored_card SET balance = balance + :addAmount, total_recharge = total_recharge + :addAmount, updated_at = NOW() " +
-            "WHERE member_id = :memberId AND deleted_at IS NULL")
-    Mono<Integer> rechargeBalance(Long memberId, BigDecimal addAmount);
-
-    /**
-     * 储值卡消费 - 扣减余额
-     */
-    @Modifying
-    @Query("UPDATE member_stored_card SET balance = balance - :deductAmount, total_consume = total_consume + :deductAmount, updated_at = NOW() " +
-            "WHERE member_id = :memberId AND deleted_at IS NULL AND balance >= :deductAmount")
-    Mono<Integer> deductBalance(Long memberId, BigDecimal deductAmount);
-
-    /**
-     * 创建储值卡
-     */
-    @Modifying
-    @Query("INSERT INTO member_stored_card (member_id, balance, total_recharge, total_consume, is_pay_password_set, created_at, updated_at) " +
-            "VALUES (:memberId, 0, 0, 0, FALSE, NOW(), NOW())")
-    Mono<Integer> createStoredCard(Long memberId);
-
-    /**
-     * 设置支付密码
-     */
-    @Modifying
-    @Query("UPDATE member_stored_card SET pay_password = :password, is_pay_password_set = TRUE, updated_at = NOW() " +
-            "WHERE member_id = :memberId AND deleted_at IS NULL")
-    Mono<Integer> setPayPassword(Long memberId, String password);
-
-    /**
-     * 检查支付密码是否已设置
-     */
-    @Query("SELECT is_pay_password_set FROM member_stored_card WHERE member_id = :memberId AND deleted_at IS NULL")
-    Mono<Boolean> isPayPasswordSet(Long memberId);
-
-    /**
-     * 获取支付密码
-     */
-    @Query("SELECT pay_password FROM member_stored_card WHERE member_id = :memberId AND deleted_at IS NULL")
-    Mono<String> getPayPassword(Long memberId);
-}

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

@@ -32,20 +32,4 @@ public interface IMemberCardRecordService {
     Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
     
     Flux<MemberCardRecord> findExpiredCards();
-    
-    /**
-     * 查询会员的所有卡片（按状态筛选）
-     * @param memberId 会员ID
-     * @param status 状态筛选：all - 所有, active - 有效, expired - 已失效
-     * @return 会员卡记录列表
-     */
-    Flux<MemberCardRecord> findCardsByMemberIdWithStatus(Long memberId, String status);
-
-    /**
-     * 查询会员的主要有效会员卡（只返回一条）
-     * 优先返回临期卡（剩余1-3天），其次返回普通有效卡
-     * @param memberId 会员ID
-     * @return 会员卡记录，如果没有则返回空
-     */
-    Mono<MemberCardRecord> findPrimaryActiveCardByMemberId(Long memberId);
 }

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

@@ -34,11 +34,11 @@ public interface IMemberCardService {
     
     Mono<MemberCardRecord> purchaseCard(Long memberId, Long memberCardId, Long sourceOrderId);
     
-    Mono<MemberCardRecord> renewCard(Long recordId, Long memberId, Integer addTimes, Double addAmount, Integer addDays, Long sourceOrderId);
+    Mono<MemberCardRecord> renewCard(Long recordId, Integer addTimes, Double addAmount, Integer addDays, Long sourceOrderId);
     
-    Mono<MemberCardRecord> useCard(Long recordId, Long memberId, Integer deductTimes, Double deductAmount);
+    Mono<MemberCardRecord> useCard(Long recordId, Integer deductTimes, Double deductAmount);
     
-    Mono<Void> refundCard(Long recordId, Long memberId);
+    Mono<Void> refundCard(Long recordId);
     
     Mono<Integer> processExpiredCards();
 }

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

@@ -1,95 +0,0 @@
-package cn.novalon.gym.manage.member.service;
-
-import cn.novalon.gym.manage.member.entity.MemberStoredCard;
-import cn.novalon.gym.manage.member.entity.MemberStoredCardRecharge;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.math.BigDecimal;
-
-/**
- * 储值卡 Service接口
- */
-public interface IMemberStoredCardService {
-
-    /**
-     * 获取会员的储值卡，如果没有则自动创建
-     */
-    Mono<MemberStoredCard> getOrCreateStoredCard(Long memberId);
-
-    /**
-     * 获取会员的储值卡
-     */
-    Mono<MemberStoredCard> getStoredCard(Long memberId);
-
-    /**
-     * 储值卡充值
-     */
-    Mono<Integer> recharge(Long memberId, BigDecimal amount);
-
-    /**
-     * 储值卡消费
-     */
-    Mono<Integer> consume(Long memberId, BigDecimal amount);
-
-    /**
-     * 检查支付密码是否已设置
-     */
-    Mono<Boolean> isPayPasswordSet(Long memberId);
-
-    /**
-     * 设置支付密码
-     */
-    Mono<Integer> setPayPassword(Long memberId, String password);
-
-    /**
-     * 验证支付密码
-     */
-    Mono<Boolean> verifyPayPassword(Long memberId, String password);
-
-    /**
-     * 储值卡支付（验证密码并扣减余额）
-     */
-    Mono<PayResult> payWithStoredCard(Long memberId, String password, BigDecimal amount);
-
-    /**
-     * 查询会员的充值记录列表
-     */
-    Flux<MemberStoredCardRecharge> getRechargeRecords(Long memberId, int page, int size);
-
-    /**
-     * 查询会员充值记录总数
-     */
-    Mono<Long> countRechargeRecords(Long memberId);
-
-    /**
-     * 储值卡支付结果
-     */
-    class PayResult {
-        private boolean success;
-        private String message;
-        private BigDecimal balance;
-
-        public static PayResult success(BigDecimal balance) {
-            PayResult result = new PayResult();
-            result.success = true;
-            result.message = "支付成功";
-            result.balance = balance;
-            return result;
-        }
-
-        public static PayResult fail(String message) {
-            PayResult result = new PayResult();
-            result.success = false;
-            result.message = message;
-            return result;
-        }
-
-        public boolean isSuccess() { return success; }
-        public void setSuccess(boolean success) { this.success = success; }
-        public String getMessage() { return message; }
-        public void setMessage(String message) { this.message = message; }
-        public BigDecimal getBalance() { return balance; }
-        public void setBalance(BigDecimal balance) { this.balance = balance; }
-    }
-}

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

@@ -1,9 +1,7 @@
 package cn.novalon.gym.manage.member.service.impl;
 
-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.service.IMemberCardRecordService;
 import cn.novalon.gym.manage.common.util.RedisUtil;
 import lombok.extern.slf4j.Slf4j;
@@ -13,9 +11,6 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Objects;
-import java.util.stream.Collectors;
 
 /**
  * 会员卡记录服务实现
@@ -27,17 +22,13 @@ import java.util.stream.Collectors;
 @Service
 public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
     private final MemberCardRecordRepository memberCardRecordRepository;
-    private final MemberCardRepository memberCardRepository;
     private final RedisUtil redisUtil;
 
     private static final String MEMBER_CARD_RECORD_CACHE_PREFIX = "member:card:record:";
     private static final long CACHE_EXPIRE_SECONDS = 300;
 
-    public MemberCardRecordServiceImpl(MemberCardRecordRepository memberCardRecordRepository,
+    public MemberCardRecordServiceImpl(MemberCardRecordRepository memberCardRecordRepository, RedisUtil redisUtil) {
-                                       MemberCardRepository memberCardRepository,
-                                       RedisUtil redisUtil) {
         this.memberCardRecordRepository = memberCardRecordRepository;
-        this.memberCardRepository = memberCardRepository;
         this.redisUtil = redisUtil;
     }
 
@@ -65,44 +56,7 @@ public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
 
     @Override
     public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
-        return memberCardRecordRepository.findActiveCardsByMemberId(memberId)
+        return memberCardRecordRepository.findActiveCardsByMemberId(memberId);
-                // 收集所有记录，然后批量查询会员卡信息
-                .collectList()
-                .flatMapMany(records -> {
-                    if (records.isEmpty()) {
-                        return Flux.empty();
-                    }
-                    // 提取所有 memberCardId（关联的是 member_card.id 字段，即MemberCard的主键）
-                    List<Long> memberCardIds = records.stream()
-                            .map(MemberCardRecord::getMemberCardId)
-                            .filter(Objects::nonNull)
-                            .distinct()
-                            .collect(Collectors.toList());
-
-                    if (memberCardIds.isEmpty()) {
-                        return Flux.fromIterable(records);
-                    }
-
-                    // 批量查询会员卡信息（使用主键id查询，确保查询未删除的记录）
-                    return Flux.fromIterable(memberCardIds)
-                            .flatMap(id -> memberCardRepository.findByIdAndDeletedAtIsNull(id))
-                            .collectMap(MemberCard::getId, mc -> mc)
-                            .map(cardMap -> {
-                                // 填充会员卡信息到每条记录
-                                records.forEach(record -> {
-                                    MemberCard memberCard = cardMap.get(record.getMemberCardId());
-                                    if (memberCard != null) {
-                                        record.setMemberCardName(memberCard.getMemberCardName());
-                                        record.setMemberCardType(memberCard.getMemberCardType());
-                                        record.setMemberCardPrice(memberCard.getMemberCardPrice());
-                                        record.setMemberCardValidityDays(memberCard.getMemberCardValidityDays());
-                                        record.setMemberCardTotalTimes(memberCard.getMemberCardTotalTimes());
-                                    }
-                                });
-                                return records;
-                            })
-                            .flatMapMany(Flux::fromIterable);
-                });
     }
 
     @Override
@@ -162,97 +116,6 @@ public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
         return memberCardRecordRepository.findExpiredCards();
     }
 
-    @Override
-    public Flux<MemberCardRecord> findCardsByMemberIdWithStatus(Long memberId, String status) {
-        return memberCardRecordRepository.findCardsByMemberIdWithStatus(memberId, status)
-                // 收集所有记录，然后批量查询会员卡信息
-                .collectList()
-                .flatMapMany(records -> {
-                    if (records.isEmpty()) {
-                        return Flux.empty();
-                    }
-                    // 提取所有 memberCardId（关联的是 member_card.id 字段，即MemberCard的主键）
-                    List<Long> memberCardIds = records.stream()
-                            .map(MemberCardRecord::getMemberCardId)
-                            .filter(Objects::nonNull)
-                            .distinct()
-                            .collect(Collectors.toList());
-
-                    if (memberCardIds.isEmpty()) {
-                        return Flux.fromIterable(records);
-                    }
-
-                    // 批量查询会员卡信息（使用主键id查询，确保查询未删除的记录）
-                    return Flux.fromIterable(memberCardIds)
-                            .flatMap(id -> memberCardRepository.findByIdAndDeletedAtIsNull(id))
-                            .collectMap(MemberCard::getId, mc -> mc)
-                            .map(cardMap -> {
-                                // 填充会员卡信息到每条记录
-                                records.forEach(record -> {
-                                    MemberCard memberCard = cardMap.get(record.getMemberCardId());
-                                    if (memberCard != null) {
-                                        record.setMemberCardName(memberCard.getMemberCardName());
-                                        record.setMemberCardType(memberCard.getMemberCardType());
-                                        record.setMemberCardPrice(memberCard.getMemberCardPrice());
-                                        record.setMemberCardValidityDays(memberCard.getMemberCardValidityDays());
-                                        record.setMemberCardTotalTimes(memberCard.getMemberCardTotalTimes());
-                                    }
-                                });
-                                return records;
-                            })
-                            .flatMapMany(Flux::fromIterable);
-                });
-    }
-
-    @Override
-    public Mono<MemberCardRecord> findPrimaryActiveCardByMemberId(Long memberId) {
-        LocalDateTime now = LocalDateTime.now();
-        
-        return findCardsByMemberIdWithStatus(memberId, "active")
-                // 过滤掉储值卡
-                .filter(record -> record.getMemberCardType() == null || 
-                        !record.getMemberCardType().equals("STORED_VALUE_CARD"))
-                .collectList()
-                .map(records -> {
-                    if (records.isEmpty()) {
-                        return null;
-                    }
-                    
-                    // 优先找临期卡（剩余1-3天）
-                    MemberCardRecord expiringCard = records.stream()
-                            .filter(record -> {
-                                if (record.getExpireTime() == null) return false;
-                                if (record.getStatus() != null && record.getStatus().equals("USED_UP")) return false;
-                                long days = java.time.Duration.between(now, record.getExpireTime()).toDays();
-                                return days >= 1 && days <= 3;
-                            })
-                            .findFirst()
-                            .orElse(null);
-                    
-                    if (expiringCard != null) {
-                        return expiringCard;
-                    }
-                    
-                    // 再找普通有效卡（剩余>3天）
-                    MemberCardRecord activeCard = records.stream()
-                            .filter(record -> {
-                                if (record.getExpireTime() == null) return true;
-                                if (record.getStatus() != null && record.getStatus().equals("USED_UP")) return false;
-                                long days = java.time.Duration.between(now, record.getExpireTime()).toDays();
-                                return days > 3;
-                            })
-                            .findFirst()
-                            .orElse(null);
-                    
-                    if (activeCard != null) {
-                        return activeCard;
-                    }
-                    
-                    // 最后返回第一张卡
-                    return records.get(0);
-                });
-    }
-
     private void clearRecordCache(Long recordId) {
         String cacheKey = MEMBER_CARD_RECORD_CACHE_PREFIX + recordId;
         redisUtil.delete(cacheKey);

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

@@ -1,6 +1,5 @@
 package cn.novalon.gym.manage.member.service.impl;
 
-import cn.novalon.gym.manage.common.util.RedisUtil;
 import cn.novalon.gym.manage.member.entity.MemberCard;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
@@ -16,6 +15,7 @@ import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
 import cn.novalon.gym.manage.member.repository.MemberCardRepository;
 import cn.novalon.gym.manage.member.service.IMemberCardService;
 import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
+import cn.novalon.gym.manage.common.util.RedisUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
@@ -124,18 +124,11 @@ public class MemberCardServiceImpl implements IMemberCardService {
 
     @Override
     public Mono<MemberCardRecord> purchaseCard(Long memberId, Long memberCardId, Long sourceOrderId) {
-        if (memberId == null) {
+        return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
-            return Mono.error(new RuntimeException("会员ID不能为空"));
-        }
-        if (memberCardId == null) {
-            return Mono.error(new RuntimeException("会员卡类型ID不能为空"));
-        }
-        // 前端传的是数据库主键id，不是业务字段member_card_id
-        return memberCardRepository.findByIdAndDeletedAtIsNull(memberCardId)
                 .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
                 .flatMap(card -> {
-                    if (card.getMemberCardStatus() != null && card.getMemberCardStatus() == 0) {
+                    if (card.getMemberCardStatus() != null && card.getMemberCardStatus() == 1) {
-                        return Mono.error(new RuntimeException("该会员卡已下架"));
+                        return Mono.error(new RuntimeException("该会员卡已禁用"));
                     }
 
                     MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
@@ -144,13 +137,12 @@ public class MemberCardServiceImpl implements IMemberCardService {
                             memberId.toString(),
                             cardType.name(),
                             Mono.defer(() -> createCardRecord(memberId, memberCardId, sourceOrderId, card))
-                                    // 修改：将 card 对象传递给 createTransaction 以获取购买金额
-                                    .flatMap(record -> createTransactionForPurchase(record, card, TransactionType.PURCHASE, "购买会员卡")
-                                            .thenReturn(record))
-                                    .flatMap(record -> expirationReminderService.scheduleExpirationReminder(record)
-                                            .then(Mono.just(record)))
                     );
-                });
+                })
+                .flatMap(record -> createTransaction(record, TransactionType.PURCHASE, "购买会员卡")
+                        .thenReturn(record))
+                .flatMap(record -> expirationReminderService.scheduleExpirationReminder(record)
+                        .then(Mono.just(record)));
     }
 
     private Mono<MemberCardRecord> createCardRecord(Long memberId, Long memberCardId, 
@@ -169,16 +161,12 @@ public class MemberCardServiceImpl implements IMemberCardService {
 
             switch (cardType) {
                 case TIME_CARD:
-                    if (card.getMemberCardValidityDays() != null) {
+                    record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
-                        record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
-                    }
                     record.setRemainingTimes(0);
                     record.setRemainingAmount(0.0);
                     break;
                 case COUNT_CARD:
-                    if (card.getMemberCardValidityDays() != null) {
+                    record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
-                        record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
-                    }
                     record.setRemainingTimes(card.getMemberCardTotalTimes());
                     record.setRemainingAmount(0.0);
                     break;
@@ -203,17 +191,12 @@ public class MemberCardServiceImpl implements IMemberCardService {
     }
 
     @Override
-    public Mono<MemberCardRecord> renewCard(Long recordId, Long memberId, Integer addTimes, Double addAmount,
+    public Mono<MemberCardRecord> renewCard(Long recordId, Integer addTimes, Double addAmount, 
                                              Integer addDays, Long sourceOrderId) {
         return recordRepository.findById(recordId)
                 .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
-                .flatMap(originalRecord -> {
+                .flatMap(originalRecord -> stateMachine.validateTransition(originalRecord, CardEvent.RENEW)
-                    if (!originalRecord.getMemberId().equals(memberId)) {
+                        .then(Mono.just(originalRecord)))
-                        return Mono.error(new RuntimeException("无权操作此会员卡"));
-                    }
-                    return stateMachine.validateTransition(originalRecord, CardEvent.RENEW)
-                            .then(Mono.just(originalRecord));
-                })
                 .flatMap(originalRecord -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(originalRecord.getMemberCardId())
                         .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
                         .flatMap(card -> {
@@ -266,16 +249,11 @@ public class MemberCardServiceImpl implements IMemberCardService {
     }
 
     @Override
-    public Mono<MemberCardRecord> useCard(Long recordId, Long memberId, Integer deductTimes, Double deductAmount) {
+    public Mono<MemberCardRecord> useCard(Long recordId, Integer deductTimes, Double deductAmount) {
         return recordRepository.findById(recordId)
                 .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
-                .flatMap(record -> {
+                .flatMap(record -> stateMachine.validateTransition(record, CardEvent.USE)
-                    if (!record.getMemberId().equals(memberId)) {
+                        .then(Mono.just(record)))
-                        return Mono.error(new RuntimeException("无权操作此会员卡"));
-                    }
-                    return stateMachine.validateTransition(record, CardEvent.USE)
-                            .then(Mono.just(record));
-                })
                 .flatMap(record -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
                         .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
                         .flatMap(card -> {
@@ -336,24 +314,19 @@ public class MemberCardServiceImpl implements IMemberCardService {
     }
 
     @Override
-    public Mono<Void> refundCard(Long recordId, Long memberId) {
+    public Mono<Void> refundCard(Long recordId) {
         return recordRepository.findById(recordId)
                 .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
-                .flatMap(record -> {
+                .flatMap(record -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
-                    if (!record.getMemberId().equals(memberId)) {
+                        .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
-                        return Mono.error(new RuntimeException("无权操作此会员卡"));
+                        .flatMap(card -> {
-                    }
+                            MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
-                    return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
+                            return distributedLockService.executeWithLock(
-                            .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
+                                record.getMemberId().toString(),
-                            .flatMap(card -> {
+                                cardType.name(),
-                                MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+                                refundSagaHandler.executeRefund(recordId)
-                                return distributedLockService.executeWithLock(
+                            );
-                                    record.getMemberId().toString(),
+                        }));
-                                    cardType.name(),
-                                    refundSagaHandler.executeRefund(recordId)
-                                );
-                            });
-                });
     }
 
     @Override
@@ -368,7 +341,6 @@ public class MemberCardServiceImpl implements IMemberCardService {
 
     private Mono<Void> createTransaction(MemberCardRecord record, TransactionType action, String remark) {
         MemberCardTransaction transaction = MemberCardTransaction.builder()
-                .memberCardRecordId(record.getMemberCardRecordId())
                 .memberId(record.getMemberId())
                 .memberCardId(record.getMemberCardId())
                 .operationType(action.name())
@@ -382,25 +354,6 @@ public class MemberCardServiceImpl implements IMemberCardService {
         return transactionService.createTransaction(transaction);
     }
 
-    /**
-     * 创建购买会员卡的交易记录（记录购买金额为负数，表示支出）
-     */
-    private Mono<Void> createTransactionForPurchase(MemberCardRecord record, MemberCard card, TransactionType action, String remark) {
-        MemberCardTransaction transaction = MemberCardTransaction.builder()
-                .memberCardRecordId(record.getMemberCardRecordId())
-                .memberId(record.getMemberId())
-                .memberCardId(record.getMemberCardId())
-                .operationType(action.name())
-                .changeAmount(card.getMemberCardTotalTimes() != null ? card.getMemberCardTotalTimes() : 0)
-                .changeBalance(card.getMemberCardPrice() != null ? -card.getMemberCardPrice() : 0.0) // 负数表示支出
-                .afterRemainingCount(record.getRemainingTimes())
-                .afterRemainingBalance(record.getRemainingAmount())
-                .remark(remark)
-                .build();
-
-        return transactionService.createTransaction(transaction);
-    }
-
     private void clearCardCache(Long memberCardId) {
         String cacheKey = MEMBER_CARD_CACHE_PREFIX + memberCardId;
         redisUtil.delete(cacheKey);

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

@@ -91,19 +91,8 @@ public class MemberCardTransactionServiceImpl implements IMemberCardTransactionS
 
     @Override
     public Mono<Void> createTransaction(MemberCardTransaction transaction) {
-        return transactionRepository.insertTransaction(
+        return transactionRepository.save(transaction)
-                transaction.getMemberCardRecordId(),
+                .then()
-                transaction.getMemberCardId(),
-                transaction.getMemberId(),
-                transaction.getOperationType(),
-                transaction.getChangeAmount(),
-                transaction.getChangeBalance(),
-                transaction.getAfterRemainingCount(),
-                transaction.getAfterRemainingBalance(),
-                transaction.getRelatedBizType(),
-                transaction.getSourceOrderId(),
-                transaction.getRemark()
-        ).then()
                 .doOnSuccess(v -> log.info("创建会员卡交易记录: memberId={}, cardId={}, type={}",
                         transaction.getMemberId(), transaction.getMemberCardId(), transaction.getOperationType()));
     }

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

@@ -17,7 +17,6 @@ import cn.novalon.gym.manage.member.service.MemberService;
 import cn.novalon.gym.manage.member.util.AesUtil;
 import cn.novalon.gym.manage.member.util.BeanConvertUtil;
 import cn.novalon.gym.manage.member.util.EsSyncUtils;
-import cn.novalon.gym.manage.member.util.WechatPhoneUtil;
 import cn.novalon.gym.manage.common.util.RedisUtil;
 import cn.novalon.gym.manage.member.vo.MemberCardInfoVO;
 import cn.novalon.gym.manage.member.vo.MemberDetailVO;
@@ -66,37 +65,21 @@ public class MemberServiceImpl implements MemberService {
     public Mono<MemberInfoVO> getMemberInfo(Long memberId) {
         String cacheKey = MEMBER_INFO_CACHE_PREFIX + memberId;
 
-        // 先查缓存
         return redisUtil.get(cacheKey, MemberInfoVO.class)
                 .flatMap(cached -> {
                     if (cached != null) {
                         log.debug("从缓存获取会员信息, memberId: {}", memberId);
                         return Mono.just(cached);
                     }
-                    // 缓存没有，查数据库
+                    return memberRepository.findById(memberId)
-                    return queryFromDatabaseAndCache(memberId, cacheKey);
+                            .map(this::buildMemberInfoResponse)
-                })
+                            .flatMap(vo -> redisUtil.setWithExpire(cacheKey, vo, CACHE_EXPIRE_SECONDS)
-                .switchIfEmpty(Mono.defer(() -> {
+                                    .then(Mono.just(vo)))
-                    // 缓存返回null，查数据库
+                            .switchIfEmpty(Mono.error(() -> {
-                    return queryFromDatabaseAndCache(memberId, cacheKey);
+                                log.error("会员不存在: memberId={}", memberId);
-                }));
+                                throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
-    }
+                            }));
-
+                });
-    /**
-     * 从数据库查询并更新缓存
-     */
-    private Mono<MemberInfoVO> queryFromDatabaseAndCache(Long memberId, String cacheKey) {
-        return memberRepository.findById(memberId)
-                .map(this::buildMemberInfoResponse)
-                .flatMap(vo -> {
-                    // 查询到数据后更新缓存
-                    return redisUtil.setWithExpire(cacheKey, vo, CACHE_EXPIRE_SECONDS)
-                            .then(Mono.just(vo));
-                })
-                .switchIfEmpty(Mono.error(() -> {
-                    log.error("会员不存在: memberId={}", memberId);
-                    throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
-                }));
     }
 
     @Override
@@ -140,18 +123,7 @@ public class MemberServiceImpl implements MemberService {
 
     private MemberInfoVO buildMemberInfoResponse(Member member) {
         String phone = member.getPhone();
-        String maskedPhone = null;
+        String maskedPhone = phone != null ? phone.replace(phone.substring(3, 7), "****") : null;
-        
-        // 先解密手机号，再进行脱敏处理
-        if (phone != null && !phone.isEmpty()) {
-            try {
-                String decryptedPhone = AesUtil.decrypt(phone);
-                maskedPhone = WechatPhoneUtil.maskPhone(decryptedPhone);
-            } catch (Exception e) {
-                log.error("手机号解密失败, memberId: {}", member.getId(), e);
-                maskedPhone = null;
-            }
-        }
 
         GenderEnum genderEnum = GenderEnum.fromCode(member.getGender());
 

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

@@ -1,150 +0,0 @@
-package cn.novalon.gym.manage.member.service.impl;
-
-import cn.novalon.gym.manage.member.entity.MemberStoredCard;
-import cn.novalon.gym.manage.member.entity.MemberStoredCardRecharge;
-import cn.novalon.gym.manage.member.repository.MemberStoredCardRechargeRepository;
-import cn.novalon.gym.manage.member.repository.MemberStoredCardRepository;
-import cn.novalon.gym.manage.member.service.IMemberStoredCardService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
-import org.springframework.stereotype.Service;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.math.BigDecimal;
-
-/**
- * 储值卡 Service实现
- */
-@Slf4j
-@Service
-public class MemberStoredCardServiceImpl implements IMemberStoredCardService {
-
-    private final MemberStoredCardRepository memberStoredCardRepository;
-    private final MemberStoredCardRechargeRepository memberStoredCardRechargeRepository;
-    private final BCryptPasswordEncoder passwordEncoder;
-
-    public MemberStoredCardServiceImpl(MemberStoredCardRepository memberStoredCardRepository,
-                                        MemberStoredCardRechargeRepository memberStoredCardRechargeRepository) {
-        this.memberStoredCardRepository = memberStoredCardRepository;
-        this.memberStoredCardRechargeRepository = memberStoredCardRechargeRepository;
-        this.passwordEncoder = new BCryptPasswordEncoder();
-    }
-
-    @Override
-    public Mono<MemberStoredCard> getOrCreateStoredCard(Long memberId) {
-        return memberStoredCardRepository.findByMemberId(memberId)
-                .switchIfEmpty(Mono.defer(() -> {
-                    log.info("[储值卡] 为会员 {} 创建储值卡", memberId);
-                    return memberStoredCardRepository.createStoredCard(memberId)
-                            .then(memberStoredCardRepository.findByMemberId(memberId));
-                }));
-    }
-
-    @Override
-    public Mono<MemberStoredCard> getStoredCard(Long memberId) {
-        return memberStoredCardRepository.findByMemberId(memberId);
-    }
-
-    @Override
-    public Mono<Integer> recharge(Long memberId, BigDecimal amount) {
-        return memberStoredCardRepository.findByMemberId(memberId)
-                .flatMap(card -> memberStoredCardRepository.rechargeBalance(memberId, amount))
-                .switchIfEmpty(Mono.defer(() -> {
-                    log.info("[储值卡] 会员 {} 首次充值，创建储值卡并充值", memberId);
-                    return memberStoredCardRepository.createStoredCard(memberId)
-                            .then(memberStoredCardRepository.rechargeBalance(memberId, amount));
-                }));
-    }
-
-    @Override
-    public Mono<Integer> consume(Long memberId, BigDecimal amount) {
-        return memberStoredCardRepository.deductBalance(memberId, amount);
-    }
-
-    @Override
-    public Mono<Boolean> isPayPasswordSet(Long memberId) {
-        return memberStoredCardRepository.isPayPasswordSet(memberId)
-                .defaultIfEmpty(false);
-    }
-
-    @Override
-    public Mono<Integer> setPayPassword(Long memberId, String password) {
-        // 确保储值卡存在
-        return getOrCreateStoredCard(memberId)
-                .flatMap(card -> {
-                    // BCrypt加密密码
-                    String encodedPassword = passwordEncoder.encode(password);
-                    return memberStoredCardRepository.setPayPassword(memberId, encodedPassword);
-                });
-    }
-
-    @Override
-    public Mono<Boolean> verifyPayPassword(Long memberId, String password) {
-        return memberStoredCardRepository.getPayPassword(memberId)
-                .map(storedPassword -> {
-                    if (storedPassword == null || storedPassword.isEmpty()) {
-                        return false;
-                    }
-                    return passwordEncoder.matches(password, storedPassword);
-                })
-                .defaultIfEmpty(false);
-    }
-
-    @Override
-    public Mono<PayResult> payWithStoredCard(Long memberId, String password, BigDecimal amount) {
-        return memberStoredCardRepository.findByMemberId(memberId)
-                .flatMap(card -> {
-                    // 检查余额是否充足
-                    BigDecimal currentBalance = card.getBalance();
-                    if (currentBalance == null) {
-                        currentBalance = BigDecimal.ZERO;
-                    }
-                    if (currentBalance.compareTo(amount) < 0) {
-                        log.warn("[储值卡支付] 余额不足: memberId={}, balance={}, needAmount={}",
-                                memberId, currentBalance, amount);
-                        return Mono.just(PayResult.fail("余额不足，当前余额：" + currentBalance + "元"));
-                    }
-
-                    // 验证密码
-                    if (card.getPayPassword() == null || card.getPayPassword().isEmpty()) {
-                        log.warn("[储值卡支付] 未设置支付密码: memberId={}", memberId);
-                        return Mono.just(PayResult.fail("请先设置支付密码"));
-                    }
-
-                    if (!passwordEncoder.matches(password, card.getPayPassword())) {
-                        log.warn("[储值卡支付] 密码错误: memberId={}", memberId);
-                        return Mono.just(PayResult.fail("支付密码错误"));
-                    }
-
-                    // 扣减余额
-                    return memberStoredCardRepository.deductBalance(memberId, amount)
-                            .flatMap(rows -> {
-                                if (rows > 0) {
-                                    // 查询最新余额
-                                    return memberStoredCardRepository.findByMemberId(memberId)
-                                            .map(updatedCard -> PayResult.success(
-                                                    updatedCard.getBalance() != null ? updatedCard.getBalance() : BigDecimal.ZERO));
-                                } else {
-                                    log.warn("[储值卡支付] 扣减余额失败: memberId={}, amount={}", memberId, amount);
-                                    return Mono.just(PayResult.fail("支付失败，请稍后重试"));
-                                }
-                            });
-                })
-                .switchIfEmpty(Mono.defer(() -> {
-                    log.warn("[储值卡支付] 储值卡不存在: memberId={}", memberId);
-                    return Mono.just(PayResult.fail("储值卡不存在"));
-                }));
-    }
-
-    @Override
-    public Flux<MemberStoredCardRecharge> getRechargeRecords(Long memberId, int page, int size) {
-        int offset = (page - 1) * size;
-        return memberStoredCardRechargeRepository.findByMemberId(memberId, size, offset);
-    }
-
-    @Override
-    public Mono<Long> countRechargeRecords(Long memberId) {
-        return memberStoredCardRechargeRepository.countByMemberIdAndDeletedAtIsNull(memberId);
-    }
-}

gym-manage-api/gym-member/src/main/resources/db/schema.sql

@@ -279,24 +279,3 @@ CREATE INDEX IF NOT EXISTS idx_refund_application_status ON refund_application(s
 
 COMMENT ON TABLE refund_application IS '退款申请表';
 COMMENT ON COLUMN refund_application.status IS '状态：PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败';
-
-
--- ============================================
--- 7. member_pay_password 表（支付密码表）
--- ============================================
-CREATE TABLE IF NOT EXISTS member_pay_password (
-    id BIGSERIAL PRIMARY KEY,
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    
-    member_id BIGINT NOT NULL UNIQUE,
-    pay_password VARCHAR(100) NOT NULL,
-    is_set BOOLEAN DEFAULT TRUE
-);
-
-CREATE INDEX IF NOT EXISTS idx_member_pay_password_member_id ON member_pay_password(member_id);
-
-COMMENT ON TABLE member_pay_password IS '支付密码表';
-COMMENT ON COLUMN member_pay_password.member_id IS '会员ID';
-COMMENT ON COLUMN member_pay_password.pay_password IS '支付密码（明文存储）';
-COMMENT ON COLUMN member_pay_password.is_set IS '是否已设置支付密码';

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

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

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

@@ -1,75 +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>
-
-    <groupId>cn.novalon.gym.manage</groupId>
-    <artifactId>gym-payment</artifactId>
-    <packaging>jar</packaging>
-
-    <name>Gym Payment</name>
-    <description>支付模块 - 支付宝App支付</description>
-
-    <dependencies>
-        <!-- Spring Boot WebFlux -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-webflux</artifactId>
-        </dependency>
-
-        <!-- 通用模块 (含Redis工具类) -->
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>manage-common</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-
-        <!-- 汇付聚合支付SDK -->
-        <dependency>
-            <groupId>com.huifu.dg.lightning.sdk</groupId>
-            <artifactId>dg-lightning-sdk</artifactId>
-            <version>1.0.5</version>
-        </dependency>
-
-        <!-- 汇付Java SDK (托管/对账用) -->
-        <dependency>
-            <groupId>com.huifu.bspay.sdk</groupId>
-            <artifactId>dg-java-sdk</artifactId>
-            <version>3.0.38</version>
-        </dependency>
-
-        <!-- JSON处理 -->
-        <dependency>
-            <groupId>com.alibaba</groupId>
-            <artifactId>fastjson</artifactId>
-            <version>1.2.83</version>
-        </dependency>
-
-        <!-- Lombok -->
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <optional>true</optional>
-        </dependency>
-
-        <!-- Swagger -->
-        <dependency>
-            <groupId>io.swagger.core.v3</groupId>
-            <artifactId>swagger-annotations</artifactId>
-            <version>2.2.19</version>
-        </dependency>
-	    <dependency>
-		    <groupId>cn.novalon.gym.manage</groupId>
-		    <artifactId>manage-sys</artifactId>
-		    <version>1.0.0</version>
-		    <scope>compile</scope>
-	    </dependency>
-	</dependencies>
-</project>

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

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

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

@@ -1,123 +0,0 @@
-package cn.novalon.gym.manage.payment.config;
-
-import com.huifu.dg.lightning.utils.BasePay;
-import lombok.Data;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-
-import jakarta.annotation.PostConstruct;
-
-@Data
-@Configuration
-@ConfigurationProperties(prefix = "huifu")
-@Slf4j
-public class HuifuProperties {
-
-    private String mode = "prod";
-    private String skillSource = "hfps/1.3.0";
-    private ChannelConfig channel;
-    private MerchantConfig merchant;
-    private NotifyConfig notify;
-
-    @Data
-    public static class ChannelConfig {
-        private String sysId;
-        private String productId;
-        private String huifuId;
-        private String rsaPrivateKey;
-        private String rsaPublicKey;
-        private String huifuPublicKey;
-    }
-
-    @Data
-    public static class MerchantConfig {
-        private String sysId;
-        private String productId;
-        private String huifuId;
-        private String rsaPrivateKey;
-        private String rsaPublicKey;
-        private String huifuPublicKey;
-    }
-
-    @Data
-    public static class NotifyConfig {
-        private String url;
-    }
-
-    private volatile boolean sdkInitialized = false;
-
-    @PostConstruct
-    public void initSdk() {
-        try {
-            if ("test".equalsIgnoreCase(mode)) {
-                BasePay.prodMode = BasePay.MODE_TEST;
-                log.info("[Huifu] 聚合支付SDK: 联调环境");
-            } else {
-                BasePay.prodMode = BasePay.MODE_PROD;
-                log.info("[Huifu] 聚合支付SDK: 生产环境");
-            }
-
-            // 优先使用商户配置初始化SDK，确保请求身份与huifu_id匹配
-            if (merchant != null && merchant.getRsaPrivateKey() != null && merchant.getHuifuPublicKey() != null) {
-                com.huifu.dg.lightning.biz.config.MerConfig merConfig = new com.huifu.dg.lightning.biz.config.MerConfig();
-                merConfig.setProductId(merchant.getProductId());
-                merConfig.setSysId(merchant.getSysId());
-                merConfig.setRsaPrivateKey(merchant.getRsaPrivateKey());
-                merConfig.setRsaPublicKey(merchant.getHuifuPublicKey());
-                merConfig.setSkillSource(skillSource);
-
-                BasePay.initWithMerConfig(merConfig);
-                sdkInitialized = true;
-                log.info("[Huifu] 聚合支付SDK初始化完成, 使用商户配置, sysId={}, huifuId={}", 
-                        merchant.getSysId(), merchant.getHuifuId());
-
-                initDgJavaSdk(merchant);
-                return;
-            }
-
-            // 备用：渠道商配置
-            if (channel == null || channel.getRsaPrivateKey() == null || channel.getHuifuPublicKey() == null) {
-                log.warn("[Huifu] 渠道商配置不完整，跳过SDK初始化");
-                return;
-            }
-
-            com.huifu.dg.lightning.biz.config.MerConfig merConfig = new com.huifu.dg.lightning.biz.config.MerConfig();
-            merConfig.setProductId(channel.getProductId());
-            merConfig.setSysId(channel.getSysId());
-            merConfig.setRsaPrivateKey(channel.getRsaPrivateKey());
-            merConfig.setRsaPublicKey(channel.getHuifuPublicKey());
-            merConfig.setSkillSource(skillSource);
-
-            BasePay.initWithMerConfig(merConfig);
-            sdkInitialized = true;
-            log.info("[Huifu] 聚合支付SDK初始化完成, 使用渠道商配置, sysId={}", channel.getSysId());
-        } catch (Exception e) {
-            log.error("[Huifu] 聚合支付SDK初始化失败，支付功能将不可用", e);
-        }
-    }
-
-    public boolean isSdkInitialized() {
-        return sdkInitialized;
-    }
-
-    private void initDgJavaSdk(MerchantConfig config) {
-        try {
-            com.huifu.bspay.sdk.opps.core.BasePay.prodMode = "test".equalsIgnoreCase(mode) 
-                ? com.huifu.bspay.sdk.opps.core.BasePay.MODE_TEST 
-                : com.huifu.bspay.sdk.opps.core.BasePay.MODE_PROD;
-
-            com.huifu.bspay.sdk.opps.core.config.MerConfig merConfig = new com.huifu.bspay.sdk.opps.core.config.MerConfig();
-            merConfig.setSysId(config.getSysId());
-            merConfig.setProductId(config.getProductId());
-            merConfig.setRsaPrivateKey(config.getRsaPrivateKey());
-            merConfig.setRsaPublicKey(config.getHuifuPublicKey());
-            merConfig.setSkillSource(skillSource);
-
-            com.huifu.bspay.sdk.opps.core.BasePay.initWithMerConfig(merConfig);
-            log.info("[Huifu] dg-java-sdk初始化完成, sysId={}", config.getSysId());
-        } catch (Exception e) {
-            log.error("[Huifu] dg-java-sdk初始化失败", e);
-        }
-    }
-}

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

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

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

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

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

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

gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/entity/PaymentOrder.java

@@ -1,105 +0,0 @@
-package cn.novalon.gym.manage.payment.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.domain.Persistable;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@Table("payment_order")
-public class PaymentOrder implements Persistable<Long> {
-
-    @Id
-    private Long id;
-
-    @Column("order_no")
-    private String orderNo;
-
-    @Column("member_id")
-    private Long memberId;
-
-    @Column("order_type")
-    private String orderType;
-
-    @Column("goods_desc")
-    private String goodsDesc;
-
-    @Column("trans_amt")
-    private BigDecimal transAmt;
-
-    @Column("trade_type")
-    private String tradeType;
-
-    @Column("pay_status")
-    private String payStatus;
-
-    @Column("huifu_id")
-    private String huifuId;
-
-    @Column("req_seq_id")
-    private String reqSeqId;
-
-    @Column("req_date")
-    private String reqDate;
-
-    @Column("hf_seq_id")
-    private String hfSeqId;
-
-    @Column("party_order_id")
-    private String partyOrderId;
-
-    @Column("pay_info")
-    private String payInfo;
-
-    @Column("qr_code")
-    private String qrCode;
-
-    @Column("pay_url")
-    private String payUrl;
-
-    @Column("remark")
-    private String remark;
-
-    @Column("notify_url")
-    private String notifyUrl;
-
-    @Column("pay_time")
-    private LocalDateTime payTime;
-
-    @Column("expire_time")
-    private LocalDateTime expireTime;
-
-    @Column("error_code")
-    private String errorCode;
-
-    @Column("error_msg")
-    private String errorMsg;
-
-    @CreatedDate
-    @Column("created_at")
-    private LocalDateTime createdAt;
-
-    @LastModifiedDate
-    @Column("updated_at")
-    private LocalDateTime updatedAt;
-
-    @Column("deleted_at")
-    private LocalDateTime deletedAt;
-
-    @Override
-    public boolean isNew() {
-        return createdAt == null;
-    }
-}

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

@@ -1,247 +0,0 @@
-package cn.novalon.gym.manage.payment.handler;
-
-import cn.novalon.gym.manage.payment.dto.ApiResponse;
-import cn.novalon.gym.manage.payment.dto.CreatePaymentRequest;
-import cn.novalon.gym.manage.payment.service.PaymentService;
-import cn.novalon.gym.manage.sys.util.AuthUtil;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Component;
-import org.springframework.web.reactive.function.server.ServerRequest;
-import org.springframework.web.reactive.function.server.ServerResponse;
-import reactor.core.publisher.Mono;
-
-import java.util.HashMap;
-import java.util.Map;
-
-@Slf4j
-@Component
-@Tag(name = "支付管理", description = "支付宝App支付接口")
-public class PaymentHandler {
-
-    private final PaymentService paymentService;
-    private final AuthUtil authUtil;
-
-    public PaymentHandler(PaymentService paymentService, AuthUtil authUtil) {
-        this.paymentService = paymentService;
-        this.authUtil = authUtil;
-    }
-
-    @Operation(summary = "创建支付订单", description = "创建支付宝App支付订单")
-    public Mono<ServerResponse> createPayment(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        return request.bodyToMono(CreatePaymentRequest.class)
-                .flatMap(createReq -> {
-                    log.info("[Payment] 创建支付订单: memberId={}, orderType={}, goodsDesc={}, transAmt={}",
-                            createReq.getEffectiveMemberId(), createReq.getOrderType(), createReq.getGoodsDesc(), createReq.getTransAmt());
-
-                    return paymentService.alipayAppPay(memberId, createReq)
-                            .flatMap(result -> {
-                                if ("FAIL".equals(result.getStatus())) {
-                                    return ServerResponse.ok()
-                                            .bodyValue(ApiResponse.error(result.getErrorMsg()));
-                                }
-                                return ServerResponse.ok()
-                                        .bodyValue(ApiResponse.success(result));
-                            });
-                })
-                .onErrorResume(e -> {
-                    log.error("[Payment] 创建支付订单异常", e);
-                    return ServerResponse.ok()
-                            .bodyValue(ApiResponse.error("创建支付订单失败: " + e.getMessage()));
-                });
-    }
-
-    @Operation(summary = "创建扫码支付订单", description = "创建支付宝扫码支付订单，返回二维码链接")
-    public Mono<ServerResponse> createQrCodePayment(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        return request.bodyToMono(CreatePaymentRequest.class)
-                .flatMap(createReq -> {
-                    log.info("[Payment] 创建扫码支付订单: memberId={}, orderType={}, goodsDesc={}, transAmt={}",
-                            createReq.getEffectiveMemberId(), createReq.getOrderType(), createReq.getGoodsDesc(), createReq.getTransAmt());
-
-                    return paymentService.alipayQrCodePay(memberId, createReq)
-                            .flatMap(result -> {
-                                if ("FAIL".equals(result.getStatus())) {
-                                    return ServerResponse.ok()
-                                            .bodyValue(ApiResponse.error(result.getErrorMsg()));
-                                }
-                                return ServerResponse.ok()
-                                        .bodyValue(ApiResponse.success(result));
-                            });
-                })
-                .onErrorResume(e -> {
-                    log.error("[Payment] 创建扫码支付订单异常", e);
-                    return ServerResponse.ok()
-                            .bodyValue(ApiResponse.error("创建扫码支付订单失败: " + e.getMessage()));
-                });
-    }
-
-    @Operation(summary = "查询支付状态", description = "查询支付订单状态")
-    public Mono<ServerResponse> getPaymentStatus(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        String orderId = request.pathVariable("orderId");
-        log.info("[Payment] 查询支付状态: orderId={}", orderId);
-
-        return paymentService.getPaymentStatus(memberId, orderId)
-                .flatMap(result -> ServerResponse.ok().bodyValue(ApiResponse.success(result)))
-                .onErrorResume(e -> {
-                    log.error("[Payment] 查询支付状态异常", e);
-                    return ServerResponse.ok()
-                            .bodyValue(ApiResponse.error("查询支付状态失败: " + e.getMessage()));
-                });
-    }
-
-    @Operation(summary = "汇付异步通知", description = "接收汇付异步回调通知")
-    public Mono<ServerResponse> huifuNotify(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        String respData = request.queryParam("resp_data").orElse(null);
-        String sign = request.queryParam("sign").orElse(null);
-
-        log.info("[Payment] 收到汇付异步通知: resp_data={}, sign={}", respData, sign);
-
-        Map<String, String> notifyParams = new HashMap<>();
-        notifyParams.put("resp_data", respData);
-        notifyParams.put("sign", sign);
-
-        return paymentService.handleAlipayNotify(notifyParams)
-                .flatMap(result -> ServerResponse.ok().bodyValue(result))
-                .onErrorResume(e -> {
-                    log.error("[Payment] 处理异步通知异常", e);
-                    return ServerResponse.ok().bodyValue("FAIL");
-                });
-    }
-
-    @Operation(summary = "申请退款", description = "申请支付退款")
-    public Mono<ServerResponse> refundPayment(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        String orderId = request.pathVariable("orderId");
-
-        return request.bodyToMono(Map.class)
-                .flatMap(body -> {
-                    String refundAmt = String.valueOf(body.get("refundAmt"));
-                    log.info("[Payment] 申请退款: orderId={}, refundAmt={}", orderId, refundAmt);
-
-                    return paymentService.refund(memberId, orderId, refundAmt)
-                            .flatMap(success -> {
-                                if (success) {
-                                    return ServerResponse.ok()
-                                            .bodyValue(ApiResponse.success("退款申请成功"));
-                                } else {
-                                    return ServerResponse.ok()
-                                            .bodyValue(ApiResponse.error("退款申请失败"));
-                                }
-                            });
-                })
-                .onErrorResume(e -> {
-                    log.error("[Payment] 退款异常: orderId={}", orderId, e);
-                    return ServerResponse.ok()
-                            .bodyValue(ApiResponse.error("退款失败: " + e.getMessage()));
-                });
-    }
-
-    @Operation(summary = "查询所有交易记录", description = "查询所有未删除的支付订单记录")
-    public Mono<ServerResponse> getAllPaymentOrders(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        log.info("[Payment] 查询所有交易记录");
-
-        return paymentService.getAllPaymentOrders(memberId)
-                .collectList()
-                .flatMap(orders -> ServerResponse.ok()
-                        .bodyValue(ApiResponse.success(orders)))
-                .onErrorResume(e -> {
-                    log.error("[Payment] 查询所有交易记录异常", e);
-                    return ServerResponse.ok()
-                            .bodyValue(ApiResponse.error("查询失败: " + e.getMessage()));
-                });
-    }
-
-    @Operation(summary = "查询斗拱交易列表", description = "查询斗拱商户端的交易记录列表")
-    public Mono<ServerResponse> queryHuifuTradeList(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        String beginDate = request.queryParam("beginDate").orElse(null);
-        String endDate = request.queryParam("endDate").orElse(null);
-
-        log.info("[Payment] 查询斗拱交易列表: beginDate={}, endDate={}", beginDate, endDate);
-
-        return paymentService.queryHuifuTradeList(memberId, beginDate, endDate)
-                .flatMap(result -> ServerResponse.ok()
-                        .bodyValue(ApiResponse.success(result)))
-                .onErrorResume(e -> {
-                    log.error("[Payment] 查询斗拱交易列表异常", e);
-                    return ServerResponse.ok()
-                            .bodyValue(ApiResponse.error("查询失败: " + e.getMessage()));
-                });
-    }
-
-    @Operation(summary = "按订单号查询斗拱交易", description = "通过商户订单号或汇付流水号查询单笔交易记录")
-    public Mono<ServerResponse> queryHuifuTradeByOrderId(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        String outOrdId = request.queryParam("outOrdId").orElse(null);
-        String hfSeqId = request.queryParam("hfSeqId").orElse(null);
-
-        log.info("[Payment] 查询斗拱交易: outOrdId={}, hfSeqId={}", outOrdId, hfSeqId);
-
-        if (outOrdId == null || outOrdId.isEmpty()) {
-            return ServerResponse.ok()
-                    .bodyValue(ApiResponse.error("订单号不能为空"));
-        }
-
-        return paymentService.queryHuifuTradeByOrderId(memberId, outOrdId, hfSeqId)
-                .flatMap(result -> ServerResponse.ok()
-                        .bodyValue(ApiResponse.success(result)))
-                .onErrorResume(e -> {
-                    log.error("[Payment] 查询斗拱交易异常", e);
-                    return ServerResponse.ok()
-                            .bodyValue(ApiResponse.error("查询失败: " + e.getMessage()));
-                });
-    }
-
-    @Operation(summary = "查询未支付订单", description = "查询会员指定类型的未支付订单")
-    public Mono<ServerResponse> getPendingOrder(ServerRequest request) {
-        Long memberId = Long.valueOf(request.pathVariable("memberId"));
-        String orderType = request.queryParam("orderType").orElse(null);
-
-        log.info("[Payment] 查询未支付订单: memberId={}, orderType={}", memberId, orderType);
-
-        if (orderType == null || orderType.isEmpty()) {
-            return ServerResponse.ok()
-                    .bodyValue(ApiResponse.error("订单类型不能为空"));
-        }
-
-        return paymentService.getPendingOrder(memberId, orderType)
-                .flatMap(order -> ServerResponse.ok()
-                        .bodyValue(ApiResponse.success(order)))
-                .switchIfEmpty(Mono.defer(() -> ServerResponse.ok()
-                        .bodyValue(ApiResponse.success(null))))
-                .onErrorResume(e -> {
-                    log.error("[Payment] 查询未支付订单异常", e);
-                    return ServerResponse.ok()
-                            .bodyValue(ApiResponse.error("查询失败: " + e.getMessage()));
-                });
-    }
-
-    @Operation(summary = "关闭订单", description = "关闭指定的待支付订单")
-    public Mono<ServerResponse> closeOrder(ServerRequest request) {
-        Long memberId = authUtil.getMemberIdOrThrow(request);
-        String orderId = request.pathVariable("orderId");
-        log.info("[Payment] 关闭订单: orderId={}", orderId);
-
-        return paymentService.closeOrder(memberId, orderId)
-                .flatMap(success -> {
-                    if (success) {
-                        return ServerResponse.ok()
-                                .bodyValue(ApiResponse.success("订单关闭成功"));
-                    } else {
-                        return ServerResponse.ok()
-                                .bodyValue(ApiResponse.error("订单关闭失败"));
-                    }
-                })
-                .onErrorResume(e -> {
-                    log.error("[Payment] 关闭订单异常", e);
-                    return ServerResponse.ok()
-                            .bodyValue(ApiResponse.error("关闭失败: " + e.getMessage()));
-                });
-    }
-}

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

@@ -1,45 +0,0 @@
-package cn.novalon.gym.manage.payment.handler;
-
-import cn.novalon.gym.manage.payment.repository.PaymentOrderRepository;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.scheduling.annotation.Scheduled;
-import org.springframework.stereotype.Component;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Slf4j
-@Component
-@RequiredArgsConstructor
-public class PaymentScheduledHandler {
-
-    private final PaymentOrderRepository paymentOrderRepository;
-
-    private static final int BATCH_SIZE = 100;
-
-    @Scheduled(fixedRate = 60000)
-    public void closeExpiredOrders() {
-        log.info("[Payment] 开始执行超时订单关闭任务");
-
-        LocalDateTime now = LocalDateTime.now();
-
-        paymentOrderRepository.findExpiredOrders(now, BATCH_SIZE)
-                .flatMap(order -> {
-                    log.info("[Payment] 关闭超时订单, orderNo={}, expireTime={}", order.getOrderNo(), order.getExpireTime());
-                    return paymentOrderRepository.closeExpiredOrder(order.getId())
-                            .doOnSuccess(rows -> {
-                                if (rows != null && rows > 0) {
-                                    log.info("[Payment] 超时订单已关闭, orderNo={}", order.getOrderNo());
-                                }
-                            })
-                            .onErrorResume(e -> {
-                                log.error("[Payment] 关闭超时订单失败, orderNo={}", order.getOrderNo(), e);
-                                return Mono.empty();
-                            });
-                })
-                .then()
-                .doOnSuccess(v -> log.info("[Payment] 超时订单关闭任务完成"))
-                .subscribe();
-    }
-}

gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/repository/PaymentOrderRepository.java

@@ -1,41 +0,0 @@
-package cn.novalon.gym.manage.payment.repository;
-
-import cn.novalon.gym.manage.payment.entity.PaymentOrder;
-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 PaymentOrderRepository extends R2dbcRepository<PaymentOrder, Long> {
-
-    Mono<PaymentOrder> findByOrderNo(String orderNo);
-
-    Mono<PaymentOrder> findByReqSeqId(String reqSeqId);
-
-    @Query("SELECT * FROM payment_order WHERE member_id = :memberId AND order_type = :orderType AND pay_status = 'PENDING' AND deleted_at IS NULL ORDER BY created_at DESC LIMIT 1")
-    Mono<PaymentOrder> findLatestPendingOrder(Long memberId, String orderType);
-
-    @Query("SELECT * FROM payment_order WHERE pay_status = 'PENDING' AND expire_time < :now AND deleted_at IS NULL LIMIT :limit")
-    Flux<PaymentOrder> findExpiredOrders(LocalDateTime now, int limit);
-
-    @Modifying
-    @Query("UPDATE payment_order SET pay_status = :status, updated_at = NOW() WHERE id = :id AND deleted_at IS NULL")
-    Mono<Integer> updateStatus(Long id, String status);
-
-    @Modifying
-    @Query("UPDATE payment_order SET pay_status = 'CLOSED', error_code = 'TIMEOUT', error_msg = '订单超时自动关闭', updated_at = NOW() WHERE id = :id AND pay_status = 'PENDING' AND deleted_at IS NULL")
-    Mono<Integer> closeExpiredOrder(Long id);
-
-    @Modifying
-    @Query("UPDATE payment_order SET pay_status = 'SUCCESS', hf_seq_id = :hfSeqId, pay_time = NOW(), updated_at = NOW() WHERE id = :id AND pay_status = 'PENDING' AND deleted_at IS NULL")
-    Mono<Integer> markPaid(Long id, String hfSeqId);
-
-    Flux<PaymentOrder> findAllByDeletedAtIsNull();
-
-    Flux<PaymentOrder> findByMemberIdAndDeletedAtIsNull(Long memberId);
-}

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

@@ -1,9 +0,0 @@
-package cn.novalon.gym.manage.payment.service;
-
-import reactor.core.publisher.Mono;
-
-public interface PaymentNotifyService {
-
-    Mono<Void> notifyPaymentStatus(String orderNo, String status,Long memberId);
-
-}

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

@@ -1,33 +0,0 @@
-package cn.novalon.gym.manage.payment.service;
-
-import cn.novalon.gym.manage.payment.dto.CreatePaymentRequest;
-import cn.novalon.gym.manage.payment.dto.PaymentResponse;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.util.Map;
-
-public interface PaymentService {
-
-    Mono<PaymentResponse> createPayment(Long memberId, CreatePaymentRequest request);
-
-    Mono<PaymentResponse> getPaymentStatus(Long memberId, String orderId);
-
-    Mono<PaymentResponse> alipayAppPay(Long memberId, CreatePaymentRequest request);
-
-    Mono<PaymentResponse> alipayQrCodePay(Long memberId, CreatePaymentRequest request);
-
-    Mono<String> handleAlipayNotify(Map<String, String> params);
-
-    Mono<Boolean> refund(Long memberId, String orderId, String refundAmt);
-
-    Flux<PaymentResponse> getAllPaymentOrders(Long memberId);
-
-    Mono<Map<String, Object>> queryHuifuTradeList(Long memberId, String beginDate, String endDate);
-
-    Mono<Map<String, Object>> queryHuifuTradeByOrderId(Long memberId, String outOrdId, String hfSeqId);
-
-    Mono<PaymentResponse> getPendingOrder(Long memberId, String orderType);
-
-    Mono<Boolean> closeOrder(Long memberId, String orderId);
-}

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

@@ -1,939 +0,0 @@
-package cn.novalon.gym.manage.payment.service.impl;
-
-import cn.novalon.gym.manage.common.util.RedisUtil;
-import cn.novalon.gym.manage.payment.config.HuifuProperties;
-import cn.novalon.gym.manage.payment.dto.CreatePaymentRequest;
-import cn.novalon.gym.manage.payment.dto.PaymentResponse;
-import cn.novalon.gym.manage.payment.entity.PaymentOrder;
-import cn.novalon.gym.manage.payment.repository.PaymentOrderRepository;
-import cn.novalon.gym.manage.payment.service.PaymentNotifyService;
-import cn.novalon.gym.manage.payment.service.PaymentService;
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONObject;
-import com.huifu.bspay.sdk.opps.client.BasePayClient;
-import com.huifu.bspay.sdk.opps.core.request.V2TradeCheckFilequeryRequest;
-import com.huifu.bspay.sdk.opps.core.request.V2TradePaymentScanpayQueryRequest;
-import com.huifu.bspay.sdk.opps.core.utils.DateTools;
-import com.huifu.bspay.sdk.opps.core.utils.SequenceTools;
-import com.huifu.dg.lightning.biz.client.CommonPayClient;
-import com.huifu.dg.lightning.biz.exception.BasePayException;
-import com.huifu.dg.lightning.factory.Factory;
-import com.huifu.dg.lightning.models.payment.TradePaymentCreateRequest;
-import com.huifu.dg.lightning.models.payment.TradePaymentScanpayQueryRequest;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-import reactor.core.scheduler.Schedulers;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-import java.util.Map;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.UUID;
-
-@Slf4j
-@Service
-public class PaymentServiceImpl implements PaymentService {
-
-    private static final String PROCESSED_TRADE_PREFIX = "huifu:processed:trade:";
-    private static final long IDEMPOTENT_EXPIRE_SECONDS = 86400;
-    private static final int ORDER_EXPIRE_MINUTES = 15;
-    private static final String TEST_AMOUNT = "1";
-
-    private final HuifuProperties huifuProperties;
-    private final PaymentOrderRepository paymentOrderRepository;
-    private final RedisUtil redisUtil;
-    private final PaymentNotifyService paymentNotifyService;
-
-    public PaymentServiceImpl(HuifuProperties huifuProperties,
-                              PaymentOrderRepository paymentOrderRepository,
-                              RedisUtil redisUtil,
-                              PaymentNotifyService paymentNotifyService) {
-        this.huifuProperties = huifuProperties;
-        this.paymentOrderRepository = paymentOrderRepository;
-        this.redisUtil = redisUtil;
-        this.paymentNotifyService = paymentNotifyService;
-    }
-
-    @Override
-    public Mono<PaymentResponse> createPayment(Long memberId, CreatePaymentRequest request) {
-        return alipayAppPay(memberId, request);
-    }
-
-    @Override
-    public Mono<PaymentResponse> alipayAppPay(Long memberId, CreatePaymentRequest request) {
-        log.info("[Huifu] APP支付下单开始, memberId={}, goodsDesc={}, transAmt={}",
-                memberId, request.getGoodsDesc(), request.getTransAmt());
-
-        if (!huifuProperties.isSdkInitialized()) {
-            log.warn("[Huifu] 支付SDK未初始化，返回模拟订单");
-            return createMockOrder(memberId, request, "ALIPAY");
-        }
-
-        return paymentOrderRepository.findLatestPendingOrder(memberId, request.getOrderType())
-                .flatMap(existingOrder -> {
-                    log.info("[Huifu] 存在未支付订单, 直接返回, orderNo={}", existingOrder.getOrderNo());
-                    return Mono.just(convertToResponse(existingOrder));
-                })
-                .switchIfEmpty(Mono.defer(() -> doCreatePayment(memberId, request, "ALIPAY")));
-    }
-
-    @Override
-    public Mono<PaymentResponse> alipayQrCodePay(Long memberId, CreatePaymentRequest request) {
-        log.info("[Huifu] 扫码支付下单开始, memberId={}, goodsDesc={}, transAmt={}",
-                memberId, request.getGoodsDesc(), request.getTransAmt());
-
-        if (!huifuProperties.isSdkInitialized()) {
-            log.warn("[Huifu] 支付SDK未初始化，返回模拟扫码订单");
-            return createMockOrder(memberId, request, "QRCODE");
-        }
-
-        return paymentOrderRepository.findLatestPendingOrder(memberId, request.getOrderType())
-                .flatMap(existingOrder -> {
-                    log.info("[Huifu] 存在未支付订单, 直接返回, orderNo={}", existingOrder.getOrderNo());
-                    return Mono.just(convertToResponse(existingOrder));
-                })
-                .switchIfEmpty(Mono.defer(() -> doCreatePayment(memberId, request, "QRCODE")));
-    }
-
-    private Mono<PaymentResponse> doCreatePayment(Long memberId, CreatePaymentRequest request, String tradeType) {
-        String orderNo = generateOrderNo();
-        String reqSeqId = SequenceTools.getReqSeqId32();
-        String reqDate = DateTools.getCurrentDateYYYYMMDD();
-        String transAmt = TEST_AMOUNT;
-
-        log.info("[Huifu] 测试模式, 强制金额为0.01元, 前端传入金额={}", request.getTransAmt());
-
-        return Mono.fromCallable(() -> {
-            TradePaymentCreateRequest createRequest = new TradePaymentCreateRequest();
-            createRequest.setReqDate(reqDate);
-            createRequest.setReqSeqId(reqSeqId);
-            createRequest.setHuifuId(huifuProperties.getMerchant().getHuifuId());
-            createRequest.setTradeType("A_NATIVE");
-            createRequest.setTransAmt(formatAmount(transAmt));
-            createRequest.setGoodsDesc(truncate(request.getGoodsDesc(), 128));
-            createRequest.setRemark(request.getRemark());
-            createRequest.setNotifyUrl(huifuProperties.getNotify().getUrl());
-            createRequest.addExtendInfo("out_ord_id", orderNo);
-
-            CommonPayClient client = Factory.Payment.Common();
-            return client.create(createRequest);
-        })
-        .subscribeOn(Schedulers.boundedElastic())
-        .flatMap(response -> {
-            log.info("[Huifu] 支付下单响应, orderNo={}, response={}", orderNo, response);
-            
-            String outOrdId = String.valueOf(response.getOrDefault("out_ord_id", ""));
-            String merchantOrderId = String.valueOf(response.getOrDefault("merchant_order_id", ""));
-            String orgReqSeqId = String.valueOf(response.getOrDefault("org_req_seq_id", ""));
-            log.info("[Huifu] 汇付返回的订单号字段: out_ord_id={}, merchant_order_id={}, org_req_seq_id={}", outOrdId, merchantOrderId, orgReqSeqId);
-
-            String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-            boolean success = "00000000".equals(respCode) || "00000100".equals(respCode);
-
-            PaymentOrder paymentOrder = PaymentOrder.builder()
-                    .orderNo(orderNo)
-                    .memberId(memberId)
-                    .orderType(request.getOrderType())
-                    .goodsDesc(request.getGoodsDesc())
-                    .transAmt(new BigDecimal(transAmt).divide(new BigDecimal("100"), 2, BigDecimal.ROUND_HALF_UP))
-                    .tradeType(tradeType)
-                    .payStatus(success ? "PENDING" : "FAIL")
-                    .huifuId(huifuProperties.getMerchant().getHuifuId())
-                    .reqSeqId(reqSeqId)
-                    .reqDate(reqDate)
-                    .hfSeqId(String.valueOf(response.getOrDefault("hf_seq_id", "")))
-                    .partyOrderId(String.valueOf(response.getOrDefault("party_order_id", "")))
-                    .remark(request.getRemark())
-                    .notifyUrl(huifuProperties.getNotify().getUrl())
-                    .expireTime(LocalDateTime.now().plusMinutes(ORDER_EXPIRE_MINUTES))
-                    .errorCode(success ? null : respCode)
-                    .errorMsg(success ? null : String.valueOf(response.getOrDefault("resp_desc", "")))
-                    .build();
-
-            String payInfo = extractPayInfo(response);
-            paymentOrder.setPayInfo(payInfo);
-            paymentOrder.setPayUrl(payInfo);
-            paymentOrder.setQrCode(payInfo);
-
-            return paymentOrderRepository.save(paymentOrder)
-                    .map(savedOrder -> {
-                        log.info("[Huifu] 支付订单创建成功, orderNo={}", orderNo);
-                        return convertToResponse(savedOrder);
-                    });
-        })
-        .onErrorResume(e -> {
-            log.error("[Huifu] 支付下单异常, orderNo={}", orderNo, e);
-            String errorCode = "UNKNOWN_ERROR";
-            String errorMsg = e.getMessage();
-            if (e instanceof BasePayException) {
-                errorCode = ((BasePayException) e).getCode();
-            }
-            PaymentResponse resp = PaymentResponse.builder()
-                    .orderId(orderNo)
-                    .status("FAIL")
-                    .errorCode(errorCode)
-                    .errorMsg(errorMsg)
-                    .build();
-            return Mono.just(resp);
-        });
-    }
-
-    @Override
-    public Mono<PaymentResponse> getPaymentStatus(Long memberId, String orderId) {
-        log.info("[Huifu] 查询支付状态, memberId={}, orderId={}", memberId, orderId);
-
-        return paymentOrderRepository.findByOrderNo(orderId)
-                .flatMap(order -> {
-                    if (!memberId.equals(order.getMemberId())) {
-                        log.warn("[Huifu] 订单不属于当前会员, memberId={}, orderMemberId={}", memberId, order.getMemberId());
-                        return Mono.just(PaymentResponse.builder()
-                                .orderId(orderId)
-                                .status("NOT_FOUND")
-                                .errorMsg("订单不存在")
-                                .build());
-                    }
-
-                    if ("SUCCESS".equals(order.getPayStatus())
-                            || "CLOSED".equals(order.getPayStatus())
-                            || "FAIL".equals(order.getPayStatus())) {
-                        return Mono.just(convertToResponse(order));
-                    }
-
-                    if (!huifuProperties.isSdkInitialized()) {
-                        return Mono.just(convertToResponse(order));
-                    }
-
-                    return Mono.fromCallable(() -> queryFromHuifu(order))
-                            .subscribeOn(Schedulers.boundedElastic())
-                            .flatMap(response -> {
-                                log.info("[Huifu] 查询支付状态响应, orderId={}, resp_code={}, trans_stat={}", 
-                                        orderId, 
-                                        response.getOrDefault("resp_code", ""),
-                                        response.getOrDefault("trans_stat", ""));
-
-                                String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                                String transStat = String.valueOf(response.getOrDefault("trans_stat", ""));
-
-                                if ("00000000".equals(respCode)) {
-                                    if ("S".equals(transStat)) {
-                                        if (!"SUCCESS".equals(order.getPayStatus())) {
-                                            log.info("[Huifu] 查询到支付成功，更新订单状态并触发业务处理, orderNo={}, orderType={}",
-                                                    order.getOrderNo(), order.getOrderType());
-                                            order.setPayStatus("SUCCESS");
-                                            order.setHfSeqId(String.valueOf(response.getOrDefault("hf_seq_id", order.getHfSeqId())));
-                                            order.setPayTime(LocalDateTime.now());
-                                            return paymentOrderRepository.save(order)
-                                                    .flatMap(savedOrder -> {
-                                                        log.info("[Huifu] 订单状态已更新，开始触发业务处理, orderNo={}", savedOrder.getOrderNo());
-                                                        return paymentNotifyService.notifyPaymentStatus(savedOrder.getOrderNo(), "SUCCESS", memberId)
-                                                                .thenReturn(convertToResponse(savedOrder));
-                                                    });
-                                        } else {
-                                            log.info("[Huifu] 订单已处理过，跳过业务处理, orderNo={}", order.getOrderNo());
-                                        }
-                                    } else if ("F".equals(transStat)) {
-                                        if (!"FAIL".equals(order.getPayStatus())) {
-                                            log.info("[Huifu] 查询到支付失败，更新订单状态, orderNo={}", order.getOrderNo());
-                                            order.setPayStatus("FAIL");
-                                            order.setErrorMsg(String.valueOf(response.getOrDefault("resp_desc", "支付失败")));
-                                            return paymentOrderRepository.save(order)
-                                                    .flatMap(savedOrder -> paymentNotifyService.notifyPaymentStatus(savedOrder.getOrderNo(), "FAIL", memberId)
-                                                            .thenReturn(convertToResponse(savedOrder)));
-                                        }
-                                    } else if ("P".equals(transStat)) {
-                                        order.setPayStatus("PENDING");
-                                    }
-                                } else {
-                                    log.warn("[Huifu] 查询返回非成功状态码, orderId={}, resp_code={}, resp_desc={}", 
-                                            orderId, respCode, response.getOrDefault("resp_desc", ""));
-                                }
-
-                                return paymentOrderRepository.save(order)
-                                        .map(savedOrder -> convertToResponse(savedOrder));
-                            })
-                            .onErrorResume(e -> {
-                                log.error("[Huifu] 查询支付状态异常, orderId={}", orderId, e);
-                                return Mono.just(convertToResponse(order));
-                            });
-                })
-                .switchIfEmpty(Mono.defer(() -> {
-                    log.warn("[Huifu] 订单不存在, orderId={}", orderId);
-                    return Mono.just(PaymentResponse.builder()
-                            .orderId(orderId)
-                            .status("NOT_FOUND")
-                            .errorMsg("订单不存在")
-                            .build());
-                }));
-    }
-
-    private Map<String, Object> queryFromHuifu(PaymentOrder order) {
-        String orderNo = order.getOrderNo();
-        String hfSeqId = order.getHfSeqId();
-
-        log.info("[Huifu] 开始从汇付查询订单状态, orderNo={}, hfSeqId={}", orderNo, hfSeqId);
-
-        List<String> huifuIds = new ArrayList<>();
-        if (huifuProperties.getMerchant() != null && huifuProperties.getMerchant().getHuifuId() != null) {
-            huifuIds.add(huifuProperties.getMerchant().getHuifuId());
-        }
-        if (huifuProperties.getChannel() != null && huifuProperties.getChannel().getHuifuId() != null) {
-            String channelHuifuId = huifuProperties.getChannel().getHuifuId();
-            if (!huifuIds.contains(channelHuifuId)) {
-                huifuIds.add(channelHuifuId);
-            }
-        }
-
-        log.info("[Huifu] 查询ID列表: huifuIds={}", huifuIds);
-
-        for (String huifuId : huifuIds) {
-            try {
-                if (hfSeqId != null && !hfSeqId.isEmpty() && !"null".equals(hfSeqId)) {
-                    Map<String, Object> response = executeV2QueryByHfSeqId(huifuId, hfSeqId);
-                    String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                    log.info("[Huifu] 按汇付流水号查询: huifuId={}, hfSeqId={}, resp_code={}", huifuId, hfSeqId, respCode);
-                    if ("00000000".equals(respCode)) {
-                        return response;
-                    }
-                }
-
-                Map<String, Object> response = executeV2QueryByOrgReqSeqId(huifuId, order.getReqSeqId());
-                String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                log.info("[Huifu] 按请求流水号查询: huifuId={}, reqSeqId={}, resp_code={}", huifuId, order.getReqSeqId(), respCode);
-                if ("00000000".equals(respCode)) {
-                    return response;
-                }
-
-                response = executeV4SingleQuery(huifuId, orderNo);
-                respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                log.info("[Huifu] V4接口按订单号查询: huifuId={}, orderNo={}, resp_code={}", huifuId, orderNo, respCode);
-                if ("00000000".equals(respCode)) {
-                    return response;
-                }
-
-                response = executeV2SingleQuery(huifuId, orderNo);
-                respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                log.info("[Huifu] V2接口按订单号查询: huifuId={}, orderNo={}, resp_code={}", huifuId, orderNo, respCode);
-                if ("00000000".equals(respCode)) {
-                    return response;
-                }
-            } catch (Exception e) {
-                log.warn("[Huifu] 查询异常, huifuId={}, orderNo={}", huifuId, orderNo, e);
-            }
-        }
-
-        log.warn("[Huifu] 所有查询方式均未成功, orderNo={}", orderNo);
-        Map<String, Object> emptyResult = new HashMap<>();
-        emptyResult.put("resp_code", "QUERY_FAILED");
-        emptyResult.put("resp_desc", "查询失败");
-        return emptyResult;
-    }
-
-    @Override
-    public Mono<String> handleAlipayNotify(Map<String, String> params) {
-        String respData = params.get("resp_data");
-        String sign = params.get("sign");
-
-        log.info("[Huifu] 收到异步通知, respData={}, sign={}", respData, sign);
-
-        if (respData == null || sign == null) {
-            log.error("[Huifu] 异步通知参数为空");
-            return Mono.just("FAIL");
-        }
-
-        JSONObject notification = JSONObject.parseObject(respData);
-        String reqSeqId = notification.getString("req_seq_id");
-        String hfSeqId = notification.getString("hf_seq_id");
-        String transStat = notification.getString("trans_stat");
-
-        log.info("[Huifu] 解析异步通知, reqSeqId={}, hfSeqId={}, transStat={}", reqSeqId, hfSeqId, transStat);
-
-        return isTradeProcessed(reqSeqId)
-                .flatMap(processed -> {
-                    if (processed) {
-                        log.info("[Huifu] 幂等处理：通知已处理，跳过, reqSeqId={}", reqSeqId);
-                        return Mono.just("RECV_ORD_ID_" + reqSeqId);
-                    }
-
-                    return paymentOrderRepository.findByReqSeqId(reqSeqId)
-                            .flatMap(order -> {
-                                if ("S".equals(transStat)) {
-                                    log.info("[Huifu] 交易成功, hfSeqId={}, orderNo={}", hfSeqId, order.getOrderNo());
-                                    order.setPayStatus("SUCCESS");
-                                    order.setHfSeqId(hfSeqId);
-                                    order.setPayTime(LocalDateTime.now());
-                                    return paymentOrderRepository.save(order)
-                                            .flatMap(saved -> markTradeProcessed(reqSeqId))
-                                            .then(paymentNotifyService.notifyPaymentStatus(order.getOrderNo(), "SUCCESS", order.getMemberId()))
-                                            .thenReturn("RECV_ORD_ID_" + reqSeqId);
-                                } else if ("F".equals(transStat)) {
-                                    log.info("[Huifu] 交易失败, hfSeqId={}, orderNo={}", hfSeqId, order.getOrderNo());
-                                    order.setPayStatus("FAIL");
-                                    order.setErrorMsg(notification.getString("resp_desc"));
-                                    return paymentOrderRepository.save(order)
-                                            .flatMap(saved -> markTradeProcessed(reqSeqId))
-                                            .then(paymentNotifyService.notifyPaymentStatus(order.getOrderNo(), "FAIL", order.getMemberId()))
-                                            .thenReturn("RECV_ORD_ID_" + reqSeqId);
-                                } else if ("P".equals(transStat)) {
-                                    log.info("[Huifu] 交易处理中, hfSeqId={}, orderNo={}", hfSeqId, order.getOrderNo());
-                                    return paymentNotifyService.notifyPaymentStatus(order.getOrderNo(), "PENDING", order.getMemberId())
-                                            .thenReturn("RECV_ORD_ID_" + reqSeqId);
-                                }
-                                return Mono.just("RECV_ORD_ID_" + reqSeqId);
-                            })
-                            .switchIfEmpty(Mono.defer(() -> {
-                                log.warn("[Huifu] 未找到对应订单, reqSeqId={}", reqSeqId);
-                                return Mono.just("FAIL");
-                            }));
-                })
-                .onErrorResume(e -> {
-                    log.error("[Huifu] 处理异步通知异常", e);
-                    return Mono.just("FAIL");
-                });
-    }
-
-    @Override
-    public Mono<Boolean> refund(Long memberId, String orderId, String refundAmt) {
-        log.warn("[Huifu] 退款功能暂未实现, memberId={}, orderId={}, refundAmt={}", memberId, orderId, refundAmt);
-        return Mono.just(false);
-    }
-
-    @Override
-    public Flux<PaymentResponse> getAllPaymentOrders(Long memberId) {
-        System.err.println("========== 开始查询交易记录, memberId=" + memberId + " ==========");
-        return paymentOrderRepository.findByMemberIdAndDeletedAtIsNull(memberId)
-                .doOnNext(order -> {
-                    System.err.println("订单记录:");
-                    System.err.println("  ID: " + order.getId());
-                    System.err.println("  订单号: " + order.getOrderNo());
-                    System.err.println("  汇付流水号: " + order.getHfSeqId());
-                    System.err.println("  商户号: " + order.getHuifuId());
-                    System.err.println("  请求流水号: " + order.getReqSeqId());
-                    System.err.println("  请求日期: " + order.getReqDate());
-                    System.err.println("  支付状态: " + order.getPayStatus());
-                    System.err.println("  交易金额: " + order.getTransAmt());
-                    System.err.println("  创建时间: " + order.getCreatedAt());
-                    System.err.println("----------------------------------------");
-                })
-                .doOnComplete(() -> {
-                    System.err.println("========== 查询完成 ==========");
-                })
-                .map(this::convertToResponse);
-    }
-
-    @Override
-    public Mono<Map<String, Object>> queryHuifuTradeList(Long memberId, String beginDate, String endDate) {
-        log.info("[Huifu] 查询斗拱官方交易记录, memberId={}, beginDate={}, endDate={}", memberId, beginDate, endDate);
-
-        return Mono.fromCallable(() -> {
-            String today = DateTools.getCurrentDateYYYYMMDD();
-            
-            java.time.LocalDate todayDate = java.time.LocalDate.parse(today, java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-            java.time.LocalDate yesterdayDate = todayDate.minusDays(1);
-            String yesterday = yesterdayDate.format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-            
-            String effectiveEndDate = (endDate != null && !endDate.isEmpty()) ? endDate : yesterday;
-            String effectiveBeginDate = (beginDate != null && !beginDate.isEmpty()) ? beginDate : yesterday;
-
-            Map<String, Object> allResults = new java.util.HashMap<>();
-            allResults.put("begin_date", effectiveBeginDate);
-            allResults.put("end_date", effectiveEndDate);
-            allResults.put("note", "斗拱对账文件T+1生成，当日交易次日可查；如已知订单号请使用/api/payment/huifu/query?outOrdId=xxx单笔查询");
-
-            java.util.List<Map<String, Object>> tradeList = new java.util.ArrayList<>();
-            java.util.List<Map<String, Object>> apiResults = new java.util.ArrayList<>();
-
-            java.util.List<String> huifuIds = new java.util.ArrayList<>();
-            if (huifuProperties.getMerchant() != null && huifuProperties.getMerchant().getHuifuId() != null) {
-                huifuIds.add(huifuProperties.getMerchant().getHuifuId());
-            }
-            if (huifuProperties.getChannel() != null && huifuProperties.getChannel().getHuifuId() != null) {
-                String channelId = huifuProperties.getChannel().getHuifuId();
-                if (!huifuIds.contains(channelId)) {
-                    huifuIds.add(channelId);
-                }
-            }
-
-            allResults.put("huifu_ids", huifuIds);
-
-            java.time.LocalDate startDate = java.time.LocalDate.parse(effectiveBeginDate, java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-            java.time.LocalDate endDateObj = java.time.LocalDate.parse(effectiveEndDate, java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-
-            String[] billTypes = {"TRADE_BILL", "MERGE_BILL"};
-
-            for (String huifuId : huifuIds) {
-                log.info("[Huifu] 使用 huifuId={} 查询对账文件", huifuId);
-
-                for (java.time.LocalDate date = startDate; !date.isAfter(endDateObj); date = date.plusDays(1)) {
-                    String fileDate = date.format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-                    
-                    for (String billType : billTypes) {
-                        try {
-                            V2TradeCheckFilequeryRequest request = new V2TradeCheckFilequeryRequest();
-                            request.setReqDate(DateTools.getCurrentDateYYYYMMDD());
-                            request.setReqSeqId(SequenceTools.getReqSeqId32());
-                            request.setHuifuId(huifuId);
-                            request.setFileDate(fileDate);
-
-                            Map<String, Object> extendInfoMap = new java.util.HashMap<>();
-                            extendInfoMap.put("bill_type", billType);
-                            request.setExtendInfo(extendInfoMap);
-
-                            log.info("[Huifu] 调用对账单查询接口, billType={}, fileDate={}, huifuId={}", billType, fileDate, huifuId);
-
-                            Map<String, Object> response = BasePayClient.request(request, false);
-                            String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                            String respDesc = String.valueOf(response.getOrDefault("resp_desc", ""));
-
-                            log.info("[Huifu] 对账单查询响应: billType={}, fileDate={}, resp_code={}, resp_desc={}", billType, fileDate, respCode, respDesc);
-
-                            Map<String, Object> apiResult = new java.util.HashMap<>();
-                            apiResult.put("api", "V2TradeCheckFilequeryRequest");
-                            apiResult.put("bill_type", billType);
-                            apiResult.put("file_date", fileDate);
-                            apiResult.put("huifu_id", huifuId);
-                            apiResult.put("resp_code", respCode);
-                            apiResult.put("resp_desc", respDesc);
-
-                            if ("00000000".equals(respCode)) {
-                                apiResult.put("full_response", response);
-                                
-                                Object fileDetails = response.get("file_details");
-                                Object fileList = response.get("file_list");
-                                Object taskDetails = response.get("task_details");
-                                Object billList = response.get("bill_list");
-                                Object downloadUrl = response.get("download_url");
-                                Object fileName = response.get("file_name");
-                                
-                                boolean hasData = false;
-                                if (fileDetails != null && !"null".equals(String.valueOf(fileDetails)) && !String.valueOf(fileDetails).isEmpty()) {
-                                    apiResult.put("file_details", fileDetails);
-                                    hasData = true;
-                                    log.info("[Huifu] 获取到file_details, billType={}, fileDate={}", billType, fileDate);
-                                    try {
-                                        if (fileDetails instanceof java.util.List) {
-                                            java.util.List<?> detailsList = (java.util.List<?>) fileDetails;
-                                            for (Object detail : detailsList) {
-                                                if (detail instanceof Map) {
-                                                    tradeList.add((Map<String, Object>) detail);
-                                                }
-                                            }
-                                        } else if (fileDetails instanceof Map) {
-                                            tradeList.add((Map<String, Object>) fileDetails);
-                                        }
-                                    } catch (Exception e) {
-                                        log.warn("[Huifu] 解析file_details失败", e);
-                                    }
-                                }
-                                if (fileList != null && !"null".equals(String.valueOf(fileList)) && !String.valueOf(fileList).isEmpty()) {
-                                    apiResult.put("file_list", fileList);
-                                    hasData = true;
-                                    log.info("[Huifu] 获取到file_list, billType={}, fileDate={}", billType, fileDate);
-                                }
-                                if (taskDetails != null && !"null".equals(String.valueOf(taskDetails)) && !String.valueOf(taskDetails).isEmpty()) {
-                                    apiResult.put("task_details", taskDetails);
-                                    hasData = true;
-                                    log.info("[Huifu] 获取到task_details, billType={}, fileDate={}", billType, fileDate);
-                                }
-                                if (billList != null && !"null".equals(String.valueOf(billList)) && !String.valueOf(billList).isEmpty()) {
-                                    apiResult.put("bill_list", billList);
-                                    hasData = true;
-                                    log.info("[Huifu] 获取到bill_list, billType={}, fileDate={}", billType, fileDate);
-                                }
-                                if (downloadUrl != null && !"null".equals(String.valueOf(downloadUrl)) && !String.valueOf(downloadUrl).isEmpty()) {
-                                    apiResult.put("download_url", downloadUrl);
-                                    hasData = true;
-                                    log.info("[Huifu] 获取到download_url, billType={}, fileDate={}", billType, fileDate);
-                                }
-                                if (fileName != null && !"null".equals(String.valueOf(fileName)) && !String.valueOf(fileName).isEmpty()) {
-                                    apiResult.put("file_name", fileName);
-                                    hasData = true;
-                                    log.info("[Huifu] 获取到file_name, billType={}, fileDate={}", billType, fileDate);
-                                }
-                                
-                                if (!hasData) {
-                                    log.info("[Huifu] 对账单查询成功但无文件数据, billType={}, fileDate={}, huifuId={}", billType, fileDate, huifuId);
-                                }
-                            }
-                            apiResults.add(apiResult);
-                        } catch (Exception e) {
-                            log.warn("[Huifu] 对账单查询接口调用失败, billType={}, fileDate={}, error={}", billType, fileDate, e.getMessage());
-                            Map<String, Object> apiResult = new java.util.HashMap<>();
-                            apiResult.put("api", "V2TradeCheckFilequeryRequest");
-                            apiResult.put("bill_type", billType);
-                            apiResult.put("file_date", fileDate);
-                            apiResult.put("huifu_id", huifuId);
-                            apiResult.put("error", e.getMessage());
-                            apiResults.add(apiResult);
-                        }
-                    }
-                }
-            }
-
-            allResults.put("api_results", apiResults);
-            allResults.put("trade_list", tradeList);
-            allResults.put("total_count", tradeList.size());
-
-            log.info("[Huifu] 查询完成, 共获取到 {} 条交易记录", tradeList.size());
-
-            return allResults;
-        }).subscribeOn(Schedulers.boundedElastic());
-    }
-
-    @Override
-    public Mono<Map<String, Object>> queryHuifuTradeByOrderId(Long memberId, String outOrdId, String hfSeqId) {
-        log.info("[Huifu] 查询单笔交易记录, memberId={}, outOrdId={}, hfSeqId={}", memberId, outOrdId, hfSeqId);
-
-        return Mono.fromCallable(() -> {
-            Map<String, Object> result = new java.util.HashMap<>();
-            result.put("out_ord_id", outOrdId);
-            result.put("hf_seq_id", hfSeqId);
-
-            try {
-                Map<String, Object> response = null;
-                String usedHuifuId = null;
-                String respCode = null;
-                String usedApi = null;
-
-                java.util.List<String> huifuIds = new java.util.ArrayList<>();
-                String merchantId = null;
-                String channelId = null;
-                if (huifuProperties.getMerchant() != null && huifuProperties.getMerchant().getHuifuId() != null) {
-                    merchantId = huifuProperties.getMerchant().getHuifuId();
-                    huifuIds.add(merchantId);
-                }
-                if (huifuProperties.getChannel() != null && huifuProperties.getChannel().getHuifuId() != null) {
-                    channelId = huifuProperties.getChannel().getHuifuId();
-                    if (!huifuIds.contains(channelId)) {
-                        huifuIds.add(channelId);
-                    }
-                }
-
-                log.info("[Huifu] 查询ID列表: merchantId={}, channelId={}, huifuIds={}", merchantId, channelId, huifuIds);
-
-                for (String huifuId : huifuIds) {
-                    if (hfSeqId != null && !hfSeqId.isEmpty()) {
-                        response = executeV2QueryByHfSeqId(huifuId, hfSeqId);
-                        respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                        usedApi = "V2TradePaymentScanpayQuery(hfSeqId)";
-                        log.info("[Huifu] V2接口按汇付流水号查询: huifuId={}, hfSeqId={}, resp_code={}", huifuId, hfSeqId, respCode);
-
-                        if ("00000000".equals(respCode)) {
-                            usedHuifuId = huifuId;
-                            break;
-                        }
-                    }
-
-                    response = executeV2QueryByOrgReqSeqId(huifuId, outOrdId);
-                    respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                    usedApi = "V2TradePaymentScanpayQuery(orgReqSeqId)";
-                    log.info("[Huifu] V2接口按商户订单号查询: huifuId={}, orgReqSeqId={}, resp_code={}", huifuId, outOrdId, respCode);
-
-                    if ("00000000".equals(respCode)) {
-                        usedHuifuId = huifuId;
-                        break;
-                    }
-
-                    response = executeV4SingleQuery(huifuId, outOrdId);
-                    respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                    usedApi = "V4TradePaymentScanpayQuery";
-                    log.info("[Huifu] V4接口查询: huifuId={}, resp_code={}", huifuId, respCode);
-
-                    if ("00000000".equals(respCode)) {
-                        usedHuifuId = huifuId;
-                        break;
-                    }
-
-                    response = executeV2SingleQuery(huifuId, outOrdId);
-                    respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                    usedApi = "V2TradePaymentScanpayQuery(outOrdId)";
-                    log.info("[Huifu] V2接口查询: huifuId={}, resp_code={}", huifuId, respCode);
-
-                    if ("00000000".equals(respCode)) {
-                        usedHuifuId = huifuId;
-                        break;
-                    }
-                }
-
-                String respDesc = String.valueOf(response.getOrDefault("resp_desc", ""));
-
-                result.put("huifu_id", usedHuifuId);
-                result.put("resp_code", respCode);
-                result.put("resp_desc", respDesc);
-                result.put("trade_info", response);
-                result.put("api", usedApi);
-                result.put("success", "00000000".equals(respCode));
-
-            } catch (Exception e) {
-                log.error("[Huifu] 单笔交易查询失败", e);
-                result.put("success", false);
-                result.put("error", e.getMessage());
-            }
-
-            return result;
-        }).subscribeOn(Schedulers.boundedElastic());
-    }
-    
-    private Map<String, Object> executeV2QueryByOrgReqSeqId(String huifuId, String orgReqSeqId) throws Exception {
-        String today = DateTools.getCurrentDateYYYYMMDD();
-        
-        V2TradePaymentScanpayQueryRequest request = new V2TradePaymentScanpayQueryRequest();
-        request.setHuifuId(huifuId);
-        request.setOrgReqSeqId(orgReqSeqId);
-        request.setOrgReqDate(today);
-        log.info("[Huifu] V2按商户订单号查询: huifuId={}, orgReqSeqId={}, orgReqDate={}", huifuId, orgReqSeqId, today);
-        
-        Map<String, Object> response = BasePayClient.request(request, false);
-        String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-        if ("00000000".equals(respCode)) {
-            return response;
-        }
-        
-        String yesterday = java.time.LocalDate.now().minusDays(1).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-        request.setOrgReqDate(yesterday);
-        response = BasePayClient.request(request, false);
-        respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-        if ("00000000".equals(respCode)) {
-            return response;
-        }
-        
-        String dayBeforeYesterday = java.time.LocalDate.now().minusDays(2).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-        request.setOrgReqDate(dayBeforeYesterday);
-        return BasePayClient.request(request, false);
-    }
-
-    private Map<String, Object> executeV2QueryByHfSeqId(String huifuId, String hfSeqId) throws Exception {
-        V2TradePaymentScanpayQueryRequest request = new V2TradePaymentScanpayQueryRequest();
-        request.setHuifuId(huifuId);
-        request.setOrgHfSeqId(hfSeqId);
-        request.setOrgReqDate(DateTools.getCurrentDateYYYYMMDD());
-        Map<String, Object> response = BasePayClient.request(request, false);
-        String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-        if ("00000000".equals(respCode)) {
-            return response;
-        }
-        
-        String yesterday = java.time.LocalDate.now().minusDays(1).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-        request.setOrgReqDate(yesterday);
-        response = BasePayClient.request(request, false);
-        respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-        if ("00000000".equals(respCode)) {
-            return response;
-        }
-        
-        String dayBeforeYesterday = java.time.LocalDate.now().minusDays(2).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-        request.setOrgReqDate(dayBeforeYesterday);
-        return BasePayClient.request(request, false);
-    }
-
-    private Map<String, Object> executeV4SingleQuery(String huifuId, String outOrdId) throws Exception {
-        String huifuOrderNo = stripPayPrefix(outOrdId);
-        CommonPayClient client = Factory.Payment.Common();
-        TradePaymentScanpayQueryRequest request = new TradePaymentScanpayQueryRequest();
-        request.setReqDate(DateTools.getCurrentDateYYYYMMDD());
-        request.setReqSeqId(com.huifu.dg.lightning.utils.SequenceTools.getReqSeqId32());
-        request.setHuifuId(huifuId);
-        request.setOutOrdId(huifuOrderNo);
-        log.info("[Huifu] V4查询: outOrdId={} -> huifuOrderNo={}", outOrdId, huifuOrderNo);
-        return client.query(request);
-    }
-
-    private Map<String, Object> executeV2SingleQuery(String huifuId, String outOrdId) throws Exception {
-        String huifuOrderNo = stripPayPrefix(outOrdId);
-        String today = DateTools.getCurrentDateYYYYMMDD();
-        
-        V2TradePaymentScanpayQueryRequest request = new V2TradePaymentScanpayQueryRequest();
-        request.setHuifuId(huifuId);
-        request.setOutOrdId(huifuOrderNo);
-        request.setOrgReqSeqId(huifuOrderNo);
-        request.setOrgReqDate(today);
-        log.info("[Huifu] V2查询参数: huifuId={}, outOrdId={} -> huifuOrderNo={}, orgReqDate={}", huifuId, outOrdId, huifuOrderNo, today);
-        
-        Map<String, Object> response = BasePayClient.request(request, false);
-        String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-        if ("00000000".equals(respCode)) {
-            return response;
-        }
-        
-        String yesterday = java.time.LocalDate.now().minusDays(1).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-        request.setOrgReqDate(yesterday);
-        response = BasePayClient.request(request, false);
-        respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-        if ("00000000".equals(respCode)) {
-            return response;
-        }
-        
-        String dayBeforeYesterday = java.time.LocalDate.now().minusDays(2).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-        request.setOrgReqDate(dayBeforeYesterday);
-        return BasePayClient.request(request, false);
-    }
-    
-    private String extractDateFromOrderId(String orderId) {
-        if (orderId == null || orderId.length() < 12) {
-            return DateTools.getCurrentDateYYYYMMDD();
-        }
-        String datePart = orderId.substring(3, 11);
-        if (datePart.matches("\\d{8}")) {
-            return datePart;
-        }
-        return DateTools.getCurrentDateYYYYMMDD();
-    }
-
-    private String extractPayInfo(Map<String, Object> response) {
-        String qrCode = String.valueOf(response.getOrDefault("qr_code", ""));
-        String payInfo = String.valueOf(response.getOrDefault("pay_info", ""));
-        String methodExpand = String.valueOf(response.getOrDefault("method_expand", ""));
-
-        if (qrCode != null && !qrCode.isEmpty() && !"null".equals(qrCode)) {
-            return qrCode;
-        }
-        if (payInfo != null && !payInfo.isEmpty() && !"null".equals(payInfo)) {
-            return payInfo;
-        }
-        if (methodExpand != null && !methodExpand.isEmpty() && !"null".equals(methodExpand)) {
-            try {
-                Map<String, Object> expand = JSON.parseObject(methodExpand, Map.class);
-                if (expand.containsKey("code_url")) {
-                    return String.valueOf(expand.get("code_url"));
-                } else if (expand.containsKey("qr_code")) {
-                    return String.valueOf(expand.get("qr_code"));
-                }
-            } catch (Exception e) {
-                log.warn("[Huifu] 解析method_expand失败, methodExpand={}", methodExpand);
-            }
-        }
-        return "";
-    }
-
-    private PaymentResponse convertToResponse(PaymentOrder order) {
-        return PaymentResponse.builder()
-                .orderId(order.getOrderNo())
-                .status(order.getPayStatus())
-                .payUrl(order.getPayUrl())
-                .qrCode(order.getQrCode())
-                .payInfo(order.getPayInfo())
-                .h5PayUrl(order.getPayUrl())
-                .errorCode(order.getErrorCode())
-                .errorMsg(order.getErrorMsg())
-                .transAmt(order.getTransAmt() != null ? order.getTransAmt().toString() : "0")
-                .goodsDesc(order.getGoodsDesc())
-                .tradeType(order.getTradeType())
-                .payTime(order.getPayTime() != null ?
-                        order.getPayTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) : null)
-                .hfSeqId(order.getHfSeqId())
-                .partyOrderId(order.getPartyOrderId())
-                .merchantOrderId(order.getReqSeqId())
-                .build();
-    }
-
-    private String formatAmount(String transAmt) {
-        if (transAmt == null || transAmt.isEmpty()) {
-            throw new IllegalArgumentException("交易金额不能为空");
-        }
-        BigDecimal amount = new BigDecimal(transAmt);
-        return amount.divide(new BigDecimal("100"), 2, BigDecimal.ROUND_HALF_UP).toString();
-    }
-
-    private String truncate(String str, int maxLength) {
-        if (str == null) {
-            return null;
-        }
-        if (str.length() <= maxLength) {
-            return str;
-        }
-        return str.substring(0, maxLength);
-    }
-
-    private String generateOrderNo() {
-        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
-        String uuid = UUID.randomUUID().toString().replace("-", "").substring(0, 8);
-        return "PAY" + timestamp + uuid;
-    }
-    
-    private String stripPayPrefix(String orderNo) {
-        if (orderNo != null && orderNo.startsWith("PAY")) {
-            return orderNo.substring(3);
-        }
-        return orderNo;
-    }
-
-    private Mono<Boolean> isTradeProcessed(String reqSeqId) {
-        return redisUtil.hasKey(PROCESSED_TRADE_PREFIX + reqSeqId)
-                .onErrorResume(e -> {
-                    log.error("[Huifu] 检查交易处理状态异常: reqSeqId={}", reqSeqId, e);
-                    return Mono.just(false);
-                });
-    }
-
-    private Mono<Void> markTradeProcessed(String reqSeqId) {
-        return redisUtil.setWithExpire(PROCESSED_TRADE_PREFIX + reqSeqId, "1", IDEMPOTENT_EXPIRE_SECONDS)
-                .onErrorResume(e -> {
-                    log.error("[Huifu] 标记交易处理状态异常: reqSeqId={}", reqSeqId, e);
-                    return Mono.empty();
-                })
-                .then();
-    }
-
-    private Mono<PaymentResponse> createMockOrder(Long memberId, CreatePaymentRequest request, String tradeType) {
-        String orderNo = generateOrderNo();
-        String reqSeqId = SequenceTools.getReqSeqId32();
-        String reqDate = DateTools.getCurrentDateYYYYMMDD();
-
-        PaymentOrder paymentOrder = PaymentOrder.builder()
-                .orderNo(orderNo)
-                .memberId(memberId)
-                .orderType(request.getOrderType())
-                .goodsDesc(request.getGoodsDesc())
-                .transAmt(new BigDecimal(request.getTransAmt()).divide(new BigDecimal("100"), 2, BigDecimal.ROUND_HALF_UP))
-                .tradeType(tradeType)
-                .payStatus("PENDING")
-                .huifuId(huifuProperties.getMerchant() != null ? huifuProperties.getMerchant().getHuifuId() : "MOCK")
-                .reqSeqId(reqSeqId)
-                .reqDate(reqDate)
-                .remark(request.getRemark())
-                .notifyUrl(huifuProperties.getNotify() != null ? huifuProperties.getNotify().getUrl() : "")
-                .expireTime(LocalDateTime.now().plusMinutes(ORDER_EXPIRE_MINUTES))
-                .build();
-
-        String mockPayInfo = "alipays://platformapi/startapp?appId=2021000122672222&page=pages/pay/pay&orderNo=" + orderNo;
-        paymentOrder.setPayInfo(mockPayInfo);
-        paymentOrder.setPayUrl(mockPayInfo);
-        paymentOrder.setQrCode("https://qr.alipay.com/bax0" + orderNo);
-
-        return paymentOrderRepository.save(paymentOrder)
-                .map(savedOrder -> {
-                    log.info("[Huifu] 模拟订单创建成功, orderNo={}", orderNo);
-                    return convertToResponse(savedOrder);
-                });
-    }
-
-    @Override
-    public Mono<PaymentResponse> getPendingOrder(Long memberId, String orderType) {
-        log.info("[Huifu] 查询未支付订单, memberId={}, orderType={}", memberId, orderType);
-        return paymentOrderRepository.findLatestPendingOrder(memberId, orderType)
-                .map(this::convertToResponse);
-    }
-
-    @Override
-    public Mono<Boolean> closeOrder(Long memberId, String orderId) {
-        log.info("[Huifu] 关闭订单, memberId={}, orderId={}", memberId, orderId);
-        return paymentOrderRepository.findByOrderNo(orderId)
-                .flatMap(order -> {
-                    if (!memberId.equals(order.getMemberId())) {
-                        log.warn("[Huifu] 订单不属于当前会员, memberId={}, orderMemberId={}", memberId, order.getMemberId());
-                        return Mono.just(false);
-                    }
-                    if (!"PENDING".equals(order.getPayStatus())) {
-                        log.warn("[Huifu] 订单状态不是待支付，无法关闭, orderId={}, status={}", orderId, order.getPayStatus());
-                        return Mono.just(false);
-                    }
-                    return paymentOrderRepository.closeExpiredOrder(order.getId())
-                            .map(rows -> rows != null && rows > 0);
-                })
-                .switchIfEmpty(Mono.just(false));
-    }
-}

gym-manage-api/gym-payment/src/test/java/ListAllQueryApis.java

@@ -1,77 +0,0 @@
-import com.huifu.bspay.sdk.opps.core.request.*;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.List;
-
-public class ListAllQueryApis {
-    public static void main(String[] args) {
-        System.out.println("=== 查找所有查询相关的请求类及字段 ===\n");
-        
-        List<Class<?>> queryClasses = new ArrayList<>();
-        
-        try {
-            Package pkg = V2TradePaymentScanpayQueryRequest.class.getPackage();
-            String pkgName = pkg.getName();
-            System.out.println("Package: " + pkgName);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        
-        Class<?>[] classes = {
-            V2TradePaymentScanpayQueryRequest.class,
-            V2TradeCheckFilequeryRequest.class,
-            V2TradeTransstatQueryRequest.class,
-            V2TradeSettleCollectionDetailQueryRequest.class,
-            V2TradeBatchtranslogQueryRequest.class,
-        };
-        
-        for (Class<?> clazz : classes) {
-            System.out.println("\n=== " + clazz.getSimpleName() + " ===");
-            System.out.println("functionCode: " + getFunctionCode(clazz));
-            System.out.println("所有setter方法:");
-            listSetters(clazz);
-        }
-    }
-    
-    private static String getFunctionCode(Class<?> clazz) {
-        try {
-            Object instance = clazz.getDeclaredConstructor().newInstance();
-            Field functionCodeField = clazz.getSuperclass().getDeclaredField("functionCode");
-            functionCodeField.setAccessible(true);
-            return String.valueOf(functionCodeField.get(instance));
-        } catch (Exception e) {
-            try {
-                Field functionCodeField = clazz.getDeclaredField("functionCode");
-                functionCodeField.setAccessible(true);
-                Object instance = clazz.getDeclaredConstructor().newInstance();
-                return String.valueOf(functionCodeField.get(instance));
-            } catch (Exception e2) {
-                return "unknown";
-            }
-        }
-    }
-    
-    private static void listSetters(Class<?> clazz) {
-        Method[] methods = clazz.getMethods();
-        List<String> setters = new ArrayList<>();
-        for (Method m : methods) {
-            if (m.getName().startsWith("set") && !m.getName().equals("setClass")) {
-                StringBuilder sb = new StringBuilder("  ");
-                sb.append(m.getName());
-                sb.append("(");
-                Class<?>[] params = m.getParameterTypes();
-                for (int i = 0; i < params.length; i++) {
-                    if (i > 0) sb.append(", ");
-                    sb.append(params[i].getSimpleName());
-                }
-                sb.append(")");
-                setters.add(sb.toString());
-            }
-        }
-        java.util.Collections.sort(setters);
-        for (String s : setters) {
-            System.out.println(s);
-        }
-    }
-}

gym-manage-api/gym-payment/src/test/java/TestBatchtranslogQuery.java

@@ -1,71 +0,0 @@
-import com.huifu.bspay.sdk.opps.client.BasePayClient;
-import com.huifu.bspay.sdk.opps.core.request.V2TradeBatchtranslogQueryRequest;
-import com.huifu.bspay.sdk.opps.core.utils.DateTools;
-import com.huifu.bspay.sdk.opps.core.utils.SequenceTools;
-import com.alibaba.fastjson.JSON;
-import java.util.Map;
-import java.util.Set;
-
-public class TestBatchtranslogQuery {
-    public static void main(String[] args) {
-        try {
-            String privateKey = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCcxAwrhZF+izz1gxQKOr4jnC05obIBHbl0DzHOcd4CaaDV7Kv1NRJKi33JhdDsW4JGgu16e5Rtzq1VzU5VWz5EKgGL46maOFwCkngJUTP/LC3JVf/wtJmYCm8xNE8C7GNNIqKzYEvUOEfXqagpVvVrGsQ9FpzFp2rP9hBmHY3yizVyPX/uT9S+af5TRxiaItj3SSJGgloaEMrnKOpb/EH7JwPSS0liAyT/NxPfOyyZHc22AvaAIOE5y+0PMUCKPuIdfpOrej3LVpO1Arc2hSgmdB+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=";
-            String huifuPublicKey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuqolFneAH66z3/3gaIYIaRZOIk/UYzdsXIm0RyawYBYAOu/NJ7ul8CRIrRlt5vd98HodW2yPrXA4+VHF3AS9UE4WTDpo9qV5brhqQSr/lAuZtEwMZwUWwgdnGFMkUFd9RvyGXAqY0bsQrcQgQ6zGjZHzlMljogDR3iblG0ak5ssD2TSC2W+1cxu+id+FP6onZXlXizuClTyIRh17m7CbS6rl0P3M96MlTdCzTeBw/Y54CiegBJI2wOrm2Qa6Dg6KRc+YkaJWjuRJVJkwjk8JhSyALno9oEzuDKaAXlsQlxeIhmAy4esRrZGrMV8SG0gwUZIP8lduPjQE95lCqqJ0gQIDAQAB";
-            String sysId = "6666000207581039";
-            String productId = "XLSISV";
-            String huifuId = "6666000207581039";
-            String skillSource = "hfps/1.3.0";
-
-            com.huifu.bspay.sdk.opps.core.config.MerConfig merConfig = new com.huifu.bspay.sdk.opps.core.config.MerConfig();
-            merConfig.setSysId(sysId);
-            merConfig.setProductId(productId);
-            merConfig.setRsaPrivateKey(privateKey);
-            merConfig.setRsaPublicKey(huifuPublicKey);
-            merConfig.setSkillSource(skillSource);
-
-            com.huifu.bspay.sdk.opps.core.BasePay.prodMode = com.huifu.bspay.sdk.opps.core.BasePay.MODE_PROD;
-            com.huifu.bspay.sdk.opps.core.BasePay.initWithMerConfig(merConfig);
-
-            System.out.println("========== V2TradeBatchtranslogQuery 批量交易日志查询测试 ==========");
-            System.out.println();
-
-            String today = DateTools.getCurrentDateYYYYMMDD();
-            String weekAgo = java.time.LocalDate.now().minusDays(7).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-
-            try {
-                V2TradeBatchtranslogQueryRequest request = new V2TradeBatchtranslogQueryRequest();
-                request.setHuifuId(huifuId);
-                request.setBeginDate(weekAgo);
-                request.setEndDate(today);
-
-                System.out.println("请求参数: " + JSON.toJSONString(request));
-                System.out.println();
-
-                Map<String, Object> response = BasePayClient.request(request, false);
-
-                System.out.println("响应: " + JSON.toJSONString(response, true));
-                System.out.println();
-
-                String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                System.out.println("resp_code: " + respCode);
-                System.out.println("resp_desc: " + response.getOrDefault("resp_desc", ""));
-
-                System.out.println();
-                System.out.println("所有字段:");
-                Set<String> keys = response.keySet();
-                for (String key : keys) {
-                    System.out.println("  " + key);
-                }
-            } catch (Exception e) {
-                System.out.println("调用失败: " + e.getMessage());
-                e.printStackTrace();
-            }
-
-            System.out.println();
-            System.out.println("========== 测试结束 ==========");
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-}

gym-manage-api/gym-payment/src/test/java/TestBatchtranslogQuery2.java

@@ -1,87 +0,0 @@
-import com.huifu.bspay.sdk.opps.client.BasePayClient;
-import com.huifu.bspay.sdk.opps.core.request.V2TradeBatchtranslogQueryRequest;
-import com.huifu.bspay.sdk.opps.core.utils.DateTools;
-import com.huifu.bspay.sdk.opps.core.utils.SequenceTools;
-import com.alibaba.fastjson.JSON;
-import java.util.Map;
-import java.util.Set;
-
-public class TestBatchtranslogQuery2 {
-    public static void main(String[] args) {
-        try {
-            String privateKey = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCcxAwrhZF+izz1gxQKOr4jnC05obIBHbl0DzHOcd4CaaDV7Kv1NRJKi33JhdDsW4JGgu16e5Rtzq1VzU5VWz5EKgGL46maOFwCkngJUTP/LC3JVf/wtJmYCm8xNE8C7GNNIqKzYEvUOEfXqagpVvVrGsQ9FpzFp2rP9hBmHY3yizVyPX/uT9S+af5TRxiaItj3SSJGgloaEMrnKOpb/EH7JwPSS0liAyT/NxPfOyyZHc22AvaAIOE5y+0PMUCKPuIdfpOrej3LVpO1Arc2hSgmdB+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=";
-            String huifuPublicKey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuqolFneAH66z3/3gaIYIaRZOIk/UYzdsXIm0RyawYBYAOu/NJ7ul8CRIrRlt5vd98HodW2yPrXA4+VHF3AS9UE4WTDpo9qV5brhqQSr/lAuZtEwMZwUWwgdnGFMkUFd9RvyGXAqY0bsQrcQgQ6zGjZHzlMljogDR3iblG0ak5ssD2TSC2W+1cxu+id+FP6onZXlXizuClTyIRh17m7CbS6rl0P3M96MlTdCzTeBw/Y54CiegBJI2wOrm2Qa6Dg6KRc+YkaJWjuRJVJkwjk8JhSyALno9oEzuDKaAXlsQlxeIhmAy4esRrZGrMV8SG0gwUZIP8lduPjQE95lCqqJ0gQIDAQAB";
-            String sysId = "6666000207581039";
-            String productId = "XLSISV";
-            String huifuId = "6666000207581039";
-            String skillSource = "hfps/1.3.0";
-
-            com.huifu.bspay.sdk.opps.core.config.MerConfig merConfig = new com.huifu.bspay.sdk.opps.core.config.MerConfig();
-            merConfig.setSysId(sysId);
-            merConfig.setProductId(productId);
-            merConfig.setRsaPrivateKey(privateKey);
-            merConfig.setRsaPublicKey(huifuPublicKey);
-            merConfig.setSkillSource(skillSource);
-
-            com.huifu.bspay.sdk.opps.core.BasePay.prodMode = com.huifu.bspay.sdk.opps.core.BasePay.MODE_PROD;
-            com.huifu.bspay.sdk.opps.core.BasePay.initWithMerConfig(merConfig);
-
-            System.out.println("========== V2TradeBatchtranslogQuery 批量交易日志查询测试 ==========");
-            System.out.println();
-
-            String today = DateTools.getCurrentDateYYYYMMDD();
-            String daysAgo30 = java.time.LocalDate.now().minusDays(30).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-            String daysAgo7 = java.time.LocalDate.now().minusDays(7).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-            String daysAgo5 = java.time.LocalDate.now().minusDays(5).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-
-            System.out.println("测试1: 近30天");
-            testQuery(huifuId, daysAgo30, today);
-
-            System.out.println();
-            System.out.println("测试2: 近7天");
-            testQuery(huifuId, daysAgo7, today);
-
-            System.out.println();
-            System.out.println("测试3: 近5天");
-            testQuery(huifuId, daysAgo5, today);
-
-            System.out.println();
-            System.out.println("========== 测试结束 ==========");
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    private static void testQuery(String huifuId, String beginDate, String endDate) {
-        try {
-            V2TradeBatchtranslogQueryRequest request = new V2TradeBatchtranslogQueryRequest();
-            request.setHuifuId(huifuId);
-            request.setBeginDate(beginDate);
-            request.setEndDate(endDate);
-
-            System.out.println("  beginDate=" + beginDate + ", endDate=" + endDate);
-
-            Map<String, Object> response = BasePayClient.request(request, false);
-
-            String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-            String respDesc = String.valueOf(response.getOrDefault("resp_desc", ""));
-
-            System.out.println("  resp_code: " + respCode);
-            System.out.println("  resp_desc: " + respDesc);
-            System.out.println("  result_count: " + response.get("result_count"));
-            System.out.println("  page_num: " + response.get("page_num"));
-            System.out.println("  page_size: " + response.get("page_size"));
-
-            if ("00000000".equals(respCode)) {
-                System.out.println("  *** 查询成功！ ***");
-                Object transList = response.get("trans_log_result_list");
-                if (transList != null) {
-                    System.out.println("  交易列表: " + JSON.toJSONString(transList, true));
-                }
-            }
-        } catch (Exception e) {
-            System.out.println("  调用失败: " + e.getMessage());
-        }
-    }
-}

gym-manage-api/gym-payment/src/test/java/TestBatchtranslogQuery3.java

@@ -1,78 +0,0 @@
-import com.huifu.bspay.sdk.opps.client.BasePayClient;
-import com.huifu.bspay.sdk.opps.core.request.V2TradeBatchtranslogQueryRequest;
-import com.huifu.bspay.sdk.opps.core.utils.DateTools;
-import com.alibaba.fastjson.JSON;
-import java.util.Map;
-
-public class TestBatchtranslogQuery3 {
-    public static void main(String[] args) {
-        try {
-            String privateKey = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCcxAwrhZF+izz1gxQKOr4jnC05obIBHbl0DzHOcd4CaaDV7Kv1NRJKi33JhdDsW4JGgu16e5Rtzq1VzU5VWz5EKgGL46maOFwCkngJUTP/LC3JVf/wtJmYCm8xNE8C7GNNIqKzYEvUOEfXqagpVvVrGsQ9FpzFp2rP9hBmHY3yizVyPX/uT9S+af5TRxiaItj3SSJGgloaEMrnKOpb/EH7JwPSS0liAyT/NxPfOyyZHc22AvaAIOE5y+0PMUCKPuIdfpOrej3LVpO1Arc2hSgmdB+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=";
-            String huifuPublicKey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuqolFneAH66z3/3gaIYIaRZOIk/UYzdsXIm0RyawYBYAOu/NJ7ul8CRIrRlt5vd98HodW2yPrXA4+VHF3AS9UE4WTDpo9qV5brhqQSr/lAuZtEwMZwUWwgdnGFMkUFd9RvyGXAqY0bsQrcQgQ6zGjZHzlMljogDR3iblG0ak5ssD2TSC2W+1cxu+id+FP6onZXlXizuClTyIRh17m7CbS6rl0P3M96MlTdCzTeBw/Y54CiegBJI2wOrm2Qa6Dg6KRc+YkaJWjuRJVJkwjk8JhSyALno9oEzuDKaAXlsQlxeIhmAy4esRrZGrMV8SG0gwUZIP8lduPjQE95lCqqJ0gQIDAQAB";
-            String sysId = "6666000207581039";
-            String productId = "XLSISV";
-            String huifuId = "6666000207581039";
-            String skillSource = "hfps/1.3.0";
-
-            com.huifu.bspay.sdk.opps.core.config.MerConfig merConfig = new com.huifu.bspay.sdk.opps.core.config.MerConfig();
-            merConfig.setSysId(sysId);
-            merConfig.setProductId(productId);
-            merConfig.setRsaPrivateKey(privateKey);
-            merConfig.setRsaPublicKey(huifuPublicKey);
-            merConfig.setSkillSource(skillSource);
-
-            com.huifu.bspay.sdk.opps.core.BasePay.prodMode = com.huifu.bspay.sdk.opps.core.BasePay.MODE_PROD;
-            com.huifu.bspay.sdk.opps.core.BasePay.initWithMerConfig(merConfig);
-
-            System.out.println("========== V2TradeBatchtranslogQuery 测试 ==========");
-            System.out.println();
-
-            String today = DateTools.getCurrentDateYYYYMMDD();
-            String daysAgo90 = java.time.LocalDate.now().minusDays(90).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-            String daysAgo30 = java.time.LocalDate.now().minusDays(30).format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd"));
-
-            System.out.println("测试1: 近90天 (跨度90天)");
-            testQuery(huifuId, daysAgo90, today);
-
-            System.out.println();
-            System.out.println("测试2: 近30天 (跨度30天)");
-            testQuery(huifuId, daysAgo30, today);
-
-            System.out.println();
-            System.out.println("========== 测试结束 ==========");
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    private static void testQuery(String huifuId, String beginDate, String endDate) {
-        try {
-            V2TradeBatchtranslogQueryRequest request = new V2TradeBatchtranslogQueryRequest();
-            request.setHuifuId(huifuId);
-            request.setBeginDate(beginDate);
-            request.setEndDate(endDate);
-
-            System.out.println("  beginDate=" + beginDate + ", endDate=" + endDate);
-
-            Map<String, Object> response = BasePayClient.request(request, false);
-
-            String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-            String respDesc = String.valueOf(response.getOrDefault("resp_desc", ""));
-
-            System.out.println("  resp_code: " + respCode);
-            System.out.println("  resp_desc: " + respDesc);
-            System.out.println("  result_count: " + response.get("result_count"));
-
-            if ("00000000".equals(respCode)) {
-                System.out.println("  *** 查询成功！ ***");
-                Object transList = response.get("trans_log_result_list");
-                if (transList != null) {
-                    System.out.println("  交易列表: " + JSON.toJSONString(transList, true));
-                }
-            }
-        } catch (Exception e) {
-            System.out.println("  调用失败: " + e.getMessage());
-        }
-    }
-}

gym-manage-api/gym-payment/src/test/java/TestChannelQuery.java

@@ -1,123 +0,0 @@
-import com.huifu.bspay.sdk.opps.client.BasePayClient;
-import com.huifu.bspay.sdk.opps.core.request.V2TradeCheckFilequeryRequest;
-import com.huifu.bspay.sdk.opps.core.request.V2TradeBatchtranslogQueryRequest;
-import com.huifu.bspay.sdk.opps.core.request.V2TradeSettleCollectionDetailQueryRequest;
-import com.huifu.bspay.sdk.opps.core.utils.DateTools;
-import com.huifu.bspay.sdk.opps.core.utils.SequenceTools;
-import com.alibaba.fastjson.JSON;
-import java.util.Map;
-import java.util.HashMap;
-
-public class TestChannelQuery {
-    public static void main(String[] args) {
-        try {
-            String privateKey = "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCNUdQE59I4bV1dIgLs2IRN3Wl8KI2yS4KpTUQWrvvlUcBTztB8rIeN5lr6Yv4VsZ1TG0FAb0D80JjxEQ1+0HizYNOQ1h2935v2r8h7rx3VTLbMOkmsg8Lb8LQRTbPaJOZfsIZMzBytYiRzWunHaMlCr800EA3q5NMj9VjHQuamxKqyzyHqfkIjA/sZ8q9atVjn8ahUjPKdrGA8b79HexHhCgOSLdK+fWw0eMCsWWYP2qECLsvZ+tjfvqSBXx1kg7womwT1VBCf+0Dx+jJPKR3mxQfz2szoucJYuXRo55kA6yCwoeNsjanLDRkPBSy3NHdKrffP6YODhRHG6KHyayyNAgMBAAECggEATIR69TEETVNCEzRgOxe9A2AYRoa6ukhSdhMFA/c5IuCR747yqh7MwtNwfVRuWRazpZUDTr0uhfT4asad9QUx5YZO54RX1EAn9XkWZ4nY8G46J/iDfapWLrp09U2KTVpfdn5hKWH3QRX7wI4AON2O49HGnSL4NjAx9q1YpYOe2bqevxmB4uD9vR/FHMjZ2qWzPaL7pId98x4DCJCiZctBQqb7gxR8EseD1Ddn2HbH5DEUjoxz2umtL+zrcGKDFBy4kM3r+10FP5jFG4fJfZFQwrzMTEkXJriau9DMRTQ83rWHzNvhdTNUuyqah74ez5V1piVEOXCPudzFsMttD2DyzQKBgQDokQH3WtcQqwFTUo+uWVVup4NoQzNZpEGIHK17afRsf9YnkoJVqjhywq1dhQT+yuyW9geJJKWpHQIAS4gGudhNK+j6d//bbvvbkOmtsdWyZ6Z2EmY8JrPkHdHAcadNJX7vrIc1xPeyci4AHhErDHc3hhD5njuSLx3DUp4iODNxKwKBgQCbjyHvP90YGjh49DWklh2NJgR2+OR6Fd0afdmwtGKeCUP5l2To6rfLBbcSRIWCON4iLME5wLLdHcm5wAQukC4dsUB5iZffp21+7hrrwUw/G0MUzFudfhZkjsDU5i+FwnVMqmsLJPUsjJTOfKsJdA2DjnwfMcgxw9FeClGveSFNJwKBgQDCpjuDECDY7oeZeYyQXGzIxKOTbEtaR8Qha/83QCM3fHd9f35evK2qP45iq6bWqnkCkMEV4/pTZNf77zvWhU2oqYvBtxYKTwW1a8BphGJbg60rPZMb3TjLQLoB3B4uz6dCaqBwPH8kd7RQnNm5siFF84vZoLozTAQZKtj3wxorKQKBgQCGKnEONHqwaw0B5T7O8VoTfxKiug/07B6C1sCGk03rF/q0rkquSKK0S/2Vl9u+cOXFe+w7r2OVKjfuKRpyPpBHs7T0HiQLFhBuRVaat2DXnN/CdG8f6rvNhwHxnYanSwx4TxN7zShYf/doEEZEJP/y01ViYkFUCpvtC+FgAo0iSQKBgFrkJGxPo6T7i5ZF7VoZWdARnypfbOl4gF9GMrXykk0fnKBDTof9Bg34a8OX54cf4yEH1ifZzVtNyzPTH9FxV88TksWRouqi1Uo6///kJI6gXROspE91TpNtNGHPgLhebA83WlFtS/H7i5G6RO+6KO0uflSImfy3Owp/ChyFUGmn";
-            String huifuPublicKey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7PYy64gcO1Y44ntGFRdHzDJy6KnNoMLB6H5ZyCvqB2m2Bvzx18TMCjwevt5A4XF0ke9HfXRvZOL8TOaHdeiSbXWVBEpNsbQr0612U41cN688uHk4ShtoYuvSAbT0SuQULPh90BthzBrxrIuduex7qISk4d4mKvfM+tMTBQPWJc2au2yfTpisZPlKS5jg5xUCxG4UIze/xC4I92rVyVfziMm19Tzh1EXq4Hm1nXmRejgE2o2Hi/wu8Et6hj5UjZzPu3DPvzDN4AP372DP6EREYrVGYiD9qDqxx63jDqlGsdKmENXPp27gUqXX4vGD5xn0lOSXMHUQ5NUcXzdGbpWBBwIDAQAB";
-            String sysId = "6666000207573586";
-            String productId = "XLSISV";
-            String huifuId = "6666000207573586";
-            String skillSource = "hfps/1.3.0";
-
-            com.huifu.bspay.sdk.opps.core.config.MerConfig merConfig = new com.huifu.bspay.sdk.opps.core.config.MerConfig();
-            merConfig.setSysId(sysId);
-            merConfig.setProductId(productId);
-            merConfig.setRsaPrivateKey(privateKey);
-            merConfig.setRsaPublicKey(huifuPublicKey);
-            merConfig.setSkillSource(skillSource);
-
-            com.huifu.bspay.sdk.opps.core.BasePay.prodMode = com.huifu.bspay.sdk.opps.core.BasePay.MODE_PROD;
-            com.huifu.bspay.sdk.opps.core.BasePay.initWithMerConfig(merConfig);
-
-            System.out.println("========== 渠道商ID查询测试 ==========");
-            System.out.println("渠道商huifuId: " + huifuId);
-            System.out.println();
-
-            String[] dates = {"20260620", "20260621", "20260622", "20260623", "20260624", "20260625", "20260626"};
-            String[] billTypes = {"TRADE_BILL", "MERGE_BILL"};
-
-            System.out.println("========== 1. 对账文件查询 ==========");
-            for (String date : dates) {
-                for (String billType : billTypes) {
-                    try {
-                        V2TradeCheckFilequeryRequest request = new V2TradeCheckFilequeryRequest();
-                        request.setReqDate(DateTools.getCurrentDateYYYYMMDD());
-                        request.setReqSeqId(SequenceTools.getReqSeqId32());
-                        request.setHuifuId(huifuId);
-                        request.setFileDate(date);
-
-                        Map<String, Object> extendInfoMap = new HashMap<>();
-                        extendInfoMap.put("bill_type", billType);
-                        request.setExtendInfo(extendInfoMap);
-
-                        Map<String, Object> response = BasePayClient.request(request, false);
-
-                        String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                        String respDesc = String.valueOf(response.getOrDefault("resp_desc", ""));
-                        
-                        boolean hasData = response.containsKey("file_details") || response.containsKey("file_list") 
-                            || response.containsKey("download_url") || response.containsKey("bill_list");
-                        
-                        if (hasData || !"00000000".equals(respCode)) {
-                            System.out.println("date=" + date + ", billType=" + billType + ": resp_code=" + respCode + ", resp_desc=" + respDesc + ", hasData=" + hasData);
-                            if (hasData) {
-                                System.out.println("  完整响应: " + JSON.toJSONString(response, true));
-                            }
-                        }
-                    } catch (Exception e) {
-                        System.out.println("date=" + date + ", billType=" + billType + ": 失败 - " + e.getMessage());
-                    }
-                }
-            }
-
-            System.out.println();
-            System.out.println("========== 2. 批量交易日志查询 ==========");
-            try {
-                V2TradeBatchtranslogQueryRequest request = new V2TradeBatchtranslogQueryRequest();
-                request.setHuifuId(huifuId);
-                request.setBeginDate("20260620");
-                request.setEndDate("20260626");
-                
-                Map<String, Object> response = BasePayClient.request(request, false);
-                
-                String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                String respDesc = String.valueOf(response.getOrDefault("resp_desc", ""));
-                String resultCount = String.valueOf(response.getOrDefault("result_count", ""));
-                
-                System.out.println("resp_code=" + respCode + ", resp_desc=" + respDesc + ", result_count=" + resultCount);
-                System.out.println("完整响应: " + JSON.toJSONString(response, true));
-            } catch (Exception e) {
-                System.out.println("调用失败: " + e.getMessage());
-                e.printStackTrace();
-            }
-
-            System.out.println();
-            System.out.println("========== 3. 结算汇总明细查询 ==========");
-            try {
-                V2TradeSettleCollectionDetailQueryRequest request = new V2TradeSettleCollectionDetailQueryRequest();
-                request.setReqDate(DateTools.getCurrentDateYYYYMMDD());
-                request.setReqSeqId(SequenceTools.getReqSeqId32());
-                request.setBeginDate("20260620");
-                request.setEndDate("20260626");
-                request.setInHuifuId(huifuId);
-                
-                Map<String, Object> response = BasePayClient.request(request, false);
-                
-                String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                String respDesc = String.valueOf(response.getOrDefault("resp_desc", ""));
-                String totalCount = String.valueOf(response.getOrDefault("total_count", ""));
-                
-                System.out.println("resp_code=" + respCode + ", resp_desc=" + respDesc + ", total_count=" + totalCount);
-                System.out.println("完整响应: " + JSON.toJSONString(response, true));
-            } catch (Exception e) {
-                System.out.println("调用失败: " + e.getMessage());
-                e.printStackTrace();
-            }
-
-            System.out.println();
-            System.out.println("========== 测试结束 ==========");
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-}

gym-manage-api/gym-payment/src/test/java/TestCheckFileQuery.java

@@ -1,73 +0,0 @@
-import com.huifu.bspay.sdk.opps.client.BasePayClient;
-import com.huifu.bspay.sdk.opps.core.request.V2TradeCheckFilequeryRequest;
-import com.huifu.bspay.sdk.opps.core.utils.DateTools;
-import com.huifu.bspay.sdk.opps.core.utils.SequenceTools;
-import com.alibaba.fastjson.JSON;
-import java.util.Map;
-import java.util.HashMap;
-
-public class TestCheckFileQuery {
-    public static void main(String[] args) {
-        try {
-            String privateKey = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCcxAwrhZF+izz1gxQKOr4jnC05obIBHbl0DzHOcd4CaaDV7Kv1NRJKi33JhdDsW4JGgu16e5Rtzq1VzU5VWz5EKgGL46maOFwCkngJUTP/LC3JVf/wtJmYCm8xNE8C7GNNIqKzYEvUOEfXqagpVvVrGsQ9FpzFp2rP9hBmHY3yizVyPX/uT9S+af5TRxiaItj3SSJGgloaEMrnKOpb/EH7JwPSS0liAyT/NxPfOyyZHc22AvaAIOE5y+0PMUCKPuIdfpOrej3LVpO1Arc2hSgmdB+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=";
-            String huifuPublicKey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuqolFneAH66z3/3gaIYIaRZOIk/UYzdsXIm0RyawYBYAOu/NJ7ul8CRIrRlt5vd98HodW2yPrXA4+VHF3AS9UE4WTDpo9qV5brhqQSr/lAuZtEwMZwUWwgdnGFMkUFd9RvyGXAqY0bsQrcQgQ6zGjZHzlMljogDR3iblG0ak5ssD2TSC2W+1cxu+id+FP6onZXlXizuClTyIRh17m7CbS6rl0P3M96MlTdCzTeBw/Y54CiegBJI2wOrm2Qa6Dg6KRc+YkaJWjuRJVJkwjk8JhSyALno9oEzuDKaAXlsQlxeIhmAy4esRrZGrMV8SG0gwUZIP8lduPjQE95lCqqJ0gQIDAQAB";
-            String sysId = "6666000207581039";
-            String productId = "XLSISV";
-            String huifuId = "6666000207581039";
-            String skillSource = "hfps/1.3.0";
-
-            com.huifu.bspay.sdk.opps.core.config.MerConfig merConfig = new com.huifu.bspay.sdk.opps.core.config.MerConfig();
-            merConfig.setSysId(sysId);
-            merConfig.setProductId(productId);
-            merConfig.setRsaPrivateKey(privateKey);
-            merConfig.setRsaPublicKey(huifuPublicKey);
-            merConfig.setSkillSource(skillSource);
-
-            com.huifu.bspay.sdk.opps.core.BasePay.prodMode = com.huifu.bspay.sdk.opps.core.BasePay.MODE_PROD;
-            com.huifu.bspay.sdk.opps.core.BasePay.initWithMerConfig(merConfig);
-
-            System.out.println("========== 对账单查询测试 ==========");
-            System.out.println("商户号: " + huifuId);
-            System.out.println();
-
-            String[] billTypes = {"TRADE_BILL", "MERGE_BILL"};
-            String[] dates = {"20260624", "20260625", "20260626"};
-
-            for (String date : dates) {
-                for (String billType : billTypes) {
-                    try {
-                        System.out.println("--- 查询: date=" + date + ", billType=" + billType + " ---");
-                        
-                        V2TradeCheckFilequeryRequest request = new V2TradeCheckFilequeryRequest();
-                        request.setReqDate(DateTools.getCurrentDateYYYYMMDD());
-                        request.setReqSeqId(SequenceTools.getReqSeqId32());
-                        request.setHuifuId(huifuId);
-                        request.setFileDate(date);
-
-                        Map<String, Object> extendInfoMap = new HashMap<>();
-                        extendInfoMap.put("bill_type", billType);
-                        request.setExtendInfo(extendInfoMap);
-
-                        Map<String, Object> response = BasePayClient.request(request, false);
-
-                        String respCode = String.valueOf(response.getOrDefault("resp_code", ""));
-                        String respDesc = String.valueOf(response.getOrDefault("resp_desc", ""));
-
-                        System.out.println("响应码: " + respCode);
-                        System.out.println("响应描述: " + respDesc);
-                        System.out.println("完整响应: " + JSON.toJSONString(response, true));
-                        System.out.println();
-                    } catch (Exception e) {
-                        System.out.println("调用失败: " + e.getMessage());
-                        e.printStackTrace();
-                    }
-                }
-            }
-
-            System.out.println("========== 测试结束 ==========");
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-}