membercard与member-reguster合并，能进行编译和启动

删除冗余 AuthUtil，更新 manage-app 配置
2026-05-27 16:51:05 +08:00 · 2026-05-27 16:06:19 +08:00 · 2026-05-27 13:42:05 +08:00 · 2026-05-27 13:26:46 +08:00 · 2026-05-27 03:21:38 +08:00 · 2026-05-27 02:13:50 +08:00
120 changed files with 6810 additions and 2467 deletions
@@ -1,84 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.5.13</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>cn.novalon.gym.manage</groupId>
    <artifactId>gym-member-card</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>gym-member-card</name>
    <description>gym-member-card</description>
    <properties>
        <java.version>21</java.version>
    </properties>
    <dependencies>
        <!-- WebFlux 启动器（响应式） -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <!-- PostgreSQL 驱动（JDBC，如果工具类需要） -->
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- 你的内部模块 -->
        <dependency>
            <groupId>cn.novalon.gym.manage</groupId>
            <artifactId>manage-db</artifactId>
            <version>1.0.0</version>
            <scope>compile</scope>
        </dependency>
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.36</version>
            <scope>provided</scope>
        </dependency>
        <!-- Hutool 工具箱 -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.22</version>
        </dependency>
        <!-- Spring 上下文（其实 WebFlux 已经包含，保留也可以） -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <!-- ⭐ 必须添加：测试依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <!-- 保留标准 JAR，供其他模块引用 -->
                    <classifier>exec</classifier>
                </configuration>
            </plugin>
        </plugins>
    </build>
 </project>
@@ -1,15 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
@SpringBootApplication
@EnableR2dbcRepositories(basePackages = "cn.novalon.gym.manage.db.dao")
 public class GymMemberCardApplication {
    public static void main(String[] args) {
        SpringApplication.run(GymMemberCardApplication.class, args);
    }
 }
@@ -1,130 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.dao;
 import cn.novalon.gym.manage.gymmembercard.entity.MemberCardEntity;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.r2dbc.repository.Modifying;
 import org.springframework.data.r2dbc.repository.Query;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@Repository
 public interface MemberCardDao extends R2dbcRepository<MemberCardEntity, Long> {
    /**
     * 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
     * @param memberCardId 会员卡ID
     * @return 会员卡完整信息，如果不存在或已删除则返回空
     */
    Mono<MemberCardEntity> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
    /**
     * 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
     * 注意：模糊查询使用前后缀通配符，若数据量较大可能影响索引效率，建议后期引入全文索引或改用后缀模糊
     * @param status 会员卡状态（上架/下架）
     * @param name 会员卡名称（模糊查询）
     * @param type 会员卡类型
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @param pageable 分页和排序参数
     * @return 符合条件的会员卡列表
     */
    @Query("SELECT * FROM member_card WHERE deleted_at IS NULL " +
            "AND (:status IS NULL OR member_card_status = :status) " +
            "AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
            "AND (:type IS NULL OR member_card_type = :type) " +
            "AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
            "AND (:maxPrice IS NULL OR member_card_price <= :maxPrice) " +
            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
    Flux<MemberCardEntity> findWithConditions(Integer status, String name, String type,
                                              Double minPrice, Double maxPrice, Pageable pageable);
    /**
     * 统计符合条件的会员卡总数（配合列表查询使用）
     * @param status 会员卡状态
     * @param name 会员卡名称（模糊查询）
     * @param type 会员卡类型
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @return 符合条件的会员卡数量
     */
    @Query("SELECT COUNT(*) FROM member_card WHERE deleted_at IS NULL " +
            "AND (:status IS NULL OR member_card_status = :status) " +
            "AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
            "AND (:type IS NULL OR member_card_type = :type) " +
            "AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
            "AND (:maxPrice IS NULL OR member_card_price <= :maxPrice)")
    Mono<Long> countWithConditions(Integer status, String name, String type,
                                   Double minPrice, Double maxPrice);
    /**
     * 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
     * @param status 会员卡状态（通常传上架状态）
     * @param pageable 分页和排序参数
     * @return 符合条件的会员卡列表
     */
    Flux<MemberCardEntity> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
    /**
     * 检查会员卡是否已被购买（用于删除前的校验）
     * 注意：此查询关联到 member_card_record 表，建议后续独立至 MemberCardRecordDao
     * @param memberCardId 会员卡ID
     * @return 如果存在关联的会员记录则返回true，否则返回false
     */
    @Query("SELECT EXISTS(SELECT 1 FROM member_card_record WHERE member_card_id = :memberCardId AND deleted_at IS NULL LIMIT 1)")
    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
    /**
     * 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
     * @param memberCardId 会员卡ID
     * @return 受影响的行数
     */
    @Modifying
    @Query("UPDATE member_card SET deleted_at = NOW() WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
    Mono<Integer> logicalDelete(Long memberCardId);
    /**
     * 【新增】安全更新会员卡信息（仅允许修改业务相关字段，防止覆盖敏感字段）
     * @param memberCardId 会员卡ID
     * @param name 卡种名称
     * @param price 价格
     * @param durationDays 有效天数
     * @param totalCount 总次数
     * @param denomination 面额
     * @param status 状态
     * @return 受影响的行数
     */
    @Modifying
    @Query("UPDATE member_card SET " +
            "member_card_name = COALESCE(:name, member_card_name), " +
            "member_card_price = COALESCE(:price, member_card_price), " +
            "duration_days = COALESCE(:durationDays, duration_days), " +
            "total_count = COALESCE(:totalCount, total_count), " +
            "denomination = COALESCE(:denomination, denomination), " +
            "member_card_status = COALESCE(:status, member_card_status), " +
            "updated_at = NOW() " +
            "WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
    Mono<Integer> updateSafe(Long memberCardId, String name, Double price,
                             Integer durationDays, Integer totalCount,
                             Double denomination, Integer status);
    /**
     * 保存卡种信息（新增或更新）
     * - 新增：entity.memberCardId 为 null 时，插入新记录
     * - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
     * 注意：直接 save 会更新所有字段，如需安全更新请调用 updateSafe 方法
     * @param entity 卡种信息
     * @return 保存后的实体对象
     */
    @Override
    <S extends MemberCardEntity> Mono<S> save(S entity);
    /**
     * 批量查询上架的会员卡（用于小程序端展示）
     * @param status 上架状态值
     * @return 上架的会员卡列表
     */
    @Query("SELECT * FROM member_card WHERE deleted_at IS NULL AND member_card_status = :status ORDER BY member_card_price ASC")
    Flux<MemberCardEntity> findActiveCards(Integer status);
 }
@@ -1,148 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.dao;
 import cn.novalon.gym.manage.gymmembercard.entity.MemberCardRecordEntity;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.r2dbc.repository.Modifying;
 import org.springframework.data.r2dbc.repository.Query;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
@Repository
 public interface MemberCardRecordDao extends R2dbcRepository<MemberCardRecordEntity, Long> {
    /**
     * 会员购卡/后台发卡
     * 支付成功后插入一条记录，状态为ACTIVE，设置有效期和初始剩余次数/余额
     * @param memberId 会员ID
     * @param memberCardId 会员卡类型ID
     * @param expireTime 到期时间
     * @param remainingTimes 剩余次数
     * @param remainingAmount 剩余余额
     * @param sourceOrderId 来源订单ID
     * @return 插入的记录
     */
    @Modifying
    @Query("INSERT INTO member_card_record (member_id, member_card_id, status, expire_time, remaining_times, remaining_amount, source_order_id, purchase_time, created_at, updated_at) " +
            "VALUES (:memberId, :memberCardId, 'ACTIVE', :expireTime, :remainingTimes, :remainingAmount, :sourceOrderId, NOW(), NOW(), NOW()) " +
            "RETURNING *")
    Mono<MemberCardRecordEntity> insertActiveRecord(@Param("memberId") Long memberId,
                                                    @Param("memberCardId") Long memberCardId,
                                                    @Param("expireTime") LocalDateTime expireTime,
                                                    @Param("remainingTimes") Integer remainingTimes,
                                                    @Param("remainingAmount") Double remainingAmount,
                                                    @Param("sourceOrderId") Long sourceOrderId);
    /**
     * 扣次/扣费（含防超扣校验）
     * 预约团课或私教成功后，更新 remaining_times 减1 或 remaining_amount 减课程价格
     * @param recordId 会员卡记录ID
     * @param deductTimes 扣除次数
     * @param deductAmount 扣除金额
     * @return 受影响的行数（0表示余额不足，扣费失败）
     */
    @Modifying
    @Query("UPDATE member_card_record SET " +
            "remaining_times = remaining_times - :deductTimes, " +
            "remaining_amount = remaining_amount - :deductAmount, " +
            "updated_at = NOW() " +
            "WHERE member_card_record_id = :recordId " +
            "AND deleted_at IS NULL " +
            "AND remaining_times >= :deductTimes " +
            "AND remaining_amount >= :deductAmount")
    Mono<Integer> deductUsage(@Param("recordId") Long recordId,
                              @Param("deductTimes") Integer deductTimes,
                              @Param("deductAmount") Double deductAmount);
    /**
     * 续费
     * 累加剩余次数/余额，顺延到期日期
     * @param recordId 会员卡记录ID
     * @param addTimes 增加次数
     * @param addAmount 增加金额
     * @param newExpireTime 新的到期时间
     * @return 受影响的行数
     */
    @Modifying
    @Query("UPDATE member_card_record SET remaining_times = remaining_times + :addTimes, " +
            "remaining_amount = remaining_amount + :addAmount, expire_time = :newExpireTime, updated_at = NOW() " +
            "WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
    Mono<Integer> renewCard(@Param("recordId") Long recordId,
                            @Param("addTimes") Integer addTimes,
                            @Param("addAmount") Double addAmount,
                            @Param("newExpireTime") LocalDateTime newExpireTime);
    /**
     * 状态变更
     * 过期定时任务将状态改为EXPIRED；退款后改为REFUNDED
     * @param recordId 会员卡记录ID
     * @param status 新状态
     * @return 受影响的行数
     */
    @Modifying
    @Query("UPDATE member_card_record SET status = :status, updated_at = NOW() " +
            "WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
    Mono<Integer> updateStatus(@Param("recordId") Long recordId,
                               @Param("status") MemberCardRecordStatus status);
    /**
     * 会员端"我的卡包"
     * 根据会员ID查询所有卡，过滤状态为ACTIVE的，展示剩余次数/天数/余额
     * @param memberId 会员ID
     * @return 有效会员卡列表
     */
    @Query("SELECT * FROM member_card_record WHERE member_id = :memberId AND status = 'ACTIVE' AND deleted_at IS NULL ORDER BY expire_time ASC")
    Flux<MemberCardRecordEntity> findActiveCardsByMemberId(@Param("memberId") Long memberId);
    /**
     * 前台/店长查会员卡
     * 输入会员手机号或姓名，查出该会员持有的所有卡的信息
     * @param memberId 会员ID
     * @param pageable 分页参数
     * @return 会员卡列表
     */
    @Query("SELECT mcr.* FROM member_card_record mcr " +
            "INNER JOIN member m ON mcr.member_id = m.member_id " +
            "WHERE mcr.member_id = :memberId AND mcr.deleted_at IS NULL " +
            "ORDER BY mcr.purchase_time DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
    Flux<MemberCardRecordEntity> findByMemberId(@Param("memberId") Long memberId, Pageable pageable);
    /**
     * 验证次卡是否可用（仅检验次数和过期时间）
     * @param recordId 会员卡记录ID
     * @param requiredTimes 需要的次数
     * @return 符合条件的记录，空表示不可用
     */
    @Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
            "AND status = 'ACTIVE' AND deleted_at IS NULL " +
            "AND expire_time > NOW() " +
            "AND remaining_times >= :requiredTimes")
    Mono<MemberCardRecordEntity> validateCountCard(@Param("recordId") Long recordId,
                                                   @Param("requiredTimes") Integer requiredTimes);
    /**
     * 验证储值卡是否可用（仅检验余额和过期时间）
     * @param recordId 会员卡记录ID
     * @param requiredAmount 需要的金额
     * @return 符合条件的记录，空表示不可用
     */
    @Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
            "AND status = 'ACTIVE' AND deleted_at IS NULL " +
            "AND expire_time > NOW() " +
            "AND remaining_amount >= :requiredAmount")
    Mono<MemberCardRecordEntity> validateStoredCard(@Param("recordId") Long recordId,
                                                    @Param("requiredAmount") Double requiredAmount);
    /**
     * 到期扫描（分批处理，避免内存压力）
     * 定时任务：查询 status=ACTIVE 且 expire_time < 当前时间 的记录，用于批量过期处理
     * @return 已过期的会员卡记录列表（最多500条）
     */
    @Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND expire_time < NOW() AND deleted_at IS NULL LIMIT 500")
    Flux<MemberCardRecordEntity> findExpiredCards();
 }
@@ -1,159 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.dao;
 import cn.novalon.gym.manage.gymmembercard.entity.MemberCardTransactionsEntity;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.r2dbc.repository.Modifying;
 import org.springframework.data.r2dbc.repository.Query;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
@Repository
 public interface MemberCardTransactionsDao extends R2dbcRepository<MemberCardTransactionsEntity, Long> {
    /**
     * 记录每一次变动
     * 购卡、扣次、续费、退款、过期，均插入一条流水，记录变动前后快照
     * 注意：返回值依赖 PostgreSQL 的 RETURNING 语法，若使用 MySQL 请删除 RETURNING * 并改用 save()
     * @param memberCardId 会员卡ID
     * @param memberId 会员ID
     * @param operationType 操作类型
     * @param changeAmount 变动次数（次卡）
     * @param changeBalance 变动金额（储值卡）
     * @param afterRemainingCount 变动后剩余次数
     * @param afterRemainingBalance 变动后剩余余额
     * @param relatedBizType 关联业务类型
     * @param remark 备注
     * @return 插入的流水记录
     */
    @Modifying
    @Query("INSERT INTO member_card_transactions (member_card_id, member_id, operation_type, change_amount, " +
            "change_balance, after_remaining_count, after_remaining_balance, related_biz_type, remark, created_at, updated_at) " +
            "VALUES (:memberCardId, :memberId, :operationType, :changeAmount, :changeBalance, " +
            ":afterRemainingCount, :afterRemainingBalance, :relatedBizType, :remark, NOW(), NOW()) " +
            "RETURNING *")
    Mono<MemberCardTransactionsEntity> insertTransaction(@Param("memberCardId") Long memberCardId,
                                                         @Param("memberId") Long memberId,
                                                         @Param("operationType") MemberCardTransactionsAction operationType,
                                                         @Param("changeAmount") Integer changeAmount,
                                                         @Param("changeBalance") Double changeBalance,
                                                         @Param("afterRemainingCount") Integer afterRemainingCount,
                                                         @Param("afterRemainingBalance") Double afterRemainingBalance,
                                                         @Param("relatedBizType") MemberCardTransactionsType relatedBizType,
                                                         @Param("remark") String remark);
    /**
     * 会员端"使用记录"
     * 按会员ID和时间范围查询，按时间倒序，显示每次变动明细
     * @param memberId 会员ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageable 分页参数
     * @return 流水记录列表
     */
    @Query("SELECT * FROM member_card_transactions WHERE member_id = :memberId " +
            "AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL " +
            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
    Flux<MemberCardTransactionsEntity> findByMemberIdAndTimeRange(@Param("memberId") Long memberId,
                                                                  @Param("startTime") LocalDateTime startTime,
                                                                  @Param("endTime") LocalDateTime endTime,
                                                                  Pageable pageable);
    /**
     * 后台"使用记录查询"
     * 按会员、卡号、操作类型、时间范围等条件组合查询
     * @param memberId 会员ID
     * @param memberCardId 会员卡ID
     * @param operationType 操作类型
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageable 分页参数
     * @return 流水记录列表
     */
    @Query("SELECT * FROM member_card_transactions WHERE deleted_at IS NULL " +
            "AND (:memberId IS NULL OR member_id = :memberId) " +
            "AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
            "AND (:operationType IS NULL OR operation_type = :operationType) " +
            "AND (:startTime IS NULL OR created_at >= :startTime) " +
            "AND (:endTime IS NULL OR created_at <= :endTime) " +
            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
    Flux<MemberCardTransactionsEntity> findWithConditions(@Param("memberId") Long memberId,
                                                          @Param("memberCardId") Long memberCardId,
                                                          @Param("operationType") MemberCardTransactionsAction operationType,
                                                          @Param("startTime") LocalDateTime startTime,
                                                          @Param("endTime") LocalDateTime endTime,
                                                          Pageable pageable);
    /**
     * 统计符合条件的流水总数
     * @param memberId 会员ID
     * @param memberCardId 会员卡ID
     * @param operationType 操作类型
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 流水记录数量
     */
    @Query("SELECT COUNT(*) FROM member_card_transactions WHERE deleted_at IS NULL " +
            "AND (:memberId IS NULL OR member_id = :memberId) " +
            "AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
            "AND (:operationType IS NULL OR operation_type = :operationType) " +
            "AND (:startTime IS NULL OR created_at >= :startTime) " +
            "AND (:endTime IS NULL OR created_at <= :endTime)")
    Mono<Long> countWithConditions(@Param("memberId") Long memberId,
                                   @Param("memberCardId") Long memberCardId,
                                   @Param("operationType") MemberCardTransactionsAction operationType,
                                   @Param("startTime") LocalDateTime startTime,
                                   @Param("endTime") LocalDateTime endTime);
    /**
     * 按会员卡ID查询所有流水记录（补充常用方法）
     * @param memberCardId 会员卡ID
     * @return 该卡的所有流水记录，按时间倒序
     */
    @Query("SELECT * FROM member_card_transactions WHERE member_card_id = :memberCardId AND deleted_at IS NULL ORDER BY created_at DESC")
    Flux<MemberCardTransactionsEntity> findByMemberCardId(@Param("memberCardId") Long memberCardId);
    /**
     * 数据统计 - 统计某卡种的总扣次数
     * @param memberCardId 会员卡ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 总扣次数
     */
    @Query("SELECT COALESCE(SUM(change_amount), 0) FROM member_card_transactions " +
            "WHERE member_card_id = :memberCardId AND operation_type = 'DEDUCT' " +
            "AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
    Mono<Long> sumDeductCountByCardId(@Param("memberCardId") Long memberCardId,
                                      @Param("startTime") LocalDateTime startTime,
                                      @Param("endTime") LocalDateTime endTime);
    /**
     * 数据统计 - 统计某时间段的续费总金额
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 续费总金额
     */
    @Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
            "WHERE operation_type = 'RENEW' AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
    Mono<Double> sumRenewAmountByTimeRange(@Param("startTime") LocalDateTime startTime,
                                           @Param("endTime") LocalDateTime endTime);
    /**
     * 数据统计 - 统计某会员的购卡总金额
     * @param memberId 会员ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 购卡总金额
     */
    @Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
            "WHERE member_id = :memberId AND operation_type = 'PURCHASE' " +
            "AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
    Mono<Double> sumPurchaseAmountByMemberId(@Param("memberId") Long memberId,
                                             @Param("startTime") LocalDateTime startTime,
                                             @Param("endTime") LocalDateTime endTime);
 }
@@ -1,49 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.domain;
 import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
 import io.swagger.v3.oas.annotations.media.Schema;
 import java.time.LocalDateTime;
 /*
 *@Author:shizhounian
 *@Date:2026/5/10-05 22:47:31
 */
@Schema(description = "会员卡类型表")
 public class MemberCard extends BaseDomain {
    //会员卡id
    @Schema(description = "会员卡Id",example = "1")
    private Long memberCardId;
    //会员卡名称
    @Schema(description = "会员卡名称",example = "月卡")
    private String memberCardName;
    //会员卡类型
    @Schema(description = "会员卡类型",example = "TIME_CARD")
    private String memberCardType;
    //会员卡价格
    @Schema(description = "会员卡价格",example = "199.0")
    private Double memberCardPrice;
    //会员卡有效天数（时长卡用）
    @Schema(description = "会员卡有效天数",example = "30")
    private Integer memberCardValidityDays;
    //会员卡总次数（次卡用）
    @Schema(description = "会员卡总次数",example = "10")
    private Integer memberCardTotalTimes;
    //会员卡面额（储值卡用）
    @Schema(description = "会员卡面额",example = "500.0")
    private Double memberCardAmount;
    //会员卡状态：0-正常，1-禁用
    @Schema(description = "会员卡状态",example = "0")
    private Integer memberCardStatus;
    //会员卡创建时间
    @Schema(description = "会员卡创建时间",example = "2026-05-10 05:22:47")
    private LocalDateTime memberCardCreateTime;
 }
@@ -1,50 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.domain;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
 import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
 import io.swagger.v3.oas.annotations.media.Schema;
 import java.time.LocalDateTime;
 /*
 *@Author:shizhounian
 *@Date:2026/5/10-05 22:47:31
 */
@Schema(description = "会员卡记录",example = "member_card_record")
 public class MemberCardRecord extends BaseDomain {
    //会员持有卡id
    @Schema(description = "会员持有卡Id",example = "1")
    private Long memberCardRecordId;
    //会员Id
    @Schema(description = "会员Id",example = "1")
    private Long memberId;
    //关联会员卡Id
    @Schema(description = "关联会员卡Id",example = "1")
    private Long memberCardId;
    //状态：ACTIVE(有效) / USED_UP(用完) / EXPIRED(过期) / REFUNDED(已退款)
    @Schema(description = "状态",example = "ACTIVE")
    private MemberCardRecordStatus status;
    //剩余次数
    @Schema(description = "剩余次数",example = "1")
    private Integer remainingTimes;
    //剩余余额
    @Schema(description = "剩余余额",example = "1")
    private Double remainingAmount;
    //到期时间
    @Schema(description = "到期时间",example = "2026-05-10 05:22:47")
    private LocalDateTime expireTime;
    //购买订单Id
    @Schema(description = "购买订单Id",example = "1")
    private Long sourceOrderId;
    //购买时间
    @Schema(description = "购买时间",example = "2026-05-10 05:22:47")
    private LocalDateTime purchaseTime;
 }
@@ -1,59 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.domain;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
 import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
 import io.swagger.v3.oas.annotations.media.Schema;
 import java.time.LocalDateTime;
 /*
 *@Author:shizhounian
 *@Date:2026/5/10-05 22:47:31
 */
@Schema(description = "会员卡流水")
 public class MemberCardTransactions extends BaseDomain {
    //会员卡流水Id
    @Schema(description = "会员卡流水Id",example = "1")
    private Long memberCardTransactionsId;
    //会员卡Id
    @Schema(description = "会员卡Id",example = "1")
    private Long memberCardId;
    //会员Id
    @Schema(description = "会员Id",example = "1")
    private Long memberId;
    //操作类型：PURCHASE(购买) / DEDUCT(扣次/扣费) / RENEW(续费) / REFUND(退款) / EXPIRE(过期)
    @Schema(description = "操作类型",example = "PURCHASE")
    private MemberCardTransactionsAction operationType;
    //变动次数（次卡用）
    @Schema(description = "变动次数（次卡用）",example = "1")
    private Integer changeAmount;
    //变动金额（储值卡用）
    @Schema(description = "变动金额（储值卡用）",example = "1")
    private Double changeBalance;
    //变动后剩余次数
    @Schema(description = "变动后剩余次数",example = "1")
    private Integer afterRemainingCount;
    //变动后剩余金额
    @Schema(description = "变动后剩余金额",example = "500.0")
    private Double afterRemainingBalance;
    //关联业务类型
    @Schema(description = "关联业务类型",example = "GROUP_CLASS")
    private MemberCardTransactionsType relatedBizType;
    //备注
    @Schema(description = "备注",example = "预约团课：瑜伽课扣1次")
    private String remark;
    //创建时间
    @Schema(description = "创建时间",example = "2026-05-10 05:22:47")
    private LocalDateTime createdAt;
 }
@@ -1,53 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.entity;
 import cn.novalon.gym.manage.db.entity.BaseEntity;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
 import lombok.Data;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 import java.time.LocalDateTime;
 /*
 *@Author:shizhounian
 *@Date:2026/5/10-05 22:47:31
 */
@Data
@Table("member_card_record")
 public class MemberCardRecordEntity extends BaseEntity {
    //会员持有卡id
    @Column("member_card_record_id")
    private Long memberCardRecordId;
    //会员Id
    @Column("member_id")
    private Long memberId;
    //关联会员卡Id
    @Column("member_card_id")
    private Long memberCardId;
    //状态：ACTIVE(有效) / USED_UP(用完) / EXPIRED(过期) / REFUNDED(已退款)
    @Column("status")
    private MemberCardRecordStatus status;
    //剩余次数
    @Column("remaining_times")
    private Integer remainingTimes;
    //剩余余额
    @Column("remaining_amount")
    private Double remainingAmount;
    //到期时间
    @Column("expire_time")
    private LocalDateTime expireTime;
    //购买订单Id
    @Column("source_order_id")
    private Long sourceOrderId;
    //购买时间
    @Column("purchase_time")
    private LocalDateTime purchaseTime;
 }
@@ -1,62 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.entity;
 import cn.novalon.gym.manage.db.entity.BaseEntity;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
 import lombok.Data;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 import java.time.LocalDateTime;
 /*
 *@Author:shizhounian
 *@Date:2026/5/10-05 22:47:31
 */
@Data
@Table("member_card_transactions")
 public class MemberCardTransactionsEntity extends BaseEntity {
    //会员卡流水Id
    @Column("member_card_transactions_id")
    private Long memberCardTransactionsId;
    //会员卡Id
    @Column("member_card_id")
    private Long memberCardId;
    //会员Id
    @Column("member_id")
    private Long memberId;
    //操作类型：PURCHASE(购买) / DEDUCT(扣次/扣费) / RENEW(续费) / REFUND(退款) / EXPIRE(过期)
    @Column("operation_type")
    private MemberCardTransactionsAction operationType;
    //变动次数（次卡用）
    @Column("change_amount")
    private Integer changeAmount;
    //变动金额（储值卡用）
    @Column("change_balance")
    private Double changeBalance;
    //变动后剩余次数
    @Column("after_remaining_count")
    private Integer afterRemainingCount;
    //变动后剩余金额
    @Column("after_remaining_balance")
    private Double afterRemainingBalance;
    //关联业务类型
    @Column("related_biz_type")
    private MemberCardTransactionsType relatedBizType;
    //备注
    @Column("remark")
    private String remark;
    //创建时间
    @Column("created_at")
    private LocalDateTime createdAt;
 }
@@ -1,36 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.enums;
 import io.swagger.v3.oas.annotations.media.Schema;
 /*
 *@Author:shizhounian
 *@Date:2026/5/10-05 23:59:29
 */
@Schema(description = "会员卡状态枚举")
 public enum MemberCardRecordStatus {
    //有效
    @Schema(description = "有效")
    ACTIVE("有效"),
    //用完
    @Schema(description = "用完")
    USED_UP("用完"),
    //过期
    @Schema(description = "过期")
    EXPIRED("过期"),
    //已退款
    @Schema(description = "已退款")
    REFUNDED("已退款");
    private final String desc;
    MemberCardRecordStatus(String desc) {
        this.desc = desc;
    }
    public String getDesc() {
        return desc;
    }
 }
@@ -1,40 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.enums;
 import io.swagger.v3.oas.annotations.media.Schema;
 /*
 *@Author:shizhounian
 *@Date:2026/5/10-05 23:59:29
 */
@Schema(description = "会员卡流水操作枚举")
 public enum MemberCardTransactionsAction {
    //购买
    @Schema(description = "购买")
    PURCHASE("购买"),
    //扣次/扣费
    @Schema(description = "扣次/扣费")
    DEDUCT("扣次/扣费"),
    //续费
    @Schema(description = "续费")
    RENEW("续费"),
    //退款
    @Schema(description = "退款")
    REFUND("退款"),
    //过期
    @Schema(description = "过期")
    EXPIRE("过期");
    private final String desc;
    MemberCardTransactionsAction(String desc) {
        this.desc = desc;
    }
    public String getDesc() {
        return desc;
    }
 }
@@ -1,32 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.enums;
 import io.swagger.v3.oas.annotations.media.Schema;
 /*
 *@Author:shizhounian
 *@Date:2026/5/10-05 23:59:29
 */
@Schema(description = "会员卡流水关联业务类型枚举")
 public enum MemberCardTransactionsType {
    //团课
    @Schema(description = "团课")
    GROUP_CLASS("团课"),
    //私教
    @Schema(description = "私教")
    PT_CLASS("私教"),
    //签到
    @Schema(description = "签到")
    CHECK_IN("签到");
    private final String desc;
    MemberCardTransactionsType(String desc) {
        this.desc = desc;
    }
    public String getDesc() {
        return desc;
    }
 }
@@ -1,114 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.handler;
 import cn.hutool.db.PageResult;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
 import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Validator;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Component;
 import org.springframework.web.reactive.function.server.ServerRequest;
 import org.springframework.web.reactive.function.server.ServerResponse;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.util.List;
 /*
 *@Author:shizhounian
 *@Date:2026/5/17-05 20:10:22
 */
@Component
@Tag(name = "会员卡类型管理", description = "会员卡类型相关操作")
 public class MemberCardHandler {
    private final IMemberCardService memberCardService;
    private final Validator validator;
    public MemberCardHandler(IMemberCardService memberCardService, Validator validator) {
        this.memberCardService = memberCardService;
        this.validator = validator;
    }
    /**
     * 根据会员卡ID查询会员卡详情
     */
    @Operation(summary = "根据会员卡ID查询会员卡详情", description = "用于编辑前回显或小程序端展示")
    public Mono<ServerResponse> getMemberCardById(ServerRequest request) {
        Long memberCardId = Long.parseLong(request.pathVariable("memberCardId"));
        return memberCardService.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
                .flatMap(card -> ServerResponse.ok().bodyValue(card))
                .switchIfEmpty(ServerResponse.notFound().build());
    }
    /**
     * 条件查询会员卡列表（分页）
     */
    @Operation(summary = "条件查询会员卡列表", description = "后台卡种列表展示，支持多条件组合+分页+排序")
    public Mono<ServerResponse> getMemberCardList(ServerRequest request) {
        Integer status = request.queryParam("status").map(Integer::parseInt).orElse(null);
        String name = request.queryParam("name").orElse(null);
        String type = request.queryParam("type").orElse(null);
        Double minPrice = request.queryParam("minPrice").map(Double::parseDouble).orElse(null);
        Double maxPrice = request.queryParam("maxPrice").map(Double::parseDouble).orElse(null);
        int page = request.queryParam("page").map(Integer::parseInt).orElse(0);
        int size = request.queryParam("size").map(Integer::parseInt).orElse(10);
        String sortField = request.queryParam("sortField").orElse("created_at");
        String sortOrder = request.queryParam("sortOrder").orElse("DESC");
        Pageable pageable = PageRequest.of(page, size, Sort.by(Sort.Direction.fromString(sortOrder), sortField));
        Mono<Long> countMono = memberCardService.countWithConditions(status, name, type, minPrice, maxPrice);
        Flux<MemberCard> cardsFlux = memberCardService.findWithConditions(status, name, type, minPrice, maxPrice, pageable);
        return Mono.zip(countMono, cardsFlux.collectList())
                .flatMap(tuple -> {
                    long total = tuple.getT1();
                    List<MemberCard> list = tuple.getT2();
                    // 使用 PageResult(int page, int pageSize, int total) 构造，
                    // 它会自动计算 totalPage
                    PageResult<MemberCard> result = new PageResult<>(page, size, (int) total);
                    result.addAll(list);   // 将查询结果填充进去
                    return ServerResponse.ok().bodyValue(result);
                });
    }
    /**
     * 保存卡种信息（新增或更新）
     */
    @Operation(summary = "保存卡种信息", description = "新增或更新会员卡类型")
    public Mono<ServerResponse> saveMemberCard(ServerRequest request) {
        return request.bodyToMono(MemberCard.class)
                .flatMap(memberCardService::save)
                .flatMap(card -> ServerResponse.ok().bodyValue(card));
    }
    /**
     * 逻辑删除会员卡（下架）
     */
    @Operation(summary = "逻辑删除会员卡", description = "下架卡种，防止已购会员数据异常")
    public Mono<ServerResponse> deleteMemberCard(ServerRequest request) {
        Long memberCardId = Long.parseLong(request.pathVariable("memberCardId"));
        return memberCardService.logicalDelete(memberCardId)
                .flatMap(rows -> {
                    if (rows > 0) {
                        return ServerResponse.noContent().build();
                    } else {
                        return ServerResponse.notFound().build();
                    }
                });
    }
    /**
     * 批量查询上架的会员卡
     */
    @Operation(summary = "批量查询上架的会员卡", description = "用于小程序端展示")
    public Mono<ServerResponse> getActiveCards(ServerRequest request) {
        Integer status = request.queryParam("status").map(Integer::parseInt).orElse(0);
        return ServerResponse.ok().body(memberCardService.findActiveCards(status), MemberCard.class);
    }
 }
@@ -1,179 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.handler;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
 import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardRecordService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Validator;
 import lombok.Data;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Component;
 import org.springframework.web.reactive.function.server.ServerRequest;
 import org.springframework.web.reactive.function.server.ServerResponse;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 /*
 *@Author:shizhounian
 *@Date:2026/5/17-05 20:10:22
 */
@Component
@Tag(name = "会员卡记录管理", description = "会员卡记录相关操作")
 public class MemberCardRecordHandler {
    private final IMemberCardRecordService memberCardRecordService;
    private final Validator validator;
    public MemberCardRecordHandler(IMemberCardRecordService memberCardRecordService, Validator validator) {
        this.memberCardRecordService = memberCardRecordService;
        this.validator = validator;
    }
    /**
     * 会员购卡/后台发卡
     */
    @Operation(summary = "会员购卡/后台发卡", description = "支付成功后插入一条记录，状态为ACTIVE")
    public Mono<ServerResponse> insertActiveRecord(ServerRequest request) {
        return request.bodyToMono(MemberCardRecord.class)
                .flatMap(memberCardRecordService::insertActiveRecord)
                .flatMap(record -> ServerResponse.ok().bodyValue(record));
    }
    /**
     * 扣次/扣费
     */
    @Operation(summary = "扣次/扣费", description = "预约团课或私教成功后扣减次数或余额")
    public Mono<ServerResponse> deductUsage(ServerRequest request) {
        Long recordId = Long.parseLong(request.pathVariable("id"));
        return request.bodyToMono(DeductRequest.class)
                .flatMap(body -> memberCardRecordService.deductUsage(recordId,
                        body.getDeductTimes(),
                        body.getDeductAmount()))
                .flatMap(rows -> {
                    if (rows > 0) {
                        return ServerResponse.ok().build();
                    } else {
                        return ServerResponse.badRequest().bodyValue("余额不足或卡无效");
                    }
                });
    }
    /**
     * 续费
     */
    @Operation(summary = "续费", description = "累加剩余次数/余额，顺延到期日期")
    public Mono<ServerResponse> renewCard(ServerRequest request) {
        Long recordId = Long.parseLong(request.pathVariable("id"));
        return request.bodyToMono(RenewRequest.class)
                .flatMap(body -> memberCardRecordService.renewCard(recordId,
                        body.getAddTimes(),
                        body.getAddAmount(),
                        body.getNewExpireTime()))
                .flatMap(rows -> {
                    if (rows > 0) {
                        return ServerResponse.ok().build();
                    } else {
                        return ServerResponse.notFound().build();
                    }
                });
    }
    /**
     * 状态变更（过期、退款）
     */
    @Operation(summary = "状态变更", description = "将卡状态改为EXPIRED或REFUNDED")
    public Mono<ServerResponse> updateStatus(ServerRequest request) {
        Long recordId = Long.parseLong(request.pathVariable("id"));
        return request.queryParam("status")
                .map(s -> {
                    try {
                        return MemberCardRecordStatus.valueOf(s.toUpperCase());
                    } catch (IllegalArgumentException e) {
                        return null;
                    }
                })
                .map(status -> memberCardRecordService.updateStatus(recordId, status)
                        .flatMap(rows -> {
                            if (rows > 0) {
                                return ServerResponse.ok().build();
                            } else {
                                return ServerResponse.notFound().build();
                            }
                        }))
                .orElse(ServerResponse.badRequest().bodyValue("status 参数缺失或无效"));
    }
    /**
     * 会员端“我的卡包”
     */
    @Operation(summary = "会员我的卡包", description = "查询当前登录会员的所有有效卡")
    public Mono<ServerResponse> getMyCards(ServerRequest request) {
        Long memberId = Long.parseLong(request.pathVariable("memberId"));
        return ServerResponse.ok().body(memberCardRecordService.findActiveCardsByMemberId(memberId),
                MemberCardRecord.class);
    }
    /**
     * 前台/店长查会员卡（分页）
     */
    @Operation(summary = "管理端查询会员卡", description = "按会员ID分页查询所有会员卡记录")
    public Mono<ServerResponse> getMemberCardRecords(ServerRequest request) {
        Long memberId = Long.parseLong(request.pathVariable("memberId"));
        int page = request.queryParam("page").map(Integer::parseInt).orElse(0);
        int size = request.queryParam("size").map(Integer::parseInt).orElse(10);
        Pageable pageable = PageRequest.of(page, size, Sort.by("purchase_time").descending());
        return ServerResponse.ok().body(memberCardRecordService.findByMemberId(memberId, pageable),
                MemberCardRecord.class);
    }
    /**
     * 验证次卡是否可用
     */
    @Operation(summary = "验证次卡", description = "校验次卡剩余次数是否足够")
    public Mono<ServerResponse> validateCountCard(ServerRequest request) {
        Long recordId = Long.parseLong(request.pathVariable("id"));
        Integer requiredTimes = request.queryParam("times").map(Integer::parseInt).orElse(1);
        return memberCardRecordService.validateCountCard(recordId, requiredTimes)
                .flatMap(card -> ServerResponse.ok().bodyValue(card))
                .switchIfEmpty(ServerResponse.badRequest().bodyValue("次卡不可用"));
    }
    /**
     * 验证储值卡是否可用
     */
    @Operation(summary = "验证储值卡", description = "校验储值卡余额是否足够")
    public Mono<ServerResponse> validateStoredCard(ServerRequest request) {
        Long recordId = Long.parseLong(request.pathVariable("id"));
        Double requiredAmount = request.queryParam("amount").map(Double::parseDouble).orElse(0.0);
        return memberCardRecordService.validateStoredCard(recordId, requiredAmount)
                .flatMap(card -> ServerResponse.ok().bodyValue(card))
                .switchIfEmpty(ServerResponse.badRequest().bodyValue("储值卡不可用"));
    }
    /**
     * 到期扫描（管理端触发）
     */
    @Operation(summary = "到期扫描", description = "扫描并返回已过期的会员卡（最多500条）")
    public Mono<ServerResponse> getExpiredCards(ServerRequest request) {
        return ServerResponse.ok().body(memberCardRecordService.findExpiredCards(), MemberCardRecord.class);
    }
    // ==================== 内部请求体 DTO ====================
    @Data
    public static class DeductRequest {
        private Integer deductTimes;
        private Double deductAmount;
    }
    @Data
    public static class RenewRequest {
        private Integer addTimes;
        private Double addAmount;
        private LocalDateTime newExpireTime;
    }
 }
@@ -1,83 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.repository;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
 import org.springframework.data.domain.Pageable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 public interface IMemberCardRecordRepository {
    /**
     * 会员购卡/后台发卡
     * @param record 会员卡记录
     * @return 插入的记录
     */
    Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
    /**
     * 扣次/扣费（含防超扣校验）
     * @param recordId 会员卡记录ID
     * @param deductTimes 扣除次数
     * @param deductAmount 扣除金额
     * @return 受影响的行数（0表示余额不足，扣费失败）
     */
    Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
    /**
     * 续费
     * @param recordId 会员卡记录ID
     * @param addTimes 增加次数
     * @param addAmount 增加金额
     * @param newExpireTime 新的到期时间
     * @return 受影响的行数
     */
    Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime);
    /**
     * 状态变更
     * @param recordId 会员卡记录ID
     * @param status 新状态
     * @return 受影响的行数
     */
    Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status);
    /**
     * 会员端"我的卡包"
     * @param memberId 会员ID
     * @return 有效会员卡列表
     */
    Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
    /**
     * 前台/店长查会员卡
     * @param memberId 会员ID
     * @param pageable 分页参数
     * @return 会员卡列表
     */
    Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
    /**
     * 验证次卡是否可用（仅检验次数和过期时间）
     * @param recordId 会员卡记录ID
     * @param requiredTimes 需要的次数
     * @return 符合条件的记录，空表示不可用
     */
    Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
    /**
     * 验证储值卡是否可用（仅检验余额和过期时间）
     * @param recordId 会员卡记录ID
     * @param requiredAmount 需要的金额
     * @return 符合条件的记录，空表示不可用
     */
    Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
    /**
     * 到期扫描（分批处理，避免内存压力）
     * @return 已过期的会员卡记录列表（最多500条）
     */
    Flux<MemberCardRecord> findExpiredCards();
 }
@@ -1,78 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.repository;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
 import org.springframework.data.domain.Pageable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 public interface IMemberCardRepository {
    /**
     * 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
     * @param memberCardId 会员卡ID
     * @return 会员卡完整信息，如果不存在或已删除则返回空
     */
    Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
    /**
     * 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
     * @param status 会员卡状态（上架/下架）
     * @param name 会员卡名称（模糊查询）
     * @param type 会员卡类型
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @param pageable 分页和排序参数
     * @return 符合条件的会员卡列表
     */
    Flux<MemberCard> findWithConditions(Integer status, String name, String type,
                                              Double minPrice, Double maxPrice, Pageable pageable);
    /**
     * 统计符合条件的会员卡总数（配合列表查询使用）
     * @param status 会员卡状态
     * @param name 会员卡名称（模糊查询）
     * @param type 会员卡类型
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @return 符合条件的会员卡数量
     */
    Mono<Long> countWithConditions(Integer status, String name, String type,
                                   Double minPrice, Double maxPrice);
    /**
     * 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
     * @param status 会员卡状态（通常传上架状态）
     * @param pageable 分页和排序参数
     * @return 符合条件的会员卡列表
     */
    Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
    /**
     * 检查会员卡是否已被购买（用于删除前的校验）
     * @param memberCardId 会员卡ID
     * @return 如果存在关联的会员记录则返回true，否则返回false
     */
    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
    /**
     * 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
     * @param memberCardId 会员卡ID
     * @return 受影响的行数
     */
    Mono<Integer> logicalDelete(Long memberCardId);
    /**
     * 保存卡种信息（新增或更新）
     * - 新增：entity.memberCardId 为 null 时，插入新记录
     * - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
     * @param entity 卡种信息
     * @return 保存后的实体对象
     */
    Mono<MemberCard> save(MemberCard entity);
    /**
     * 批量查询上架的会员卡（用于小程序端展示）
     * @param status 上架状态值
     * @return 上架的会员卡列表
     */
    Flux<MemberCard> findActiveCards(Integer status);
 }
@@ -1,91 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.repository;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
 import org.springframework.data.domain.Pageable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 public interface IMemberCardTransactionsRepository {
    /**
     * 记录每一次变动
     * @param transactions 流水记录
     * @return 插入的流水记录
     */
    Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions);
    /**
     * 会员端"使用记录"
     * @param memberId 会员ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageable 分页参数
     * @return 流水记录列表
     */
    Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
                                                             LocalDateTime endTime, Pageable pageable);
    /**
     * 后台"使用记录查询"
     * @param memberId 会员ID
     * @param memberCardId 会员卡ID
     * @param operationType 操作类型
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageable 分页参数
     * @return 流水记录列表
     */
    Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
                                                     MemberCardTransactionsAction operationType,
                                                     LocalDateTime startTime, LocalDateTime endTime,
                                                     Pageable pageable);
    /**
     * 统计符合条件的流水总数
     * @param memberId 会员ID
     * @param memberCardId 会员卡ID
     * @param operationType 操作类型
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 流水记录数量
     */
    Mono<Long> countWithConditions(Long memberId, Long memberCardId,
                                   MemberCardTransactionsAction operationType,
                                   LocalDateTime startTime, LocalDateTime endTime);
    /**
     * 按会员卡ID查询所有流水记录
     * @param memberCardId 会员卡ID
     * @return 该卡的所有流水记录，按时间倒序
     */
    Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId);
    /**
     * 数据统计 - 统计某卡种的总扣次数
     * @param memberCardId 会员卡ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 总扣次数
     */
    Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime);
    /**
     * 数据统计 - 统计某时间段的续费总金额
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 续费总金额
     */
    Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
    /**
     * 数据统计 - 统计某会员的购卡总金额
     * @param memberId 会员ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 购卡总金额
     */
    Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
 }
