新增会员卡模块基础

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

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/GymMemberCardApplication.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/dao/MemberCardDao.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/dao/MemberCardRecordDao.java

@@ -0,0 +1,148 @@
+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();
+}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/dao/MemberCardTransactionsDao.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/domain/MemberCard.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/domain/MemberCardRecord.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/domain/MemberCardTransactions.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/entity/MemberCardEntity.java

@@ -0,0 +1,52 @@
+package cn.novalon.gym.manage.gymmembercard.entity;
+
+import cn.novalon.gym.manage.db.entity.BaseEntity;
+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")
+public class MemberCardEntity extends BaseEntity {
+    //会员卡id
+    @Column("member_card_id")
+    private Long memberCardId;
+
+    //会员卡名称
+    @Column("member_card_name")
+    private String memberCardName;
+
+    //会员卡类型
+    @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-禁用
+    @Column("member_card_status")
+    private Integer memberCardStatus;
+
+    //会员卡创建时间
+    @Column("member_card_create_time")
+    private LocalDateTime memberCardCreateTime;
+}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/entity/MemberCardRecordEntity.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/entity/MemberCardTransactionsEntity.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/enums/MemberCardRecordStatus.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/enums/MemberCardTransactionsAction.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/enums/MemberCardTransactionsType.java

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

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

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

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

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

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

@@ -0,0 +1,150 @@
+package cn.novalon.gym.manage.gymmembercard.handler;
+
+import cn.hutool.db.PageResult;
+import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
+import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
+import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardTransactionsService;
+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.time.LocalDateTime;
+import java.util.List;
+
+/*
+ *@Author:shizhounian
+ *@Date:2026/5/17-05 20:10:22
+ */
+@Component
+@Tag(name = "会员卡流水管理", description = "会员卡流水相关操作")
+public class MemberCardTransactionHandler {
+
+    private final IMemberCardTransactionsService memberCardTransactionsService;
+    private final Validator validator;
+
+    public MemberCardTransactionHandler(IMemberCardTransactionsService memberCardTransactionsService,
+                                        Validator validator) {
+        this.memberCardTransactionsService = memberCardTransactionsService;
+        this.validator = validator;
+    }
+
+    /**
+     * 记录每一次变动
+     */
+    @Operation(summary = "插入流水记录", description = "购卡、扣次、续费、退款、过期时插入流水")
+    public Mono<ServerResponse> insertTransaction(ServerRequest request) {
+        return request.bodyToMono(MemberCardTransactions.class)
+                .flatMap(memberCardTransactionsService::insertTransaction)
+                .flatMap(record -> ServerResponse.ok().bodyValue(record));
+    }
+
+    /**
+     * 会员端"使用记录"
+     */
+    @Operation(summary = "会员查询使用记录", description = "按会员ID和时间范围查询流水，支持分页")
+    public Mono<ServerResponse> getMemberTransactions(ServerRequest request) {
+        Long memberId = Long.parseLong(request.pathVariable("memberId"));
+        LocalDateTime startTime = request.queryParam("startTime")
+                .map(LocalDateTime::parse).orElse(LocalDateTime.now().minusMonths(1));
+        LocalDateTime endTime = request.queryParam("endTime")
+                .map(LocalDateTime::parse).orElse(LocalDateTime.now());
+        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());
+
+        return ServerResponse.ok()
+                .body(memberCardTransactionsService.findByMemberIdAndTimeRange(
+                        memberId, startTime, endTime, pageable), MemberCardTransactions.class);
+    }
+
+    /**
+     * 后台"使用记录查询"（条件分页）
+     */
+    @Operation(summary = "管理端流水查询", description = "按会员、卡号、操作类型、时间等条件分页查询流水")
+    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")
+                .map(s -> MemberCardTransactionsAction.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(
+                memberId, memberCardId, operationType, startTime, endTime);
+        Flux<MemberCardTransactions> flux = memberCardTransactionsService.findWithConditions(
+                memberId, memberCardId, operationType, startTime, endTime, pageable);
+
+        return Mono.zip(countMono, flux.collectList())
+                .flatMap(tuple -> {
+                    Long total = tuple.getT1();
+                    List<MemberCardTransactions> list = tuple.getT2();
+                    // 构造 PageResult，内部自动计算总页数
+                    PageResult<MemberCardTransactions> result = new PageResult<>(page, size, total.intValue());
+                    result.addAll(list);
+                    return ServerResponse.ok().bodyValue(result);
+                });
+    }
+
+    /**
+     * 按卡ID查询流水
+     */
+    @Operation(summary = "按卡ID查询流水", description = "查看某张卡的所有流水记录")
+    public Mono<ServerResponse> getTransactionsByCardId(ServerRequest request) {
+        Long memberCardId = Long.parseLong(request.pathVariable("cardId"));
+        return ServerResponse.ok()
+                .body(memberCardTransactionsService.findByMemberCardId(memberCardId),
+                        MemberCardTransactions.class);
+    }
+
+    /**
+     * 统计某卡种的总扣次数
+     */
+    @Operation(summary = "统计卡种总扣次数", description = "按卡种ID和时间范围统计扣次总数")
+    public Mono<ServerResponse> getDeductCountByCardId(ServerRequest request) {
+        Long memberCardId = Long.parseLong(request.pathVariable("cardId"));
+        LocalDateTime startTime = request.queryParam("startTime")
+                .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)
+                .flatMap(count -> ServerResponse.ok().bodyValue(count));
+    }
+
+    /**
+     * 统计某时间段的续费总金额
+     */
+    @Operation(summary = "统计续费总金额", description = "按时间段统计续费总金额")
+    public Mono<ServerResponse> getRenewAmountByTimeRange(ServerRequest request) {
+        LocalDateTime startTime = request.queryParam("startTime")
+                .map(LocalDateTime::parse).orElse(LocalDateTime.now().minusMonths(1));
+        LocalDateTime endTime = request.queryParam("endTime")
+                .map(LocalDateTime::parse).orElse(LocalDateTime.now());
+        return memberCardTransactionsService.sumRenewAmountByTimeRange(startTime, endTime)
+                .flatMap(amount -> ServerResponse.ok().bodyValue(amount));
+    }
+
+    /**
+     * 统计某会员的购卡总金额
+     */
+    @Operation(summary = "统计会员购卡总金额", description = "按会员ID和时间段统计购卡总金额")
+    public Mono<ServerResponse> getPurchaseAmountByMember(ServerRequest request) {
+        Long memberId = Long.parseLong(request.pathVariable("memberId"));
+        LocalDateTime startTime = request.queryParam("startTime")
+                .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)
+                .flatMap(amount -> ServerResponse.ok().bodyValue(amount));
+    }
+}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/IMemberCardRecordRepository.java