@@ -1,141 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.repository.impl;
 import cn.novalon.gym.manage.gymmembercard.dao.MemberCardRecordDao;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
 import cn.novalon.gym.manage.gymmembercard.entity.MemberCardRecordEntity;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
 import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
 import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
@Repository
 public class MemberCardRecordRepositoryImpl implements IMemberCardRecordRepository {
    private final MemberCardRecordDao memberCardRecordDao;
    private final BeanConvertUtil beanConvertUtil;
    private final R2dbcEntityTemplate r2dbcEntityTemplate;
    public MemberCardRecordRepositoryImpl(MemberCardRecordDao memberCardRecordDao,
                                          BeanConvertUtil beanConvertUtil,
                                          R2dbcEntityTemplate r2dbcEntityTemplate) {
        this.memberCardRecordDao = memberCardRecordDao;
        this.beanConvertUtil = beanConvertUtil;
        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
    }
    /**
     * 会员购卡/后台发卡
     * @param record 会员卡记录
     * @return 插入的记录
     */
    @Override
    public Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record) {
        MemberCardRecordEntity entity = BeanConvertUtil.toBean(record, MemberCardRecordEntity.class);
        return memberCardRecordDao.insertActiveRecord(
                        entity.getMemberId(),
                        entity.getMemberCardId(),
                        entity.getExpireTime(),
                        entity.getRemainingTimes(),
                        entity.getRemainingAmount(),
                        entity.getSourceOrderId())
                .map(e -> beanConvertUtil.toBean(e, MemberCardRecord.class));
    }
    /**
     * 扣次/扣费（含防超扣校验）
     * @param recordId 会员卡记录ID
     * @param deductTimes 扣除次数
     * @param deductAmount 扣除金额
     * @return 受影响的行数（0表示余额不足，扣费失败）
     */
    @Override
    public Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount) {
        return memberCardRecordDao.deductUsage(recordId, deductTimes, deductAmount);
    }
    /**
     * 续费
     * @param recordId 会员卡记录ID
     * @param addTimes 增加次数
     * @param addAmount 增加金额
     * @param newExpireTime 新的到期时间
     * @return 受影响的行数
     */
    @Override
    public Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime) {
        return memberCardRecordDao.renewCard(recordId, addTimes, addAmount, newExpireTime);
    }
    /**
     * 状态变更
     * @param recordId 会员卡记录ID
     * @param status 新状态
     * @return 受影响的行数
     */
    @Override
    public Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status) {
        return memberCardRecordDao.updateStatus(recordId, status);
    }
    /**
     * 会员端"我的卡包"
     * @param memberId 会员ID
     * @return 有效会员卡列表
     */
    @Override
    public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
        return memberCardRecordDao.findActiveCardsByMemberId(memberId)
                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
    }
    /**
     * 前台/店长查会员卡
     * @param memberId 会员ID
     * @param pageable 分页参数
     * @return 会员卡列表
     */
    @Override
    public Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable) {
        return memberCardRecordDao.findByMemberId(memberId, pageable)
                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
    }
    /**
     * 验证次卡是否可用（仅检验次数和过期时间）
     * @param recordId 会员卡记录ID
     * @param requiredTimes 需要的次数
     * @return 符合条件的记录，空表示不可用
     */
    @Override
    public Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes) {
        return memberCardRecordDao.validateCountCard(recordId, requiredTimes)
                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
    }
    /**
     * 验证储值卡是否可用（仅检验余额和过期时间）
     * @param recordId 会员卡记录ID
     * @param requiredAmount 需要的金额
     * @return 符合条件的记录，空表示不可用
     */
    @Override
    public Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount) {
        return memberCardRecordDao.validateStoredCard(recordId, requiredAmount)
                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
    }
    /**
     * 到期扫描（分批处理，避免内存压力）
     * @return 已过期的会员卡记录列表（最多500条）
     */
    @Override
    public Flux<MemberCardRecord> findExpiredCards() {
        return memberCardRecordDao.findExpiredCards()
                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
    }
 }
@@ -1,146 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.repository.impl;
 import cn.novalon.gym.manage.gymmembercard.dao.MemberCardDao;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
 import cn.novalon.gym.manage.gymmembercard.entity.MemberCardEntity;
 import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRepository;
 import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@Repository
 public class MemberCardRepositoryImpl implements IMemberCardRepository {
    private final MemberCardDao memberCardDao;
    private final BeanConvertUtil beanConvertUtil;
    private final R2dbcEntityTemplate r2dbcEntityTemplate;
    //构造函数,初始化
    public MemberCardRepositoryImpl(MemberCardDao memberCardDao, BeanConvertUtil beanConvertUtil, R2dbcEntityTemplate r2dbcEntityTemplate) {
        this.memberCardDao = memberCardDao;
        this.beanConvertUtil = beanConvertUtil;
        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
    }
    /**
     * 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
     * @param memberCardId 会员卡ID
     * @return 会员卡完整信息，如果不存在或已删除则返回空
     */
    @Override
    public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
        return memberCardDao.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
    }
    /**
     * 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
     * @param status 会员卡状态（上架/下架）
     * @param name 会员卡名称（模糊查询）
     * @param type 会员卡类型
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @param pageable 分页和排序参数
     * @return 符合条件的会员卡列表
     */
    @Override
    public Flux<MemberCard> findWithConditions(Integer status, String name, String type,
                                               Double minPrice, Double maxPrice, Pageable pageable) {
        return memberCardDao.findWithConditions(status, name, type, minPrice, maxPrice, pageable)
                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
    }
    /**
     * 统计符合条件的会员卡总数（配合列表查询使用）
     * @param status 会员卡状态
     * @param name 会员卡名称（模糊查询）
     * @param type 会员卡类型
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @return 符合条件的会员卡数量
     */
    @Override
    public Mono<Long> countWithConditions(Integer status, String name, String type,
                                          Double minPrice, Double maxPrice) {
        return memberCardDao.countWithConditions(status, name, type, minPrice, maxPrice);
    }
    /**
     * 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
     * @param status 会员卡状态（通常传上架状态）
     * @param pageable 分页和排序参数
     * @return 符合条件的会员卡列表
     */
    @Override
    public Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable) {
        return memberCardDao.findByMemberCardStatusAndDeletedAtIsNull(status, pageable)
                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
    }
    /**
     * 检查会员卡是否已被购买（用于删除前的校验）
     * @param memberCardId 会员卡ID
     * @return 如果存在关联的会员记录则返回true，否则返回false
     */
    @Override
    public Mono<Boolean> existsPurchasedRecord(Long memberCardId) {
        return memberCardDao.existsPurchasedRecord(memberCardId);
    }
    /**
     * 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
     * @param memberCardId 会员卡ID
     * @return 受影响的行数
     */
    @Override
    public Mono<Integer> logicalDelete(Long memberCardId) {
        return memberCardDao.logicalDelete(memberCardId);
    }
    /**
     * 安全更新会员卡信息（不覆盖不允许修改的字段）
     * @param memberCardId 会员卡ID
     * @param updateData 需要更新的卡种信息
     * @return 受影响的行数
     */
    public Mono<Integer> updateSafe(Long memberCardId, MemberCard updateData) {
        MemberCardEntity memberCardEntity = beanConvertUtil.toBean(updateData, MemberCardEntity.class);
        return memberCardDao.updateSafe(
                memberCardId,
                memberCardEntity.getMemberCardName(),
                memberCardEntity.getMemberCardPrice(),
                memberCardEntity.getMemberCardValidityDays(),
                memberCardEntity.getMemberCardTotalTimes(),
                memberCardEntity.getMemberCardAmount(),
                memberCardEntity.getMemberCardStatus()
        );
    }
    /**
     * 保存卡种信息（新增或更新）
     * - 新增：entity.memberCardId 为 null 时，插入新记录
     * - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
     * 建议：更新时优先使用 updateSafe 方法避免全字段覆盖
     * @param entity 卡种信息
     * @return 保存后的实体对象
     */
    @Override
    public Mono<MemberCard> save(MemberCard entity) {
        MemberCardEntity cardEntity = beanConvertUtil.toBean(entity, MemberCardEntity.class);
        return memberCardDao.save(cardEntity)
                .map(savedEntity -> beanConvertUtil.toBean(savedEntity, MemberCard.class));
    }
    /**
     * 批量查询上架的会员卡（用于小程序端展示）
     * @param status 上架状态值
     * @return 上架的会员卡列表
     */
    @Override
    public Flux<MemberCard> findActiveCards(Integer status) {
        return memberCardDao.findActiveCards(status)
                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
    }
 }
@@ -1,147 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.repository.impl;
 import cn.novalon.gym.manage.gymmembercard.dao.MemberCardTransactionsDao;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
 import cn.novalon.gym.manage.gymmembercard.entity.MemberCardTransactionsEntity;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
 import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardTransactionsRepository;
 import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
@Repository
 public class MemberCardTransactionsRepositoryImpl implements IMemberCardTransactionsRepository {
    private final MemberCardTransactionsDao memberCardTransactionsDao;
    private final BeanConvertUtil beanConvertUtil;
    private final R2dbcEntityTemplate r2dbcEntityTemplate;
    public MemberCardTransactionsRepositoryImpl(MemberCardTransactionsDao memberCardTransactionsDao, BeanConvertUtil beanConvertUtil, R2dbcEntityTemplate r2dbcEntityTemplate) {
        this.memberCardTransactionsDao = memberCardTransactionsDao;
        this.beanConvertUtil = beanConvertUtil;
        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
    }
    /**
     * 记录每一次变动
     * @param transactions 流水记录
     * @return 插入的流水记录
     */
    @Override
    public Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions) {
        MemberCardTransactionsEntity entity = beanConvertUtil.toBean(transactions, MemberCardTransactionsEntity.class);
        return memberCardTransactionsDao.insertTransaction(
                        entity.getMemberCardId(),
                        entity.getMemberId(),
                        entity.getOperationType(),
                        entity.getChangeAmount(),
                        entity.getChangeBalance(),
                        entity.getAfterRemainingCount(),
                        entity.getAfterRemainingBalance(),
                        entity.getRelatedBizType(),
                        entity.getRemark())
                .map(e -> beanConvertUtil.toBean(e, MemberCardTransactions.class));
    }
    /**
     * 会员端"使用记录"
     * @param memberId 会员ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageable 分页参数
     * @return 流水记录列表
     */
    @Override
    public Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
                                                                    LocalDateTime endTime, Pageable pageable) {
        return memberCardTransactionsDao.findByMemberIdAndTimeRange(memberId, startTime, endTime, pageable)
                .map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
    }
    /**
     * 后台"使用记录查询"
     * @param memberId 会员ID
     * @param memberCardId 会员卡ID
     * @param operationType 操作类型
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageable 分页参数
     * @return 流水记录列表
     */
    @Override
    public Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
                                                            MemberCardTransactionsAction operationType,
                                                            LocalDateTime startTime, LocalDateTime endTime,
                                                            Pageable pageable) {
        return memberCardTransactionsDao.findWithConditions(memberId, memberCardId, operationType,
                                                             startTime, endTime, pageable)
                .map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
    }
    /**
     * 统计符合条件的流水总数
     * @param memberId 会员ID
     * @param memberCardId 会员卡ID
     * @param operationType 操作类型
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 流水记录数量
     */
    @Override
    public Mono<Long> countWithConditions(Long memberId, Long memberCardId,
                                          MemberCardTransactionsAction operationType,
                                          LocalDateTime startTime, LocalDateTime endTime) {
        return memberCardTransactionsDao.countWithConditions(memberId, memberCardId,
                                                              operationType, startTime, endTime);
    }
    /**
     * 按会员卡ID查询所有流水记录
     * @param memberCardId 会员卡ID
     * @return 该卡的所有流水记录，按时间倒序
     */
    @Override
    public Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId) {
        return memberCardTransactionsDao.findByMemberCardId(memberCardId)
                .map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
    }
    /**
     * 数据统计 - 统计某卡种的总扣次数
     * @param memberCardId 会员卡ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 总扣次数
     */
    @Override
    public Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime) {
        return memberCardTransactionsDao.sumDeductCountByCardId(memberCardId, startTime, endTime);
    }
    /**
     * 数据统计 - 统计某时间段的续费总金额
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 续费总金额
     */
    @Override
    public Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
        return memberCardTransactionsDao.sumRenewAmountByTimeRange(startTime, endTime);
    }
    /**
     * 数据统计 - 统计某会员的购卡总金额
     * @param memberId 会员ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 购卡总金额
     */
    @Override
    public Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime) {
        return memberCardTransactionsDao.sumPurchaseAmountByMemberId(memberId, startTime, endTime);
    }
 }
@@ -1,83 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.sevice;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
 import org.springframework.data.domain.Pageable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 public interface IMemberCardRecordService {
    /**
     * 会员购卡/后台发卡
     * @param record 会员卡记录
     * @return 插入的记录
     */
    Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
    /**
     * 扣次/扣费（含防超扣校验）
     * @param recordId 会员卡记录ID
     * @param deductTimes 扣除次数
     * @param deductAmount 扣除金额
     * @return 受影响的行数（0表示余额不足，扣费失败）
     */
    Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
    /**
     * 续费
     * @param recordId 会员卡记录ID
     * @param addTimes 增加次数
     * @param addAmount 增加金额
     * @param newExpireTime 新的到期时间
     * @return 受影响的行数
     */
    Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime);
    /**
     * 状态变更
     * @param recordId 会员卡记录ID
     * @param status 新状态
     * @return 受影响的行数
     */
    Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status);
    /**
     * 会员端"我的卡包"
     * @param memberId 会员ID
     * @return 有效会员卡列表
     */
    Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
    /**
     * 前台/店长查会员卡
     * @param memberId 会员ID
     * @param pageable 分页参数
     * @return 会员卡列表
     */
    Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
    /**
     * 验证次卡是否可用（仅检验次数和过期时间）
     * @param recordId 会员卡记录ID
     * @param requiredTimes 需要的次数
     * @return 符合条件的记录，空表示不可用
     */
    Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
    /**
     * 验证储值卡是否可用（仅检验余额和过期时间）
     * @param recordId 会员卡记录ID
     * @param requiredAmount 需要的金额
     * @return 符合条件的记录，空表示不可用
     */
    Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
    /**
     * 到期扫描（分批处理，避免内存压力）
     * @return 已过期的会员卡记录列表（最多500条）
     */
    Flux<MemberCardRecord> findExpiredCards();
 }
@@ -1,78 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.sevice;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
 import org.springframework.data.domain.Pageable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 public interface IMemberCardService {
    /**
     * 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
     * @param memberCardId 会员卡ID
     * @return 会员卡完整信息，如果不存在或已删除则返回空
     */
    Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
    /**
     * 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
     * @param status 会员卡状态（上架/下架）
     * @param name 会员卡名称（模糊查询）
     * @param type 会员卡类型
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @param pageable 分页和排序参数
     * @return 符合条件的会员卡列表
     */
    Flux<MemberCard> findWithConditions(Integer status, String name, String type,
                                        Double minPrice, Double maxPrice, Pageable pageable);
    /**
     * 统计符合条件的会员卡总数（配合列表查询使用）
     * @param status 会员卡状态
     * @param name 会员卡名称（模糊查询）
     * @param type 会员卡类型
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @return 符合条件的会员卡数量
     */
    Mono<Long> countWithConditions(Integer status, String name, String type,
                                   Double minPrice, Double maxPrice);
    /**
     * 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
     * @param status 会员卡状态（通常传上架状态）
     * @param pageable 分页和排序参数
     * @return 符合条件的会员卡列表
     */
    Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
    /**
     * 检查会员卡是否已被购买（用于删除前的校验）
     * @param memberCardId 会员卡ID
     * @return 如果存在关联的会员记录则返回true，否则返回false
     */
    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
    /**
     * 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
     * @param memberCardId 会员卡ID
     * @return 受影响的行数
     */
    Mono<Integer> logicalDelete(Long memberCardId);
    /**
     * 保存卡种信息（新增或更新）
     * - 新增：entity.memberCardId 为 null 时，插入新记录
     * - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
     * @param entity 卡种信息
     * @return 保存后的实体对象
     */
    Mono<MemberCard> save(MemberCard entity);
    /**
     * 批量查询上架的会员卡（用于小程序端展示）
     * @param status 上架状态值
     * @return 上架的会员卡列表
     */
    Flux<MemberCard> findActiveCards(Integer status);
 }
@@ -1,91 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.sevice;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
 import org.springframework.data.domain.Pageable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 public interface IMemberCardTransactionsService {
    /**
     * 记录每一次变动
     * @param transactions 流水记录
     * @return 插入的流水记录
     */
    Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions);
    /**
     * 会员端"使用记录"
     * @param memberId 会员ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageable 分页参数
     * @return 流水记录列表
     */
    Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
                                                             LocalDateTime endTime, Pageable pageable);
    /**
     * 后台"使用记录查询"
     * @param memberId 会员ID
     * @param memberCardId 会员卡ID
     * @param operationType 操作类型
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageable 分页参数
     * @return 流水记录列表
     */
    Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
                                                     MemberCardTransactionsAction operationType,
                                                     LocalDateTime startTime, LocalDateTime endTime,
                                                     Pageable pageable);
    /**
     * 统计符合条件的流水总数
     * @param memberId 会员ID
     * @param memberCardId 会员卡ID
     * @param operationType 操作类型
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 流水记录数量
     */
    Mono<Long> countWithConditions(Long memberId, Long memberCardId,
                                   MemberCardTransactionsAction operationType,
                                   LocalDateTime startTime, LocalDateTime endTime);
    /**
     * 按会员卡ID查询所有流水记录
     * @param memberCardId 会员卡ID
     * @return 该卡的所有流水记录，按时间倒序
     */
    Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId);
    /**
     * 数据统计 - 统计某卡种的总扣次数
     * @param memberCardId 会员卡ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 总扣次数
     */
    Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime);
    /**
     * 数据统计 - 统计某时间段的续费总金额
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 续费总金额
     */
    Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
    /**
     * 数据统计 - 统计某会员的购卡总金额
     * @param memberId 会员ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 购卡总金额
     */
    Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
 }
@@ -1,65 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.sevice.impl;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
 import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRepository;
 import cn.novalon.gym.manage.gymmembercard.repository.impl.MemberCardRepositoryImpl;
 import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardService;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@Service
 public class MemberCardServiceImpl implements IMemberCardService {
    private final IMemberCardRepository memberCardRepository;
    public MemberCardServiceImpl(IMemberCardRepository memberCardRepository) {
        this.memberCardRepository = memberCardRepository;
    }
    @Override
    public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
        return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId);
    }
    @Override
    public Flux<MemberCard> findWithConditions(Integer status, String name, String type,
                                               Double minPrice, Double maxPrice, Pageable pageable) {
        return memberCardRepository.findWithConditions(status, name, type, minPrice, maxPrice, pageable);
    }
    @Override
    public Mono<Long> countWithConditions(Integer status, String name, String type,
                                          Double minPrice, Double maxPrice) {
        return memberCardRepository.countWithConditions(status, name, type, minPrice, maxPrice);
    }
    @Override
    public Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable) {
        return memberCardRepository.findByMemberCardStatusAndDeletedAtIsNull(status, pageable);
    }
    @Override
    public Mono<Boolean> existsPurchasedRecord(Long memberCardId) {
        return memberCardRepository.existsPurchasedRecord(memberCardId);
    }
    @Override
    public Mono<Integer> logicalDelete(Long memberCardId) {
        return memberCardRepository.logicalDelete(memberCardId);
    }
    public Mono<Integer> updateSafe(Long memberCardId, MemberCard updateData) {
        return ((MemberCardRepositoryImpl) memberCardRepository).updateSafe(memberCardId, updateData);
    }
    @Override
    public Mono<MemberCard> save(MemberCard entity) {
        return memberCardRepository.save(entity);
    }
    @Override
    public Flux<MemberCard> findActiveCards(Integer status) {
        return memberCardRepository.findActiveCards(status);
    }
 }
@@ -1,69 +0,0 @@
 package cn.novalon.gym.manage.gymmembercard.sevice.impl;
 import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
 import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
 import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardTransactionsRepository;
 import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardTransactionsService;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
@Service
 public class MemberCardTransactionsServiceImpl implements IMemberCardTransactionsService {
    private final IMemberCardTransactionsRepository memberCardTransactionsRepository;
    public MemberCardTransactionsServiceImpl(IMemberCardTransactionsRepository memberCardTransactionsRepository) {
        this.memberCardTransactionsRepository = memberCardTransactionsRepository;
    }
    @Override
    public Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions) {
        return memberCardTransactionsRepository.insertTransaction(transactions);
    }
    @Override
    public Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
                                                                    LocalDateTime endTime, Pageable pageable) {
        return memberCardTransactionsRepository.findByMemberIdAndTimeRange(memberId, startTime, endTime, pageable);
    }
    @Override
    public Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
                                                            MemberCardTransactionsAction operationType,
                                                            LocalDateTime startTime, LocalDateTime endTime,
                                                            Pageable pageable) {
        return memberCardTransactionsRepository.findWithConditions(memberId, memberCardId, operationType,
                                                             startTime, endTime, pageable);
    }
    @Override
    public Mono<Long> countWithConditions(Long memberId, Long memberCardId,
                                          MemberCardTransactionsAction operationType,
                                          LocalDateTime startTime, LocalDateTime endTime) {
        return memberCardTransactionsRepository.countWithConditions(memberId, memberCardId,
                                                              operationType, startTime, endTime);
    }
    @Override
    public Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId) {
        return memberCardTransactionsRepository.findByMemberCardId(memberCardId);
    }
    @Override
    public Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime) {
        return memberCardTransactionsRepository.sumDeductCountByCardId(memberCardId, startTime, endTime);
    }
    @Override
    public Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
        return memberCardTransactionsRepository.sumRenewAmountByTimeRange(startTime, endTime);
    }
    @Override
    public Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime) {
        return memberCardTransactionsRepository.sumPurchaseAmountByMemberId(memberId, startTime, endTime);
    }
 }
@@ -1 +0,0 @@
 spring.application.name=gym-member-card
@@ -0,0 +1,47 @@
 target/
 !.mvn/wrapper/maven-wrapper.jar
 !**/src/main/**/target/
 !**/src/test/**/target/
 ### STS ###
 .apt_generated
 .classpath
 .factorypath
 .project
 .settings
 .springBeans
 .sts4-cache
 ### IntelliJ IDEA ###
 .idea
 *.iws
 *.iml
 *.ipr
 ### NetBeans ###
 /nbproject/private/
 /nbbuild/
 /dist/
 /nbdist/
 /.nb-gradle/
 build/
 !**/src/main/**/build/
 !**/src/test/**/build/
 ### VS Code ###
 .vscode/
 ### Maven ###
 pom.xml.tag
 pom.xml.releaseBackup
 pom.xml.versionsBackup
 pom.xml.next
 release.properties
 dependency-reduced-pom.xml
 buildNumber.properties
 .mvn/timing.properties
 .mvn/wrapper/maven-wrapper.jar
 ### System Files ###
 .DS_Store
 Thumbs.db
@@ -0,0 +1,199 @@
 # gym-member-card 模块合并到 gym-member 完成报告
 ## 合并概述
 将 `gym-member-card` 模块的功能合并到 `gym-member` 模块的 `card` 子包中，保持功能不变，代码风格以 `gym-member` 为基准。
 ## 已完成的工作
 ### 1. 目录结构创建 ✅
 在 `gym-member/src/main/java/cn/novalon/gym/manage/member/card` 下创建了以下子目录：
 - `entity/` - 实体类
 - `dto/` - 数据传输对象
 - `vo/` - 视图对象
 - `repository/` - 数据访问层
 - `service/` - 服务接口
 - `service/impl/` - 服务实现
 - `handler/` - 业务处理器
 - `enums/` - 枚举类
 - `util/` - 工具类
 ### 2. 实体类重构（Entity）✅
 按照 gym-member 的风格（使用 Lombok），创建了以下实体类：
 | 原文件 | 新文件 | 说明 |
 |--------|--------|------|
 | MemberCardEntity.java + MemberCard.java | card/entity/MemberCard.java | 会员卡类型实体 |
 | MemberCardRecordEntity.java + MemberCardRecord.java | card/entity/MemberCardRecord.java | 会员持卡记录实体 |
 | MemberCardTransactionsEntity.java | card/entity/MemberCardTransaction.java | 交易流水实体 |
 | RefundApplicationEntity.java | card/entity/RefundApplication.java | 退款申请实体 |
 **主要改进：**
 - 使用 `@Data`, `@Builder`, `@NoArgsConstructor`, `@AllArgsConstructor` Lombok 注解
 - 继承 `cn.novalon.gym.manage.member.entity.BaseEntity`
 - 移除手动编写的 getter/setter
 - 添加规范的 JavaDoc 注释
 ### 3. 枚举类创建 ✅
 创建了以下枚举类：
 | 原文件 | 新文件 | 说明 |
 |--------|--------|------|
 | MemberCardType.java | card/enums/MemberCardType.java | 会员卡类型 |
 | MemberCardRecordStatus.java | card/enums/MemberCardRecordStatus.java | 卡片状态 |
 | MemberCardTransactionsAction.java | card/enums/TransactionType.java | 交易操作类型 |
 | MemberCardTransactionsType.java | card/enums/BizType.java | 关联业务类型 |
 | MemberCardEvent.java | card/enums/CardEvent.java | 状态机事件 |
 ### 4. Repository 层合并 ✅
 将原有的 DAO 接口整合为 Repository 接口，直接继承 `R2dbcRepository`：
 | 原文件 | 新文件 | 说明 |
 |--------|--------|------|
 | MemberCardDao.java | card/repository/MemberCardRepository.java | 会员卡类型 Repository |
 | MemberCardRecordDao.java | card/repository/MemberCardRecordRepository.java | 持卡记录 Repository |
 | MemberCardTransactionsDao.java | card/repository/MemberCardTransactionRepository.java | 交易流水 Repository |
 | RefundApplicationDao.java | card/repository/RefundApplicationRepository.java | 退款申请 Repository |
 **主要改进：**
 - 统一命名规范（移除 Dao，使用 Repository）
 - 继承 `R2dbcRepository<Entity, Long>`
 - 保留所有自定义查询方法
 - 更新参数类型为新的实体类
 ### 5. 数据库 Schema 迁移 ✅
 将会员卡相关的表结构添加到 `gym-member/src/main/resources/db/schema.sql`：
 新增表：
 - `member_card` - 会员卡类型表
 - `member_card_record` - 会员持卡记录表
 - `member_card_transactions` - 交易流水表
 - `refund_application` - 退款申请表
 包含完整的索引和注释。
 ### 6. pom.xml 依赖更新 ✅
 在 `gym-member/pom.xml` 中添加了 Redis 响应式支持：
 ```xml
 <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
 </dependency>
 ```
 ## 待完成的工作
 ### 需要手动复制的文件（约30个）
 以下文件需要从 `gym-member-card` 复制到 `gym-member/card`，并修改包名：
 #### Handler 层（8个文件）
 源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/handler/`
 目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/handler/`
 - DistributedLockService.java
 - ExpirationReminderService.java
 - MemberCardHandler.java
 - MemberCardRecordHandler.java
 - MemberCardScheduledHandler.java
 - MemberCardStateMachine.java
 - MemberCardTransactionHandler.java
 - RefundSagaHandler.java
 #### Service 接口层（4个文件）
 源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/`
 目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/service/`
 注意：目录名从 `sevice`（拼写错误）改为 `service`
 - IMemberCardService.java
 - IMemberCardRecordService.java
 - IMemberCardTransactionsService.java
 - IRefundApplicationService.java
 #### Service 实现层（4个文件）
 源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/`
 目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/service/impl/`
 - MemberCardServiceImpl.java
 - MemberCardRecordServiceImpl.java
 - MemberCardTransactionsServiceImpl.java
 - RefundApplicationServiceImpl.java
 #### Util 工具类（1个文件）
 源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/util/`
 目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/util/`
 - BeanConvertUtil.java
 ### 批量替换规则
 复制每个文件后，需要进行以下文本替换：
 1. **包名替换：**
   ```
   package cn.novalon.gym.manage.gymmembercard -> package cn.novalon.gym.manage.member.card
   ```
 2. **导入语句替换：**
   ```
   import cn.novalon.gym.manage.gymmembercard -> import cn.novalon.gym.manage.member.card
   ```
 3. **BaseEntity 导入替换：**
   ```
   import cn.novalon.gym.manage.db.entity.BaseEntity -> import cn.novalon.gym.manage.member.entity.BaseEntity
   ```
 4. **BaseDomain 处理（如果存在）：**
   ```
   import cn.novalon.gym.manage.sys.core.domain.BaseDomain -> （注释掉或删除）
   ```
 5. **Repository 引用更新（如果需要）：**
   ```
   IMemberCardRepository -> MemberCardRepository
   IMemberCardRecordRepository -> MemberCardRecordRepository
   IMemberCardTransactionsRepository -> MemberCardTransactionRepository
   IRefundApplicationRepository -> RefundApplicationRepository
   ```
 ## 验证步骤
 完成文件复制后，执行以下验证：
 1. **编译验证：**
   ```bash
   cd gym-manage-api/gym-member
   mvn clean compile
   ```
 2. **检查是否有编译错误：**
   - 修复任何缺失的导入
   - 确认所有依赖类都已正确迁移
   - 检查枚举引用是否正确
 3. **运行测试（如果有）：**
   ```bash
   mvn test
   ```
 ## 注意事项
 1. **包名一致性：** 确保所有文件中的包声明和导入语句都正确更新
 2. **依赖注入：** Spring 的 `@Autowired` 或构造函数注入应自动工作，因为使用了相同的注解
 3. **数据库兼容性：** schema.sql 已追加新表，不会影响现有表
 4. **Redis 配置：** 确保 application.yml 中有 Redis 配置（如果需要分布式锁功能）
 5. **定时任务：** MemberCardScheduledHandler 和 ExpirationReminderService 可能需要启用 `@EnableScheduling`
 ## 自动化脚本
 项目根目录下提供了两个辅助脚本：
 - `gym-member-card/migrate_to_member.py` - Python 迁移脚本
 - `gym-member-card/migrate-to-member.ps1` - PowerShell 迁移脚本
 可以运行这些脚本来自动完成文件复制和包名替换。
 ---
 **生成时间：** 2026-05-27
 **合并状态：** 基础架构完成，待复制业务逻辑文件
@@ -0,0 +1,58 @@
 -- ============================================
 -- member_user 表 - 简洁版建表语句
 -- ============================================
 -- 用途：直接复制执行，快速创建会员表
 -- ============================================
 CREATE TABLE IF NOT EXISTS member_user (
    -- 主键和基础字段
    id BIGSERIAL PRIMARY KEY,
    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    -- 会员核心字段
    member_no VARCHAR(50) NOT NULL UNIQUE,
    nickname VARCHAR(100),
    phone VARCHAR(255),
    gender INTEGER DEFAULT 0,
    birthday TIMESTAMP,
    address VARCHAR(500),
    avatar VARCHAR(500),
    subscribed BOOLEAN DEFAULT FALSE,
    last_login_at TIMESTAMP,
    -- 微信相关字段
    union_id VARCHAR(100),
    miniapp_open_id VARCHAR(100),
    official_open_id VARCHAR(100),
    -- 软删除字段
    is_deleted BOOLEAN DEFAULT FALSE
 );
 -- 创建索引
 CREATE UNIQUE INDEX IF NOT EXISTS idx_member_user_member_no ON member_user(member_no);
 CREATE INDEX IF NOT EXISTS idx_member_user_union_id ON member_user(union_id);
 CREATE INDEX IF NOT EXISTS idx_member_user_miniapp_openid ON member_user(miniapp_open_id);
 CREATE INDEX IF NOT EXISTS idx_member_user_official_openid ON member_user(official_open_id);
 CREATE INDEX IF NOT EXISTS idx_member_user_phone ON member_user(phone);
 CREATE INDEX IF NOT EXISTS idx_member_user_is_deleted ON member_user(is_deleted);
 -- 添加注释
 COMMENT ON TABLE member_user IS '会员表';
 COMMENT ON COLUMN member_user.id IS '主键ID';
 COMMENT ON COLUMN member_user.created_at IS '创建时间';
 COMMENT ON COLUMN member_user.updated_at IS '更新时间';
 COMMENT ON COLUMN member_user.member_no IS '会员编号（唯一）';
 COMMENT ON COLUMN member_user.nickname IS '昵称';
 COMMENT ON COLUMN member_user.phone IS '手机号（AES加密存储）';
 COMMENT ON COLUMN member_user.gender IS '性别：0-未知，1-男，2-女';
 COMMENT ON COLUMN member_user.birthday IS '生日';
 COMMENT ON COLUMN member_user.address IS '地址';
 COMMENT ON COLUMN member_user.avatar IS '头像URL';
 COMMENT ON COLUMN member_user.subscribed IS '是否关注服务号';
 COMMENT ON COLUMN member_user.last_login_at IS '最后登录时间';
 COMMENT ON COLUMN member_user.union_id IS '微信UnionID（跨应用唯一标识）';
 COMMENT ON COLUMN member_user.miniapp_open_id IS '小程序OpenID';
 COMMENT ON COLUMN member_user.official_open_id IS '服务号OpenID';
 COMMENT ON COLUMN member_user.is_deleted IS '是否删除（软删除标记）';
@@ -0,0 +1,250 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>cn.novalon.gym.manage</groupId>
        <artifactId>gym-manage-api</artifactId>
        <version>1.0.0</version>
    </parent>
    <artifactId>gym-member</artifactId>
    <packaging>jar</packaging>
    <name>Gym Member</name>
    <description>Member Management Module - Frontend User Services</description>
    <dependencies>
        <dependency>
            <groupId>cn.novalon.gym.manage</groupId>
            <artifactId>manage-common</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>cn.novalon.gym.manage</groupId>
            <artifactId>manage-db</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>cn.novalon.gym.manage</groupId>
            <artifactId>manage-sys</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-commons</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.github.resilience4j</groupId>
            <artifactId>resilience4j-spring-boot3</artifactId>
        </dependency>
        <dependency>
            <groupId>io.github.resilience4j</groupId>
            <artifactId>resilience4j-reactor</artifactId>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>testcontainers</artifactId>
            <version>1.21.4</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>postgresql</artifactId>
            <version>1.21.4</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>1.21.4</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.r2dbc</groupId>
            <artifactId>r2dbc-h2</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>r2dbc-postgresql</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 微信SDK依赖 -->
        <dependency>
            <groupId>com.github.binarywang</groupId>
            <artifactId>weixin-java-miniapp</artifactId>
            <version>4.6.0</version>
        </dependency>
        <dependency>
            <groupId>com.github.binarywang</groupId>
            <artifactId>weixin-java-mp</artifactId>
            <version>4.6.0</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.25</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
        <!-- Redis响应式支持（会员卡模块需要） -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.4.2</version>
                <executions>
                    <execution>
                        <id>default-jar</id>
                        <phase>package</phase>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>21</source>
                    <target>21</target>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>1.5.5.Final</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>${lombok.version}</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok-mapstruct-binding</artifactId>
                            <version>0.2.0</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>0.8.12</version>
                <executions>
                    <execution>
                        <id>prepare-agent</id>
                        <goals>
                            <goal>prepare-agent</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>report</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>report</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>check</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>check</goal>
                        </goals>
                        <configuration>
                            <rules>
                                <rule>
                                    <element>BUNDLE</element>
                                    <limits>
                                        <limit>
                                            <counter>INSTRUCTION</counter>
                                            <value>COVEREDRATIO</value>
                                            <minimum>0.60</minimum>
                                        </limit>
                                    </limits>
                                </rule>
                            </rules>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>com.github.spotbugs</groupId>
                <artifactId>spotbugs-maven-plugin</artifactId>
                <version>4.8.6.0</version>
                <dependencies>
                    <dependency>
                        <groupId>com.github.spotbugs</groupId>
                        <artifactId>spotbugs</artifactId>
                        <version>4.8.6</version>
                    </dependency>
                </dependencies>
                <executions>
                    <execution>
                        <id>spotbugs-check</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>check</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <effort>Max</effort>
                    <threshold>High</threshold>
                    <failOnError>true</failOnError>
                    <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
                </configuration>
            </plugin>
        </plugins>
    </build>
 </project>
@@ -0,0 +1,22 @@
 package cn.novalon.gym.manage.member.config;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.reactive.function.client.WebClient;
 /**
 * HTTP 客户端配置
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Configuration
 public class HttpClientConfig {
    // WebClient Bean，用于调用微信 API
    @Bean
    public WebClient webClient() {
        return WebClient.builder().build();
    }
 }
@@ -0,0 +1,63 @@
 package cn.novalon.gym.manage.member.config;
 import lombok.Data;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.stereotype.Component;
 /**
 * 微信配置
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Data
@Component
@ConfigurationProperties(prefix = "wechat")
 public class WechatProperties {
    // 小程序配置
    private MiniApp miniapp = new MiniApp();
    // 服务号配置
    private Mp mp = new Mp();
    // 手机号加密配置
    private PhoneEncryption phoneEncryption = new PhoneEncryption();
    @Data
    public static class MiniApp {
        // 小程序 AppID
        private String appId;
        // 小程序 AppSecret
        private String appSecret;
    }
    @Data
    public static class Mp {
        // 服务号 AppID
        private String appId;
        // 服务号 AppSecret
        private String appSecret;
        // Token 验证信息
        private String token;
        // EncodingAESKey
        private String aesKey;
        // 回调地址（微信服务号事件推送 URL）
        private String callbackUrl;
    }
    @Data
    public static class PhoneEncryption {
        // 手机号加密密钥
        private String secretKey;
        // 初始化向量 IV
        private String iv;
    }
 }
@@ -0,0 +1,17 @@
 package cn.novalon.gym.manage.member.dto;
 import lombok.Data;
 /**
 * 更新手机号Dto
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Data
 public class AdminUpdatePhoneDto {
    // 手机号
    private String phone;
 }
@@ -0,0 +1,61 @@
 package cn.novalon.gym.manage.member.dto
 ;
 import lombok.Data;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import java.math.BigDecimal;
 /**
 * 创建会员卡类型请求 DTO
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
 public class CreateMemberCardRequest {
    /**
     * 会员卡名称
     */
    @NotBlank(message = "会员卡名称不能为空")
    private String memberCardName;
    /**
     * 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
     */
    @NotBlank(message = "会员卡类型不能为空")
    private String memberCardType;
    /**
     * 会员卡价格
     */
    @NotNull(message = "会员卡价格不能为空")
    private BigDecimal memberCardPrice;
    /**
     * 有效天数（时长卡用）
     */
    private Integer memberCardValidityDays;
    /**
     * 总次数（次卡用）
     */
    private Integer memberCardTotalTimes;
    /**
     * 面额（储值卡用）
     */
    private BigDecimal memberCardAmount;
    /**
     * 状态：0-下架, 1-上架
     */
    private Integer memberCardStatus = 1;
    /**
     * 扩展配置（JSON格式）
     */
    private String extraConfig;
 }
@@ -0,0 +1,32 @@
 package cn.novalon.gym.manage.member.dto;
 import lombok.Data;
 import jakarta.validation.constraints.NotNull;
 /**
 * 购买会员卡请求 DTO
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
 public class PurchaseCardRequest {
    /**
     * 会员ID
     */
    @NotNull(message = "会员ID不能为空")
    private Long memberId;
    /**
     * 会员卡类型ID
     */
    @NotNull(message = "会员卡类型ID不能为空")
    private Long memberCardId;
    /**
     * 来源订单ID
     */
    private Long sourceOrderId;
 }
@@ -0,0 +1,21 @@
 package cn.novalon.gym.manage.member.dto;
 import lombok.Data;
 import jakarta.validation.constraints.NotBlank;
 /**
 * 退款申请请求 DTO
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
 public class RefundCardRequest {
    /**
     * 退款原因
     */
    @NotBlank(message = "退款原因不能为空")
    private String reason;
 }
@@ -0,0 +1,35 @@
 package cn.novalon.gym.manage.member.dto;
 import lombok.Data;
 import jakarta.validation.constraints.NotNull;
 /**
 * 续费会员卡请求 DTO
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
 public class RenewCardRequest {
    /**
     * 增加的次数
     */
    private Integer addTimes;
    /**
     * 增加的金额
     */
    private Double addAmount;
    /**
     * 增加的天数
     */
    private Integer addDays;
    /**
     * 来源订单ID
     */
    private Long sourceOrderId;
 }
@@ -0,0 +1,23 @@
 package cn.novalon.gym.manage.member.dto;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
 public class SearchMemberDto {
    // 搜索字段 - 包括 会员号、昵称、手机号
    private String searchValue;
    // 排序
    private String filter;
    // 页码
    private Integer pageNum = 1;
    // 页大小
    private Integer pageSize = 10;
 }
@@ -0,0 +1,60 @@
 package cn.novalon.gym.manage.member.dto;
 import lombok.Data;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import java.math.BigDecimal;
 /**
 * 更新会员卡类型请求 DTO
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
 public class UpdateMemberCardRequest {
    /**
     * 会员卡名称
     */
    @NotBlank(message = "会员卡名称不能为空")
    private String memberCardName;
    /**
     * 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
     */
    @NotBlank(message = "会员卡类型不能为空")
    private String memberCardType;
    /**
     * 会员卡价格
     */
    @NotNull(message = "会员卡价格不能为空")
    private BigDecimal memberCardPrice;
    /**
     * 有效天数（时长卡用）
     */
    private Integer memberCardValidityDays;
    /**
     * 总次数（次卡用）
     */
    private Integer memberCardTotalTimes;
    /**
     * 面额（储值卡用）
     */
    private BigDecimal memberCardAmount;
    /**
     * 状态：0-下架, 1-上架
     */
    private Integer memberCardStatus;
    /**
     * 扩展配置（JSON格式）
     */
    private String extraConfig;
 }
@@ -0,0 +1,30 @@
 package cn.novalon.gym.manage.member.dto;
 import lombok.Data;
 import java.util.Date;
 /**
 * 更新会员信息Dto
 * 
 * @author 付嘉
 * @date 2026-05-10
 */
@Data
 public class UpdateMemberInfoDto {
    // 昵称
    private String nickname;
    // 性别
    private Integer gender;
    // 生日
    private Date birthday;
    // 头像
    private String avatar;
    // 地址
    private String address;
 }
@@ -0,0 +1,23 @@
 package cn.novalon.gym.manage.member.dto;
 import lombok.Data;
 /**
 * 使用会员卡请求 DTO
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
 public class UseCardRequest {
    /**
     * 扣减的次数
     */
    private Integer deductTimes;
    /**
     * 扣减的金额
     */
    private Double deductAmount;
 }
@@ -0,0 +1,29 @@
 package cn.novalon.gym.manage.member.dto;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import jakarta.validation.constraints.NotBlank;
 /**
 * 微信小程序登录 DTO
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
 public class WechatLoginDto {
    // 微信小程序登录 code
    @NotBlank(message = "登录code不能为空")
    private String code;
    // 手机号code
    private String phoneCode;
 }
@@ -0,0 +1,35 @@
 package cn.novalon.gym.manage.member.dto;
 import lombok.Data;
 /**
 * 微信服务号事件 DTO
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Data
 public class WechatOfficialEventDto {
    // 微信号
    private String toUserName;
    // 发送方帐号（一个 OpenID）
    private String fromUserName;
    // 消息创建时间（整型）
    private Long createTime;
    // 消息类型，event
    private String msgType;
    // 事件类型：subscribe（关注）/ unsubscribe（取消关注）
    private String event;
    // 事件 KEY
    private String eventKey;
    // 二维码 ticket（获取二维码图片）
    private String ticket;
 }
@@ -0,0 +1,41 @@
 package cn.novalon.gym.manage.member.entity;
 import org.springframework.data.annotation.CreatedDate;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.annotation.LastModifiedDate;
 import org.springframework.data.domain.Persistable;
 import org.springframework.data.relational.core.mapping.Column;
 import lombok.Data;
 import java.time.LocalDateTime;
 /**
 * 会员模块实体基类
 * 
 * @author 付嘉
 * @date 2026-05-08
 */
@Data
 public abstract class BaseEntity implements Persistable<Long> {
    // ID
    @Id
    private Long id;
    // 创建时间
    @CreatedDate
    @Column("created_at")
    private LocalDateTime createdAt;
    // 更新时间
    @LastModifiedDate
    @Column("updated_at")
    private LocalDateTime updatedAt;
    // 判断当前实体是否是新建的
    @Override
    public boolean isNew() {
        return createdAt == null;
    }
 }