@@ -0,0 +1,83 @@
+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();
+}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/IMemberCardRepository.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/IMemberCardTransactionsRepository.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/impl/MemberCardRecordRepositoryImpl.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/impl/MemberCardRepositoryImpl.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/impl/MemberCardTransactionsRepositoryImpl.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/IMemberCardRecordService.java

@@ -0,0 +1,83 @@
+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();
+}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/IMemberCardService.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/IMemberCardTransactionsService.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/MemberCardRecordServiceImpl.java

@@ -0,0 +1,67 @@
+package cn.novalon.gym.manage.gymmembercard.sevice.impl;
+
+import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
+import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
+import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
+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;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+@Service
+public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
+    private final IMemberCardRecordRepository memberCardRecordRepository;
+
+    public MemberCardRecordServiceImpl(IMemberCardRecordRepository memberCardRecordRepository) {
+        this.memberCardRecordRepository = memberCardRecordRepository;
+    }
+
+    @Override
+    public Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record) {
+        return memberCardRecordRepository.insertActiveRecord(record);
+    }
+
+    @Override
+    public Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount) {
+        return memberCardRecordRepository.deductUsage(recordId, deductTimes, deductAmount);
+    }
+
+    @Override
+    public Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime) {
+        return memberCardRecordRepository.renewCard(recordId, addTimes, addAmount, newExpireTime);
+    }
+
+    @Override
+    public Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus 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);
+    }
+
+    @Override
+    public Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount) {
+        return memberCardRecordRepository.validateStoredCard(recordId, requiredAmount);
+    }
+
+    @Override
+    public Flux<MemberCardRecord> findExpiredCards() {
+        return memberCardRecordRepository.findExpiredCards();
+    }
+}

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/MemberCardServiceImpl.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/MemberCardTransactionsServiceImpl.java

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

gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/util/BeanConvertUtil.java

@@ -0,0 +1,49 @@
+package cn.novalon.gym.manage.gymmembercard.util;
+/*
+ *@Author:shizhounian
+ *@Date:2026/5/11-05 21:19:04
+ */
+
+import cn.hutool.core.bean.BeanUtil;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Entity、Domain、VO、DTO转换工具类
+ */
+@Component
+public class BeanConvertUtil {
+
+    /**
+     * 单个对象泛型转换
+     * @param source 源对象
+     * @param targetClass 目标类Class
+     * @return 转换后的目标对象
+     */
+    public static <S, T> T toBean(S source, Class<T> targetClass) {
+        if (source == null) {
+            return null;
+        }
+        return BeanUtil.copyProperties(source, targetClass);
+    }
+
+    /**
+     * 集合批量泛型转换
+     * @param sourceList 源对象集合
+     * @param targetClass 目标类Class
+     * @return 转换后的目标对象集合
+     */
+    public static <S, T> List<T> toBeanList(List<S> sourceList, Class<T> targetClass) {
+        if (sourceList == null || sourceList.isEmpty()) {
+            return List.of();
+        }
+
+        List<T> targetList = new ArrayList<>();
+        for (S source : sourceList) {
+            targetList.add(toBean(source, targetClass));
+        }
+        return targetList;
+    }
+}

gym-manage-api/gym-member-card/src/main/resources/application.properties

@@ -0,0 +1 @@
+spring.application.name=gym-member-card

gym-manage-api/gym-member-card/src/test/java/cn/novalon/gym/manage/gymmembercard/GymMemberCardApplicationTests.java

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

gym-manage-api/gym-member/.gitignore

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

gym-manage-api/gym-member/MEMBER_USER_TABLE_SIMPLE.sql

@@ -1,58 +0,0 @@
--- ============================================
--- 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 '是否删除（软删除标记）';

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

@@ -1,245 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>cn.novalon.gym.manage</groupId>
-        <artifactId>gym-manage-api</artifactId>
-        <version>1.0.0</version>
-    </parent>
-
-    <artifactId>gym-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>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
-                <version>3.4.2</version>
-                <executions>
-                    <execution>
-                        <id>default-jar</id>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>jar</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.11.0</version>
-                <configuration>
-                    <source>21</source>
-                    <target>21</target>
-                    <annotationProcessorPaths>
-                        <path>
-                            <groupId>org.mapstruct</groupId>
-                            <artifactId>mapstruct-processor</artifactId>
-                            <version>1.5.5.Final</version>
-                        </path>
-                        <path>
-                            <groupId>org.projectlombok</groupId>
-                            <artifactId>lombok</artifactId>
-                            <version>${lombok.version}</version>
-                        </path>
-                        <path>
-                            <groupId>org.projectlombok</groupId>
-                            <artifactId>lombok-mapstruct-binding</artifactId>
-                            <version>0.2.0</version>
-                        </path>
-                    </annotationProcessorPaths>
-                </configuration>
-            </plugin>
-            <plugin>
-                <groupId>org.jacoco</groupId>
-                <artifactId>jacoco-maven-plugin</artifactId>
-                <version>0.8.12</version>
-                <executions>
-                    <execution>
-                        <id>prepare-agent</id>
-                        <goals>
-                            <goal>prepare-agent</goal>
-                        </goals>
-                    </execution>
-                    <execution>
-                        <id>report</id>
-                        <phase>verify</phase>
-                        <goals>
-                            <goal>report</goal>
-                        </goals>
-                    </execution>
-                    <execution>
-                        <id>check</id>
-                        <phase>verify</phase>
-                        <goals>
-                            <goal>check</goal>
-                        </goals>
-                        <configuration>
-                            <rules>
-                                <rule>
-                                    <element>BUNDLE</element>
-                                    <limits>
-                                        <limit>
-                                            <counter>INSTRUCTION</counter>
-                                            <value>COVEREDRATIO</value>
-                                            <minimum>0.60</minimum>
-                                        </limit>
-                                    </limits>
-                                </rule>
-                            </rules>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>com.github.spotbugs</groupId>
-                <artifactId>spotbugs-maven-plugin</artifactId>
-                <version>4.8.6.0</version>
-                <dependencies>
-                    <dependency>
-                        <groupId>com.github.spotbugs</groupId>
-                        <artifactId>spotbugs</artifactId>
-                        <version>4.8.6</version>
-                    </dependency>
-                </dependencies>
-                <executions>
-                    <execution>
-                        <id>spotbugs-check</id>
-                        <phase>verify</phase>
-                        <goals>
-                            <goal>check</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <configuration>
-                    <effort>Max</effort>
-                    <threshold>High</threshold>
-                    <failOnError>true</failOnError>
-                    <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-</project>

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/config/HttpClientConfig.java