@@ -0,0 +1,81 @@
 package cn.novalon.gym.manage.member.entity;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 import java.time.LocalDateTime;
 import java.util.Date;
 /**
 * 会员实体类 - 对应 member_user 表 
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("member_user")
 public class Member extends BaseEntity {
    //会员号
    @Column("member_no")
    private String memberNo;
    //昵称
    @Column("nickname")
    private String nickname;
    //手机号（AES 加密存储
    @Column("phone")
    private String phone;
    //性别
    @Column("gender")
    private Integer gender;
    //生日
    @Column("birthday")
    private Date birthday;
    //地址
    @Column("address")
    private String address;
    //是否关注服务号
    @Column("subscribed")
    private Boolean subscribed;
    // 最后登录时间
    @Column("last_login_at")
    private LocalDateTime lastLoginAt;
    // 头像
    @Column("avatar")
    private String avatar;
    // 微信UnionID
    @Column("union_id")
    private String unionId;
    // 微信OpenID小程序
    @Column("miniapp_open_id")
    private String miniappOpenId;
    // 服务号openid
    @Column("official_open_id")
    private String officialOpenId;
    // 软删除
    @Column("is_deleted")
    private Boolean isDeleted;
 }
@@ -1,52 +1,63 @@
-package cn.novalon.gym.manage.gymmembercard.entity;
+package cn.novalon.gym.manage.member.entity;
-import cn.novalon.gym.manage.db.entity.BaseEntity;
+import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 import java.time.LocalDateTime;
-/*
+/**
- *@Author:shizhounian
+ * 会员卡类型实体 - 对应 member_card 表
- *@Date:2026/5/10-05 22:47:31
+ * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("member_card")
-public class MemberCardEntity extends BaseEntity {
+public class MemberCard extends BaseEntity {
-    //会员卡id
+
    // 会员卡ID
    @Column("member_card_id")
    private Long memberCardId;
-    //会员卡名称
+    // 会员卡名称
    @Column("member_card_name")
    private String memberCardName;
-    //会员卡类型
+    // 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
    @Column("member_card_type")
    private String memberCardType;
-    //会员卡价格
+    // 会员卡价格
    @Column("member_card_price")
    private Double memberCardPrice;
-    //会员卡有效天数（时长卡用）
+    // 有效天数（时长卡用）
    @Column("member_card_validity_days")
    private Integer memberCardValidityDays;
-    //会员卡总次数（次卡用）
+    // 总次数（次卡用）
    @Column("member_card_total_times")
    private Integer memberCardTotalTimes;
-    //会员卡面额（储值卡用）
+    // 面额（储值卡用）
    @Column("member_card_amount")
    private Double memberCardAmount;
-    //会员卡状态：0-正常，1-禁用
+    // 状态：0-下架, 1-上架
    @Column("member_card_status")
    private Integer memberCardStatus;
-    //会员卡创建时间
+    // 扩展配置（JSON格式）
-    @Column("member_card_create_time")
+    @Column("extra_config")
-    private LocalDateTime memberCardCreateTime;
+    private String extraConfig;
 }
@@ -0,0 +1,72 @@
 package cn.novalon.gym.manage.member.entity;
 import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 import java.time.LocalDateTime;
 /**
 * 会员卡记录实体（会员持有的卡）- 对应 member_card_record 表
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("member_card_record")
 public class MemberCardRecord extends BaseEntity {
    // 会员持有卡ID
    @Column("member_card_record_id")
    private Long memberCardRecordId;
    // 会员ID
    @Column("member_id")
    private Long memberId;
    // 关联会员卡ID
    @Column("member_card_id")
    private Long memberCardId;
    // 状态：ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款
    @Column("status")
    private MemberCardRecordStatus status;
    // 剩余次数
    @Column("remaining_times")
    private Integer remainingTimes;
    // 剩余金额
    @Column("remaining_amount")
    private Double remainingAmount;
    // 到期时间
    @Column("expire_time")
    private LocalDateTime expireTime;
    // 来源订单ID
    @Column("source_order_id")
    private Long sourceOrderId;
    // 购买时间
    @Column("purchase_time")
    private LocalDateTime purchaseTime;
    // 乐观锁版本号
    @Column("version")
    private Integer version;
    // 卡片组成（JSON格式，用于组合卡）
    @Column("card_composition")
    private String cardComposition;
 }
@@ -0,0 +1,77 @@
 package cn.novalon.gym.manage.member.entity;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 /**
 * 会员卡交易流水实体 - 对应 member_card_transactions 表
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("member_card_transactions")
 public class MemberCardTransaction extends BaseEntity {
    // 交易ID
    @Column("member_card_record_id")
    private Long memberCardRecordId;
    // 会员ID
    @Column("member_id")
    private Long memberId;
    // 会员卡ID
    @Column("member_card_id")
    private Long memberCardId;
    // 操作类型：PURCHASE-购买, DEDUCT-扣次/扣费, RENEW-续费, REFUND-退款, EXPIRE-过期
    @Column("operation_type")
    private String operationType;
    // 变动次数
    @Column("change_amount")
    private Integer changeAmount;
    // 变动金额
    @Column("change_balance")
    private Double changeBalance;
    // 变动后剩余次数
    @Column("after_remaining_count")
    private Integer afterRemainingCount;
    // 变动后剩余金额
    @Column("after_remaining_balance")
    private Double afterRemainingBalance;
    // 关联业务类型：GROUP_CLASS-团课, PT_CLASS-私教, CHECK_IN-签到
    @Column("related_biz_type")
    private String relatedBizType;
    // 来源订单ID
    @Column("source_order_id")
    private Long sourceOrderId;
    // 备注
    @Column("remark")
    private String remark;
    // 是否已归档
    @Column("is_archived")
    private Boolean isArchived;
    // 归档时间
    @Column("archived_at")
    private java.time.LocalDateTime archivedAt;
 }
@@ -0,0 +1,65 @@
 package cn.novalon.gym.manage.member.entity;
 import cn.novalon.gym.manage.member.enums.RefundStatus;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
 /**
 * 退款申请实体 - 对应 refund_application 表
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("refund_application")
 public class RefundApplication extends BaseEntity {
    // 会员卡记录ID
    @Column("record_id")
    private Long recordId;
    // 会员ID
    @Column("member_id")
    private Long memberId;
    // 状态：PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败
    @Column("status")
    private RefundStatus status;
    // 退款原因
    @Column("reason")
    private String reason;
    // 申请时间
    @Column("apply_time")
    private LocalDateTime applyTime;
    // 审核时间
    @Column("audit_time")
    private LocalDateTime auditTime;
    // 审核人ID
    @Column("auditor_id")
    private Long auditorId;
    // 审核备注
    @Column("audit_remark")
    private String auditRemark;
    // 退款金额
    @Column("refund_amount")
    private BigDecimal refundAmount;
 }
@@ -0,0 +1,38 @@
 package cn.novalon.gym.manage.member.entity;
 import lombok.*;
 import org.springframework.data.annotation.CreatedDate;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Table("sign_in_record")
 public class SignInRecord {
    @Id
    private Long id;
    // 会员ID
    @Column("member_id")
    private Long memberId;
    // 签到日期
    @Column("sign_in_date")
    private LocalDate signInDate;
    // 签到时间
    @Column("sign_in_time")
    private LocalDateTime signInTime;
    // 创建时间
    @CreatedDate
    @Column("created_at")
    private LocalDateTime createdAt;
 }
@@ -0,0 +1,55 @@
 package cn.novalon.gym.manage.member.entity;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 import java.time.LocalDateTime;
 /**
 * 微信用户信息
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("wechat_user")
 public class WechatUser extends BaseEntity {
    // 会员 ID
    @Column("member_id")
    private Long memberId;
    // 微信 UnionID
    @Column("union_id")
    private String unionId;
    // 小程序 OpenID
    @Column("miniapp_openid")
    private String miniappOpenid;
    // 服务号 OpenID
    @Column("mp_openid")
    private String mpOpenid;
    // 是否关注服务号
    @Column("is_subscribed")
    private Boolean isSubscribed;
    // 首次关注时间公众号的时间
    @Column("subscribe_time")
    private LocalDateTime subscribeTime;
    // 最后一次取消关注的时间
    @Column("unsubscribe_time")
    private LocalDateTime unsubscribeTime;
 }
@@ -0,0 +1,24 @@
 package cn.novalon.gym.manage.member.enums;
 /**
 * 会员卡流水关联业务类型枚举
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
 public enum BizType {
    GROUP_CLASS("团课"),
    PT_CLASS("私教"),
    CHECK_IN("签到");
    private final String desc;
    BizType(String desc) {
        this.desc = desc;
    }
    public String getDesc() {
        return desc;
    }
 }
@@ -0,0 +1,27 @@
 package cn.novalon.gym.manage.member.enums;
 /**
 * 会员卡状态机事件枚举
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
 public enum CardEvent {
    ACTIVATE("激活卡片"),
    USE("使用卡片"),
    RENEW("续费"),
    EXPIRE("过期"),
    REFUND("退款"),
    DISABLE("禁用");
    private final String desc;
    CardEvent(String desc) {
        this.desc = desc;
    }
    public String getDesc() {
        return desc;
    }
 }
@@ -0,0 +1,25 @@
 package cn.novalon.gym.manage.member.enums;
 /**
 * 会员卡记录状态枚举
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
 public enum MemberCardRecordStatus {
    ACTIVE("有效"),
    USED_UP("用完"),
    EXPIRED("过期"),
    REFUNDED("已退款");
    private final String desc;
    MemberCardRecordStatus(String desc) {
        this.desc = desc;
    }
    public String getDesc() {
        return desc;
    }
 }
@@ -0,0 +1,24 @@
 package cn.novalon.gym.manage.member.enums;
 /**
 * 会员卡类型枚举
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
 public enum MemberCardType {
    TIME_CARD("时长卡"),
    COUNT_CARD("次卡"),
    STORED_VALUE_CARD("储值卡");
    private final String desc;
    MemberCardType(String desc) {
        this.desc = desc;
    }
    public String getDesc() {
        return desc;
    }
 }
@@ -0,0 +1,27 @@
 package cn.novalon.gym.manage.member.enums;
 /**
 * 退款申请状态枚举
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
 public enum RefundStatus {
    PENDING("待审核"),
    APPROVED("已批准"),
    REJECTED("已拒绝"),
    PROCESSING("处理中"),
    SUCCESS("成功"),
    FAILED("失败");
    private final String desc;
    RefundStatus(String desc) {
        this.desc = desc;
    }
    public String getDesc() {
        return desc;
    }
 }
@@ -0,0 +1,26 @@
 package cn.novalon.gym.manage.member.enums;
 /**
 * 会员卡流水操作类型枚举
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
 public enum TransactionType {
    PURCHASE("购买"),
    DEDUCT("扣次/扣费"),
    RENEW("续费"),
    REFUND("退款"),
    EXPIRE("过期");
    private final String desc;
    TransactionType(String desc) {
        this.desc = desc;
    }
    public String getDesc() {
        return desc;
    }
 }
@@ -0,0 +1,35 @@
 package cn.novalon.gym.manage.member.es.entity;
 import lombok.Data;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.elasticsearch.annotations.Document;
 import org.springframework.data.elasticsearch.annotations.Field;
 import org.springframework.data.elasticsearch.annotations.FieldType;
@Data
@Document(indexName = "gym_members")
 public class MemberES {
    @Id
    private String id;
    // 会员号 - 需要搜索（精确匹配）
    @Field(type = FieldType.Keyword)
    private String memberNo;
    // 昵称 - 需要搜索（模糊搜索）
    @Field(type = FieldType.Text)
    private String nickname;
    // 手机号 - 需要搜索（精确匹配）
    @Field(type = FieldType.Keyword)
    private String phone;
    // 性别 - 用于筛选
    @Field(type = FieldType.Integer)
    private Integer gender;
    // 头像 - 列表展示
    @Field(type = FieldType.Keyword)
    private String avatar;
 }
@@ -0,0 +1,20 @@
 package cn.novalon.gym.manage.member.es.repository;
 import cn.novalon.gym.manage.member.es.entity.MemberES;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.elasticsearch.repository.ReactiveElasticsearchRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 /**
 * ES 会员数据访问层
 */
@Repository
 public interface MemberESRepository extends ReactiveElasticsearchRepository<MemberES, String> {
    /**
     * 前台通用搜索：会员号（精确匹配） 或 昵称（模糊匹配） 或 手机号（精确匹配）并且 性别筛选（精确匹配）
     */
    Flux<MemberES> findByMemberNoOrPhoneOrNicknameContainingAndGender(
            String memberNo, String phone, String nickname,String gender, Pageable pageable);
 }
@@ -0,0 +1,50 @@
 package cn.novalon.gym.manage.member.handler;
 import org.springframework.stereotype.Component;
 import reactor.core.publisher.Mono;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.locks.ReentrantLock;
 /**
 * 分布式锁服务（简化版，使用本地锁）
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Component
 public class DistributedLockService {
    private final ConcurrentHashMap<String, ReentrantLock> locks = new ConcurrentHashMap<>();
    /**
     * 执行带锁的操作（业务操作）
     */
    public <T> Mono<T> executeWithLock(String userId, String cardType, Mono<T> operation) {
        String lockKey = "lock:member:card:operation:" + userId + ":" + cardType;
        ReentrantLock lock = locks.computeIfAbsent(lockKey, k -> new ReentrantLock());
        lock.lock();
        try {
            return operation.doFinally(signalType -> lock.unlock());
        } catch (Exception e) {
            lock.unlock();
            return Mono.error(e);
        }
    }
    /**
     * 执行带锁的操作（通用/定时任务）
     */
    public <T> Mono<T> executeWithLock(String lockKey, Mono<T> operation) {
        ReentrantLock lock = locks.computeIfAbsent(lockKey, k -> new ReentrantLock());
        lock.lock();
        try {
            return operation.doFinally(signalType -> lock.unlock());
        } catch (Exception e) {
            lock.unlock();
            return Mono.error(e);
        }
    }
 }
@@ -0,0 +1,157 @@
 package cn.novalon.gym.manage.member.handler;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Range;
 import org.springframework.data.redis.connection.RedisZSetCommands;
 import org.springframework.data.redis.core.ReactiveStringRedisTemplate;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.Duration;
 import java.time.LocalDateTime;
 import java.util.UUID;
 /**
 * 会员卡到期提醒服务
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Slf4j
@Component
@RequiredArgsConstructor
 public class ExpirationReminderService {
    private final ReactiveStringRedisTemplate redisTemplate;
    private final ObjectMapper objectMapper;
    private static final String REMINDER_QUEUE = "queue:member_card_expiration";
    private static final String DEAD_LETTER_QUEUE = "queue:member_card_expiration_dead_letter";
    private static final int REMINDER_DAYS_BEFORE = 7;
    private static final long MAX_DELAY_MILLIS = Duration.ofDays(365).toMillis();
    /**
     * 设置到期提醒（购卡/续费时调用）
     */
    public Mono<Void> scheduleExpirationReminder(MemberCardRecord record) {
        if (record.getExpireTime() == null) {
            return Mono.empty();
        }
        LocalDateTime now = LocalDateTime.now();
        Flux<Void> reminderFlux = Flux.range(1, REMINDER_DAYS_BEFORE)
            .flatMap(daysBefore -> {
                LocalDateTime reminderTime = record.getExpireTime().minusDays(daysBefore);
                if (reminderTime.isBefore(now)) {
                    log.debug("会员卡记录ID={} 的{}天前提醒时间已过，跳过",
                        record.getMemberCardRecordId(), daysBefore);
                    return Mono.empty();
                }
                long delayMillis = Duration.between(now, reminderTime).toMillis();
                if (delayMillis > MAX_DELAY_MILLIS) {
                    log.warn("会员卡记录ID={} 的{}天后提醒时间超过1年，跳过",
                        record.getMemberCardRecordId(), daysBefore);
                    return Mono.empty();
                }
                try {
                    String messageId = UUID.randomUUID().toString();
                    String message = objectMapper.writeValueAsString(new ExpirationMessage(
                            messageId,
                            record.getMemberCardRecordId(),
                            record.getMemberId(),
                            record.getExpireTime(),
                            daysBefore
                    ));
                    double executeTime = System.currentTimeMillis() + delayMillis;
                    return redisTemplate.opsForZSet()
                            .add(REMINDER_QUEUE, message, executeTime)
                            .doOnSuccess(v -> log.info("设置会员卡到期提醒: recordId={}, daysBefore={}, expireTime={}, executeTime={}",
                                    record.getMemberCardRecordId(), daysBefore, record.getExpireTime(), executeTime))
                            .then();
                } catch (Exception e) {
                    log.error("设置会员卡到期提醒失败: recordId={}, daysBefore={}",
                        record.getMemberCardRecordId(), daysBefore, e);
                    return Mono.error(e);
                }
            });
        return reminderFlux.then();
    }
    /**
     * 定时任务：每分钟扫描到期的提醒并发送
     */
    @Scheduled(fixedRate = 60000)
    public void processDueReminders() {
        double now = System.currentTimeMillis();
        redisTemplate.opsForZSet()
                .rangeByScoreWithScores(
                        REMINDER_QUEUE,
                        Range.from(Range.Bound.inclusive(0.0))
                                .to(Range.Bound.inclusive(now)),
                        RedisZSetCommands.Limit.limit().count(100)
                )
                .flatMap(tuple -> {
                    String message = tuple.getValue();
                    if (message == null) {
                        return Mono.empty();
                    }
                    return Mono.fromCallable(() -> objectMapper.readValue(message, ExpirationMessage.class))
                        .flatMap(expirationMessage -> {
                            log.info("处理到期提醒: messageId={}, memberId={}, expireTime={}, daysBefore={}",
                                    expirationMessage.messageId(),
                                    expirationMessage.memberId(),
                                    expirationMessage.expireTime(),
                                    expirationMessage.daysBefore());
                            // TODO: 集成微信/短信通知服务
                            sendNotification(expirationMessage);
                            return redisTemplate.opsForZSet()
                                .remove(REMINDER_QUEUE, message)
                                .doOnSuccess(removed -> {
                                    if (removed > 0) {
                                        log.info("成功删除已处理的提醒消息");
                                    }
                                });
                        })
                        .onErrorResume(e -> {
                            log.error("解析到期提醒消息失败，移至死信队列: message={}", message, e);
                            return redisTemplate.opsForZSet()
                                .add(DEAD_LETTER_QUEUE, message, System.currentTimeMillis())
                                .then(Mono.empty());
                        });
                })
                .then()
                .subscribe();
    }
    private void sendNotification(ExpirationMessage reminder) {
        // TODO: 实际项目中调用微信模板消息或短信API
        log.info("[模拟发送] 会员卡到期提醒 - 会员ID: {}, 到期时间: {}, 提前天数: {}",
            reminder.memberId(), reminder.expireTime(), reminder.daysBefore());
    }
    public record ExpirationMessage(
            String messageId,
            Long recordId,
            Long memberId,
            LocalDateTime expireTime,
            int daysBefore
    ) {}
 }
@@ -0,0 +1,132 @@
 package cn.novalon.gym.manage.member.handler;
 import cn.novalon.gym.manage.member.entity.MemberCard;
 import cn.novalon.gym.manage.member.service.IMemberCardService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Component;
 import org.springframework.web.reactive.function.server.ServerRequest;
 import org.springframework.web.reactive.function.server.ServerResponse;
 import reactor.core.publisher.Mono;
 /**
 * 会员卡管理处理器
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Slf4j
@Component
@Tag(name = "会员卡管理", description = "会员卡类型管理和会员持卡管理")
 public class MemberCardHandler {
    private final IMemberCardService memberCardService;
    public MemberCardHandler(IMemberCardService memberCardService) {
        this.memberCardService = memberCardService;
    }
    @Operation(summary = "根据ID查询会员卡类型", description = "查询指定ID的会员卡类型详情")
    public Mono<ServerResponse> getMemberCardById(ServerRequest request) {
        Long id = Long.valueOf(request.pathVariable("id"));
        return memberCardService.findByMemberCardIdAndDeletedAtIsNull(id)
                .flatMap(card -> ServerResponse.ok().bodyValue(card))
                .switchIfEmpty(ServerResponse.notFound().build());
    }
    @Operation(summary = "查询会员卡类型列表", description = "支持分页和条件查询")
    public Mono<ServerResponse> listMemberCards(ServerRequest request) {
        Integer status = request.queryParam("status").map(Integer::valueOf).orElse(null);
        String name = request.queryParam("name").orElse(null);
        String type = request.queryParam("type").orElse(null);
        Double minPrice = request.queryParam("minPrice").map(Double::valueOf).orElse(null);
        Double maxPrice = request.queryParam("maxPrice").map(Double::valueOf).orElse(null);
        int page = request.queryParam("page").map(Integer::valueOf).orElse(0);
        int size = request.queryParam("size").map(Integer::valueOf).orElse(10);
        var pageable = PageRequest.of(page, size);
        return ServerResponse.ok()
                .body(memberCardService.findWithConditions(status, name, type, minPrice, maxPrice, pageable),
                        MemberCard.class);
    }
    @Operation(summary = "创建会员卡类型", description = "创建新的会员卡类型（时长卡、次卡或储值卡）")
    public Mono<ServerResponse> createMemberCard(ServerRequest request) {
        return request.bodyToMono(MemberCard.class)
                .flatMap(memberCardService::save)
                .flatMap(card -> ServerResponse.status(HttpStatus.CREATED).bodyValue(card));
    }
    @Operation(summary = "更新会员卡类型", description = "更新会员卡类型信息")
    public Mono<ServerResponse> updateMemberCard(ServerRequest request) {
        Long id = Long.valueOf(request.pathVariable("id"));
        return request.bodyToMono(MemberCard.class)
                .flatMap(card -> {
                    card.setMemberCardId(id);
                    return memberCardService.save(card);
                })
                .flatMap(updated -> ServerResponse.ok().bodyValue(updated))
                .switchIfEmpty(ServerResponse.notFound().build());
    }
    @Operation(summary = "删除会员卡类型", description = "逻辑删除会员卡类型")
    public Mono<ServerResponse> deleteMemberCard(ServerRequest request) {
        Long id = Long.valueOf(request.pathVariable("id"));
        return memberCardService.logicalDelete(id)
                .flatMap(rows -> {
                    if (rows > 0) {
                        return ServerResponse.noContent().build();
                    }
                    return ServerResponse.notFound().build();
                });
    }
    @Operation(summary = "购买会员卡", description = "会员购买会员卡，生成会员卡记录")
    public Mono<ServerResponse> purchaseCard(ServerRequest request) {
        Long memberId = Long.valueOf(request.queryParam("memberId").orElseThrow());
        Long memberCardId = Long.valueOf(request.queryParam("memberCardId").orElseThrow());
        Long sourceOrderId = request.queryParam("sourceOrderId").map(Long::valueOf).orElse(null);
        return memberCardService.purchaseCard(memberId, memberCardId, sourceOrderId)
                .flatMap(record -> ServerResponse.status(HttpStatus.CREATED).bodyValue(record));
    }
    @Operation(summary = "续费会员卡", description = "为已有会员卡续费")
    public Mono<ServerResponse> renewCard(ServerRequest request) {
        Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
        Integer addTimes = request.queryParam("addTimes").map(Integer::valueOf).orElse(null);
        Double addAmount = request.queryParam("addAmount").map(Double::valueOf).orElse(null);
        Integer addDays = request.queryParam("addDays").map(Integer::valueOf).orElse(null);
        Long sourceOrderId = request.queryParam("sourceOrderId").map(Long::valueOf).orElse(null);
        return memberCardService.renewCard(recordId, addTimes, addAmount, addDays, sourceOrderId)
                .flatMap(record -> ServerResponse.ok().bodyValue(record));
    }
    @Operation(summary = "使用会员卡", description = "扣减会员卡次数或余额")
    public Mono<ServerResponse> useCard(ServerRequest request) {
        Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
        Integer deductTimes = request.queryParam("deductTimes").map(Integer::valueOf).orElse(null);
        Double deductAmount = request.queryParam("deductAmount").map(Double::valueOf).orElse(null);
        return memberCardService.useCard(recordId, deductTimes, deductAmount)
                .flatMap(record -> ServerResponse.ok().bodyValue(record));
    }
    @Operation(summary = "退款会员卡", description = "申请会员卡退款")
    public Mono<ServerResponse> refundCard(ServerRequest request) {
        Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
        return memberCardService.refundCard(recordId)
                .then(ServerResponse.noContent().build());
    }
    @Operation(summary = "查询有效会员卡", description = "查询指定状态的会员卡类型")
    public Mono<ServerResponse> getActiveCards(ServerRequest request) {
        Integer status = request.queryParam("status").map(Integer::valueOf).orElse(1);
        return ServerResponse.ok()
                .body(memberCardService.findActiveCards(status), MemberCard.class);
    }
 }
@@ -0,0 +1,118 @@
 package cn.novalon.gym.manage.member.handler;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
 import cn.novalon.gym.manage.member.service.IMemberCardService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.Data;
 import org.springframework.stereotype.Component;
 import org.springframework.web.reactive.function.server.ServerRequest;
 import org.springframework.web.reactive.function.server.ServerResponse;
 import reactor.core.publisher.Mono;
 /**
 * 会员卡记录管理处理器
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Component
@Tag(name = "会员卡记录管理", description = "会员卡购买、续费、使用、退款等核心业务")
 public class MemberCardRecordHandler {
    private final IMemberCardService memberCardService;
    private final IMemberCardRecordService memberCardRecordService;
    public MemberCardRecordHandler(IMemberCardService memberCardService,
                                   IMemberCardRecordService memberCardRecordService) {
        this.memberCardService = memberCardService;
        this.memberCardRecordService = memberCardRecordService;
    }
    @Operation(summary = "购买会员卡", description = "支持时长卡、次卡、储值卡，自动设置到期提醒")
    public Mono<ServerResponse> purchaseCard(ServerRequest request) {
        return request.bodyToMono(PurchaseRequest.class)
                .flatMap(body -> memberCardService.purchaseCard(
                        body.getMemberId(),
                        body.getMemberCardId(),
                        body.getSourceOrderId()))
                .flatMap(record -> ServerResponse.ok().bodyValue(record))
                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("购买失败: " + e.getMessage()));
    }
    @Operation(summary = "续费会员卡", description = "累加剩余次数/余额，顺延到期日期，权益立即生效")
    public Mono<ServerResponse> renewCard(ServerRequest request) {
        Long recordId = Long.parseLong(request.pathVariable("recordId"));
        return request.bodyToMono(RenewRequest.class)
                .flatMap(body -> memberCardService.renewCard(recordId,
                        body.getAddTimes(),
                        body.getAddAmount(),
                        body.getAddDays(),
                        body.getSourceOrderId()))
                .flatMap(record -> ServerResponse.ok().bodyValue(record))
                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("续费失败: " + e.getMessage()));
    }
    @Operation(summary = "使用会员卡", description = "预约团课或私教成功后扣减次数或余额")
    public Mono<ServerResponse> useCard(ServerRequest request) {
        Long recordId = Long.parseLong(request.pathVariable("recordId"));
        return request.bodyToMono(UseCardRequest.class)
                .flatMap(body -> memberCardService.useCard(recordId,
                        body.getDeductTimes(),
                        body.getDeductAmount()))
                .flatMap(record -> ServerResponse.ok().bodyValue(record))
                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("使用失败: " + e.getMessage()));
    }
    @Operation(summary = "退款会员卡", description = "使用Saga模式执行退款流程，保证事务一致性")
    public Mono<ServerResponse> refundCard(ServerRequest request) {
        Long recordId = Long.parseLong(request.pathVariable("recordId"));
        return memberCardService.refundCard(recordId)
                .then(ServerResponse.ok().bodyValue("退款成功"))
                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("退款失败: " + e.getMessage()));
    }
    @Operation(summary = "查询会员卡记录详情", description = "根据记录ID查询详细信息")
    public Mono<ServerResponse> getMemberCardRecordById(ServerRequest request) {
        Long recordId = Long.parseLong(request.pathVariable("recordId"));
        return memberCardRecordService.findById(recordId)
                .flatMap(record -> ServerResponse.ok().bodyValue(record))
                .switchIfEmpty(ServerResponse.notFound().build());
    }
    @Operation(summary = "会员我的卡包", description = "查询当前会员的所有有效卡")
    public Mono<ServerResponse> getMyCards(ServerRequest request) {
        Long memberId = Long.parseLong(request.pathVariable("memberId"));
        return ServerResponse.ok().body(
                memberCardRecordService.findActiveCardsByMemberId(memberId),
                MemberCardRecord.class);
    }
    @Operation(summary = "处理过期会员卡", description = "定时任务调用，扫描并更新过期卡状态")
    public Mono<ServerResponse> processExpiredCards(ServerRequest request) {
        return memberCardService.processExpiredCards()
                .flatMap(count -> ServerResponse.ok().bodyValue("处理完成，共处理" + count + "条"));
    }
    @Data
    public static class PurchaseRequest {
        private Long memberId;
        private Long memberCardId;
        private Long sourceOrderId;
    }
    @Data
    public static class UseCardRequest {
        private Integer deductTimes;
        private Double deductAmount;
    }
    @Data
    public static class RenewRequest {
        private Integer addTimes;
        private Double addAmount;
        private Integer addDays;
        private Long sourceOrderId;
    }
 }
@@ -0,0 +1,102 @@
 package cn.novalon.gym.manage.member.handler;
 import cn.novalon.gym.manage.member.enums.CardEvent;
 import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 /**
 * 会员卡定时任务处理器
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Slf4j
@Component
@RequiredArgsConstructor
 public class MemberCardScheduledHandler {
    private final MemberCardRecordRepository recordRepository;
    private final ExpirationReminderService expirationReminderService;
    private final MemberCardStateMachine stateMachine;
    private final DistributedLockService distributedLockService;
    /**
     * 每日凌晨2点检查过期会员卡
     */
    @Scheduled(cron = "0 0 2 * * ?")
    public void checkExpiredCards() {
        String lockKey = "scheduled:check_expired_cards";
        distributedLockService.executeWithLock("SYSTEM", "EXPIRE_CHECK",
            Mono.fromRunnable(() -> {
                log.info("开始执行会员卡过期检查任务");
                LocalDateTime now = LocalDateTime.now();
                recordRepository.findActiveRecords()
                    .filter(record -> record.getExpireTime() != null && record.getExpireTime().isBefore(now))
                    .flatMap(record ->
                            stateMachine.transition(record.getStatus(), CardEvent.EXPIRE)
                                    .flatMap(newState -> {
                                        record.setStatus(newState);
                                        return recordRepository.save(record);
                                    })
                                .doOnSuccess(r -> log.info("会员卡记录ID={} 已标记为过期", r.getMemberCardRecordId()))
                                .onErrorResume(e -> {
                                    log.error("处理会员卡过期失败: recordId={}", record.getMemberCardRecordId(), e);
                                    return Mono.empty();
                                })
                        )
                        .then()
                        .subscribe();
            })
        ).subscribe();
    }
    /**
     * 每日凌晨3点检查是否有遗漏的到期提醒（兜底机制）
     */
    @Scheduled(cron = "0 0 3 * * ?")
    public void checkAndSendExpirationReminders() {
        String lockKey = "scheduled:expiration_reminder";
        distributedLockService.executeWithLock("SYSTEM", "REMINDER_CHECK",
            Mono.fromRunnable(() -> {
                log.info("开始执行到期提醒兜底检查任务");
                LocalDateTime now = LocalDateTime.now();
                // 查询所有活跃的会员卡
                recordRepository.findActiveRecords()
                    .filter(record -> record.getExpireTime() != null)
                    .flatMap(record -> {
                        try {
                            // 计算距离到期还有几天
                            long daysBetween = java.time.Duration.between(now, record.getExpireTime()).toDays();
                            // 如果到期时间在1-7天范围内，记录日志供人工检查
                            if (daysBetween >= 1 && daysBetween <= 7) {
                                log.warn("发现到期前{}天的会员卡记录ID={}，请确认是否已发送提醒",
                                    daysBetween, record.getMemberCardRecordId());
                            }
                            return Mono.empty();
                        } catch (Exception e) {
                            log.error("检查到期提醒失败: recordId={}", record.getMemberCardRecordId(), e);
                            return Mono.empty();
                        }
                    })
                    .then()
                    .subscribe();
            })
        ).subscribe();
        log.info("到期提醒兜底检查任务完成");
    }
 }
@@ -0,0 +1,91 @@
 package cn.novalon.gym.manage.member.handler;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.enums.CardEvent;
 import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import reactor.core.publisher.Mono;
 import java.util.HashMap;
 import java.util.Map;
 /**
 * 会员卡状态机处理器
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Slf4j
@Component
 public class MemberCardStateMachine {
    private final Map<MemberCardRecordStatus, Map<CardEvent, MemberCardRecordStatus>> stateTransitionMap;
    public MemberCardStateMachine() {
        this.stateTransitionMap = buildStateTransitionMap();
    }
    private Map<MemberCardRecordStatus, Map<CardEvent, MemberCardRecordStatus>> buildStateTransitionMap() {
        Map<MemberCardRecordStatus, Map<CardEvent, MemberCardRecordStatus>> map = new HashMap<>();
        // ACTIVE 状态可以转换的事件
        Map<CardEvent, MemberCardRecordStatus> activeTransitions = new HashMap<>();
        activeTransitions.put(CardEvent.USE, MemberCardRecordStatus.ACTIVE);
        activeTransitions.put(CardEvent.RENEW, MemberCardRecordStatus.ACTIVE);
        activeTransitions.put(CardEvent.EXPIRE, MemberCardRecordStatus.EXPIRED);
        activeTransitions.put(CardEvent.REFUND, MemberCardRecordStatus.REFUNDED);
        map.put(MemberCardRecordStatus.ACTIVE, activeTransitions);
        // USED_UP 状态可以转换的事件
        Map<CardEvent, MemberCardRecordStatus> usedUpTransitions = new HashMap<>();
        usedUpTransitions.put(CardEvent.RENEW, MemberCardRecordStatus.ACTIVE);
        usedUpTransitions.put(CardEvent.REFUND, MemberCardRecordStatus.REFUNDED);
        map.put(MemberCardRecordStatus.USED_UP, usedUpTransitions);
        // EXPIRED 状态可以转换的事件
        Map<CardEvent, MemberCardRecordStatus> expiredTransitions = new HashMap<>();
        expiredTransitions.put(CardEvent.RENEW, MemberCardRecordStatus.ACTIVE);
        map.put(MemberCardRecordStatus.EXPIRED, expiredTransitions);
        // REFUNDED 状态是终态，不允许任何转换
        return map;
    }
    public Mono<Boolean> canTransition(MemberCardRecordStatus currentState, CardEvent event) {
        return Mono.fromSupplier(() -> {
            Map<CardEvent, MemberCardRecordStatus> transitions = stateTransitionMap.get(currentState);
            if (transitions == null) {
                return false;
            }
            return transitions.containsKey(event);
        });
    }
    public Mono<MemberCardRecordStatus> transition(MemberCardRecordStatus currentState, CardEvent event) {
        return Mono.fromSupplier(() -> {
            Map<CardEvent, MemberCardRecordStatus> transitions = stateTransitionMap.get(currentState);
            if (transitions == null || !transitions.containsKey(event)) {
                log.error("Invalid state transition: currentState={}, event={}", currentState, event);
                throw new IllegalStateException(
                        String.format("不允许的状态转换: 当前状态=%s, 事件=%s", currentState, event));
            }
            MemberCardRecordStatus newState = transitions.get(event);
            log.info("State transition: {} --({})--> {}", currentState, event, newState);
            return newState;
        });
    }
    public Mono<Void> validateTransition(MemberCardRecord card, CardEvent event) {
        return canTransition(card.getStatus(), event)
                .flatMap(canTransition -> {
                    if (!canTransition) {
                        return Mono.error(new IllegalStateException(
                                String.format("会员卡记录ID=%d 不允许的状态转换: 当前状态=%s, 事件=%s",
                                        card.getMemberCardRecordId(), card.getStatus(), event)));
                    }
                    return Mono.empty();
                });
    }
 }
@@ -1,9 +1,9 @@
-package cn.novalon.gym.manage.gymmembercard.handler;
+package cn.novalon.gym.manage.member.handler;
 import cn.hutool.db.PageResult;
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
+import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
+import cn.novalon.gym.manage.member.enums.TransactionType;
-import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardTransactionsService;
+import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Validator;
@@ -19,20 +19,22 @@ import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 import java.util.List;
-/*
+/**
- *@Author:shizhounian
+ * 会员卡流水管理处理器
- *@Date:2026/5/17-05 20:10:22
+ * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Component
@Tag(name = "会员卡流水管理", description = "会员卡流水相关操作")
 public class MemberCardTransactionHandler {
-    private final IMemberCardTransactionsService memberCardTransactionsService;
+    private final IMemberCardTransactionService memberCardTransactionService;
    private final Validator validator;
-    public MemberCardTransactionHandler(IMemberCardTransactionsService memberCardTransactionsService,
+    public MemberCardTransactionHandler(IMemberCardTransactionService memberCardTransactionService,
                                        Validator validator) {
-        this.memberCardTransactionsService = memberCardTransactionsService;
+        this.memberCardTransactionService = memberCardTransactionService;
        this.validator = validator;
    }
@@ -41,8 +43,8 @@ public class MemberCardTransactionHandler {
     */
    @Operation(summary = "插入流水记录", description = "购卡、扣次、续费、退款、过期时插入流水")
    public Mono<ServerResponse> insertTransaction(ServerRequest request) {
-        return request.bodyToMono(MemberCardTransactions.class)
+        return request.bodyToMono(MemberCardTransaction.class)
-                .flatMap(memberCardTransactionsService::insertTransaction)
+                .flatMap(memberCardTransactionService::insertTransaction)
                .flatMap(record -> ServerResponse.ok().bodyValue(record));
    }
@@ -61,8 +63,8 @@ public class MemberCardTransactionHandler {
        Pageable pageable = PageRequest.of(page, size, Sort.by("created_at").descending());
        return ServerResponse.ok()
-                .body(memberCardTransactionsService.findByMemberIdAndTimeRange(
+                .body(memberCardTransactionService.findByMemberIdAndTimeRange(
-                        memberId, startTime, endTime, pageable), MemberCardTransactions.class);
+                        memberId, startTime, endTime, pageable), MemberCardTransaction.class);
    }
    /**
@@ -72,25 +74,25 @@ public class MemberCardTransactionHandler {
    public Mono<ServerResponse> getTransactionsWithConditions(ServerRequest request) {
        Long memberId = request.queryParam("memberId").map(Long::parseLong).orElse(null);
        Long memberCardId = request.queryParam("memberCardId").map(Long::parseLong).orElse(null);
-        MemberCardTransactionsAction operationType = request.queryParam("operationType")
+        TransactionType operationType = request.queryParam("operationType")
-                .map(s -> MemberCardTransactionsAction.valueOf(s.toUpperCase())).orElse(null);
+                .map(s -> TransactionType.valueOf(s.toUpperCase())).orElse(null);
        LocalDateTime startTime = request.queryParam("startTime").map(LocalDateTime::parse).orElse(null);
        LocalDateTime endTime = request.queryParam("endTime").map(LocalDateTime::parse).orElse(null);
        int page = request.queryParam("page").map(Integer::parseInt).orElse(0);
        int size = request.queryParam("size").map(Integer::parseInt).orElse(10);
        Pageable pageable = PageRequest.of(page, size, Sort.by("created_at").descending());
-        Mono<Long> countMono = memberCardTransactionsService.countWithConditions(
+        Mono<Long> countMono = memberCardTransactionService.countWithConditions(
                memberId, memberCardId, operationType, startTime, endTime);
-        Flux<MemberCardTransactions> flux = memberCardTransactionsService.findWithConditions(
+        Flux<MemberCardTransaction> flux = memberCardTransactionService.findWithConditions(
                memberId, memberCardId, operationType, startTime, endTime, pageable);
        return Mono.zip(countMono, flux.collectList())
                .flatMap(tuple -> {
                    Long total = tuple.getT1();
-                    List<MemberCardTransactions> list = tuple.getT2();
+                    List<MemberCardTransaction> list = tuple.getT2();
                    // 构造 PageResult，内部自动计算总页数
-                    PageResult<MemberCardTransactions> result = new PageResult<>(page, size, total.intValue());
+                    PageResult<MemberCardTransaction> result = new PageResult<>(page, size, total.intValue());
                    result.addAll(list);
                    return ServerResponse.ok().bodyValue(result);
                });
@@ -103,8 +105,8 @@ public class MemberCardTransactionHandler {
    public Mono<ServerResponse> getTransactionsByCardId(ServerRequest request) {
        Long memberCardId = Long.parseLong(request.pathVariable("cardId"));
        return ServerResponse.ok()
-                .body(memberCardTransactionsService.findByMemberCardId(memberCardId),
+                .body(memberCardTransactionService.findByMemberCardId(memberCardId),
-                        MemberCardTransactions.class);
+                        MemberCardTransaction.class);
    }
    /**
@@ -117,7 +119,7 @@ public class MemberCardTransactionHandler {
                .map(LocalDateTime::parse).orElse(LocalDateTime.now().minusMonths(1));
        LocalDateTime endTime = request.queryParam("endTime")
                .map(LocalDateTime::parse).orElse(LocalDateTime.now());
-        return memberCardTransactionsService.sumDeductCountByCardId(memberCardId, startTime, endTime)
+        return memberCardTransactionService.sumDeductCountByCardId(memberCardId, startTime, endTime)
                .flatMap(count -> ServerResponse.ok().bodyValue(count));
    }
@@ -130,7 +132,7 @@ public class MemberCardTransactionHandler {
                .map(LocalDateTime::parse).orElse(LocalDateTime.now().minusMonths(1));
        LocalDateTime endTime = request.queryParam("endTime")
                .map(LocalDateTime::parse).orElse(LocalDateTime.now());
-        return memberCardTransactionsService.sumRenewAmountByTimeRange(startTime, endTime)
+        return memberCardTransactionService.sumRenewAmountByTimeRange(startTime, endTime)
                .flatMap(amount -> ServerResponse.ok().bodyValue(amount));
    }
@@ -144,7 +146,7 @@ public class MemberCardTransactionHandler {
                .map(LocalDateTime::parse).orElse(LocalDateTime.now().minusMonths(1));
        LocalDateTime endTime = request.queryParam("endTime")
                .map(LocalDateTime::parse).orElse(LocalDateTime.now());
-        return memberCardTransactionsService.sumPurchaseAmountByMemberId(memberId, startTime, endTime)
+        return memberCardTransactionService.sumPurchaseAmountByMemberId(memberId, startTime, endTime)
                .flatMap(amount -> ServerResponse.ok().bodyValue(amount));
    }
 }
@@ -0,0 +1,287 @@
 package cn.novalon.gym.manage.member.handler;
 import cn.novalon.gym.manage.member.config.WechatProperties;
 import cn.novalon.gym.manage.member.dto.AdminUpdatePhoneDto;
 import cn.novalon.gym.manage.member.dto.SearchMemberDto;
 import cn.novalon.gym.manage.member.dto.UpdateMemberInfoDto;
 import cn.novalon.gym.manage.member.service.MemberService;
 import cn.novalon.gym.manage.member.service.WechatAuthService;
 import cn.novalon.gym.manage.member.service.WechatOfficialService;
 import cn.novalon.gym.manage.member.util.AesUtil;
 import cn.novalon.gym.manage.sys.util.AuthUtil;
 import cn.novalon.gym.manage.sys.security.JwtTokenProvider;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.math.NumberUtils;
 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;
 /**
 * 会员信息处理器
 *
 * @author 付嘉
 * @date 2026-05-01
 */
@Slf4j
@Component
@RequiredArgsConstructor
 public class MemberHandler {
    private final MemberService memberService;
    private final WechatAuthService wechatAuthService;
    private final WechatOfficialService wechatOfficialService;
    private final JwtTokenProvider jwtTokenProvider;
    private final WechatProperties wechatProperties;
    private final AuthUtil authUtil;
    /**
     * 获取会员信息
     *
     * GET /api/member/info
     * header: { "Authorization": "Bearer xxx" }
     */
    public Mono<ServerResponse> getMemberInfo(ServerRequest request) {
        Long memberId = authUtil.getMemberIdOrThrow(request);
        log.info("获取会员信息, memberId: {}", memberId);
        return memberService.getMemberInfo(memberId)
                .flatMap(info -> ServerResponse.ok()
                            .contentType(MediaType.APPLICATION_JSON)
                            .bodyValue(info));
    }
    /**
     * 更新会员信息
     *
     * PUT /api/member/info
     * header: { "Authorization": "Bearer xxx" }
     * Body: {
     *   "nickname": "新昵称",
     *   "gender": 1,
     *   "birthday": "2000-01-01",
     *   "avatar": "https://example.com/avatar.jpg",
     *   "address": "北京市朝阳区"
     * }
     */
    public Mono<ServerResponse> updateMemberInfo(ServerRequest request) {
        Long memberId = authUtil.getMemberIdOrThrow(request);
        log.info("更新会员信息, memberId: {}", memberId);
        return request.bodyToMono(UpdateMemberInfoDto.class)
                .flatMap(updateDto -> memberService.updateMemberInfo(memberId, updateDto))
                .flatMap(info -> ServerResponse.ok()
                        .contentType(MediaType.APPLICATION_JSON)
                        .bodyValue(info));
    }
    /**
     * 绑定手机号（微信小程序）
     * header: { "Authorization": "Bearer xxx" }
     * POST /api/member/phone/bind?code=PHONE_CODE
     */
    public Mono<ServerResponse> bindPhone(ServerRequest request) {
        Long memberId = authUtil.getMemberIdOrThrow(request);
        String phoneCode = request.queryParam("phoneCode").orElse("");
        if (phoneCode.trim().isEmpty()) throw new IllegalArgumentException("手机号code不能为空");
        log.info("收到绑定手机号请求, memberId: {}, phoneCode: {}", memberId, phoneCode);
        return wechatAuthService.bindPhone(memberId, phoneCode)
                .flatMap(success -> ServerResponse.ok()
                        .contentType(MediaType.APPLICATION_JSON)
                        .bodyValue(success));
    }
    /**
     * 查询服务号关注状态
     *
     * GET /api/member/subscribe/status
     *
     */
    public Mono<ServerResponse> checkSubscribeStatus(ServerRequest request) {
        Long memberId = authUtil.getMemberIdOrThrow(request);
        log.info("查询服务号关注状态, memberId: {}", memberId);
        return wechatOfficialService.checkSubscribeStatus(memberId)
                .flatMap(subscribed -> {
                    return ServerResponse.ok()
                            .contentType(MediaType.APPLICATION_JSON)
                            .bodyValue(subscribed);
                });
    }
    /**
     * 管理员更新手机号
     *
     * POST /api/admin/member/123/phone
     * header: { "Authorization": "Bearer xxx" }
     * Body: { "phone": "13800138000" }
     *
     */
    public Mono<ServerResponse> adminUpdatePhone(ServerRequest request) {
        Long adminId = authUtil.getMemberIdOrThrow(request);
        String memberIdStr = request.pathVariable("id");
        long memberId = NumberUtils.toLong(memberIdStr, 0L);
        if (memberId <= 0) throw new IllegalArgumentException("更新手机号失败: memberId 无效");
        log.info("收到更新手机号请求, memberId: {}", memberId);
        return request.bodyToMono(AdminUpdatePhoneDto.class)
                .flatMap(body -> {
                    String phone = body.getPhone();
                    if (phone == null || phone.isEmpty()) return Mono.error(new IllegalArgumentException("手机号不能为空"));
                    if (!phone.matches("^1[3-9]\\d{9}$")) return Mono.error(new IllegalArgumentException("手机号格式不正确"));
                    log.info("开始更新手机号, memberId: {}, phone: {}", memberId, phone);
                    return memberService.adminUpdatePhone(memberId, phone);
                })
                .flatMap(success -> {
                    log.info("手机号更新成功, memberId: {}", memberId);
                    return ServerResponse.ok()
                            .contentType(MediaType.APPLICATION_JSON)
                            .bodyValue(success);
                });
    }
    /**
     * 前台查看会员信息
     *
     * GET /api/admin/member/{id}
     * header: { "Authorization": "xxx" }
     *
     */
    public Mono<ServerResponse> adminGetMemberInfo(ServerRequest request) {
        Long adminId = authUtil.getMemberIdOrThrow(request);
        String memberIdStr = request.pathVariable("id");
        long memberId = NumberUtils.toLong(memberIdStr, 0L);
        if(memberId <= 0) throw new IllegalArgumentException("会员ID格式错误");
        log.info("前台查看会员信息, adminId: {}, memberId: {}", adminId, memberId);
        // TODO 多表查询：会员信息、团课信息、会员卡信息
        return ServerResponse.ok()
                .contentType(MediaType.APPLICATION_JSON)
                .bodyValue("成功");
    }
    /**
     * 前台编辑会员信息
     *
     * PUT /api/admin/member/{id}
     * header: { "Authorization": "xxx" }
     * Body:{"字段","值"}
     */
    public Mono<ServerResponse> adminUpdateMemberInfo(ServerRequest request) {
        Long adminId = authUtil.getMemberIdOrThrow(request);
        String memberIdStr = request.pathVariable("id");
        long memberId = NumberUtils.toLong(memberIdStr, 0L);
        if(memberId <= 0L) throw new IllegalArgumentException("会员ID格式错误");
        log.info("前台编辑会员信息, adminId: {}, memberId: {}", adminId, memberId);
        // TODO 多表查询：会员信息、团课信息、会员卡信息
        return ServerResponse.ok()
                .contentType(MediaType.APPLICATION_JSON)
                .bodyValue("成功");
    }
    /**
     * 前台搜索会员列表
     *
     * GET /api/admin/members?searchValue=手机号/姓名/会员号&filter=男/女&pageNum=1&pageSize=10
     * header: { "Authorization": "Bearer xxx" }
     */
    public Mono<ServerResponse> searchMembers(ServerRequest request) {
        Long adminId = authUtil.getMemberIdOrThrow(request);
        String keyword = request.queryParam("searchValue").orElse(null);
        String filter = request.queryParam("filter").orElse(null);
        int pageNum = NumberUtils.toInt(request.queryParam("pageNum").orElse("1"), 1);
        int pageSize = NumberUtils.toInt(request.queryParam("pageSize").orElse("10"), 10);
        log.info("前台搜索会员列表, adminId: {}, keyword: {}, filter: {}, pageNum: {}, pageSize: {}",
                adminId, keyword, filter, pageNum, pageSize);
        return memberService.searchMember(new SearchMemberDto(keyword, filter, pageNum, pageSize))
                .map(member -> {
                    // 解密手机号
                    if (member.getPhone() != null && !member.getPhone().isEmpty()) {
                        try {
                            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
                            String iv = wechatProperties.getPhoneEncryption().getIv();
                            String decryptedPhone = AesUtil.decrypt(member.getPhone(), secretKey, iv);
                            member.setPhone(decryptedPhone);
                        } catch (Exception e) {
                            log.error("手机号解密失败, memberId: {}", member.getId(), e);
                            member.setPhone(null);
                        }
                    }
                    return member;
                })
                .collectList()
                .flatMap(list -> ServerResponse.ok().bodyValue(list));
    }
    /**
     * 前台查看会员列表
     *
     * GET /api/admin/members/all?pageNum=1&pageSize=10
     * header: { "Authorization": "Bearer xxx" }
     */
    public Mono<ServerResponse> getAllMembers(ServerRequest request) {
        Long adminId = authUtil.getMemberIdOrThrow(request);
        int pageNum = NumberUtils.toInt(request.queryParam("pageNum").orElse("1"), 1);
        int pageSize = NumberUtils.toInt(request.queryParam("pageSize").orElse("10"), 10);
        log.info("前台查看会员列表, adminId: {}, pageNum: {}, pageSize: {}", adminId, pageNum, pageSize);
        return memberService.findAll(pageNum, pageSize)
                .map(member -> {
                    // 解密手机号
                    if (member.getPhone() != null && !member.getPhone().isEmpty()) {
                        try {
                            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
                            String iv = wechatProperties.getPhoneEncryption().getIv();
                            String decryptedPhone = AesUtil.decrypt(member.getPhone(), secretKey, iv);
                            member.setPhone(decryptedPhone);
                        } catch (Exception e) {
                            log.error("手机号解密失败, memberId: {}", member.getId(), e);
                            member.setPhone(null);
                        }
                    }
                    return member;
                })
                .collectList()
                .flatMap(list -> ServerResponse.ok().bodyValue(list));
    }
 }
@@ -0,0 +1,134 @@
 package cn.novalon.gym.manage.member.handler;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
 import cn.novalon.gym.manage.member.enums.CardEvent;
 import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
 import cn.novalon.gym.manage.member.enums.TransactionType;
 import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
 import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import reactor.core.publisher.Mono;
 import java.util.ArrayList;
 import java.util.List;
 /**
 * 退款 Saga 处理器
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Slf4j
@Component
@RequiredArgsConstructor
 public class RefundSagaHandler {
    private final MemberCardRecordRepository recordRepository;
    private final IMemberCardTransactionService transactionService;
    private final MemberCardStateMachine stateMachine;
    public Mono<Void> executeRefund(Long recordId) {
        return recordRepository.findById(recordId)
                .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
                .flatMap(record -> stateMachine.validateTransition(record, CardEvent.REFUND)
                        .then(Mono.defer(() -> doExecuteRefund(recordId, record))));
    }
    private Mono<Void> doExecuteRefund(Long recordId, MemberCardRecord record) {
        List<SagaStep> steps = new ArrayList<>();
        List<SagaStep> rollbackSteps = new ArrayList<>();
        SagaStep step1 = new SagaStep(
                "更新会员卡状态为已退款",
                updateCardStatus(recordId, MemberCardRecordStatus.REFUNDED),
                Mono.defer(() -> updateCardStatus(recordId, record.getStatus()))
        );
        steps.add(step1);
        rollbackSteps.add(0, step1);
        SagaStep step2 = new SagaStep(
                "记录退款流水",
                createRefundTransaction(record),
                createReversalTransaction(record)
        );
        steps.add(step2);
        rollbackSteps.add(0, step2);
        return executeSaga(steps, rollbackSteps);
    }
    private Mono<Void> updateCardStatus(Long recordId, MemberCardRecordStatus status) {
        return recordRepository.updateStatus(recordId, status.name())
                .flatMap(rows -> {
                    if (rows == 0) {
                        return Mono.error(new RuntimeException("更新会员卡状态失败"));
                    }
                    return Mono.empty();
                });
    }
    private Mono<Void> createRefundTransaction(MemberCardRecord record) {
        MemberCardTransaction transaction = MemberCardTransaction.builder()
                .memberId(record.getMemberId())
                .memberCardId(record.getMemberCardId())
                .operationType(TransactionType.REFUND.name())
                .changeAmount(-record.getRemainingTimes())
                .changeBalance(-record.getRemainingAmount())
                .afterRemainingCount(0)
                .afterRemainingBalance(0.0)
                .remark("会员卡退款")
                .build();
        return transactionService.createTransaction(transaction);
    }
    private Mono<Void> createReversalTransaction(MemberCardRecord record) {
        MemberCardTransaction reversal = MemberCardTransaction.builder()
                .memberId(record.getMemberId())
                .memberCardId(record.getMemberCardId())
                .operationType(TransactionType.REFUND.name())
                .changeAmount(record.getRemainingTimes())
                .changeBalance(record.getRemainingAmount())
                .remark("退款冲正")
                .build();
        return transactionService.createTransaction(reversal);
    }
    private Mono<Void> executeSaga(List<SagaStep> steps, List<SagaStep> rollbackSteps) {
        return executeStep(steps, 0, rollbackSteps);
    }
    private Mono<Void> executeStep(List<SagaStep> steps, int index, List<SagaStep> rollbackSteps) {
        if (index >= steps.size()) {
            return Mono.empty();
        }
        SagaStep currentStep = steps.get(index);
        return currentStep.operation()
                .then(Mono.defer(() -> executeStep(steps, index + 1, rollbackSteps)))
                .onErrorResume(error -> {
                    log.error("Saga步骤执行失败: step={}, error={}", currentStep.description(), error.getMessage());
                    return rollback(rollbackSteps, 0).then(Mono.error(error));
                });
    }
    private Mono<Void> rollback(List<SagaStep> rollbackSteps, int index) {
        if (index >= rollbackSteps.size()) {
            return Mono.empty();
        }
        SagaStep currentStep = rollbackSteps.get(index);
        return currentStep.rollbackOperation()
                .then(Mono.defer(() -> rollback(rollbackSteps, index + 1)))
                .doOnError(error -> log.error("Saga回滚失败: step={}, error={}", currentStep.description(), error.getMessage()))
                .onErrorResume(e -> Mono.empty());
    }
    private record SagaStep(String description, Mono<Void> operation, Mono<Void> rollbackOperation) {}
 }
@@ -0,0 +1,68 @@
 package cn.novalon.gym.manage.member.handler;
 import cn.novalon.gym.manage.member.dto.WechatLoginDto;
 import cn.novalon.gym.manage.member.service.WechatAuthService;
 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;
 /**
 * 微信认证
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Slf4j
@Component
@RequiredArgsConstructor
 public class WechatAuthHandler {
    private final WechatAuthService wechatAuthService;
    private final WechatOfficialEventHandler wechatOfficialEventHandler;
    /**
     * 小程序更新
     * 
     * POST /api/member/auth/miniapp/login
     * Body: {"code": "wx_login_code"}
     * 
     * @param request ServerRequest
     * @return Mono<ServerResponse> 登录响应
     */
    public Mono<ServerResponse> miniappLogin(ServerRequest request) {
        log.info("收到小程序登录请求");
        return request.bodyToMono(WechatLoginDto.class)
                .flatMap(loginRequest -> {
                    log.info("开始微信AuthService, code: {}", loginRequest.getCode());
                    return wechatAuthService.miniappLogin(loginRequest);
                })
                .flatMap(response -> {
                    log.info("更新成功, memberId: {}", response.getMemberId());
                    return ServerResponse.ok()
                            .contentType(MediaType.APPLICATION_JSON)
                            .bodyValue(response);
                });
    }
    /**
     * 公众号回调
     * 
     * POST /api/member/auth/mp/callback
     * Body: <xml><Event>subscribe</Event><FromUserName>openid</FromUserName></xml>
     * 
     */
    public Mono<ServerResponse> mpCallback(ServerRequest request) {
        return wechatOfficialEventHandler.handleEvent(request);
    }
    // 验证微信公众号签名
    public Mono<ServerResponse> verifyMpSignature(ServerRequest request) {
        return wechatOfficialEventHandler.verifySignature(request);
    }
 }
@@ -0,0 +1,218 @@
 package cn.novalon.gym.manage.member.handler;
 import cn.novalon.gym.manage.member.config.WechatProperties;
 import cn.novalon.gym.manage.member.service.WechatOfficialService;
 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.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.util.Arrays;
 /**
 * 微信公众号事件处理器
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Slf4j
@Component
@RequiredArgsConstructor
 public class WechatOfficialEventHandler {
    private final WechatOfficialService wechatOfficialService;
    private final WechatProperties wechatProperties;
    /**
     * 处理微信公众号事件
     * 
     * 请求格式:XML
     * 响应格式:success 或 回复消息内容
     */
    public Mono<ServerResponse> handleEvent(ServerRequest request) {
        return request.bodyToMono(String.class)
                .flatMap(xmlBody -> {
                    log.info("收到微信公众号事件 {}", xmlBody);
                    // TODO: 将XML解析为WechatOfficialEventDto
                    // 目前简化处理直接获取openId和event
                    String openId = extractOpenId(xmlBody);
                    String event = extractEvent(xmlBody);
                    if (openId == null || event == null) {
                        log.error("无法解析微信公众号事件");
                        return ServerResponse.badRequest().bodyValue("error");
                    }
                    log.info("处理事件 openId={}, event={}", openId, event);
                    // 根据事件类型处理
                    if ("subscribe".equals(event)) {
                        return wechatOfficialService.handleSubscribeEvent(openId)
                                .then(ServerResponse.ok()
                                        .contentType(MediaType.TEXT_PLAIN)
                                        .bodyValue("success"));
                    } else if ("unsubscribe".equals(event)) {
                        return wechatOfficialService.handleUnsubscribeEvent(openId)
                                .then(ServerResponse.ok()
                                        .contentType(MediaType.TEXT_PLAIN)
                                        .bodyValue("success"));
                    } else {
                        log.warn("未知事件类型: {}", event);
                        return ServerResponse.ok()
                                .contentType(MediaType.TEXT_PLAIN)
                                .bodyValue("success");
                    }
                })
                .onErrorResume(e -> {
                    log.error("处理微信公众号事件失败", e);
                    return ServerResponse.ok()
                            .contentType(MediaType.TEXT_PLAIN)
                            .bodyValue("success"); // 即使处理失败也返回success避免微信重试
                });
    }
    /**
     * 验证微信公众号签名
     * 
     * GET请求用于验证服务器地址
     */
    public Mono<ServerResponse> verifySignature(ServerRequest request) {
        String signature = request.queryParam("signature").orElse("");
        String timestamp = request.queryParam("timestamp").orElse("");
        String nonce = request.queryParam("nonce").orElse("");
        String echostr = request.queryParam("echostr").orElse("");
        log.info("========== 微信公众号签名验证 ==========");
        log.info("收到的参数:");
        log.info("  signature: {}", signature);
        log.info("  timestamp: {}", timestamp);
        log.info("  nonce: {}", nonce);
        log.info("  echostr: {}", echostr);
        // 获取配置的Token
        String token = wechatProperties.getMp().getToken();
        log.info("配置的Token: {}", token);
        // 验证签名
        if (checkSignature(signature, timestamp, nonce, token)) {
            log.info("签名验证成功，返回echostr: {}", echostr);
            log.info("========== 微信公众号签名验证结束 ==========");
            return ServerResponse.ok()
                    .contentType(MediaType.TEXT_PLAIN)
                    .bodyValue(echostr);
        } else {
            log.warn("签名验证失败");
            log.info("========== 微信公众号签名验证结束 ==========");
            return ServerResponse.badRequest()
                    .contentType(MediaType.TEXT_PLAIN)
                    .bodyValue("error");
        }
    }
    /**
     * 验证签名
     * 
     * @param signature 微信加密签名
     * @param timestamp 时间戳
     * @param nonce     随机数
     * @param token     Token
     * @return 是否验证通过
     */
    private boolean checkSignature(String signature, String timestamp, String nonce, String token) {
        // 1. 将token、timestamp、nonce三个参数进行字典序排序
        String[] arr = new String[]{token, timestamp, nonce};
        Arrays.sort(arr);
        // 2. 将三个参数字符串拼接成一个字符串
        StringBuilder sb = new StringBuilder();
        for (String str : arr) {
            sb.append(str);
        }
        // 3. 将拼接后的字符串进行sha1加密
        String encrypted = sha1(sb.toString());
        log.debug("计算的签名 {}", encrypted);
        // 4. 将加密后的字符串与signature对比
        return encrypted != null && encrypted.equalsIgnoreCase(signature);
    }
    /**
     * SHA1加密
     * 
     * @param str 待加密字符串
     * @return 加密后字符串
     */
    private String sha1(String str) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-1");
            byte[] digest = md.digest(str.getBytes(StandardCharsets.UTF_8));
            StringBuilder hexString = new StringBuilder();
            for (byte b : digest) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }
            return hexString.toString();
        } catch (Exception e) {
            log.error("SHA1加密失败", e);
            return null;
        }
    }
    /**
     * 从XML中提取OpenID
     */
    private String extractOpenId(String xml) {
        int start = xml.indexOf("<FromUserName>");
        int end = xml.indexOf("</FromUserName>");
        if (start != -1 && end != -1) {
            String value = xml.substring(start + 14, end);
            // 去除 CDATA 标记
            return cleanCdata(value);
        }
        return null;
    }
    /**
     * 从XML中获取事件类型
     */
    private String extractEvent(String xml) {
        int start = xml.indexOf("<Event>");
        int end = xml.indexOf("</Event>");
        if (start != -1 && end != -1) {
            String value = xml.substring(start + 7, end);
            // 去除 CDATA 标记
            return cleanCdata(value);
        }
        return null;
    }
    /**
     * 清理 CDATA 标记
     * 例如: <![CDATA[subscribe]]> -> subscribe
     */
    private String cleanCdata(String value) {
        if (value == null) {
            return null;
        }
        // 去除前后空白
        value = value.trim();
        // 提取 CDATA 中间内容
        // 格式: <![CDATA[xxx]]>
        if (value.startsWith("<![CDATA[") && value.endsWith("]]>")) {
            return value.substring(9, value.length() - 3);
        }
        return value;
    }
 }
@@ -0,0 +1,36 @@
 package cn.novalon.gym.manage.member.repository;
 import cn.novalon.gym.manage.member.entity.Member;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 /**
 *  会员Repository
 *  @author 付嘉
 *  @date 2026-05-01
 */
@Repository
 public interface IMemberRepository extends R2dbcRepository<Member, Long> {
    // UnionID查询会员
    Mono<Member> findByUnionId(String unionId);
    // 小程序OpenID查询会员
    Mono<Member> findByMiniappOpenId(String miniappOpenId);
    // 服务号OpenID查询会员
    Mono<Member> findByOfficialOpenId(String officialOpenId);
    // 手机号查询
    Mono<Member> findByPhone(String phone);
    /**
     * 分页查询所有会员
     * 方法名 findAllBy 是 Spring Data 的约定，表示按条件查询所有
     */
    Flux<Member> findAllBy(Pageable pageable);
 }