@@ -1,22 +0,0 @@
-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();
-    }
-}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/config/WechatProperties.java

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

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/AdminUpdatePhoneDto.java

@@ -1,17 +0,0 @@
-package cn.novalon.gym.manage.member.dto;
-
-import lombok.Data;
-
-/**
- * 更新手机号Dto
- * 
- * @author 付嘉
- * @date 2026-05-01
- */
-
-@Data
-public class AdminUpdatePhoneDto {
-    
-    // 手机号
-    private String phone;
-}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/SearchMemberDto.java

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

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/UpdateMemberInfoDto.java

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

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/WechatLoginDto.java

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

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/WechatOfficialEventDto.java

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

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

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

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

@@ -1,81 +0,0 @@
-package cn.novalon.gym.manage.member.entity;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.NoArgsConstructor;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.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;
-
-}

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

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

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

@@ -1,55 +0,0 @@
-package cn.novalon.gym.manage.member.entity;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.NoArgsConstructor;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.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;
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,208 +0,0 @@
-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, "会员不存在");
-                }));
-    }
-}

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

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

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

@@ -1,300 +0,0 @@
-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();
-    }
-}

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

@@ -1,338 +0,0 @@
-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(); // 即使发送失败也不影响主流程
-                });
-    }
-}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/util/AesUtil.java

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

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/util/EsSyncUtils.java

@@ -1,159 +0,0 @@
-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();
-            }
-        }
-    }
-}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/util/MemberNoGenerator.java

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

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/util/WechatPhoneUtil.java

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

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

@@ -1,46 +0,0 @@
-package cn.novalon.gym.manage.member.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.Date;
-
-/**
- * 会员信息 VO
- * 
- * @author 付嘉
- * @date 2026-05-01
- */
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class MemberInfoVO {
-
-    // 会员 ID
-    private Long id;
-
-    // 昵称
-    private String nickname;
-
-    // 手机号（脱敏）
-    private String phone;
-
-    // 性别
-    private Integer gender;
-
-    // 生日
-    private Date birthday;
-
-    // 头像
-    private String avatar;
-
-    // 是否已绑定手机号
-    private Boolean hasPhone;
-
-    // 是否已关注公众号
-    private Boolean isSubscribed;
-}

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

@@ -1,38 +0,0 @@
-package cn.novalon.gym.manage.member.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-/**
- * 微信登录VO
- * 
- * @author 付嘉
- * @date 2026-05-01
- */
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class WechatLoginVO {
-
-    // 会员 ID
-    private Long memberId;
-
-    // Access Token（访问令牌）
-    private String accessToken;
-
-    // Refresh Token（刷新令牌）
-    private String refreshToken;
-
-    // Token 过期时间（秒）
-    private Integer expiresIn;
-
-    // 是否为新用户
-    private Boolean isNewUser;
-
-    // 是否需要补全信息（昵称、手机号等）
-    private Boolean needCompleteInfo;
-}

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

@@ -1,72 +0,0 @@
-package cn.novalon.gym.manage.member.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import java.util.List;
-
-/**
- * 微信用户信息 VO
- * 
- * @author 付嘉
- * @date 2026-05-01
- */
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class WechatUserInfoVO {
-
-    // 用户是否关注该公众号（true-已关注，false-未关注）
-    private Boolean subscribe;
-
-    // 服务号 OpenID
-    private String openid;
-
-    // 用户昵称
-    private String nickname;
-
-    // 性别（1-男，2-女，0-未知）
-    private Integer sex;
-
-    // 国家
-    private String country;
-
-    // 省份
-    private String province;
-
-    // 城市
-    private String city;
-
-    // 语言
-    private String language;
-
-    // 头像 URL
-    private String headimgurl;
-
-    // 关注时间
-    private Long subscribeTime;
-
-    // UnionID
-    private String unionid;
-
-    // 公众号运营者对粉丝的备注
-    private String remark;
-
-    // 用户所在的分组 ID
-    private Integer groupid;
-
-    // 用户被打上的标签 ID 列表
-    private List<Integer> tagidList;
-
-    // 关注来源
-    private Integer subscribeScene;
-
-    // 二维码场景值
-    private String qrScene;
-
-    // 二维码场景值字符串
-    private String qrSceneStr;
-}

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

@@ -1 +0,0 @@
-cn.novalon.gym.manage.member.config.WechatProperties

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

@@ -1,138 +0,0 @@
--- ============================================
--- 1. member_user 表（会员表）
--- ============================================
-
--- Step 1: 删除已存在的表（如果需要重建）
--- DROP TABLE IF EXISTS member_user CASCADE;
-
--- Step 2: 创建 member_user 表
-CREATE TABLE IF NOT EXISTS member_user (
-    -- ========== 主键和基础字段（来自BaseEntity）==========
-    id BIGSERIAL PRIMARY KEY,                                      -- 主键ID，自增
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,      -- 创建时间
-    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,      -- 更新时间
-    
-    -- ========== 会员核心字段 ==========
-    member_no VARCHAR(50) NOT NULL UNIQUE,                         -- 会员编号（唯一）
-    nickname VARCHAR(100),                                         -- 昵称
-    phone VARCHAR(255),                                            -- 手机号（AES加密存储）
-    gender INTEGER DEFAULT 0,                                      -- 性别：0-未知，1-男，2-女
-    birthday TIMESTAMP,                                            -- 生日
-    address VARCHAR(500),                                          -- 地址
-    avatar VARCHAR(500),                                           -- 头像URL
-    subscribed BOOLEAN DEFAULT FALSE,                              -- 是否关注服务号
-    last_login_at TIMESTAMP,                                       -- 最后登录时间
-    
-    -- ========== 微信相关字段 ==========
-    union_id VARCHAR(100),                                         -- 微信UnionID（跨应用唯一标识）
-    miniapp_open_id VARCHAR(100),                                  -- 小程序OpenID
-    official_open_id VARCHAR(100),                                 -- 服务号OpenID
-    
-    -- ========== 软删除字段 ==========
-    is_deleted BOOLEAN DEFAULT FALSE                               -- 是否删除（软删除标记）
-);
-
--- Step 3: 创建索引
--- 会员编号索引（唯一索引，加速查询）
-CREATE UNIQUE INDEX IF NOT EXISTS idx_member_user_member_no ON member_user(member_no);
-
--- UnionID索引（加速跨平台用户查找）
-CREATE INDEX IF NOT EXISTS idx_member_user_union_id ON member_user(union_id);
-
--- 小程序OpenID索引（加速小程序登录查询）
-CREATE INDEX IF NOT EXISTS idx_member_user_miniapp_openid ON member_user(miniapp_open_id);
-
--- 服务号OpenID索引（加速服务号事件处理）
-CREATE INDEX IF NOT EXISTS idx_member_user_official_openid ON member_user(official_open_id);
-
--- 手机号索引（加速手机号查询和去重）
-CREATE INDEX IF NOT EXISTS idx_member_user_phone ON member_user(phone);
-
--- 软删除索引（加速查询未删除的记录）
-CREATE INDEX IF NOT EXISTS idx_member_user_is_deleted ON member_user(is_deleted);
-
--- Step 4: 添加注释
-COMMENT ON TABLE member_user IS '会员表';
-
-COMMENT ON COLUMN member_user.id IS '主键ID';
-COMMENT ON COLUMN member_user.created_at IS '创建时间';
-COMMENT ON COLUMN member_user.updated_at IS '更新时间';
-
-COMMENT ON COLUMN member_user.member_no IS '会员编号（唯一，格式：MEM + 8位随机字符）';
-COMMENT ON COLUMN member_user.nickname IS '昵称';
-COMMENT ON COLUMN member_user.phone IS '手机号（AES-128-CBC加密存储）';
-COMMENT ON COLUMN member_user.gender IS '性别：0-未知，1-男，2-女';
-COMMENT ON COLUMN member_user.birthday IS '生日';
-COMMENT ON COLUMN member_user.address IS '地址';
-COMMENT ON COLUMN member_user.avatar IS '头像URL';
-COMMENT ON COLUMN member_user.subscribed IS '是否关注服务号：true-已关注，false-未关注';
-COMMENT ON COLUMN member_user.last_login_at IS '最后登录时间';
-
-COMMENT ON COLUMN member_user.union_id IS '微信UnionID（用户在开放平台的唯一标识，跨应用相同）';
-COMMENT ON COLUMN member_user.miniapp_open_id IS '小程序OpenID（用户在当前小程序的唯一标识）';
-COMMENT ON COLUMN member_user.official_open_id IS '服务号OpenID（用户在当前服务号的唯一标识）';
-
-COMMENT ON COLUMN member_user.is_deleted IS '是否删除（软删除标记）：false-正常，true-已删除';
-
-
--- ============================================
--- 2. wechat_user 表（微信用户表）
--- ============================================
-
--- Step 1: 删除已存在的表（如果需要重建）
--- DROP TABLE IF EXISTS wechat_user CASCADE;
-
--- Step 2: 创建 wechat_user 表
-CREATE TABLE IF NOT EXISTS wechat_user (
-    -- ========== 主键和基础字段（来自BaseEntity）==========
-    id BIGSERIAL PRIMARY KEY,                                      -- 主键ID，自增
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,      -- 创建时间
-    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,      -- 更新时间
-    
-    -- ========== 关联字段 ==========
-    member_id BIGINT NOT NULL,                                     -- 会员ID（外键）
-    
-    -- ========== 微信标识字段 ==========
-    union_id VARCHAR(100),                                         -- 微信UnionID
-    miniapp_openid VARCHAR(100),                                   -- 小程序OpenID
-    mp_openid VARCHAR(100),                                        -- 服务号OpenID
-    
-    -- ========== 关注状态字段 ==========
-    is_subscribed BOOLEAN DEFAULT FALSE,                           -- 是否关注服务号
-    subscribe_time TIMESTAMP,                                      -- 首次关注时间
-    unsubscribe_time TIMESTAMP                                     -- 最后一次取消关注时间
-);
-
--- Step 3: 创建外键约束
-ALTER TABLE wechat_user 
-    ADD CONSTRAINT fk_wechat_user_member 
-    FOREIGN KEY (member_id) REFERENCES member_user(id) ON DELETE CASCADE;
-
--- Step 4: 创建索引
--- UnionID索引（加速跨平台用户查找）
-CREATE INDEX IF NOT EXISTS idx_wechat_user_union_id ON wechat_user(union_id);
-
--- 小程序OpenID索引（加速小程序登录查询）
-CREATE INDEX IF NOT EXISTS idx_wechat_user_miniapp_openid ON wechat_user(miniapp_openid);
-
--- 服务号OpenID索引（加速服务号事件处理）
-CREATE INDEX IF NOT EXISTS idx_wechat_user_mp_openid ON wechat_user(mp_openid);
-
--- 会员ID索引（加速关联查询）
-CREATE INDEX IF NOT EXISTS idx_wechat_user_member_id ON wechat_user(member_id);
-
--- Step 5: 添加注释
-COMMENT ON TABLE wechat_user IS '微信用户表';
-
-COMMENT ON COLUMN wechat_user.id IS '主键ID';
-COMMENT ON COLUMN wechat_user.created_at IS '创建时间';
-COMMENT ON COLUMN wechat_user.updated_at IS '更新时间';
-
-COMMENT ON COLUMN wechat_user.member_id IS '会员ID（关联 member_user 表的 id 字段）';
-COMMENT ON COLUMN wechat_user.union_id IS '微信UnionID（用户在开放平台的唯一标识）';
-COMMENT ON COLUMN wechat_user.miniapp_openid IS '小程序OpenID（用户在当前小程序的唯一标识）';
-COMMENT ON COLUMN wechat_user.mp_openid IS '服务号OpenID（用户在当前服务号的唯一标识）';
-
-COMMENT ON COLUMN wechat_user.is_subscribed IS '是否关注服务号：true-已关注，false-未关注';
-COMMENT ON COLUMN wechat_user.subscribe_time IS '首次关注时间';
-COMMENT ON COLUMN wechat_user.unsubscribe_time IS '最后一次取消关注时间';

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