@@ -0,0 +1,109 @@
 package cn.novalon.gym.manage.member.repository;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.r2dbc.repository.Modifying;
 import org.springframework.data.r2dbc.repository.Query;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 /**
 * 会员卡记录 Repository（会员持有的卡）
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Repository
 public interface MemberCardRecordRepository extends R2dbcRepository<MemberCardRecord, Long> {
    /**
     * 插入新的激活卡记录
     */
    @Modifying
    @Query("INSERT INTO member_card_record (member_id, member_card_id, status, expire_time, remaining_times, remaining_amount, source_order_id, purchase_time, created_at, updated_at) " +
            "VALUES (:memberId, :memberCardId, 'ACTIVE', :expireTime, :remainingTimes, :remainingAmount, :sourceOrderId, NOW(), NOW(), NOW()) " +
            "RETURNING *")
    Mono<MemberCardRecord> insertActiveRecord(Long memberId, Long memberCardId,
                                              LocalDateTime expireTime, Integer remainingTimes,
                                              Double remainingAmount, Long sourceOrderId);
    /**
     * 扣减使用次数/金额
     */
    @Modifying
    @Query("UPDATE member_card_record SET " +
            "remaining_times = remaining_times - :deductTimes, " +
            "remaining_amount = remaining_amount - :deductAmount, " +
            "updated_at = NOW() " +
            "WHERE member_card_record_id = :recordId " +
            "AND deleted_at IS NULL " +
            "AND remaining_times >= :deductTimes " +
            "AND remaining_amount >= :deductAmount")
    Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
    /**
     * 续费卡片
     */
    @Modifying
    @Query("UPDATE member_card_record SET remaining_times = remaining_times + :addTimes, " +
            "remaining_amount = remaining_amount + :addAmount, expire_time = :newExpireTime, updated_at = NOW() " +
            "WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
    Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime);
    /**
     * 更新卡片状态
     */
    @Modifying
    @Query("UPDATE member_card_record SET status = :status, updated_at = NOW() " +
            "WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
    Mono<Integer> updateStatus(Long recordId, String status);
    /**
     * 查询会员的有效卡片
     */
    @Query("SELECT * FROM member_card_record WHERE member_id = :memberId AND status = 'ACTIVE' AND deleted_at IS NULL ORDER BY expire_time ASC")
    Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
    /**
     * 查询会员的所有卡片（分页）
     */
    @Query("SELECT mcr.* FROM member_card_record mcr " +
            "INNER JOIN member_user m ON mcr.member_id = m.id " +
            "WHERE mcr.member_id = :memberId AND mcr.deleted_at IS NULL " +
            "ORDER BY mcr.purchase_time DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
    Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
    /**
     * 验证次卡是否有足够次数
     */
    @Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
            "AND status = 'ACTIVE' AND deleted_at IS NULL " +
            "AND expire_time > NOW() " +
            "AND remaining_times >= :requiredTimes")
    Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
    /**
     * 验证储值卡是否有足够余额
     */
    @Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
            "AND status = 'ACTIVE' AND deleted_at IS NULL " +
            "AND expire_time > NOW() " +
            "AND remaining_amount >= :requiredAmount")
    Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
    /**
     * 查询已过期的卡片
     */
    @Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND expire_time < NOW() AND deleted_at IS NULL LIMIT 500")
    Flux<MemberCardRecord> findExpiredCards();
    /**
     * 查询所有有效记录
     */
    @Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND deleted_at IS NULL")
    Flux<MemberCardRecord> findActiveRecords();
 }
@@ -0,0 +1,91 @@
 package cn.novalon.gym.manage.member.repository;
 import cn.novalon.gym.manage.member.entity.MemberCard;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.r2dbc.repository.Modifying;
 import org.springframework.data.r2dbc.repository.Query;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 /**
 * 会员卡类型 Repository
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Repository
 public interface MemberCardRepository extends R2dbcRepository<MemberCard, Long> {
    /**
     * 根据会员卡ID查询（未删除的）
     */
    Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
    /**
     * 条件查询会员卡列表
     */
    @Query("SELECT * FROM member_card WHERE deleted_at IS NULL " +
            "AND (:status IS NULL OR member_card_status = :status) " +
            "AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
            "AND (:type IS NULL OR member_card_type = :type) " +
            "AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
            "AND (:maxPrice IS NULL OR member_card_price <= :maxPrice) " +
            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
    Flux<MemberCard> findWithConditions(Integer status, String name, String type,
                                        Double minPrice, Double maxPrice, Pageable pageable);
    /**
     * 统计符合条件的会员卡总数
     */
    @Query("SELECT COUNT(*) FROM member_card WHERE deleted_at IS NULL " +
            "AND (:status IS NULL OR member_card_status = :status) " +
            "AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
            "AND (:type IS NULL OR member_card_type = :type) " +
            "AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
            "AND (:maxPrice IS NULL OR member_card_price <= :maxPrice)")
    Mono<Long> countWithConditions(Integer status, String name, String type,
                                   Double minPrice, Double maxPrice);
    /**
     * 按状态查询会员卡列表
     */
    Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
    /**
     * 检查会员卡是否已被购买
     */
    @Query("SELECT EXISTS(SELECT 1 FROM member_card_record WHERE member_card_id = :memberCardId AND deleted_at IS NULL LIMIT 1)")
    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
    /**
     * 逻辑删除会员卡
     */
    @Modifying
    @Query("UPDATE member_card SET deleted_at = NOW() WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
    Mono<Integer> logicalDelete(Long memberCardId);
    /**
     * 安全更新会员卡信息
     */
    @Modifying
    @Query("UPDATE member_card SET " +
            "member_card_name = COALESCE(:name, member_card_name), " +
            "member_card_price = COALESCE(:price, member_card_price), " +
            "member_card_validity_days = COALESCE(:durationDays, member_card_validity_days), " +
            "member_card_total_times = COALESCE(:totalCount, member_card_total_times), " +
            "member_card_amount = COALESCE(:denomination, member_card_amount), " +
            "member_card_status = COALESCE(:status, member_card_status), " +
            "updated_at = NOW() " +
            "WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
    Mono<Integer> updateSafe(Long memberCardId, String name, Double price,
                             Integer durationDays, Integer totalCount,
                             Double denomination, Integer status);
    /**
     * 批量查询上架的会员卡
     */
    @Query("SELECT * FROM member_card WHERE deleted_at IS NULL AND member_card_status = :status ORDER BY member_card_price ASC")
    Flux<MemberCard> findActiveCards(Integer status);
 }
@@ -0,0 +1,121 @@
 package cn.novalon.gym.manage.member.repository;
 import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.r2dbc.repository.Modifying;
 import org.springframework.data.r2dbc.repository.Query;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 /**
 * 会员卡交易流水 Repository
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Repository
 public interface MemberCardTransactionRepository extends R2dbcRepository<MemberCardTransaction, Long> {
    /**
     * 插入交易流水记录
     */
    @Modifying
    @Query("INSERT INTO member_card_transactions (member_card_record_id, member_card_id, member_id, operation_type, change_amount, " +
            "change_balance, after_remaining_count, after_remaining_balance, related_biz_type, source_order_id, remark, created_at) " +
            "VALUES (:memberCardRecordId, :memberCardId, :memberId, :operationType, :changeAmount, :changeBalance, " +
            ":afterRemainingCount, :afterRemainingBalance, :relatedBizType, :sourceOrderId, :remark, NOW()) " +
            "RETURNING *")
    Mono<MemberCardTransaction> insertTransaction(Long memberCardRecordId, Long memberCardId, Long memberId,
                                                   String operationType, Integer changeAmount,
                                                   Double changeBalance, Integer afterRemainingCount,
                                                   Double afterRemainingBalance, String relatedBizType,
                                                   Long sourceOrderId, String remark);
    /**
     * 查询会员的使用记录（按时间范围）
     */
    @Query("SELECT * FROM member_card_transactions WHERE member_id = :memberId " +
            "AND created_at BETWEEN :startTime AND :endTime " +
            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
    Flux<MemberCardTransaction> findByMemberIdAndTimeRange(Long memberId,
                                                           LocalDateTime startTime,
                                                           LocalDateTime endTime,
                                                           Pageable pageable);
    /**
     * 条件查询流水记录
     */
    @Query("SELECT * FROM member_card_transactions " +
            "AND (:memberId IS NULL OR member_id = :memberId) " +
            "AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
            "AND (:operationType IS NULL OR operation_type = :operationType) " +
            "AND (:startTime IS NULL OR created_at >= :startTime) " +
            "AND (:endTime IS NULL OR created_at <= :endTime) " +
            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
    Flux<MemberCardTransaction> findWithConditions(Long memberId, Long memberCardId,
                                                   String operationType,
                                                   LocalDateTime startTime,
                                                   LocalDateTime endTime,
                                                   Pageable pageable);
    /**
     * 统计符合条件的流水总数
     */
    @Query("SELECT COUNT(*) FROM member_card_transactions " +
            "AND (:memberId IS NULL OR member_id = :memberId) " +
            "AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
            "AND (:operationType IS NULL OR operation_type = :operationType) " +
            "AND (:startTime IS NULL OR created_at >= :startTime) " +
            "AND (:endTime IS NULL OR created_at <= :endTime)")
    Mono<Long> countWithConditions(Long memberId, Long memberCardId,
                                   String operationType,
                                   LocalDateTime startTime,
                                   LocalDateTime endTime);
    /**
     * 按会员卡ID查询所有流水
     */
    @Query("SELECT * FROM member_card_transactions WHERE member_card_id = :memberCardId ORDER BY created_at DESC")
    Flux<MemberCardTransaction> findByMemberCardId(Long memberCardId);
    /**
     * 按会员ID查询所有流水
     */
    @Query("SELECT * FROM member_card_transactions WHERE member_id = :memberId ORDER BY created_at DESC")
    Flux<MemberCardTransaction> findByMemberId(Long memberId);
    /**
     * 按会员卡记录ID查询所有流水
     */
    @Query("SELECT * FROM member_card_transactions WHERE member_card_record_id = :recordId ORDER BY created_at DESC")
    Flux<MemberCardTransaction> findByRecordId(Long recordId);
    /**
     * 统计某卡种的总扣次数
     */
    @Query("SELECT COALESCE(SUM(change_amount), 0) FROM member_card_transactions " +
            "WHERE member_card_id = :memberCardId AND operation_type = 'DEDUCT' " +
            "AND created_at BETWEEN :startTime AND :endTime")
    Mono<Long> sumDeductCountByCardId(Long memberCardId,
                                      LocalDateTime startTime,
                                      LocalDateTime endTime);
    /**
     * 统计某时间段的续费总金额
     */
    @Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
            "WHERE operation_type = 'RENEW' AND created_at BETWEEN :startTime AND :endTime")
    Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
    /**
     * 统计某会员的购卡总金额
     */
    @Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
            "WHERE member_id = :memberId AND operation_type = 'PURCHASE' " +
            "AND created_at BETWEEN :startTime AND :endTime")
    Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
 }
@@ -0,0 +1,48 @@
 package cn.novalon.gym.manage.member.repository;
 import cn.novalon.gym.manage.member.entity.RefundApplication;
 import org.springframework.data.r2dbc.repository.Query;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 /**
 * 退款申请 Repository
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Repository
 public interface RefundApplicationRepository extends R2dbcRepository<RefundApplication, Long> {
    /**
     * 根据会员卡记录ID查询退款申请
     */
    @Query("SELECT * FROM refund_application WHERE record_id = :recordId AND deleted_at IS NULL LIMIT 1")
    Mono<RefundApplication> findByRecordId(Long recordId);
    /**
     * 根据会员ID查询退款申请列表
     */
    @Query("SELECT * FROM refund_application WHERE member_id = :memberId AND deleted_at IS NULL ORDER BY created_at DESC")
    Flux<RefundApplication> findByMemberId(Long memberId);
    /**
     * 根据状态查询退款申请列表
     */
    @Query("SELECT * FROM refund_application WHERE status = :status AND deleted_at IS NULL ORDER BY created_at DESC")
    Flux<RefundApplication> findByStatus(String status);
    /**
     * 审核退款申请
     */
    @Query("UPDATE refund_application SET status = :status, auditor_id = :auditorId, audit_time = NOW(), audit_remark = :auditRemark, updated_at = NOW() WHERE id = :id")
    Mono<Integer> approve(Long id, String status, Long auditorId, String auditRemark);
    /**
     * 逻辑删除退款申请
     */
    @Query("UPDATE refund_application SET deleted_at = NOW() WHERE id = :id")
    Mono<Integer> logicalDelete(Long id);
 }
@@ -0,0 +1,29 @@
 package cn.novalon.gym.manage.member.repository;
 import cn.novalon.gym.manage.member.entity.WechatUser;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Mono;
 /**
 * 微信用户Repository
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Repository
 public interface WechatUserRepository extends R2dbcRepository<WechatUser, Long> {
    // 通过UnionID查询微信用户
    Mono<WechatUser> findByUnionId(String unionId);
    // 通过小程序OpenID查询微信用户
    Mono<WechatUser> findByMiniappOpenid(String miniappOpenid);
    // 通过服务号OpenID查询微信用户
    Mono<WechatUser> findByMpOpenid(String mpOpenid);
    // 通过会员ID查询微信用户
    Mono<WechatUser> findByMemberId(Long memberId);
 }
@@ -0,0 +1,35 @@
 package cn.novalon.gym.manage.member.service;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import org.springframework.data.domain.Pageable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 /**
 * 会员卡记录服务接口
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
 public interface IMemberCardRecordService {
    Mono<MemberCardRecord> findById(Long id);
    Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
    Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
    Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
    Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
    Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, java.time.LocalDateTime newExpireTime);
    Mono<Integer> updateStatus(Long recordId, String status);
    Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
    Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
    Flux<MemberCardRecord> findExpiredCards();
 }
@@ -0,0 +1,44 @@
 package cn.novalon.gym.manage.member.service;
 import cn.novalon.gym.manage.member.entity.MemberCard;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import org.springframework.data.domain.Pageable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 /**
 * 会员卡服务接口
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
 public interface IMemberCardService {
    Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
    Flux<MemberCard> findWithConditions(Integer status, String name, String type,
                                        Double minPrice, Double maxPrice, Pageable pageable);
    Mono<Long> countWithConditions(Integer status, String name, String type,
                                   Double minPrice, Double maxPrice);
    Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
    Mono<Integer> logicalDelete(Long memberCardId);
    Flux<MemberCard> findActiveCards(Integer status);
    Mono<MemberCard> save(MemberCard entity);
    Mono<MemberCardRecord> purchaseCard(Long memberId, Long memberCardId, Long sourceOrderId);
    Mono<MemberCardRecord> renewCard(Long recordId, Integer addTimes, Double addAmount, Integer addDays, Long sourceOrderId);
    Mono<MemberCardRecord> useCard(Long recordId, Integer deductTimes, Double deductAmount);
    Mono<Void> refundCard(Long recordId);
    Mono<Integer> processExpiredCards();
 }
@@ -0,0 +1,93 @@
 package cn.novalon.gym.manage.member.service;
 import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
 import cn.novalon.gym.manage.member.enums.TransactionType;
 import org.springframework.data.domain.Pageable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 /**
 * 会员卡交易流水服务接口
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
 public interface IMemberCardTransactionService {
    /**
     * 记录每一次变动
     * @param transaction 流水记录
     * @return 插入的流水记录
     */
    Mono<MemberCardTransaction> insertTransaction(MemberCardTransaction transaction);
    /**
     * 会员端"使用记录"
     * @param memberId 会员ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageable 分页参数
     * @return 流水记录列表
     */
    Flux<MemberCardTransaction> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
                                                           LocalDateTime endTime, Pageable pageable);
    /**
     * 后台"使用记录查询"
     * @param memberId 会员ID
     * @param memberCardId 会员卡ID
     * @param operationType 操作类型
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageable 分页参数
     * @return 流水记录列表
     */
    Flux<MemberCardTransaction> findWithConditions(Long memberId, Long memberCardId,
                                                   TransactionType operationType,
                                                   LocalDateTime startTime, LocalDateTime endTime,
                                                   Pageable pageable);
    /**
     * 统计符合条件的流水总数
     */
    Mono<Long> countWithConditions(Long memberId, Long memberCardId,
                                   TransactionType operationType,
                                   LocalDateTime startTime, LocalDateTime endTime);
    /**
     * 按会员卡ID查询所有流水记录
     */
    Flux<MemberCardTransaction> findByMemberCardId(Long memberCardId);
    /**
     * 数据统计 - 统计某卡种的总扣次数
     */
    Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime);
    /**
     * 数据统计 - 统计某时间段的续费总金额
     */
    Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
    /**
     * 数据统计 - 统计某会员的购卡总金额
     */
    Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
    /**
     * 创建交易记录
     */
    Mono<Void> createTransaction(MemberCardTransaction transaction);
    /**
     * 查询会员的交易记录
     */
    Flux<MemberCardTransaction> findByMemberId(Long memberId);
    /**
     * 查询会员卡记录的交易历史
     */
    Flux<MemberCardTransaction> findByRecordId(Long recordId);
 }
@@ -0,0 +1,33 @@
 package cn.novalon.gym.manage.member.service;
 import cn.novalon.gym.manage.member.entity.RefundApplication;
 import reactor.core.publisher.Mono;
 /**
 * 退款申请服务接口
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
 public interface IRefundApplicationService {
    /**
     * 创建退款申请
     */
    Mono<RefundApplication> create(Long recordId, String reason);
    /**
     * 审核退款申请
     */
    Mono<RefundApplication> approve(Long applicationId, Long auditorId, String remark);
    /**
     * 拒绝退款申请
     */
    Mono<RefundApplication> reject(Long applicationId, Long auditorId, String remark);
    /**
     * 根据记录ID查询申请
     */
    Mono<RefundApplication> findByRecordId(Long recordId);
 }
@@ -0,0 +1,61 @@
 package cn.novalon.gym.manage.member.service;
 import cn.novalon.gym.manage.member.dto.SearchMemberDto;
 import cn.novalon.gym.manage.member.dto.UpdateMemberInfoDto;
 import cn.novalon.gym.manage.member.entity.Member;
 import cn.novalon.gym.manage.member.es.entity.MemberES;
 import cn.novalon.gym.manage.member.vo.MemberInfoVO;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 /**
 * 会员服务接口
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
 public interface MemberService {
    /**
     * 获取会员信息
     *
     * @param memberId 会员ID
     * @return 会员信息
     */
    Mono<MemberInfoVO> getMemberInfo(Long memberId);
    /**
     * 会员更新个人信息
     * 
     * @param memberId 会员ID
     * @param updateDto 更新信息DTO
     * @return 更新后的会员信息
     */
    Mono<MemberInfoVO> updateMemberInfo(Long memberId, UpdateMemberInfoDto updateDto);
    /**
     * 管理端更新会员手机号
     * 
     * @param memberId 会员ID
     * @param phone 明文手机号
     * @return 是否成功
     */
    Mono<Boolean> adminUpdatePhone(Long memberId, String phone);
    /**
     * 管理端查询会员（es查询）
     *
     * @param searchMemberDto 会员信息dto
     * @return 会员信息
     */
    Flux<MemberES> searchMember(SearchMemberDto searchMemberDto);
    /**
     * 管理端查询所有会员
     *
     * @param pageNum 页码
     * @param pageSize 页大小
     * @return 所有会员信息
     */
    Flux<Member> findAll(Integer pageNum, Integer pageSize);
 }
@@ -0,0 +1,48 @@
 package cn.novalon.gym.manage.member.service;
 import reactor.core.publisher.Mono;
 import java.util.Map;
 /**
 * 微信API服务接口
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
 public interface WechatApiService {
    /**
     * 小程序- 通过code获取session_key/openid
     * 
     * @param code 小程序登录的code
     * @return Mono<Map<String, String>> session_keyopenidunionid
     */
    Mono<Map<String, String>> jsCode2Session(String code);
    /**
     * 获取手机号- 通过code获取手机号
     * 
     * @param code 小程序登录的code
     * @return Mono<String> ܺ手机号
     */
    Mono<String> getPhoneNumber(String code);
    /**
     * 获取Access Token
     * 
     * @param appType 应用类型miniapp-小程序mp
     * @return Mono<String> access_token
     */
    Mono<String> getAccessToken(String appType);
    /**
     * 验证签名
     * 
     * @param signature 微信签名
     * @param timestamp 创建时间
     * @param nonce 随机字符串
     * @return boolean 签名是否有效
     */
    boolean checkSignature(String signature, String timestamp, String nonce);
 }
@@ -0,0 +1,31 @@
 package cn.novalon.gym.manage.member.service;
 import cn.novalon.gym.manage.member.dto.WechatLoginDto;
 import cn.novalon.gym.manage.member.vo.WechatLoginVO;
 import reactor.core.publisher.Mono;
 /**
 * 微信授权服务接口
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
 public interface WechatAuthService {
    /**
     * 小程序
     *
     * @param request 小程序登录请求
     * @return 小程序登录响应
     */
    Mono<WechatLoginVO> miniappLogin(WechatLoginDto request);
    /**
     * 手机号
     *
     * @param memberId 会员ID
     * @param code     微信手机号code
     * @return 是否绑定成功
     */
    Mono<Boolean> bindPhone(Long memberId, String code);
 }
@@ -0,0 +1,54 @@
 package cn.novalon.gym.manage.member.service;
 import cn.novalon.gym.manage.member.vo.WechatUserInfoVO;
 import reactor.core.publisher.Mono;
 /**
 * 微信公众号服务接口
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
 public interface WechatOfficialService {
    /**
     * 处理订阅事件
     * 
     * @param openId OpenID
     * @return Mono<Void>
     */
    Mono<Void> handleSubscribeEvent(String openId);
    /**
     * 处理取消订阅事件
     * 
     * @param openId OpenID
     * @return Mono<Void>
     */
    Mono<Void> handleUnsubscribeEvent(String openId);
    /**
     * 获取微信用户信息
     * 
     * @param openId OpenID
     * @return Mono<WechatUserInfoVO> 用户信息
     */
    Mono<WechatUserInfoVO> getUserInfo(String openId);
    /**
     * 通过 UnionID 关联小程序用户
     * 
     * @param unionId 微信 UnionID
     * @param officialOpenId OpenID
     * @return Mono<Boolean> 是否关联成功
     */
    Mono<Boolean> linkByUnionId(String unionId, String officialOpenId);
    /**
      * 查询会员订阅状态
     * 
     * @param memberId 会员ID
     * @return Mono<Boolean> true=已订阅false=未订阅
     */
    Mono<Boolean> checkSubscribeStatus(Long memberId);
 }
@@ -1,10 +1,8 @@
-package cn.novalon.gym.manage.gymmembercard.sevice.impl;
+package cn.novalon.gym.manage.member.service.impl;
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
+import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
+import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
 import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardRecordService;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
@@ -12,17 +10,45 @@ import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 /**
 * 会员卡记录服务实现
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Service
 public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
-    private final IMemberCardRecordRepository memberCardRecordRepository;
+    private final MemberCardRecordRepository memberCardRecordRepository;
-    public MemberCardRecordServiceImpl(IMemberCardRecordRepository memberCardRecordRepository) {
+    public MemberCardRecordServiceImpl(MemberCardRecordRepository memberCardRecordRepository) {
        this.memberCardRecordRepository = memberCardRecordRepository;
    }
    @Override
    public Mono<MemberCardRecord> findById(Long recordId) {
        return memberCardRecordRepository.findById(recordId);
    }
    @Override
    public Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable) {
        return memberCardRecordRepository.findByMemberId(memberId, pageable);
    }
    @Override
    public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
        return memberCardRecordRepository.findActiveCardsByMemberId(memberId);
    }
    @Override
    public Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record) {
-        return memberCardRecordRepository.insertActiveRecord(record);
+        return memberCardRecordRepository.insertActiveRecord(
                record.getMemberId(),
                record.getMemberCardId(),
                record.getExpireTime(),
                record.getRemainingTimes(),
                record.getRemainingAmount(),
                record.getSourceOrderId()
        );
    }
    @Override
@@ -36,20 +62,10 @@ public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
    }
    @Override
-    public Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status) {
+    public Mono<Integer> updateStatus(Long recordId, String status) {
        return memberCardRecordRepository.updateStatus(recordId, status);
    }
    @Override
    public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
        return memberCardRecordRepository.findActiveCardsByMemberId(memberId);
    }
    @Override
    public Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable) {
        return memberCardRecordRepository.findByMemberId(memberId, pageable);
    }
    @Override
    public Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes) {
        return memberCardRecordRepository.validateCountCard(recordId, requiredTimes);
@@ -0,0 +1,332 @@
 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.entity.MemberCardTransaction;
 import cn.novalon.gym.manage.member.enums.CardEvent;
 import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
 import cn.novalon.gym.manage.member.enums.MemberCardType;
 import cn.novalon.gym.manage.member.enums.TransactionType;
 import cn.novalon.gym.manage.member.handler.DistributedLockService;
 import cn.novalon.gym.manage.member.handler.ExpirationReminderService;
 import cn.novalon.gym.manage.member.handler.MemberCardStateMachine;
 import cn.novalon.gym.manage.member.handler.RefundSagaHandler;
 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 lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 /**
 * 会员卡服务实现
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Slf4j
@Service
 public class MemberCardServiceImpl implements IMemberCardService {
    private final MemberCardRepository memberCardRepository;
    private final MemberCardRecordRepository recordRepository;
    private final IMemberCardTransactionService transactionService;
    private final MemberCardStateMachine stateMachine;
    private final DistributedLockService distributedLockService;
    private final ExpirationReminderService expirationReminderService;
    private final RefundSagaHandler refundSagaHandler;
    public MemberCardServiceImpl(MemberCardRepository memberCardRepository,
                                 MemberCardRecordRepository recordRepository,
                                 IMemberCardTransactionService transactionService,
                                 MemberCardStateMachine stateMachine,
                                 DistributedLockService distributedLockService,
                                 ExpirationReminderService expirationReminderService,
                                 RefundSagaHandler refundSagaHandler) {
        this.memberCardRepository = memberCardRepository;
        this.recordRepository = recordRepository;
        this.transactionService = transactionService;
        this.stateMachine = stateMachine;
        this.distributedLockService = distributedLockService;
        this.expirationReminderService = expirationReminderService;
        this.refundSagaHandler = refundSagaHandler;
    }
    @Override
    public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
        return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId);
    }
    @Override
    public Flux<MemberCard> findWithConditions(Integer status, String name, String type,
                                               Double minPrice, Double maxPrice, Pageable pageable) {
        return memberCardRepository.findWithConditions(status, name, type, minPrice, maxPrice, pageable);
    }
    @Override
    public Mono<Long> countWithConditions(Integer status, String name, String type,
                                          Double minPrice, Double maxPrice) {
        return memberCardRepository.countWithConditions(status, name, type, minPrice, maxPrice);
    }
    @Override
    public Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable) {
        return memberCardRepository.findByMemberCardStatusAndDeletedAtIsNull(status, pageable);
    }
    @Override
    public Mono<Boolean> existsPurchasedRecord(Long memberCardId) {
        return memberCardRepository.existsPurchasedRecord(memberCardId);
    }
    @Override
    public Mono<Integer> logicalDelete(Long memberCardId) {
        return memberCardRepository.logicalDelete(memberCardId);
    }
    @Override
    public Flux<MemberCard> findActiveCards(Integer status) {
        return memberCardRepository.findActiveCards(status);
    }
    @Override
    public Mono<MemberCard> save(MemberCard entity) {
        return memberCardRepository.save(entity);
    }
    @Override
    public Mono<MemberCardRecord> purchaseCard(Long memberId, Long memberCardId, Long sourceOrderId) {
        return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
                .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
                .flatMap(card -> {
                    if (card.getMemberCardStatus() != null && card.getMemberCardStatus() == 1) {
                        return Mono.error(new RuntimeException("该会员卡已禁用"));
                    }
                    MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
                    return distributedLockService.executeWithLock(
                            memberId.toString(),
                            cardType.name(),
                            Mono.defer(() -> createCardRecord(memberId, memberCardId, sourceOrderId, card))
                    );
                })
                .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, 
                                                      Long sourceOrderId, MemberCard card) {
        return Mono.defer(() -> {
            MemberCardRecord record = MemberCardRecord.builder()
                    .memberId(memberId)
                    .memberCardId(memberCardId)
                    .sourceOrderId(sourceOrderId)
                    .purchaseTime(LocalDateTime.now())
                    .status(MemberCardRecordStatus.ACTIVE)
                    .build();
            MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
            LocalDateTime now = LocalDateTime.now();
            switch (cardType) {
                case TIME_CARD:
                    record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
                    record.setRemainingTimes(0);
                    record.setRemainingAmount(0.0);
                    break;
                case COUNT_CARD:
                    record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
                    record.setRemainingTimes(card.getMemberCardTotalTimes());
                    record.setRemainingAmount(0.0);
                    break;
                case STORED_VALUE_CARD:
                    record.setExpireTime(now.plusYears(1));
                    record.setRemainingTimes(0);
                    record.setRemainingAmount(card.getMemberCardAmount());
                    break;
                default:
                    return Mono.error(new RuntimeException("不支持的会员卡类型"));
            }
            return recordRepository.insertActiveRecord(
                    record.getMemberId(),
                    record.getMemberCardId(),
                    record.getExpireTime(),
                    record.getRemainingTimes(),
                    record.getRemainingAmount(),
                    record.getSourceOrderId()
            );
        });
    }
    @Override
    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 -> stateMachine.validateTransition(originalRecord, CardEvent.RENEW)
                        .then(Mono.just(originalRecord)))
                .flatMap(originalRecord -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(originalRecord.getMemberCardId())
                        .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
                        .flatMap(card -> {
                            MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
                            return distributedLockService.executeWithLock(
                                    originalRecord.getMemberId().toString(),
                                    cardType.name(),
                                    Mono.defer(() -> doRenewCard(originalRecord, card, addTimes, addAmount, addDays))
                            );
                        }));
    }
     private Mono<MemberCardRecord> doRenewCard(MemberCardRecord record, MemberCard card, 
                                                Integer addTimes, Double addAmount, Integer addDays) {
        LocalDateTime now = LocalDateTime.now();
        MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
        switch (cardType) {
            case TIME_CARD:
                LocalDateTime currentExpire = record.getExpireTime();
                LocalDateTime baseTime = (currentExpire != null && currentExpire.isAfter(now)) ? currentExpire : now;
                int daysToAdd = addDays != null ? addDays : card.getMemberCardValidityDays();
                record.setExpireTime(baseTime.plusDays(daysToAdd));
                break;
            case COUNT_CARD:
                int currentTimes = record.getRemainingTimes() != null ? record.getRemainingTimes() : 0;
                int timesToAdd = addTimes != null ? addTimes : card.getMemberCardTotalTimes();
                record.setRemainingTimes(currentTimes + timesToAdd);
                if (MemberCardRecordStatus.USED_UP.equals(record.getStatus())) {
                    record.setStatus(MemberCardRecordStatus.ACTIVE);
                }
                break;
            case STORED_VALUE_CARD:
                double currentAmount = record.getRemainingAmount() != null ? record.getRemainingAmount() : 0.0;
                double amountToAdd = addAmount != null ? addAmount : card.getMemberCardAmount();
                record.setRemainingAmount(currentAmount + amountToAdd);
                if (MemberCardRecordStatus.USED_UP.equals(record.getStatus())) {
                    record.setStatus(MemberCardRecordStatus.ACTIVE);
                }
                break;
            default:
                return Mono.error(new RuntimeException("不支持的会员卡类型"));
        }
        return recordRepository.save(record)
                .flatMap(updatedRecord -> createTransaction(updatedRecord, TransactionType.RENEW, "续费会员卡")
                        .then(expirationReminderService.scheduleExpirationReminder(updatedRecord))
                        .thenReturn(updatedRecord));
    }
    @Override
    public Mono<MemberCardRecord> useCard(Long recordId, Integer deductTimes, Double deductAmount) {
        return recordRepository.findById(recordId)
                .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
                .flatMap(record -> stateMachine.validateTransition(record, CardEvent.USE)
                        .then(Mono.just(record)))
                .flatMap(record -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
                        .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
                        .flatMap(card -> {
                            MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
                            return distributedLockService.executeWithLock(
                                record.getMemberId().toString(),
                                cardType.name(),
                                Mono.defer(() -> doUseCard(record, card, deductTimes, deductAmount))
                            );
                        }));
    }
    private Mono<MemberCardRecord> doUseCard(MemberCardRecord record, MemberCard card, 
                                              Integer deductTimes, Double deductAmount) {
        if (!MemberCardRecordStatus.ACTIVE.name().equals(record.getStatus())) {
            return Mono.error(new RuntimeException("会员卡状态不正确"));
        }
        MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
        LocalDateTime now = LocalDateTime.now();
        switch (cardType) {
            case TIME_CARD:
                if (record.getExpireTime() != null && record.getExpireTime().isBefore(now)) {
                    return Mono.error(new RuntimeException("会员卡已过期"));
                }
                break;
            case COUNT_CARD:
                int currentTimes = record.getRemainingTimes() != null ? record.getRemainingTimes() : 0;
                int timesToDeduct = deductTimes != null ? deductTimes : 1;
                if (currentTimes < timesToDeduct) {
                    return Mono.error(new RuntimeException("剩余次数不足"));
                }
                record.setRemainingTimes(currentTimes - timesToDeduct);
                if (record.getRemainingTimes() == 0) {
                    record.setStatus(MemberCardRecordStatus.USED_UP);
                }
                break;
            case STORED_VALUE_CARD:
                double currentAmount = record.getRemainingAmount() != null ? record.getRemainingAmount() : 0.0;
                double amountToDeduct = deductAmount != null ? deductAmount : 0.0;
                if (currentAmount < amountToDeduct) {
                    return Mono.error(new RuntimeException("余额不足"));
                }
                record.setRemainingAmount(currentAmount - amountToDeduct);
                if (record.getRemainingAmount() == 0) {
                    record.setStatus(MemberCardRecordStatus.USED_UP);
                }
                break;
            default:
                return Mono.error(new RuntimeException("不支持的会员卡类型"));
        }
        return recordRepository.save(record)
                .flatMap(updatedRecord -> createTransaction(updatedRecord, TransactionType.DEDUCT, "使用会员卡")
                        .thenReturn(updatedRecord));
    }
    @Override
    public Mono<Void> refundCard(Long recordId) {
        return recordRepository.findById(recordId)
                .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
                .flatMap(record -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
                        .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
                        .flatMap(card -> {
                            MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
                            return distributedLockService.executeWithLock(
                                record.getMemberId().toString(),
                                cardType.name(),
                                refundSagaHandler.executeRefund(recordId)
                            );
                        }));
    }
    @Override
    public Mono<Integer> processExpiredCards() {
        return recordRepository.findExpiredCards()
            .flatMap(record -> stateMachine.transition(record.getStatus(), CardEvent.EXPIRE)
                .flatMap(newState -> recordRepository.updateStatus(
                    record.getMemberCardRecordId(), newState.name())))
            .reduce(0, (count, result) -> count + 1)
            .doOnSuccess(count -> log.info("处理过期会员卡完成，共处理{}条", count));
    }
    private Mono<Void> createTransaction(MemberCardRecord record, TransactionType action, String remark) {
        MemberCardTransaction transaction = MemberCardTransaction.builder()
                .memberId(record.getMemberId())
                .memberCardId(record.getMemberCardId())
                .operationType(action.name())
                .changeAmount(record.getRemainingTimes())
                .changeBalance(record.getRemainingAmount())
                .afterRemainingCount(record.getRemainingTimes())
                .afterRemainingBalance(record.getRemainingAmount())
                .remark(remark)
                .build();
        return transactionService.createTransaction(transaction);
    }
 }
@@ -0,0 +1,109 @@
 package cn.novalon.gym.manage.member.service.impl;
 import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
 import cn.novalon.gym.manage.member.enums.TransactionType;
 import cn.novalon.gym.manage.member.repository.MemberCardTransactionRepository;
 import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 /**
 * 会员卡交易流水服务实现
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Slf4j
@Service
 public class MemberCardTransactionServiceImpl implements IMemberCardTransactionService {
    private final MemberCardTransactionRepository transactionRepository;
    public MemberCardTransactionServiceImpl(MemberCardTransactionRepository transactionRepository) {
        this.transactionRepository = transactionRepository;
    }
    @Override
    public Mono<MemberCardTransaction> insertTransaction(MemberCardTransaction transaction) {
        return transactionRepository.insertTransaction(
                transaction.getMemberCardRecordId(),
                transaction.getMemberCardId(),
                transaction.getMemberId(),
                transaction.getOperationType(),
                transaction.getChangeAmount(),
                transaction.getChangeBalance(),
                transaction.getAfterRemainingCount(),
                transaction.getAfterRemainingBalance(),
                transaction.getRelatedBizType(),
                transaction.getSourceOrderId(),
                transaction.getRemark()
        );
    }
    @Override
    public Flux<MemberCardTransaction> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
                                                                   LocalDateTime endTime, Pageable pageable) {
        return transactionRepository.findByMemberIdAndTimeRange(memberId, startTime, endTime, pageable);
    }
    @Override
    public Flux<MemberCardTransaction> findWithConditions(Long memberId, Long memberCardId,
                                                          TransactionType operationType,
                                                          LocalDateTime startTime, LocalDateTime endTime,
                                                          Pageable pageable) {
        return transactionRepository.findWithConditions(memberId, memberCardId, 
                operationType != null ? operationType.name() : null,
                startTime, endTime, pageable);
    }
    @Override
    public Mono<Long> countWithConditions(Long memberId, Long memberCardId,
                                          TransactionType operationType,
                                          LocalDateTime startTime, LocalDateTime endTime) {
        return transactionRepository.countWithConditions(memberId, memberCardId,
                operationType != null ? operationType.name() : null,
                startTime, endTime);
    }
    @Override
    public Flux<MemberCardTransaction> findByMemberCardId(Long memberCardId) {
        return transactionRepository.findByMemberCardId(memberCardId);
    }
    @Override
    public Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime) {
        return transactionRepository.sumDeductCountByCardId(memberCardId, startTime, endTime);
    }
    @Override
    public Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
        return transactionRepository.sumRenewAmountByTimeRange(startTime, endTime);
    }
    @Override
    public Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime) {
        return transactionRepository.sumPurchaseAmountByMemberId(memberId, startTime, endTime);
    }
    @Override
    public Mono<Void> createTransaction(MemberCardTransaction transaction) {
        return transactionRepository.save(transaction)
                .then()
                .doOnSuccess(v -> log.info("创建会员卡交易记录: memberId={}, cardId={}, type={}",
                        transaction.getMemberId(), transaction.getMemberCardId(), transaction.getOperationType()));
    }
    @Override
    public Flux<MemberCardTransaction> findByMemberId(Long memberId) {
        return transactionRepository.findByMemberId(memberId);
    }
    @Override
    public Flux<MemberCardTransaction> findByRecordId(Long recordId) {
        return transactionRepository.findByRecordId(recordId);
    }
 }
@@ -0,0 +1,208 @@
 package cn.novalon.gym.manage.member.service.impl;
 import cn.novalon.gym.manage.common.exception.ConflictException;
 import cn.novalon.gym.manage.common.exception.ErrorCode;
 import cn.novalon.gym.manage.common.exception.NotFoundException;
 import cn.novalon.gym.manage.common.exception.SystemException;
 import cn.novalon.gym.manage.member.config.WechatProperties;
 import cn.novalon.gym.manage.member.dto.SearchMemberDto;
 import cn.novalon.gym.manage.member.dto.UpdateMemberInfoDto;
 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.service.MemberService;
 import cn.novalon.gym.manage.member.util.AesUtil;
 import cn.novalon.gym.manage.member.util.EsSyncUtils;
 import cn.novalon.gym.manage.member.vo.MemberInfoVO;
 import jakarta.annotation.PostConstruct;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 /**
 * 会员服务实现
 *
 * @author 付嘉
 * @date 2026-05-01
 */
@Slf4j
@Service
@RequiredArgsConstructor
 public class MemberServiceImpl implements MemberService {
    private final IMemberRepository memberRepository;
    private final MemberESRepository memberESRepository;
    private final EsSyncUtils esSyncUtils;
    private final WechatProperties wechatProperties;
    private EsSyncUtils.EntitySyncer<Member, MemberES, String> memberSyncer;
    @PostConstruct
    public void init() {
        this.memberSyncer = esSyncUtils.bind(Member.class, MemberES.class, memberESRepository);
    }
    @Override
    public Mono<MemberInfoVO> getMemberInfo(Long memberId) {
        return memberRepository.findById(memberId)
                .map(this::buildMemberInfoResponse)
                .switchIfEmpty(Mono.error(() -> {
                    log.error("会员不存在: memberId={}", memberId);
                    throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
                }));
    }
    @Override
    public Mono<MemberInfoVO> updateMemberInfo(Long memberId, UpdateMemberInfoDto updateDto) {
        log.info("会员更新个人信息, memberId: {}", memberId);
        return memberRepository.findById(memberId)
                .flatMap(member -> {
                    if (updateDto.getNickname() != null) {
                        member.setNickname(updateDto.getNickname());
                    }
                    if (updateDto.getGender() != null) {
                        member.setGender(updateDto.getGender());
                    }
                    if (updateDto.getBirthday() != null) {
                        member.setBirthday(updateDto.getBirthday());
                    }
                    if (updateDto.getAvatar() != null) {
                        member.setAvatar(updateDto.getAvatar());
                    }
                    if (updateDto.getAddress() != null) {
                        member.setAddress(updateDto.getAddress());
                    }
                    return memberRepository.save(member);
                })
                .doOnSuccess(memberSyncer::sync)
                .map(savedMember -> {
                    log.info("会员信息更新成功, memberId: {}", savedMember.getId());
                    return buildMemberInfoResponse(savedMember);
                })
                .switchIfEmpty(Mono.error(() -> {
                    log.error("会员不存在: memberId={}", memberId);
                    throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
                }));
    }
    private MemberInfoVO buildMemberInfoResponse(Member member) {
        String phone = member.getPhone();
        String maskedPhone = phone != null ? phone.replace(phone.substring(3, 7), "****") : null;
        return MemberInfoVO.builder()
                .id(member.getId())
                .nickname(member.getNickname())
                .phone(maskedPhone)
                .gender(member.getGender())
                .birthday(member.getBirthday())
                .avatar(member.getAvatar())
                .hasPhone(phone != null)
                .isSubscribed(member.getSubscribed() != null && member.getSubscribed())
                .build();
    }
    @Override
    public Mono<Boolean> adminUpdatePhone(Long memberId, String phone) {
        log.info("管理端录入手机号, memberId: {}, phone: {}", memberId, phone);
        String encryptedPhone;
        try {
            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
            String iv = wechatProperties.getPhoneEncryption().getIv();
            encryptedPhone = AesUtil.encrypt(phone, secretKey, iv);
            log.info("手机号加密成功");
        } catch (Exception e) {
            log.error("手机号加密失败", e);
            throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "手机号加密失败: " + e.getMessage());
        }
        return memberRepository.findByPhone(encryptedPhone)
                .<Boolean>flatMap(existingMember -> {
                    if (existingMember.getId().equals(memberId)) {
                        log.warn("手机号已是当前用户的: memberId={}", memberId);
                        throw new ConflictException(ErrorCode.CONFLICT_DUPLICATE_USER, "重复绑定");
                    } else {
                        log.warn("手机号已被其他用户绑定: memberId={}, existingMemberId={}",
                                memberId, existingMember.getId());
                        throw new ConflictException(ErrorCode.CONFLICT_DUPLICATE_USER, "该手机号已被其他会员绑定");
                    }
                })
                .switchIfEmpty(Mono.defer(() -> {
                    log.info("手机号未被占用，可以绑定");
                    return updateMemberPhone(memberId, encryptedPhone);
                }));
    }
    @Override
    public Flux<MemberES> searchMember(SearchMemberDto searchMemberDto) {
        log.info("搜索会员, searchValue: {}, filter: {}, pageNum: {}, pageSize: {}",
                searchMemberDto.getSearchValue(),
                searchMemberDto.getFilter(),
                searchMemberDto.getPageNum(),
                searchMemberDto.getPageSize());
        String searchValue = searchMemberDto.getSearchValue();
        if(searchValue != null && searchValue.matches("^1[3-9]\\d{9}$")){
            log.debug("搜索值为手机号格式，进行加密处理");
            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
            String iv = wechatProperties.getPhoneEncryption().getIv();
            searchValue = AesUtil.encrypt(searchValue,secretKey,iv);
        }
        Pageable pageable = PageRequest.of(
                searchMemberDto.getPageNum() - 1,
                searchMemberDto.getPageSize(),
                Sort.by(Sort.Direction.DESC, "update_at")
        );
        return memberESRepository.findByMemberNoOrPhoneOrNicknameContainingAndGender(
                searchValue,
                searchValue,
                searchValue,
                searchMemberDto.getFilter() ,
                pageable
        );
    }
    @Override
    public Flux<Member> findAll(Integer pageNum, Integer pageSize) {
        log.info("查询所有会员列表, pageNum: {}, pageSize: {}", pageNum, pageSize);
        Pageable pageable = PageRequest.of(
                pageNum - 1,
                pageSize
        );
        return memberRepository.findAllBy(pageable);
    }
    private Mono<Boolean> updateMemberPhone(Long memberId, String encryptedPhone) {
        return memberRepository.findById(memberId)
                .flatMap(member -> {
                    member.setPhone(encryptedPhone);
                    member.setLastLoginAt(LocalDateTime.now());
                    return memberRepository.save(member)
                            .doOnSuccess(memberSyncer::sync)
                            .map(savedMember -> {
                                log.info("手机号录入成功, memberId: {}", savedMember.getId());
                                return true;
                            });
                })
                .switchIfEmpty(Mono.error(() -> {
                    log.error("会员不存在: memberId={}", memberId);
                    throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
                }));
    }
 }
@@ -0,0 +1,88 @@
 package cn.novalon.gym.manage.member.service.impl;
 import cn.novalon.gym.manage.member.entity.RefundApplication;
 import cn.novalon.gym.manage.member.enums.RefundStatus;
 import cn.novalon.gym.manage.member.repository.RefundApplicationRepository;
 import cn.novalon.gym.manage.member.service.IRefundApplicationService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 /**
 * 退款申请服务实现
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Slf4j
@Service
 public class RefundApplicationServiceImpl implements IRefundApplicationService {
    private final RefundApplicationRepository refundApplicationRepository;
    public RefundApplicationServiceImpl(RefundApplicationRepository refundApplicationRepository) {
        this.refundApplicationRepository = refundApplicationRepository;
    }
    @Override
    public Mono<RefundApplication> create(Long recordId, String reason) {
        return refundApplicationRepository.findByRecordId(recordId)
                .flatMap(existing -> {
                    if (existing != null) {
                        return Mono.error(new RuntimeException("该会员卡记录已有退款申请"));
                    }
                    return Mono.empty();
                })
                .then(Mono.defer(() -> {
                    RefundApplication application = RefundApplication.builder()
                            .recordId(recordId)
                            .reason(reason)
                            .status(RefundStatus.PENDING)
                            .applyTime(LocalDateTime.now())
                            .build();
                    return refundApplicationRepository.save(application)
                            .doOnSuccess(app -> log.info("创建退款申请成功: applicationId={}, recordId={}",
                                app.getId(), recordId));
                }));
    }
    @Override
    public Mono<RefundApplication> approve(Long applicationId, Long auditorId, String remark) {
        return refundApplicationRepository.findById(applicationId)
                .switchIfEmpty(Mono.error(new RuntimeException("退款申请不存在")))
                .flatMap(application -> {
                    if (!"PENDING".equals(application.getStatus())) {
                        return Mono.error(new RuntimeException("退款申请状态不正确，当前状态: " + application.getStatus()));
                    }
                    return refundApplicationRepository.approve(applicationId, "APPROVED", auditorId, remark)
                            .thenReturn(application)
                            .doOnSuccess(app -> log.info("批准退款申请成功: applicationId={}, auditorId={}",
                                applicationId, auditorId));
                });
    }
    @Override
    public Mono<RefundApplication> reject(Long applicationId, Long auditorId, String remark) {
        return refundApplicationRepository.findById(applicationId)
                .switchIfEmpty(Mono.error(new RuntimeException("退款申请不存在")))
                .flatMap(application -> {
                    if (!"PENDING".equals(application.getStatus())) {
                        return Mono.error(new RuntimeException("退款申请状态不正确，当前状态: " + application.getStatus()));
                    }
                    return refundApplicationRepository.approve(applicationId, "REJECTED", auditorId, remark)
                            .thenReturn(application)
                            .doOnSuccess(app -> log.info("拒绝退款申请成功: applicationId={}, auditorId={}",
                                applicationId, auditorId));
                });
    }
    @Override
    public Mono<RefundApplication> findByRecordId(Long recordId) {
        return refundApplicationRepository.findByRecordId(recordId);
    }
 }
@@ -0,0 +1,221 @@
 package cn.novalon.gym.manage.member.service.impl;
 import cn.novalon.gym.manage.common.exception.ErrorCode;
 import cn.novalon.gym.manage.common.exception.SystemException;
 import cn.novalon.gym.manage.member.config.WechatProperties;
 import cn.novalon.gym.manage.member.service.WechatApiService;
 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.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 /**
 * 微信API服务实现
 *
 * @author 付嘉
 * @date 2026-05-01
 */
@Slf4j
@Service
@RequiredArgsConstructor
 public class WechatApiServiceImpl implements WechatApiService {
    private final WechatProperties wechatProperties;
    private final WebClient webClient = WebClient.builder()
            .baseUrl("https://api.weixin.qq.com")
            .codecs(configurer -> configurer.defaultCodecs().maxInMemorySize(10 * 1024 * 1024))
            .build();
    @Override
    public Mono<Map<String, String>> jsCode2Session(String code) {
        log.info("微信jsCode2Session API");
        log.info("信息 - AppID: {}, AppSecret {}",
                wechatProperties.getMiniapp().getAppId(),
                wechatProperties.getMiniapp().getAppSecret() != null ?
                    wechatProperties.getMiniapp().getAppSecret().substring(0, Math.min(4, wechatProperties.getMiniapp().getAppSecret().length())) + "***" : "null");
        log.info(" - code: {}", code);
        return webClient.get()
                .uri(uriBuilder -> uriBuilder
                        .path("/sns/jscode2session")
                        .queryParam("appid", wechatProperties.getMiniapp().getAppId())
                        .queryParam("secret", wechatProperties.getMiniapp().getAppSecret())
                        .queryParam("js_code", code)
                        .queryParam("grant_type", "authorization_code")
                        .build())
                .retrieve()
                .bodyToMono(String.class)
                .map(responseBody -> {
                    log.info("微信API响应: {}", responseBody);
                    Map<String, Object> response;
                    try {
                        com.fasterxml.jackson.databind.ObjectMapper mapper = new com.fasterxml.jackson.databind.ObjectMapper();
                        response = mapper.readValue(responseBody, Map.class);
                    } catch (Exception e) {
                        log.error("微信API响应失败", e);
                        throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "微信API响应失败: " + e.getMessage());
                    }
                    Map<String, String> result = new HashMap<>();
                    if (response.containsKey("errcode")) {
                        Integer errcode = (Integer) response.get("errcode");
                        String errmsg = (String) response.get("errmsg");
                        log.error("微信API失败, errcode: {}, errmsg: {}", errcode, errmsg);
                        throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "微信API失败 [" + errcode + "]: " + errmsg);
                    }
                    result.put("session_key", (String) response.get("session_key"));
                    result.put("openid", (String) response.get("openid"));
                    result.put("unionid", (String) response.get("unionid"));
                    log.info("微信API响应成功, openid: {}, unionid: {}",
                            result.get("openid"), result.get("unionid"));
                    return result;
                })
                .onErrorResume(e -> {
                    log.error("微信API响应异常 - URL: https://api.weixin.qq.com/sns/jscode2session");
                    log.error("异常: {}", e.getClass().getName());
                    log.error("异常信息: {}", e.getMessage());
                    if (e.getCause() != null) {
                        log.error("异常原因: {}", e.getCause().getMessage());
                    }
                    if (e instanceof SystemException) {
                        return Mono.error(e);
                    }
                    throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "微信API响应异常 " + e.getMessage());
                });
    }
    @Override
    public Mono<String> getPhoneNumber(String code) {
        log.debug("微信getPhoneNumber API, code: {}", code);
        return getAccessToken("miniapp")
                .flatMap(accessToken -> {
                    Map<String, String> requestBody = new HashMap<>();
                    requestBody.put("code", code);
                    return webClient.post()
                            .uri(uriBuilder -> uriBuilder
                                    .path("/wxa/business/getuserphonenumber")
                                    .queryParam("access_token", accessToken)
                                    .build())
                            .contentType(MediaType.APPLICATION_JSON)
                            .bodyValue(requestBody)
                            .retrieve()
                            .bodyToMono(Map.class)
                            .map(response -> {
                                if (response.containsKey("errcode") &&
                                    (Integer) response.get("errcode") == 0) {
                                    Map<String, Object> phoneInfo =
                                        (Map<String, Object>) response.get("phone_info");
                                    String phoneNumber = (String) phoneInfo.get("purePhoneNumber");
                                    log.info("获取手机号成功{}", phoneNumber);
                                    return phoneNumber;
                                } else {
                                    String errmsg = (String) response.get("errmsg");
                                    log.error("获取手机号失败 {}", errmsg);
                                    throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "获取手机号失败 " + errmsg);
                                }
                            });
                })
                .onErrorResume(e -> {
                    log.error("获取手机号失败", e);
                    if (e instanceof SystemException) {
                        return Mono.error(e);
                    }
                    throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "获取手机号失败 " + e.getMessage());
                });
    }
    @Override
    public Mono<String> getAccessToken(String appType) {
        log.debug("获取access_token, appType: {}", appType);
        String appId, appSecret;
        if ("miniapp".equals(appType)) {
            appId = wechatProperties.getMiniapp().getAppId();
            appSecret = wechatProperties.getMiniapp().getAppSecret();
        } else {
            appId = wechatProperties.getMp().getAppId();
            appSecret = wechatProperties.getMp().getAppSecret();
        }
        return webClient.get()
                .uri(uriBuilder -> uriBuilder
                        .path("/cgi-bin/token")
                        .queryParam("grant_type", "client_credential")
                        .queryParam("appid", appId)
                        .queryParam("secret", appSecret)
                        .build())
                .retrieve()
                .bodyToMono(Map.class)
                .map(response -> {
                    if (response.containsKey("access_token")) {
                        String accessToken = (String) response.get("access_token");
                        Integer expiresIn = (Integer) response.get("expires_in");
                        log.info("获取access_token成功, expires_in: {}s", expiresIn);
                        return accessToken;
                    } else {
                        String errmsg = (String) response.get("errmsg");
                        log.error("获取access_token失败: {}", errmsg);
                        throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "获取access_token失败: " + errmsg);
                    }
                });
    }
    @Override
    public boolean checkSignature(String signature, String timestamp, String nonce) {
        log.debug("验证微信消息签名, signature: {}, timestamp: {}, nonce: {}",
                signature, timestamp, nonce);
        try {
            String token = wechatProperties.getMp().getToken();
            String[] arr = new String[]{token, timestamp, nonce};
            Arrays.sort(arr);
            StringBuilder content = new StringBuilder();
            for (String s : arr) {
                content.append(s);
            }
            MessageDigest md = MessageDigest.getInstance("SHA-1");
            byte[] digest = md.digest(content.toString().getBytes(StandardCharsets.UTF_8));
            StringBuilder hexString = new StringBuilder();
            for (byte b : digest) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }
            String calculatedSignature = hexString.toString();
            boolean isValid = calculatedSignature.equals(signature);
            log.debug("验证微信消息签名结果: {}", isValid ? "通过" : "失败");
            return isValid;
        } catch (Exception e) {
            log.error("验证微信消息签名异常", e);
            return false;
        }
    }
 }
@@ -0,0 +1,300 @@
 package cn.novalon.gym.manage.member.service.impl;
 import cn.novalon.gym.manage.common.exception.ConflictException;
 import cn.novalon.gym.manage.common.exception.ErrorCode;
 import cn.novalon.gym.manage.common.exception.NotFoundException;
 import cn.novalon.gym.manage.common.exception.SystemException;
 import cn.novalon.gym.manage.member.config.WechatProperties;
 import cn.novalon.gym.manage.member.dto.WechatLoginDto;
 import cn.novalon.gym.manage.member.entity.Member;
 import cn.novalon.gym.manage.member.es.entity.MemberES;
 import cn.novalon.gym.manage.member.es.repository.MemberESRepository;
 import cn.novalon.gym.manage.member.repository.IMemberRepository;
 import cn.novalon.gym.manage.member.service.WechatApiService;
 import cn.novalon.gym.manage.member.service.WechatAuthService;
 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.member.util.WechatPhoneUtil;
 import cn.novalon.gym.manage.member.vo.WechatLoginVO;
 import cn.novalon.gym.manage.sys.security.JwtTokenProvider;
 import jakarta.annotation.PostConstruct;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
 /**
 * 微信认证服务实现
 *
 * @author 付嘉
 * @date 2026-05-01
 */
@Slf4j
@Service
@RequiredArgsConstructor
 public class WechatAuthServiceImpl implements WechatAuthService {
    private final WechatApiService wechatApiService;
    private final IMemberRepository memberRepository;
    private final WechatProperties wechatProperties;
    private final WechatPhoneUtil wechatPhoneUtil;
    private final MemberESRepository memberESRepository;
    private final EsSyncUtils esSyncUtils;
    private final JwtTokenProvider jwtTokenProvider;
    private EsSyncUtils.EntitySyncer<Member, MemberES, String> memberSyncer;
    @PostConstruct
    public void init() {
        this.memberSyncer = esSyncUtils.bind(Member.class, MemberES.class, memberESRepository);
    }
    @Override
    public Mono<WechatLoginVO> miniappLogin(WechatLoginDto request) {
        log.info("开始小程序登录");
        return wechatApiService.jsCode2Session(request.getCode())
                .flatMap(sessionData -> {
                    String openid = sessionData.get("openid");
                    String unionId = sessionData.get("unionid");
                    String sessionKey = sessionData.get("session_key");
                    log.info("微信 API 返回: openid={}, unionid={}", openid, unionId);
                    if (unionId != null && !unionId.isEmpty()) {
                        return memberRepository.findByUnionId(unionId)
                                .flatMap(member -> {
                                    log.info("找到会员, memberId: {}", member.getId());
                                    if (member.getMiniappOpenId() == null || member.getMiniappOpenId().isEmpty()) {
                                        log.info("用户已有 UnionID，补充小程序 OpenID, memberId: {}", member.getId());
                                        member.setMiniappOpenId(openid);
                                        member.setLastLoginAt(LocalDateTime.now());
                                        return memberRepository.save(member)
                                                .doOnSuccess(memberSyncer::sync)
                                                .flatMap(savedMember -> {
                                                    WechatLoginVO response = buildLoginResponse(savedMember, false, sessionKey);
                                                    return Mono.just(response);
                                                });
                                    } else {
                                        log.info("老用户登录，更新最后登录时间, memberId: {}", member.getId());
                                        member.setLastLoginAt(LocalDateTime.now());
                                        return memberRepository.save(member)
                                                .doOnSuccess(memberSyncer::sync)
                                                .flatMap(savedMember -> {
                                                    WechatLoginVO response = buildLoginResponse(savedMember, false, sessionKey);
                                                    return Mono.just(response);
                                                });
                                    }
                                })
                                .switchIfEmpty(Mono.defer(() -> {
                                    log.info("UnionID 未找到，尝试通过小程序 OpenID 查询, openid: {}", openid);
                                    return memberRepository.findByMiniappOpenId(openid)
                                            .flatMap(member -> {
                                                log.info("找到会员, memberId: {}", member.getId());
                                                member.setUnionId(unionId);
                                                member.setLastLoginAt(LocalDateTime.now());
                                                return memberRepository.save(member)
                                                        .doOnSuccess(memberSyncer::sync)
                                                        .flatMap(savedMember -> {
                                                            WechatLoginVO response = buildLoginResponse(savedMember, false, sessionKey);
                                                            return Mono.just(response);
                                                        });
                                            })
                                            .switchIfEmpty(Mono.defer(() -> {
                                                log.info("OpenID 也未找到，创建新会员（无 UnionID）, openid: {}", openid);
                                                return createNewMember(unionId, openid, sessionKey, request.getPhoneCode());
                                            }));
                                }));
                    } else {
                        log.warn("微信 API 未返回 UnionID，尝试通过小程序 OpenID 查询, openid: {}", openid);
                        return memberRepository.findByMiniappOpenId(openid)
                                .flatMap(member -> {
                                    log.info("找到会员, memberId: {}", member.getId());
                                    member.setLastLoginAt(LocalDateTime.now());
                                    return memberRepository.save(member)
                                            .doOnSuccess(memberSyncer::sync)
                                            .flatMap(savedMember -> {
                                                WechatLoginVO response = buildLoginResponse(savedMember, false, sessionKey);
                                                return Mono.just(response);
                                            });
                                })
                                .switchIfEmpty(Mono.defer(() -> {
                                    log.info("OpenID也未找到，创建新会员（无UnionID标识信息）");
                                    return createNewMember(unionId, openid, sessionKey, request.getPhoneCode());
                                }));
                    }
                })
                .onErrorResume(e -> {
                    log.error("小程序登录失败", e);
                    if (e instanceof SystemException) {
                        return Mono.error(e);
                    }
                    return Mono.error(new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "登录失败: " + e.getMessage()));
                });
    }
    @Override
    public Mono<Boolean> bindPhone(Long memberId, String code) {
        log.info("开始绑定手机号, memberId: {}", memberId);
        return wechatApiService.getPhoneNumber(code)
                .flatMap(phoneNumber -> {
                    log.info("获取手机号: {}", phoneNumber);
                    String encryptedPhone = encryptPhone(phoneNumber);
                    return memberRepository.findByPhone(encryptedPhone)
                            .flatMap(existingMember -> {
                                if (!existingMember.getId().equals(memberId)) {
                                    log.warn("手机号已被其他会员绑定, currentMemberId={}, existingMemberId={}", memberId, existingMember.getId());
                                    throw new ConflictException(ErrorCode.CONFLICT_DUPLICATE_USER, "手机号已被其他会员绑定");
                                } else {
                                    log.info("更新会员手机号, memberId: {}", memberId);
                                    return updateMemberPhone(memberId, encryptedPhone);
                                }
                            })
                            .switchIfEmpty(Mono.defer(() -> {
                                log.info("该手机号未被使用，直接绑定到当前会员, memberId: {}", memberId);
                                return updateMemberPhone(memberId, encryptedPhone);
                            }));
                })
                .onErrorResume(e -> {
                    log.error("绑定手机号失败", e);
                    if (e instanceof SystemException) {
                        return Mono.error(e);
                    }
                    return Mono.error(new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "绑定失败: " + e.getMessage()));
                });
    }
    private Mono<Boolean> updateMemberPhone(Long memberId, String encryptedPhone) {
        return memberRepository.findById(memberId)
                .flatMap(member -> {
                    member.setPhone(encryptedPhone);
                    member.setLastLoginAt(LocalDateTime.now());
                    return memberRepository.save(member)
                            .doOnSuccess(memberSyncer::sync)
                            .map(savedMember -> {
                                log.info("更新会员手机号成功, memberId: {}", savedMember.getId());
                                return true;
                            });
                })
                .switchIfEmpty(Mono.error(() -> {
                    log.error("会员不存在, memberId={}", memberId);
                    throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
                }));
    }
    private String encryptPhone(String phoneNumber) {
        try {
            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
            String iv = wechatProperties.getPhoneEncryption().getIv();
            String encryptedPhone = AesUtil.encrypt(phoneNumber, secretKey, iv);
            log.debug("手机号加密成功");
            return encryptedPhone;
        } catch (Exception e) {
            log.error("手机号加密失败", e);
            throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "手机号加密失败 " + e.getMessage());
        }
    }
    public String decryptPhone(String encryptedPhone) {
        try {
            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
            String iv = wechatProperties.getPhoneEncryption().getIv();
            String phoneNumber = AesUtil.decrypt(encryptedPhone, secretKey, iv);
            log.debug("手机号解密成功");
            return phoneNumber;
        } catch (Exception e) {
            log.error("手机号解密失败", e);
            throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "手机号解密失败 " + e.getMessage());
        }
    }
    private Mono<WechatLoginVO> createNewMember(String unionId, String openid, String sessionKey, String phoneCode) {
        log.info("开始创建新会员, unionId: {}, openid: {}", unionId, openid);
        String memberNo = MemberNoGenerator.generate();
        log.info("生成会员号: {}", memberNo);
        Member member = Member.builder()
                .memberNo(memberNo)
                .unionId(unionId)
                .miniappOpenId(openid)
                .lastLoginAt(LocalDateTime.now())
                .build();
        log.info("用户未注册，创建新会员（仅保存标识信息）");
        return memberRepository.save(member)
                .doOnSuccess(memberSyncer::sync)
                .flatMap(savedMember -> {
                    log.info("保存 Member 成功, id: {}, memberNo: {}", savedMember.getId(), savedMember.getMemberNo());
                    if (phoneCode != null && !phoneCode.isEmpty()) {
                        log.info("检测到 phoneCode，尝试获取手机号");
                        return wechatPhoneUtil.getPhoneNumber(phoneCode)
                                .flatMap(phoneNumber -> {
                                    if (phoneNumber != null && !phoneNumber.isEmpty()) {
                                        log.info("获取到手机号: {}", phoneNumber);
                                        String encryptedPhone = encryptPhone(phoneNumber);
                                        savedMember.setPhone(encryptedPhone);
                                        return memberRepository.save(savedMember)
                                                .doOnSuccess(memberSyncer::sync)
                                                .doOnSuccess(m -> {
                                                    log.info("新用户手机号绑定成功");
                                                })
                                                .thenReturn(buildLoginResponse(savedMember, true, sessionKey));
                                    } else {
                                        log.warn("未获取到手机号");
                                        return Mono.just(buildLoginResponse(savedMember, true, sessionKey));
                                    }
                                });
                    } else {
                        return Mono.just(buildLoginResponse(savedMember, true, sessionKey));
                    }
                });
    }
    private WechatLoginVO buildLoginResponse(Member member, boolean isNewUser, String sessionKey) {
        log.debug("构建登录响应, memberId: {}, isNewUser: {}", member.getId(), isNewUser);
        boolean needCompleteInfo = member.getNickname() == null || member.getPhone() == null;
        if (needCompleteInfo) {
            log.info("用户需要补全信息: nickname={}, phone={}",
                    member.getNickname() != null ? "已有" : "未设置",
                    member.getPhone() != null ? "已绑定" : "未绑定");
        }
        List<String> roles = new ArrayList<>();
        String accessToken = jwtTokenProvider.generateToken(String.valueOf(member.getId()), member.getId(), roles);
        log.info("JWT Token 生成成功, memberId: {}", member.getId());
        int expiresIn = 86400;
        return WechatLoginVO.builder()
                .memberId(member.getId())
                .accessToken(accessToken)
                .refreshToken(accessToken)
                .expiresIn(expiresIn)
                .isNewUser(isNewUser)
                .needCompleteInfo(needCompleteInfo)
                .build();
    }
 }