@@ -1,22 +0,0 @@
-# 微信配置（测试环境使用模拟数据）
-wechat:
-  # Mock模式：true=使用模拟数据（开发测试），false=调用真实微信API（生产环境）
-  mock-enabled: false
-  miniapp:
-    app-id: wx4d480112b426100b
-    app-secret: 78548f0c0ff66c73d3e8b071897eb1e5
-  mp:
-    app-id: wx6f138c9aacc8a0e8
-    app-secret: 5df2e315e9268e96a43bb2cce1d2270b
-    token: test_token
-    aes-key: ${WECHAT_MP_AESKEY:test_aes_key}
-    # 服务器回调地址（微信服务器推送事件的URL）
-    callback-url: https://1me240209tk74.vicp.fun/api/member/auth/mp/callback
-  # 手机号加密配置
-  phone-encryption:
-    secret-key: nVnA99iBfyK0IE6SkcUYdVAaVrezyn2sLRdLfkIyWnY=
-    iv: LMpG6Ih9mmfEAALOCeIJBw==
-
-spring:
-  elasticsearch:
-    uris: http://localhost:9200          # ES 服务器地址（支持多个，逗号分隔）

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

@@ -38,12 +38,6 @@
             <artifactId>manage-db</artifactId>
             <version>${project.version}</version>
         </dependency>
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>gym-member</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-webflux</artifactId>
@@ -139,6 +133,12 @@
             <groupId>org.springdoc</groupId>
             <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
         </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>gym-member-card</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
     </dependencies>
 
     <build>

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

@@ -7,8 +7,9 @@ import org.springframework.boot.CommandLineRunner;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration;
+import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
 import org.springframework.context.annotation.Bean;
-import org.springframework.data.elasticsearch.repository.config.EnableReactiveElasticsearchRepositories;
+import org.springframework.context.annotation.ComponentScan;
 import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
 import org.springframework.web.server.WebFilter;
 
@@ -16,12 +17,9 @@ import java.util.List;
 
 @SpringBootApplication(scanBasePackages = "cn.novalon.gym.manage", exclude = {
         ReactiveUserDetailsServiceAutoConfiguration.class })
-@EnableR2dbcRepositories(basePackages = {
+@EnableR2dbcRepositories(basePackages = { "cn.novalon.gym.manage.db.dao",
-        "cn.novalon.gym.manage.db.dao",
+        "cn.novalon.gym.manage.sys.audit.repository" ,
-        "cn.novalon.gym.manage.sys.audit.repository",
+        "cn.novalon.gym.manage.gymmembercard.dao"})
-        "cn.novalon.gym.manage.member.repository"
-})
-@EnableReactiveElasticsearchRepositories("cn.novalon.gym.manage.member.es.repository")
 public class ManageApplication {
 
     private static final Logger logger = LoggerFactory.getLogger(ManageApplication.class);

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

@@ -1,23 +1,23 @@
 package cn.novalon.gym.manage.app.config;
 
-
+import cn.novalon.gym.manage.gymmembercard.handler.MemberCardHandler;
-import cn.novalon.gym.manage.file.handler.SysFileHandler;
+import cn.novalon.gym.manage.gymmembercard.handler.MemberCardRecordHandler;
-import cn.novalon.gym.manage.member.handler.MemberHandler;
+import cn.novalon.gym.manage.gymmembercard.handler.MemberCardTransactionHandler;
-import cn.novalon.gym.manage.member.handler.WechatAuthHandler;
-import cn.novalon.gym.manage.notify.handler.SysNoticeHandler;
-import cn.novalon.gym.manage.notify.handler.SysUserMessageHandler;
-import cn.novalon.gym.manage.sys.handler.auth.PasswordDiagnosticHandler;
 import cn.novalon.gym.manage.sys.handler.auth.SysAuthHandler;
+import cn.novalon.gym.manage.sys.handler.auth.PasswordDiagnosticHandler;
 import cn.novalon.gym.manage.sys.handler.config.SysConfigHandler;
-import cn.novalon.gym.manage.sys.handler.dict.SysDictHandler;
 import cn.novalon.gym.manage.sys.handler.dictionary.DictionaryHandler;
-import cn.novalon.gym.manage.sys.handler.log.OperationLogHandler;
+import cn.novalon.gym.manage.sys.handler.dict.SysDictHandler;
 import cn.novalon.gym.manage.sys.handler.log.SysLogHandler;
+import cn.novalon.gym.manage.sys.handler.log.OperationLogHandler;
 import cn.novalon.gym.manage.sys.handler.menu.MenuHandler;
-import cn.novalon.gym.manage.sys.handler.permission.SysPermissionHandler;
 import cn.novalon.gym.manage.sys.handler.role.SysRoleHandler;
+import cn.novalon.gym.manage.sys.handler.permission.SysPermissionHandler;
 import cn.novalon.gym.manage.sys.handler.stats.StatsHandler;
 import cn.novalon.gym.manage.sys.handler.user.SysUserHandler;
+import cn.novalon.gym.manage.notify.handler.SysNoticeHandler;
+import cn.novalon.gym.manage.notify.handler.SysUserMessageHandler;
+import cn.novalon.gym.manage.file.handler.SysFileHandler;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.reactive.function.server.RouterFunction;
@@ -54,9 +54,10 @@ public class SystemRouter {
             SysUserMessageHandler messageHandler,
             SysFileHandler fileHandler,
             SysPermissionHandler permissionHandler,
-            MemberHandler memberHandler,
+            PasswordDiagnosticHandler passwordDiagnosticHandler,
-            WechatAuthHandler wechatAuthHandler,
+            MemberCardHandler memberCardHandler,
-            PasswordDiagnosticHandler passwordDiagnosticHandler) {
+            MemberCardRecordHandler memberCardRecordHandler,
+            MemberCardTransactionHandler memberCardTransactionHandler) {
         
         return route()
                 // ========== 诊断路由 ==========
@@ -198,24 +199,52 @@ public class SystemRouter {
                 .PUT("/api/permissions/{id}", permissionHandler::updatePermission)
                 .DELETE("/api/permissions/{id}", permissionHandler::deletePermission)
 
-                // ========== 会员模块路由 - 微信认证 ==========
+                // ========== 会员卡管理路由 ==========
-                .POST("/api/member/auth/miniapp/login", wechatAuthHandler::miniappLogin)
+                // 会员卡类型
-                .GET("/api/member/auth/mp/callback", wechatAuthHandler::verifyMpSignature)
+                // 1. 获取所有会员卡类型
-                .POST("/api/member/auth/mp/callback", wechatAuthHandler::mpCallback)
+                .GET("/api/memberCard/active", memberCardHandler::getActiveCards)
-                
+                // 2. 获取会员卡详情
-                // ========== 会员模块路由 - 会员信息 ==========
+                .GET("/api/memberCard/{memberCardId}", memberCardHandler::getMemberCardById)
-                .GET("/api/member/info", memberHandler::getMemberInfo)
+                // 3. 条件查询会员卡列表
-                .PUT("/api/member/info", memberHandler::updateMemberInfo)
+                .GET("/api/memberCard", memberCardHandler::getMemberCardList)
-                .POST("/api/member/phone/bind", memberHandler::bindPhone)
+                // 4. 新增/更新会员卡
-                .GET("/api/member/subscribe/status", memberHandler::checkSubscribeStatus)
+                .POST("/api/memberCard", memberCardHandler::saveMemberCard)
-                
+                // 5. 逻辑删除会员卡
-                // ========== 会员模块路由 - 管理端 ==========
+                .DELETE("/api/memberCard/{memberCardId}", memberCardHandler::deleteMemberCard)
-                .POST("/api/admin/member/{id}/phone", memberHandler::adminUpdatePhone)
+                // 会员卡持卡
-                .GET("/api/admin/member/{id}", memberHandler::adminGetMemberInfo)
+                // 1. 会员购卡/发卡
-                .PUT("/api/admin/member/{id}", memberHandler::adminUpdateMemberInfo)
+                .POST("/api/memberCardRecord", memberCardRecordHandler::insertActiveRecord)
-                .GET("/api/admin/members", memberHandler::searchMembers)
+                // 2. 会员端“我的卡包” - 按会员ID获取有效卡
-                .GET("/api/admin/members/all", memberHandler::getAllMembers)
+                .GET("/api/memberCardRecord/member/{memberId}/active", memberCardRecordHandler::getMyCards)
-
+                // 3. 管理端按会员ID分页查所有卡记录
+                .GET("/api/memberCardRecord/member/{memberId}", memberCardRecordHandler::getMemberCardRecords)
+                // 4. 到期扫描
+                .GET("/api/memberCardRecord/expired", memberCardRecordHandler::getExpiredCards)
+                // 5. 扣次/扣费
+                .POST("/api/memberCardRecord/{id}/deduct", memberCardRecordHandler::deductUsage)
+                // 6. 续费
+                .POST("/api/memberCardRecord/{id}/renew", memberCardRecordHandler::renewCard)
+                // 7. 状态变更（过期/退款）
+                .PUT("/api/memberCardRecord/{id}/status", memberCardRecordHandler::updateStatus)
+                // 8. 验证次卡
+                .GET("/api/memberCardRecord/{id}/validate/count", memberCardRecordHandler::validateCountCard)
+                // 9. 验证储值卡
+                .GET("/api/memberCardRecord/{id}/validate/stored", memberCardRecordHandler::validateStoredCard)
+                // 会员卡交易
+                // 1. 插入流水记录
+                .POST("/api/transactions", memberCardTransactionHandler::insertTransaction)
+                // 2. 后台条件分页查询流水（带多个查询参数）
+                .GET("/api/transactions", memberCardTransactionHandler::getTransactionsWithConditions)
+                // 3. 按会员ID查询使用记录（分页 + 时间范围）
+                .GET("/api/transactions/member/{memberId}", memberCardTransactionHandler::getMemberTransactions)
+                // 4. 按卡ID查询所有流水记录
+                .GET("/api/transactions/card/{cardId}", memberCardTransactionHandler::getTransactionsByCardId)
+                // 5. 统计某卡种总扣次数
+                .GET("/api/transactions/statistics/deduct/card/{cardId}", memberCardTransactionHandler::getDeductCountByCardId)
+                // 6. 统计某时间段续费总金额
+                .GET("/api/transactions/statistics/renew", memberCardTransactionHandler::getRenewAmountByTimeRange)
+                // 7. 统计某会员购卡总金额
+                .GET("/api/transactions/statistics/purchase/member/{memberId}", memberCardTransactionHandler::getPurchaseAmountByMember)
                 .build();
     }
 }

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

@@ -12,15 +12,11 @@ spring:
       max-life-time: 30m
       acquire-timeout: 3s
   flyway:
-    url: jdbc:postgresql://localhost:55432/manage_system
+    enabled: true
-    user: novalon
-    password: novalon123
-    enabled: false
     locations: classpath:db/migration
     baseline-on-migrate: true
     validate-on-migrate: true
 
-
 jwt:
   secret: novalon-gym-manage-jwt-secret-key-for-development-only-2026
   expiration: 86400000

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

@@ -19,7 +19,7 @@ spring:
     password: 123456
     driver-class-name: org.postgresql.Driver
   flyway:
-    enabled: false
+    enabled: true
     locations: classpath:db/migration
     baseline-on-migrate: true
     baseline-version: 0

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

@@ -15,7 +15,7 @@ spring:
       max-life-time: 1h
       acquire-timeout: 5s
   flyway:
-    enabled: false
+    enabled: true
     locations: classpath:db/migration
     baseline-on-migrate: true
     validate-on-migrate: true

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

@@ -29,7 +29,7 @@ spring:
     password: ${DB_PASSWORD:postgres}
     driver-class-name: org.postgresql.Driver
   flyway:
-    enabled: false
+    enabled: true
     locations: classpath:db/migration
     baseline-on-migrate: true
     baseline-version: 0
@@ -38,10 +38,6 @@ spring:
     user:
       name: disabled
       password: disabled
-  profiles:
-    active: dev
-  config:
-    import: classpath:member-config.yml
 
 management:
   endpoints:

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

@@ -47,7 +47,6 @@ public class JwtAuthenticationFilter extends AbstractGatewayFilterFactory<JwtAut
 
             ServerHttpRequest modifiedRequest = request.mutate()
                     .header("X-User-Id", String.valueOf(userId))
-                    .header("X-Member-Id", String.valueOf(userId))
                     .header("X-Username", username)
                     .build();
 
@@ -58,9 +57,6 @@ public class JwtAuthenticationFilter extends AbstractGatewayFilterFactory<JwtAut
     private boolean isPublicPath(String path) {
         return path.startsWith("/api/auth/") || 
                path.equals("/actuator/health") ||
-               path.equals("/api/member/auth/miniapp/login") || 
-               path.equals("/api/member/auth/mp/callback") || 
-               path.equals("/api/auth/login") || 
                path.startsWith("/actuator/info");
     }
 

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

@@ -9,27 +9,27 @@ spring:
   cloud:
     gateway:
       routes:
-      - id: manage-app
+        - id: manage-app
-        uri: http://localhost:8084
+          uri: http://localhost:8084
-        predicates:
+          predicates:
-        - Path=/api/**
+            - Path=/api/**
       default-filters:
-      - name: JwtAuthentication
+        - name: JwtAuthentication
-      - name: RbacAuthorization
+        - name: RbacAuthorization
-      - name: Retry
+        - name: Retry
-        args:
+          args:
-          retries: 3
+            retries: 3
-          statuses: BAD_GATEWAY,SERVICE_UNAVAILABLE
+            statuses: BAD_GATEWAY,SERVICE_UNAVAILABLE
-          methods: GET,POST
+            methods: GET,POST
-          backoff:
+            backoff:
-            firstBackoff: 10ms
+              firstBackoff: 10ms
-            maxBackoff: 50ms
+              maxBackoff: 50ms
-            factor: 2
+              factor: 2
-            basedOnPreviousValue: false
+              basedOnPreviousValue: false
-      - name: DedupeResponseHeader
+        - name: DedupeResponseHeader
-        args:
+          args:
-          name: Content-Encoding
+            name: Content-Encoding
-          strategy: RETAIN_FIRST
+            strategy: RETAIN_FIRST
 
 jwt:
   secret: ${JWT_SECRET:enc:U2FsdGVkX1+vZ5Y9QmKxL8nN3rP7tW2jH4fG6dA8sB1cE5yN0zX3qV7wM4}
@@ -64,7 +64,7 @@ signature:
   max-age-minutes: ${SIGNATURE_MAX_AGE_MINUTES:5}
   nonce-cache-size: ${SIGNATURE_NONCE_CACHE_SIZE:10000}
   whitelist:
-    paths: ${SIGNATURE_WHITELIST_PATHS:/actuator/health,/actuator/info,/api/auth/login,/api/auth/register,/api/member/auth/miniapp/login,/api/member/auth/mp/callback}
+    paths: ${SIGNATURE_WHITELIST_PATHS:/actuator/health,/actuator/info,/api/auth/login}
 
 resilience:
   enabled: ${RESILIENCE_ENABLED:true}

gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/dto/request/UserUpdateRequest.java

@@ -1,6 +1,7 @@
 package cn.novalon.gym.manage.sys.dto.request;
 
 import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Email;
 
 /**
  * 用户更新请求DTO
@@ -23,6 +24,7 @@ public class UserUpdateRequest {
     @Schema(description = "是否清除角色关联", example = "false")
     private Boolean clearRole;
 
+    @Email(message = "邮箱格式不正确")
     public String getEmail() {
         return email;
     }

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

@@ -1,32 +0,0 @@
-package cn.novalon.gym.manage.sys.util;
-
-import cn.novalon.gym.manage.sys.security.JwtTokenProvider;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpStatus;
-import org.springframework.stereotype.Component;
-import org.springframework.web.reactive.function.server.ServerRequest;
-import org.springframework.web.server.ResponseStatusException;
-
-@Slf4j
-@Component
-@RequiredArgsConstructor
-public class AuthUtil {
-
-    private final JwtTokenProvider jwtTokenProvider;
-
-    public String extractToken(ServerRequest request) {
-        String authorization = request.headers().firstHeader(HttpHeaders.AUTHORIZATION);
-        if (authorization == null || !authorization.startsWith("Bearer ")) return null;
-        return authorization.substring(7);
-    }
-
-    public Long getMemberIdOrThrow(ServerRequest request) {
-        String token = extractToken(request);
-        if (token == null) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "缺少 Token");
-        if (!jwtTokenProvider.validateToken(token)) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "Token 无效或已过期");
-        if (jwtTokenProvider.getUserIdFromToken(token) <= 0L) throw new IllegalArgumentException("ID无效");
-        return jwtTokenProvider.getUserIdFromToken(token);
-    }
-}

gym-manage-api/pom.xml

@@ -36,15 +36,14 @@
     <modules>
         <module>manage-sys</module>
         <module>manage-gateway</module>
+        <module>gym-member-card</module>
         <module>manage-app</module>
         <module>manage-common</module>
         <module>manage-db</module>
         <module>manage-audit</module>
         <module>manage-notify</module>
         <module>manage-file</module>
-        <module>gym-member</module>
+    </modules>
-	    <module>gym-checkIn</module>
-	</modules>
 
     <dependencyManagement>
         <dependencies>

gym-manage-web/pnpm-lock.yaml

@@ -59,7 +59,7 @@ importers:
         version: 6.21.0(eslint@8.57.1)(typescript@5.9.3)
       '@vitejs/plugin-vue':
         specifier: ^6.0.3
-        version: 6.0.5(vite@7.3.1(@types/node@20.19.37)(terser@5.48.0))(vue@3.5.30(typescript@5.9.3))
+        version: 6.0.5(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))(vue@3.5.30(typescript@5.9.3))
       '@vitest/coverage-v8':
         specifier: ^4.1.1
         version: 4.1.2(vitest@4.1.0)
@@ -83,16 +83,16 @@ importers:
         version: 3.8.1
       terser:
         specifier: ^5.46.1
-        version: 5.48.0
+        version: 5.46.2
       typescript:
         specifier: ^5.9.3
         version: 5.9.3
       vite:
         specifier: ^7.3.1
-        version: 7.3.1(@types/node@20.19.37)(terser@5.48.0)
+        version: 7.3.1(@types/node@20.19.37)(terser@5.46.2)
       vitest:
         specifier: ^4.0.16
-        version: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.48.0))
+        version: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
       vue-tsc:
         specifier: ^3.2.2
         version: 3.2.5(typescript@5.9.3)
@@ -1707,8 +1707,8 @@ packages:
   symbol-tree@3.2.4:
     resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
 
-  terser@5.48.0:
+  terser@5.46.2:
-    resolution: {integrity: sha512-J/9An6vs9Us6wKRriSFXBWdRZapREHqFzdNUKk0pmu804EMR6dr6winwo7e5JDxN4xahxQsuysyYFwlwj4XN/Q==}
+    resolution: {integrity: sha512-uxfo9fPcSgLDYob/w1FuL0c99MWiJDnv+5qXSQc5+Ki5NjVNsYi66INnMFBjf6uFz6OnX12piJQPF4IpjJTNTw==}
     engines: {node: '>=10'}
     hasBin: true
 
@@ -2416,10 +2416,10 @@ snapshots:
 
   '@ungap/structured-clone@1.3.0': {}
 
-  '@vitejs/plugin-vue@6.0.5(vite@7.3.1(@types/node@20.19.37)(terser@5.48.0))(vue@3.5.30(typescript@5.9.3))':
+  '@vitejs/plugin-vue@6.0.5(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))(vue@3.5.30(typescript@5.9.3))':
     dependencies:
       '@rolldown/pluginutils': 1.0.0-rc.2
-      vite: 7.3.1(@types/node@20.19.37)(terser@5.48.0)
+      vite: 7.3.1(@types/node@20.19.37)(terser@5.46.2)
       vue: 3.5.30(typescript@5.9.3)
 
   '@vitest/coverage-v8@4.1.2(vitest@4.1.0)':
@@ -2434,7 +2434,7 @@ snapshots:
       obug: 2.1.1
       std-env: 4.0.0
       tinyrainbow: 3.1.0
-      vitest: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.48.0))
+      vitest: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
 
   '@vitest/expect@4.1.0':
     dependencies:
@@ -2445,13 +2445,13 @@ snapshots:
       chai: 6.2.2
       tinyrainbow: 3.1.0
 
-  '@vitest/mocker@4.1.0(vite@7.3.1(@types/node@20.19.37)(terser@5.48.0))':
+  '@vitest/mocker@4.1.0(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))':
     dependencies:
       '@vitest/spy': 4.1.0
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
-      vite: 7.3.1(@types/node@20.19.37)(terser@5.48.0)
+      vite: 7.3.1(@types/node@20.19.37)(terser@5.46.2)
 
   '@vitest/pretty-format@4.1.0':
     dependencies:
@@ -2484,7 +2484,7 @@ snapshots:
       sirv: 3.0.2
       tinyglobby: 0.2.15
       tinyrainbow: 3.1.0
-      vitest: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.48.0))
+      vitest: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
 
   '@vitest/utils@4.1.0':
     dependencies:
@@ -3555,7 +3555,7 @@ snapshots:
 
   symbol-tree@3.2.4: {}
 
-  terser@5.48.0:
+  terser@5.46.2:
     dependencies:
       '@jridgewell/source-map': 0.3.11
       acorn: 8.16.0
@@ -3615,7 +3615,7 @@ snapshots:
 
   util-deprecate@1.0.2: {}
 
-  vite@7.3.1(@types/node@20.19.37)(terser@5.48.0):
+  vite@7.3.1(@types/node@20.19.37)(terser@5.46.2):
     dependencies:
       esbuild: 0.27.4
       fdir: 6.5.0(picomatch@4.0.3)
@@ -3626,12 +3626,12 @@ snapshots:
     optionalDependencies:
       '@types/node': 20.19.37
       fsevents: 2.3.3
-      terser: 5.48.0
+      terser: 5.46.2
 
-  vitest@4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.48.0)):
+  vitest@4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2)):
     dependencies:
       '@vitest/expect': 4.1.0
-      '@vitest/mocker': 4.1.0(vite@7.3.1(@types/node@20.19.37)(terser@5.48.0))
+      '@vitest/mocker': 4.1.0(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
       '@vitest/pretty-format': 4.1.0
       '@vitest/runner': 4.1.0
       '@vitest/snapshot': 4.1.0
@@ -3648,7 +3648,7 @@ snapshots:
       tinyexec: 1.0.2
       tinyglobby: 0.2.15
       tinyrainbow: 3.1.0
-      vite: 7.3.1(@types/node@20.19.37)(terser@5.48.0)
+      vite: 7.3.1(@types/node@20.19.37)(terser@5.46.2)
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 20.19.37