@@ -0,0 +1,338 @@
 package cn.novalon.gym.manage.member.service.impl;
 import cn.novalon.gym.manage.member.config.WechatProperties;
 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.service.WechatOfficialService;
 import cn.novalon.gym.manage.member.util.EsSyncUtils;
 import cn.novalon.gym.manage.member.vo.WechatUserInfoVO;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 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.HashMap;
 import java.util.Map;
 /**
 * 微信服务号服务实现类
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Slf4j
@Service
@RequiredArgsConstructor
 public class WechatOfficialServiceImpl implements WechatOfficialService {
    private final IMemberRepository memberRepository;
    private final WechatProperties wechatProperties;
    private final WebClient webClient;
    private final MemberESRepository memberESRepository;
    private final ObjectMapper objectMapper = new ObjectMapper()
            .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    private final EsSyncUtils esSyncUtils;
    private EsSyncUtils.EntitySyncer<Member, MemberES, String> memberSyncer;
    @PostConstruct
    public void init() {
        this.memberSyncer = esSyncUtils.bind(Member.class, MemberES.class, memberESRepository);
    }
    /**
     * 处理关注事件
     */
    @Override
    public Mono<Void> handleSubscribeEvent(String openId) {
        log.info("处理关注事件, openId: {}", openId);
        return getUserInfo(openId)
                .flatMap(userInfo -> {
                    String unionId = userInfo.getUnionid();
                    log.info("获取到用户信息 unionId: {}, nickname:  {}", unionId, userInfo.getNickname());
                    if (unionId != null && !unionId.isEmpty()) {
                        return memberRepository.findByUnionId(unionId)
                                .flatMap(existingMember -> {
                                    log.info("通过UnionID找到已有会员, memberId: {}", existingMember.getId());
                                    if (existingMember.getOfficialOpenId() == null || existingMember.getOfficialOpenId().isEmpty()) {
                                        log.info("用户先使用小程序，更新服务号OpenID: {}", openId);
                                        existingMember.setSubscribed(true);
                                        existingMember.setLastLoginAt(LocalDateTime.now());
                                        existingMember.setOfficialOpenId(openId);
                                        if (existingMember.getNickname() == null || existingMember.getNickname().isEmpty()) {
                                            existingMember.setNickname(userInfo.getNickname());
                                        }
                                        if (existingMember.getAvatar() == null || existingMember.getAvatar().isEmpty()) {
                                            existingMember.setAvatar(userInfo.getHeadimgurl());
                                        }
                                        return memberRepository.save(existingMember)
                                                .doOnSuccess(memberSyncer::sync)
                                                .then(sendWelcomeMessage(openId));
                                    } else {
                                        log.info("老用户关注服务号: memberId={}", existingMember.getId());
                                        existingMember.setSubscribed(true);
                                        existingMember.setLastLoginAt(LocalDateTime.now());
                                        return memberRepository.save(existingMember)
                                                .doOnSuccess(memberSyncer::sync)
                                                .then(sendWelcomeMessage(openId));
                                    }
                                })
                                .switchIfEmpty(Mono.defer(() -> {
                                    log.info("UnionID未找到，降级到服务号OpenID查询: {}", openId);
                                    return memberRepository.findByOfficialOpenId(openId)
                                            .flatMap(existingMember -> {
                                                log.info("通过服务号OpenID找到已有会员，更新UnionID, memberId: {}", existingMember.getId());
                                                existingMember.setUnionId(unionId);
                                                existingMember.setSubscribed(true);
                                                existingMember.setLastLoginAt(LocalDateTime.now());
                                                return memberRepository.save(existingMember)
                                                        .doOnSuccess(memberSyncer::sync)
                                                        .then(sendWelcomeMessage(openId));
                                            })
                                            .switchIfEmpty(Mono.defer(() -> {
                                                log.info("OpenID也未找到，创建新用户");
                                                return createNewMemberFromOfficial(unionId, openId)
                                                        .then(sendWelcomeMessage(openId));
                                            }));
                                }));
                    } else {
                        log.warn("用户没有UnionID，尝试通过服务号OpenID查询");
                        return memberRepository.findByOfficialOpenId(openId)
                                .flatMap(existingMember -> {
                                    log.info("通过服务号OpenID找到已有会员, memberId: {}", existingMember.getId());
                                    existingMember.setSubscribed(true);
                                    existingMember.setLastLoginAt(LocalDateTime.now());
                                    return memberRepository.save(existingMember)
                                            .doOnSuccess(memberSyncer::sync)
                                            .then(sendWelcomeMessage(openId));
                                })
                                .switchIfEmpty(Mono.defer(() -> {
                                    log.info("OpenID也未找到，创建新会员（无UnionID）");
                                    return createNewMemberFromOfficial(unionId, openId)
                                            .then(sendWelcomeMessage(openId));
                                }));
                    }
                })
                .then();
    }
    /**
     * 处理取消关注事件
     */
    @Override
    public Mono<Void> handleUnsubscribeEvent(String openId) {
        log.info("处理取消关注事件, openId: {}", openId);
        return memberRepository.findByOfficialOpenId(openId)
                .flatMap(member -> {
                    log.info("找到会员，更新为未关注状态, memberId: {}", member.getId());
                    member.setSubscribed(false);
                    member.setLastLoginAt(LocalDateTime.now());
                    return memberRepository.save(member)
                            .doOnSuccess(memberSyncer::sync)
                            .then();
                })
                .then()
                .switchIfEmpty(Mono.defer(() -> {
                    log.warn("未找到对应的会员记录, officialOpenId: {}", openId);
                    return Mono.empty();
                }))
                .onErrorResume(e -> {
                    log.error("处理取消关注事件失败", e);
                    return Mono.empty();
                });
    }
    /**
     * 获取微信用户信息
     */
    @Override
    public Mono<WechatUserInfoVO> getUserInfo(String openId) {
        log.debug("获取微信用户信息, openId: {}", openId);
        // 获取AccessToken
        return getAccessToken()
                .flatMap(accessToken -> {
                    String url = "https://api.weixin.qq.com/cgi-bin/user/info"
                            + "?access_token=" + accessToken
                            + "&openid=" + openId
                            + "&lang=zh_CN";
                    return webClient.get()
                            .uri(url)
                            .accept(MediaType.APPLICATION_JSON)
                            .retrieve()
                            .bodyToMono(String.class)
                            .map(responseJson -> {
                                log.info("微信API原始响应: {}", responseJson);
                                try {
                                    WechatUserInfoVO userInfo = objectMapper.readValue(responseJson, WechatUserInfoVO.class);
                                    log.info("解析后的用户信息 - unionId: {}, nickname: {}, openid: {}", 
                                            userInfo.getUnionid(), userInfo.getNickname(), userInfo.getOpenid());
                                    return userInfo;
                                } catch (Exception e) {
                                    log.error("解析微信用户信息失败", e);
                                    throw new RuntimeException("解析微信用户信息失败", e);
                                }
                            });
                });
    }
    /**
     * 通过 UnionID 关联小程序用户和服务号用户
     */
    @Override
    public Mono<Boolean> linkByUnionId(String unionId, String officialOpenId) {
        log.debug("关联小程序用户和服务号用户 unionId: {}, officialOpenId: {}", unionId, officialOpenId);
        return memberRepository.findByUnionId(unionId)
                .flatMap(member -> {
                    member.setSubscribed(true);
                    member.setLastLoginAt(LocalDateTime.now());
                    if (officialOpenId != null && !officialOpenId.isEmpty()) {
                        member.setOfficialOpenId(officialOpenId);
                    }
                    return memberRepository.save(member)
                            .doOnSuccess(memberSyncer::sync)
                            .map(savedMember -> {
                                log.info("关联成功, memberId: {}", savedMember.getId());
                                return true;
                            });
                })
                .switchIfEmpty(Mono.defer(() -> {
                    log.warn("未找到对应的会员记录, unionId: {}", unionId);
                    return Mono.just(false);
                }))
                .onErrorResume(e -> {
                    log.error("关联失败", e);
                    return Mono.just(false);
                });
    }
    /**
     * 查询用户关注状态
     */
    @Override
    public Mono<Boolean> checkSubscribeStatus(Long memberId) {
        log.info("查询用户关注状态, memberId: {}", memberId);
        return memberRepository.findById(memberId)
                .map(member -> {
                    Boolean subscribed = member.getSubscribed();
                    boolean result = subscribed != null && subscribed;
                    log.info("查询用户关注状态结果, memberId: {}, subscribed: {}", memberId, result);
                    return result;
                })
                .defaultIfEmpty(false);
    }
    /**
     * 从服务号用户信息创建新会员
     */
    private Mono<Void> createNewMemberFromOfficial(String unionId, String openId) {
        Member member = Member.builder()
                .unionId(unionId)
                .officialOpenId(openId)
                .subscribed(true)
                .lastLoginAt(LocalDateTime.now())
                .build();
        log.info("新用户关注服务号，仅保存标识信息（UnionID和OpenID）");
        return memberRepository.save(member)
                .doOnSuccess(memberSyncer::sync)
                .doOnSuccess(savedMember -> {
                    log.info("从服务号创建新会员成功, memberId: {}", savedMember.getId());
                })
                .then();
    }
    /**
     * 获取微信AccessToken
     * 
     * TODO: 应该使用缓存，避免频繁请求
     */
    private Mono<String> getAccessToken() {
        String appId = wechatProperties.getMp().getAppId();
        String appSecret = wechatProperties.getMp().getAppSecret();
        String url = "https://api.weixin.qq.com/cgi-bin/token"
                + "?grant_type=client_credential"
                + "&appid=" + appId
                + "&secret=" + appSecret;
        return webClient.get()
                .uri(url)
                .accept(MediaType.APPLICATION_JSON)
                .retrieve()
                .bodyToMono(Map.class)
                .map(response -> {
                    if (response.containsKey("errcode")) {
                        throw new RuntimeException("获取AccessToken失败: " + response.get("errmsg"));
                    }
                    return (String) response.get("access_token");
                });
    }
    /**
     * 发送欢迎消息给用户
     */
    private Mono<Void> sendWelcomeMessage(String openId) {
        log.info("发送欢迎消息给 openId: {}", openId);
        // 真正调用微信 API 发送消息（测试模式和生产模式都执行）
        return getAccessToken()
                .flatMap(accessToken -> {
                    String url = "https://api.weixin.qq.com/cgi-bin/message/custom/send"
                            + "?access_token=" + accessToken;
                    // 构建客服消息�?
                    Map<String, Object> messageBody = new HashMap<>();
                    messageBody.put("touser", openId);
                    messageBody.put("msgtype", "text");
                    Map<String, String> text = new HashMap<>();
                    text.put("content", "欢迎使用");
                    messageBody.put("text", text);
                    return webClient.post()
                            .uri(url)
                            .contentType(MediaType.APPLICATION_JSON)
                            .bodyValue(messageBody)
                            .retrieve()
                            .bodyToMono(Map.class)
                            .doOnSuccess(response -> {
                                if (response.containsKey("errcode") && !"0".equals(String.valueOf(response.get("errcode")))) {
                                    log.error("发送欢迎消息失败: {}", response.get("errmsg"));
                                } else {
                                    log.info("欢迎消息发送成功, openId: {}", openId);
                                }
                            })
                            .doOnError(error -> log.error("发送欢迎消息异常", error))
                            .then();
                })
                .onErrorResume(e -> {
                    log.error("发送欢迎消息失败, openId: {}", openId, e);
                    return Mono.empty(); // 即使发送失败也不影响主流程
                });
    }
 }
@@ -0,0 +1,77 @@
 package cn.novalon.gym.manage.member.util;
 import lombok.extern.slf4j.Slf4j;
 import javax.crypto.Cipher;
 import javax.crypto.spec.IvParameterSpec;
 import javax.crypto.spec.SecretKeySpec;
 import java.nio.charset.StandardCharsets;
 import java.util.Base64;
 /**
 * AES加密工具类
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Slf4j
 public class AesUtil {
    private static final String ALGORITHM = "AES";
    private static final String TRANSFORMATION = "AES/CBC/PKCS5Padding";
    /**
     * AES 解密
     *
     * @param encryptedData 加密数据，Base64编码
     * @param key           AES密钥，Base64编码（32字节）
     * @param iv            初始化向量IV，Base64编码（16字节）
     * @return 解密后的字符串
     */
    public static String decrypt(String encryptedData, String key, String iv) {
        try {
            byte[] dataByte = Base64.getDecoder().decode(encryptedData);
            byte[] keyByte = Base64.getDecoder().decode(key);
            byte[] ivByte = Base64.getDecoder().decode(iv);
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte, ALGORITHM);
            IvParameterSpec ivParameterSpec = new IvParameterSpec(ivByte);
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
            byte[] resultByte = cipher.doFinal(dataByte);
            return new String(resultByte, StandardCharsets.UTF_8);
        } catch (Exception e) {
            log.error("AES解密失败", e);
            throw new RuntimeException("解密失败", e);
        }
    }
    /**
     * AES 加密
     *
     * @param data 原始数据
     * @param key  AES密钥，Base64编码（32字节）
     * @param iv   初始化向量IV，Base64编码（16字节）
     * @return Base64编码的加密数据
     */
    public static String encrypt(String data, String key, String iv) {
        try {
            byte[] dataByte = data.getBytes(StandardCharsets.UTF_8);
            byte[] keyByte = Base64.getDecoder().decode(key);
            byte[] ivByte = Base64.getDecoder().decode(iv);
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte, ALGORITHM);
            IvParameterSpec ivParameterSpec = new IvParameterSpec(ivByte);
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
            byte[] resultByte = cipher.doFinal(dataByte);
            return Base64.getEncoder().encodeToString(resultByte);
        } catch (Exception e) {
            log.error("AES加密失败", e);
            throw new RuntimeException("加密失败", e);
        }
    }
 }
@@ -1,8 +1,4 @@
-package cn.novalon.gym.manage.gymmembercard.util;
+package cn.novalon.gym.manage.member.util;
 /*
 *@Author:shizhounian
 *@Date:2026/5/11-05 21:19:04
 */
 import cn.hutool.core.bean.BeanUtil;
 import org.springframework.stereotype.Component;
@@ -12,6 +8,9 @@ import java.util.List;
 /**
 * Entity、Domain、VO、DTO转换工具类
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Component
 public class BeanConvertUtil {
@@ -0,0 +1,159 @@
 package cn.novalon.gym.manage.member.util;
 import cn.hutool.core.bean.BeanUtil;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.elasticsearch.repository.ReactiveElasticsearchRepository;
 import org.springframework.stereotype.Component;
 import reactor.core.publisher.Mono;
 /**
 * 通用 ES 同步工具类
 *
 * 使用方式：
 *
 * 1. 注入工具类
 *    @Autowired private EsSyncUtils esSyncUtils;
 *
 * 2. 同步数据到 ES（不返回结果，适合 doOnSuccess）
 *    esSyncUtils.sync(Member.class, MemberES.class, member, memberESRepository);
 *
 * 3. 同步数据到 ES（返回 Mono，适合链式调用）
 *    esSyncUtils.syncToES(Member.class, MemberES.class, member, memberESRepository).subscribe();
 *
 * 4. 如果 Repository 是单例，可以先绑定
 *    var syncer = esSyncUtils.bind(Member.class, MemberES.class, memberESRepository);
 *    syncer.sync(member);
 */
@Slf4j
@Component
@RequiredArgsConstructor
 public class EsSyncUtils {
    /**
     * 同步实体到 ES（不返回结果，适合 doOnSuccess）
     *
     * @param sourceClass 源实体类（如 Member.class）
     * @param targetClass 目标ES实体类（如 MemberES.class）
     * @param source 源实体对象
     * @param repository ES Repository
     * @param <S> 源实体类型
     * @param <T> ES实体类型
     * @param <ID> ID类型
     */
    public <S, T, ID> void sync(Class<S> sourceClass, Class<T> targetClass,
                                S source, ReactiveElasticsearchRepository<T, ID> repository) {
        if (source == null) {
            log.warn("同步 ES 失败：源实体为空");
            return;
        }
        try {
            T target = BeanUtil.toBean(source, targetClass);
            repository.save(target).subscribe(
                    success -> log.debug("同步到 ES 成功, 类型: {}", targetClass.getSimpleName()),
                    error -> log.error("同步到 ES 失败, 类型: {}", targetClass.getSimpleName(), error)
            );
        } catch (Exception e) {
            log.error("转换 ES 实体失败, 源类型: {}, 目标类型: {}",
                    sourceClass.getSimpleName(), targetClass.getSimpleName(), e);
        }
    }
    /**
     * 同步实体到 ES（返回 Mono，适合链式调用）
     *
     * @param sourceClass 源实体类
     * @param targetClass 目标ES实体类
     * @param source 源实体对象
     * @param repository ES Repository
     * @return Mono<Void>
     */
    public <S, T, ID> Mono<Void> syncToES(Class<S> sourceClass, Class<T> targetClass,
                                          S source, ReactiveElasticsearchRepository<T, ID> repository) {
        if (source == null) {
            log.warn("同步 ES 失败：源实体为空");
            return Mono.empty();
        }
        try {
            T target = BeanUtil.toBean(source, targetClass);
            return repository.save(target)
                    .doOnSuccess(t -> log.debug("同步到 ES 成功, 类型: {}", targetClass.getSimpleName()))
                    .doOnError(e -> log.error("同步到 ES 失败, 类型: {}", targetClass.getSimpleName(), e))
                    .then();
        } catch (Exception e) {
            log.error("转换 ES 实体失败, 源类型: {}, 目标类型: {}",
                    sourceClass.getSimpleName(), targetClass.getSimpleName(), e);
            return Mono.empty();
        }
    }
    /**
     * 绑定 Repository，返回一个针对特定实体类型的同步器
     *
     * @param sourceClass 源实体类
     * @param targetClass 目标ES实体类
     * @param repository ES Repository
     * @return 实体同步器
     */
    public <S, T, ID> EntitySyncer<S, T, ID> bind(Class<S> sourceClass, Class<T> targetClass,
                                                  ReactiveElasticsearchRepository<T, ID> repository) {
        return new EntitySyncer<>(sourceClass, targetClass, repository);
    }
    /**
     * 实体同步器（绑定特定类型的同步器，避免重复传 Class）
     *
     * @param <S> 源实体类型
     * @param <T> ES实体类型
     * @param <ID> ID类型
     */
    public static class EntitySyncer<S, T, ID> {
        private final Class<S> sourceClass;
        private final Class<T> targetClass;
        private final ReactiveElasticsearchRepository<T, ID> repository;
        public EntitySyncer(Class<S> sourceClass, Class<T> targetClass,
                            ReactiveElasticsearchRepository<T, ID> repository) {
            this.sourceClass = sourceClass;
            this.targetClass = targetClass;
            this.repository = repository;
        }
        /**
         * 同步（不返回结果）
         */
        public void sync(S source) {
            if (source == null) return;
            try {
                T target = BeanUtil.toBean(source, targetClass);
                repository.save(target).subscribe(
                        success -> log.debug("同步到 ES 成功, 类型: {}", targetClass.getSimpleName()),
                        error -> log.error("同步到 ES 失败, 类型: {}", targetClass.getSimpleName(), error)
                );
            } catch (Exception e) {
                log.error("转换 ES 实体失败, 源类型: {}, 目标类型: {}",
                        sourceClass.getSimpleName(), targetClass.getSimpleName(), e);
            }
        }
        /**
         * 同步（返回 Mono）
         */
        public Mono<Void> syncMono(S source) {
            if (source == null) return Mono.empty();
            try {
                T target = BeanUtil.toBean(source, targetClass);
                return repository.save(target)
                        .doOnSuccess(t -> log.debug("同步到 ES 成功, 类型: {}", targetClass.getSimpleName()))
                        .doOnError(e -> log.error("同步到 ES 失败, 类型: {}", targetClass.getSimpleName(), e))
                        .then();
            } catch (Exception e) {
                log.error("转换 ES 实体失败, 源类型: {}, 目标类型: {}",
                        sourceClass.getSimpleName(), targetClass.getSimpleName(), e);
                return Mono.empty();
            }
        }
    }
 }
@@ -0,0 +1,53 @@
 package cn.novalon.gym.manage.member.util;
 import lombok.extern.slf4j.Slf4j;
 import java.security.SecureRandom;
 /**
 * 会员号生成器
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Slf4j
 public class MemberNoGenerator {
    // 会员号前缀
    private static final String PREFIX = "GYM";
    // 随机数长度
    private static final int RANDOM_LENGTH = 8;
    // 字符集（排除易混淆字符 0/O, 1/I/l
    private static final String CHARACTERS = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
    // SecureRandom 实例（线程安全）    
    private static final SecureRandom SECURE_RANDOM = new SecureRandom();
    // 生成会员号   
    public static String generate() {
        StringBuilder sb = new StringBuilder(PREFIX);
        for (int i = 0; i < RANDOM_LENGTH; i++) {
            int index = SECURE_RANDOM.nextInt(CHARACTERS.length());
            sb.append(CHARACTERS.charAt(index));
        }
        String memberNo = sb.toString();
        log.debug("生成会员号: {}", memberNo);
        return memberNo;
    }
    // 批量生成会员号
    // count 生成数量
    public static String[] generateBatch(int count) {
        String[] memberNos = new String[count];
        for (int i = 0; i < count; i++) {
            memberNos[i] = generate();
        }
        return memberNos;
    }
 }
@@ -0,0 +1,65 @@
 package cn.novalon.gym.manage.member.util;
 import cn.novalon.gym.manage.member.service.WechatApiService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import reactor.core.publisher.Mono;
 /**
 * 微信手机号获取工具类
 * 
 * @author 付嘉
 * @date 2026-05-01
 */
@Slf4j
@Component
@RequiredArgsConstructor
 public class WechatPhoneUtil {
    private final WechatApiService wechatApiService;
    /**
     * 通过phoneCode获取手机号
     * 
     * @param phoneCode 手机号 code
     * @return Mono<String> 手机号，获取失败则返回 null
     */
    public Mono<String> getPhoneNumber(String phoneCode) {
        if (phoneCode == null || phoneCode.isEmpty()) {
            log.debug("未提供phoneCode获取手机号");
            return Mono.empty();
        }
        log.info("开始获取手机号, phoneCode: {}", phoneCode);
        return wechatApiService.getPhoneNumber(phoneCode)
                .doOnSuccess(phoneNumber -> {
                    if (phoneNumber != null && !phoneNumber.isEmpty()) {
                        log.info("获取手机号成功: {}", maskPhone(phoneNumber));
                    } else {
                        log.warn("获取手机号失败");
                    }
                })
                .doOnError(e -> {
                    log.warn("获取手机号失败 {}", e.getMessage());
                })
                .onErrorResume(e -> {
                    return Mono.empty();
                });
    }
    /**
     * 手机号脱敏处理
     * 
     * @param phone 手机号
     * @return 脱敏后的手机号，如：138****8000
     */
    private String maskPhone(String phone) {
        if (phone == null || phone.length() < 7) {
            return "***";
        }
        return phone.substring(0, 3) + "****" + phone.substring(7);
    }
 }
@@ -0,0 +1,71 @@
 package cn.novalon.gym.manage.member.vo;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import java.time.LocalDateTime;
 /**
 * 会员卡记录响应 VO
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
 public class MemberCardRecordVO {
    /**
     * 会员卡记录ID
     */
    private Long memberCardRecordId;
    /**
     * 会员ID
     */
    private Long memberId;
    /**
     * 会员卡类型ID
     */
    private Long memberCardId;
    /**
     * 会员卡名称
     */
    private String memberCardName;
    /**
     * 状态：ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款
     */
    private String status;
    /**
     * 剩余次数
     */
    private Integer remainingTimes;
    /**
     * 剩余金额
     */
    private Double remainingAmount;
    /**
     * 到期时间
     */
    private LocalDateTime expireTime;
    /**
     * 购买时间
     */
    private LocalDateTime purchaseTime;
    /**
     * 创建时间
     */
    private LocalDateTime createdAt;
 }
@@ -0,0 +1,81 @@
 package cn.novalon.gym.manage.member.vo;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import java.time.LocalDateTime;
 /**
 * 会员卡交易流水响应 VO
 * 
 * @author 付嘉
 * @date 2026-05-27
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
 public class MemberCardTransactionVO {
    /**
     * 交易ID
     */
    private Long id;
    /**
     * 会员卡记录ID
     */
    private Long memberCardRecordId;
    /**
     * 会员ID
     */
    private Long memberId;
    /**
     * 会员卡类型ID
     */
    private Long memberCardId;
    /**
     * 操作类型：PURCHASE-购买, DEDUCT-扣次/扣费, RENEW-续费, REFUND-退款, EXPIRE-过期
     */
    private String operationType;
    /**
     * 变动次数
     */
    private Integer changeAmount;
    /**
     * 变动金额
     */
    private Double changeBalance;
    /**
     * 变动后剩余次数
     */
    private Integer afterRemainingCount;
    /**
     * 变动后剩余金额
     */
    private Double afterRemainingBalance;
    /**
     * 关联业务类型
     */
    private String relatedBizType;
    /**
     * 备注
     */
    private String remark;
    /**
     * 创建时间
     */
    private LocalDateTime createdAt;
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
时舟年	7c08c685d0	membercard与member-reguster合并，能进行编译和启动	2026-05-27 16:51:05 +08:00
时舟年	53624fc259	membercard与member-reguster合并，能进行编译和启动	2026-05-27 16:06:19 +08:00
future	574021d47c	删除冗余 AuthUtil，更新 manage-app 配置	2026-05-27 13:42:05 +08:00
future	8dbd507dd2	新增 AuthUtil 工具类，优化微信及会员服务实现	2026-05-27 13:26:46 +08:00
future	ddb77db605	更新会员模块和系统安全配置	2026-05-27 03:21:38 +08:00
future	e673d96f6f	删除 gym-member 模块中的无用脚本和配置文件	2026-05-27 02:13:50 +08:00
future	85ed6f9196	实现会员信息管理模块	2026-05-26 23:50:50 +08:00
时舟年	cd44caee57	会员卡管理功能初步完成	2026-05-24 00:57:22 +08:00
liwentao	3d284c8d3a	将查询用户个人信息与更新用户信息迁移至gym-member模块	2026-05-10 20:40:25 +08:00
future	538c1e0ad5	修改bug	2026-05-10 20:14:13 +08:00
future	923d147574	添加会员注册功能路由以及相关配置	2026-05-10 18:34:11 +08:00
future	6ea23b5a01	完成会员注册功能	2026-05-10 17:10:28 +08:00