7 Commits

Author SHA1 Message Date
future ddb77db605 更新会员模块和系统安全配置 2026-05-27 03:21:38 +08:00
future e673d96f6f 删除 gym-member 模块中的无用脚本和配置文件 2026-05-27 02:13:50 +08:00
future 85ed6f9196 实现会员信息管理模块 2026-05-26 23:50:50 +08:00
liwentao 3d284c8d3a 将查询用户个人信息与更新用户信息迁移至gym-member模块 2026-05-10 20:40:25 +08:00
future 538c1e0ad5 修改bug 2026-05-10 20:14:13 +08:00
future 923d147574 添加会员注册功能路由以及相关配置 2026-05-10 18:34:11 +08:00
future 6ea23b5a01 完成会员注册功能 2026-05-10 17:10:28 +08:00
98 changed files with 3646 additions and 4627 deletions
-112
View File
@@ -1,112 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.5.13</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-member-card</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>gym-member-card</name>
<description>gym-member-card</description>
<properties>
<java.version>21</java.version>
</properties>
<dependencies>
<!-- WebFlux 启动器(响应式) -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<!-- PostgreSQL 驱动(JDBC,如果工具类需要) -->
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
</dependency>
<!-- 你的内部模块 -->
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-db</artifactId>
<version>1.0.0</version>
<scope>compile</scope>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.36</version>
<scope>provided</scope>
</dependency>
<!-- Hutool 工具箱 -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.22</version>
</dependency>
<!-- Spring 上下文(其实 WebFlux 已经包含,保留也可以) -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<!-- Redis响应式支持 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>
<!-- &lt;!&ndash; ⭐ Redisson 响应式客户端 &ndash;&gt;-->
<!-- <dependency>-->
<!-- <groupId>org.redisson</groupId>-->
<!-- <artifactId>redisson-spring-boot-starter</artifactId>-->
<!-- <version>3.27.0</version>-->
<!-- </dependency>-->
<!-- &lt;!&ndash; ⭐ RabbitMQ 支持 &ndash;&gt;-->
<!-- <dependency>-->
<!-- <groupId>org.springframework.boot</groupId>-->
<!-- <artifactId>spring-boot-starter-amqp</artifactId>-->
<!-- </dependency>-->
<!-- Jackson for JSON处理 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
</dependency>
<!-- ⭐ 必须添加:测试依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<!-- 保留标准 JAR,供其他模块引用 -->
<classifier>exec</classifier>
</configuration>
</plugin>
</plugins>
</build>
</project>
@@ -1,17 +0,0 @@
package cn.novalon.gym.manage.gymmembercard;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
import org.springframework.scheduling.annotation.EnableScheduling;
@SpringBootApplication
@EnableR2dbcRepositories(basePackages = "cn.novalon.gym.manage.gymmembercard.dao")
@EnableScheduling
public class GymMemberCardApplication {
public static void main(String[] args) {
SpringApplication.run(GymMemberCardApplication.class, args);
}
}
@@ -1,130 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.dao;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardEntity;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.repository.Modifying;
import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@Repository
public interface MemberCardDao extends R2dbcRepository<MemberCardEntity, Long> {
/**
* 根据会员卡ID查询会员卡详情(用于编辑前回显或小程序端展示)
* @param memberCardId 会员卡ID
* @return 会员卡完整信息,如果不存在或已删除则返回空
*/
Mono<MemberCardEntity> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
/**
* 条件查询会员卡列表(后台卡种列表展示,支持多条件组合+分页+排序)
* 注意:模糊查询使用前后缀通配符,若数据量较大可能影响索引效率,建议后期引入全文索引或改用后缀模糊
* @param status 会员卡状态(上架/下架)
* @param name 会员卡名称(模糊查询)
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
@Query("SELECT * FROM member_card WHERE deleted_at IS NULL " +
"AND (:status IS NULL OR member_card_status = :status) " +
"AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
"AND (:type IS NULL OR member_card_type = :type) " +
"AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
"AND (:maxPrice IS NULL OR member_card_price <= :maxPrice) " +
"ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
Flux<MemberCardEntity> findWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice, Pageable pageable);
/**
* 统计符合条件的会员卡总数(配合列表查询使用)
* @param status 会员卡状态
* @param name 会员卡名称(模糊查询)
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @return 符合条件的会员卡数量
*/
@Query("SELECT COUNT(*) FROM member_card WHERE deleted_at IS NULL " +
"AND (:status IS NULL OR member_card_status = :status) " +
"AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
"AND (:type IS NULL OR member_card_type = :type) " +
"AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
"AND (:maxPrice IS NULL OR member_card_price <= :maxPrice)")
Mono<Long> countWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice);
/**
* 按状态查询会员卡列表(用于小程序端展示可购买卡列表,只展示上架的卡)
* @param status 会员卡状态(通常传上架状态)
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
Flux<MemberCardEntity> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
/**
* 检查会员卡是否已被购买(用于删除前的校验)
* 注意:此查询关联到 member_card_record 表,建议后续独立至 MemberCardRecordDao
* @param memberCardId 会员卡ID
* @return 如果存在关联的会员记录则返回true,否则返回false
*/
@Query("SELECT EXISTS(SELECT 1 FROM member_card_record WHERE member_card_id = :memberCardId AND deleted_at IS NULL LIMIT 1)")
Mono<Boolean> existsPurchasedRecord(Long memberCardId);
/**
* 逻辑删除会员卡(下架卡种,防止已购会员数据异常)
* @param memberCardId 会员卡ID
* @return 受影响的行数
*/
@Modifying
@Query("UPDATE member_card SET deleted_at = NOW() WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
Mono<Integer> logicalDelete(Long memberCardId);
/**
* 【新增】安全更新会员卡信息(仅允许修改业务相关字段,防止覆盖敏感字段)
* @param memberCardId 会员卡ID
* @param name 卡种名称
* @param price 价格
* @param durationDays 有效天数
* @param totalCount 总次数
* @param denomination 面额
* @param status 状态
* @return 受影响的行数
*/
@Modifying
@Query("UPDATE member_card SET " +
"member_card_name = COALESCE(:name, member_card_name), " +
"member_card_price = COALESCE(:price, member_card_price), " +
"duration_days = COALESCE(:durationDays, duration_days), " +
"total_count = COALESCE(:totalCount, total_count), " +
"denomination = COALESCE(:denomination, denomination), " +
"member_card_status = COALESCE(:status, member_card_status), " +
"updated_at = NOW() " +
"WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
Mono<Integer> updateSafe(Long memberCardId, String name, Double price,
Integer durationDays, Integer totalCount,
Double denomination, Integer status);
/**
* 保存卡种信息(新增或更新)
* - 新增:entity.memberCardId 为 null 时,插入新记录
* - 更新:entity.memberCardId 不为 null 时,根据ID更新现有记录
* 注意:直接 save 会更新所有字段,如需安全更新请调用 updateSafe 方法
* @param entity 卡种信息
* @return 保存后的实体对象
*/
@Override
<S extends MemberCardEntity> Mono<S> save(S entity);
/**
* 批量查询上架的会员卡(用于小程序端展示)
* @param status 上架状态值
* @return 上架的会员卡列表
*/
@Query("SELECT * FROM member_card WHERE deleted_at IS NULL AND member_card_status = :status ORDER BY member_card_price ASC")
Flux<MemberCardEntity> findActiveCards(Integer status);
}
@@ -1,87 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.dao;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardRecordEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.repository.Modifying;
import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Repository
public interface MemberCardRecordDao extends R2dbcRepository<MemberCardRecordEntity, Long> {
@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);
@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);
@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);
@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);
@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);
@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);
@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);
@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);
@Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND expire_time < NOW() AND deleted_at IS NULL LIMIT 500")
Flux<MemberCardRecordEntity> findExpiredCards();
@Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND deleted_at IS NULL")
Flux<MemberCardRecordEntity> findActiveRecords();
}
@@ -1,173 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.dao;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardTransactionsEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.repository.Modifying;
import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Repository
public interface MemberCardTransactionsDao extends R2dbcRepository<MemberCardTransactionsEntity, Long> {
/**
* 记录每一次变动
* 购卡、扣次、续费、退款、过期,均插入一条流水,记录变动前后快照
* 注意:返回值依赖 PostgreSQL 的 RETURNING 语法,若使用 MySQL 请删除 RETURNING * 并改用 save()
* @param memberCardId 会员卡ID
* @param memberId 会员ID
* @param operationType 操作类型
* @param changeAmount 变动次数(次卡)
* @param changeBalance 变动金额(储值卡)
* @param afterRemainingCount 变动后剩余次数
* @param afterRemainingBalance 变动后剩余余额
* @param relatedBizType 关联业务类型
* @param remark 备注
* @return 插入的流水记录
*/
@Modifying
@Query("INSERT INTO member_card_transactions (member_card_id, member_id, operation_type, change_amount, " +
"change_balance, after_remaining_count, after_remaining_balance, related_biz_type, remark, created_at, updated_at) " +
"VALUES (:memberCardId, :memberId, :operationType, :changeAmount, :changeBalance, " +
":afterRemainingCount, :afterRemainingBalance, :relatedBizType, :remark, NOW(), NOW()) " +
"RETURNING *")
Mono<MemberCardTransactionsEntity> insertTransaction(@Param("memberCardId") Long memberCardId,
@Param("memberId") Long memberId,
@Param("operationType") MemberCardTransactionsAction operationType,
@Param("changeAmount") Integer changeAmount,
@Param("changeBalance") Double changeBalance,
@Param("afterRemainingCount") Integer afterRemainingCount,
@Param("afterRemainingBalance") Double afterRemainingBalance,
@Param("relatedBizType") MemberCardTransactionsType relatedBizType,
@Param("remark") String remark);
/**
* 会员端"使用记录"
* 按会员ID和时间范围查询,按时间倒序,显示每次变动明细
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
@Query("SELECT * FROM member_card_transactions WHERE member_id = :memberId " +
"AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL " +
"ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
Flux<MemberCardTransactionsEntity> findByMemberIdAndTimeRange(@Param("memberId") Long memberId,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime,
Pageable pageable);
/**
* 后台"使用记录查询"
* 按会员、卡号、操作类型、时间范围等条件组合查询
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
@Query("SELECT * FROM member_card_transactions WHERE deleted_at IS NULL " +
"AND (:memberId IS NULL OR member_id = :memberId) " +
"AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
"AND (:operationType IS NULL OR operation_type = :operationType) " +
"AND (:startTime IS NULL OR created_at >= :startTime) " +
"AND (:endTime IS NULL OR created_at <= :endTime) " +
"ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
Flux<MemberCardTransactionsEntity> findWithConditions(@Param("memberId") Long memberId,
@Param("memberCardId") Long memberCardId,
@Param("operationType") MemberCardTransactionsAction operationType,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime,
Pageable pageable);
/**
* 统计符合条件的流水总数
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @return 流水记录数量
*/
@Query("SELECT COUNT(*) FROM member_card_transactions WHERE deleted_at IS NULL " +
"AND (:memberId IS NULL OR member_id = :memberId) " +
"AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
"AND (:operationType IS NULL OR operation_type = :operationType) " +
"AND (:startTime IS NULL OR created_at >= :startTime) " +
"AND (:endTime IS NULL OR created_at <= :endTime)")
Mono<Long> countWithConditions(@Param("memberId") Long memberId,
@Param("memberCardId") Long memberCardId,
@Param("operationType") MemberCardTransactionsAction operationType,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
/**
* 按会员卡ID查询所有流水记录(补充常用方法)
* @param memberCardId 会员卡ID
* @return 该卡的所有流水记录,按时间倒序
*/
@Query("SELECT * FROM member_card_transactions WHERE member_card_id = :memberCardId AND deleted_at IS NULL ORDER BY created_at DESC")
Flux<MemberCardTransactionsEntity> findByMemberCardId(@Param("memberCardId") Long memberCardId);
/**
* 数据统计 - 统计某卡种的总扣次数
* @param memberCardId 会员卡ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 总扣次数
*/
@Query("SELECT COALESCE(SUM(change_amount), 0) FROM member_card_transactions " +
"WHERE member_card_id = :memberCardId AND operation_type = 'DEDUCT' " +
"AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
Mono<Long> sumDeductCountByCardId(@Param("memberCardId") Long memberCardId,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
/**
* 数据统计 - 统计某时间段的续费总金额
* @param startTime 开始时间
* @param endTime 结束时间
* @return 续费总金额
*/
@Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
"WHERE operation_type = 'RENEW' AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
Mono<Double> sumRenewAmountByTimeRange(@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
/**
* 数据统计 - 统计某会员的购卡总金额
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 购卡总金额
*/
@Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
"WHERE member_id = :memberId AND operation_type = 'PURCHASE' " +
"AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
Mono<Double> sumPurchaseAmountByMemberId(@Param("memberId") Long memberId, @Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
/**
* 按会员ID查询所有流水记录
* @param memberId 会员ID
* @return 该会员的所有流水记录,按时间倒序
*/
@Query("SELECT * FROM member_card_transactions WHERE member_id = :memberId ORDER BY created_at DESC")
Flux<MemberCardTransactionsEntity> findByMemberId(Long memberId);
/**
* 按会员卡记录ID查询所有流水记录
* @param recordId 会员卡记录ID
* @return 该会员卡的所有流水记录,按时间倒序
*/
@Query("SELECT * FROM member_card_transactions WHERE member_card_record_id = :recordId ORDER BY created_at DESC")
Flux<MemberCardTransactionsEntity> findByRecordId(Long recordId);
}
@@ -1,64 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.dao;
import cn.novalon.gym.manage.gymmembercard.entity.RefundApplicationEntity;
import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/**
* 退款申请数据访问对象
*
* @author shizhounian
* @date 2026-05-23
*/
public interface RefundApplicationDao extends R2dbcRepository<RefundApplicationEntity, Long> {
/**
* 根据会员卡记录ID查询退款申请
*
* @param recordId 会员卡记录ID
* @return 退款申请实体
*/
@Query("SELECT * FROM refund_application WHERE record_id = :recordId AND deleted_at IS NULL LIMIT 1")
Mono<RefundApplicationEntity> findByRecordId(Long recordId);
/**
* 根据会员ID查询退款申请列表
*
* @param memberId 会员ID
* @return 退款申请列表
*/
@Query("SELECT * FROM refund_application WHERE member_id = :memberId AND deleted_at IS NULL ORDER BY created_at DESC")
Flux<RefundApplicationEntity> findByMemberId(Long memberId);
/**
* 根据状态查询退款申请列表
*
* @param status 状态
* @return 退款申请列表
*/
@Query("SELECT * FROM refund_application WHERE status = :status AND deleted_at IS NULL ORDER BY created_at DESC")
Flux<RefundApplicationEntity> findByStatus(String status);
/**
* 审核退款申请(更新状态、审核人、审核时间、备注)
*
* @param id 退款申请ID
* @param status 审核状态
* @param auditorId 审核人ID
* @param auditRemark 审核备注
* @return 受影响的行数
*/
@Query("UPDATE refund_application SET status = :status, auditor_id = :auditorId, audit_time = NOW(), audit_remark = :auditRemark, updated_at = NOW() WHERE id = :id")
Mono<Integer> approve(Long id, String status, Long auditorId, String auditRemark);
/**
* 逻辑删除退款申请
*
* @param id 退款申请ID
* @return 受影响的行数
*/
@Query("UPDATE refund_application SET deleted_at = NOW() WHERE id = :id")
Mono<Integer> logicalDelete(Long id);
}
@@ -1,121 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.domain;
import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 22:47:31
*/
@Schema(description = "会员卡类型表")
public class MemberCard extends BaseDomain {
//会员卡id
@Schema(description = "会员卡Id",example = "1")
private Long memberCardId;
//会员卡名称
@Schema(description = "会员卡名称",example = "月卡")
private String memberCardName;
//会员卡类型
@Schema(description = "会员卡类型",example = "TIME_CARD")
private String memberCardType;
//会员卡价格
@Schema(description = "会员卡价格",example = "199.0")
private Double memberCardPrice;
//会员卡有效天数(时长卡用)
@Schema(description = "会员卡有效天数",example = "30")
private Integer memberCardValidityDays;
//会员卡总次数(次卡用)
@Schema(description = "会员卡总次数",example = "10")
private Integer memberCardTotalTimes;
//会员卡面额(储值卡用)
@Schema(description = "会员卡面额",example = "500.0")
private Double memberCardAmount;
//会员卡状态:0-正常,1-禁用
@Schema(description = "会员卡状态",example = "0")
private Integer memberCardStatus;
//会员卡创建时间
@Schema(description = "会员卡创建时间",example = "2026-05-10 05:22:47")
private LocalDateTime memberCardCreateTime;
public Long getMemberCardId() {
return memberCardId;
}
public void setMemberCardId(Long memberCardId) {
this.memberCardId = memberCardId;
}
public String getMemberCardName() {
return memberCardName;
}
public void setMemberCardName(String memberCardName) {
this.memberCardName = memberCardName;
}
public String getMemberCardType() {
return memberCardType;
}
public void setMemberCardType(String memberCardType) {
this.memberCardType = memberCardType;
}
public Double getMemberCardPrice() {
return memberCardPrice;
}
public void setMemberCardPrice(Double memberCardPrice) {
this.memberCardPrice = memberCardPrice;
}
public Integer getMemberCardValidityDays() {
return memberCardValidityDays;
}
public void setMemberCardValidityDays(Integer memberCardValidityDays) {
this.memberCardValidityDays = memberCardValidityDays;
}
public Integer getMemberCardTotalTimes() {
return memberCardTotalTimes;
}
public void setMemberCardTotalTimes(Integer memberCardTotalTimes) {
this.memberCardTotalTimes = memberCardTotalTimes;
}
public Double getMemberCardAmount() {
return memberCardAmount;
}
public void setMemberCardAmount(Double memberCardAmount) {
this.memberCardAmount = memberCardAmount;
}
public Integer getMemberCardStatus() {
return memberCardStatus;
}
public void setMemberCardStatus(Integer memberCardStatus) {
this.memberCardStatus = memberCardStatus;
}
public LocalDateTime getMemberCardCreateTime() {
return memberCardCreateTime;
}
public void setMemberCardCreateTime(LocalDateTime memberCardCreateTime) {
this.memberCardCreateTime = memberCardCreateTime;
}
}
@@ -1,109 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.domain;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
@Schema(description = "会员卡记录")
public class MemberCardRecord extends BaseDomain {
@Schema(description = "会员持有卡ID", example = "1")
private Long memberCardRecordId;
@Schema(description = "会员ID", example = "1001")
private Long memberId;
@Schema(description = "关联会员卡ID", example = "1")
private Long memberCardId;
@Schema(description = "状态:ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款", example = "ACTIVE")
private MemberCardRecordStatus status;
@Schema(description = "剩余次数", example = "10")
private Integer remainingTimes;
@Schema(description = "剩余余额", example = "500.0")
private Double remainingAmount;
@Schema(description = "到期时间", example = "2026-06-23 10:00:00")
private LocalDateTime expireTime;
@Schema(description = "购买订单ID", example = "10001")
private Long sourceOrderId;
@Schema(description = "购买时间", example = "2026-05-23 10:00:00")
private LocalDateTime purchaseTime;
public Long getMemberCardRecordId() {
return memberCardRecordId;
}
public void setMemberCardRecordId(Long memberCardRecordId) {
this.memberCardRecordId = memberCardRecordId;
}
public Long getMemberId() {
return memberId;
}
public void setMemberId(Long memberId) {
this.memberId = memberId;
}
public Long getMemberCardId() {
return memberCardId;
}
public void setMemberCardId(Long memberCardId) {
this.memberCardId = memberCardId;
}
public MemberCardRecordStatus getStatus() {
return status;
}
public void setStatus(MemberCardRecordStatus status) {
this.status = status;
}
public Integer getRemainingTimes() {
return remainingTimes;
}
public void setRemainingTimes(Integer remainingTimes) {
this.remainingTimes = remainingTimes;
}
public Double getRemainingAmount() {
return remainingAmount;
}
public void setRemainingAmount(Double remainingAmount) {
this.remainingAmount = remainingAmount;
}
public LocalDateTime getExpireTime() {
return expireTime;
}
public void setExpireTime(LocalDateTime expireTime) {
this.expireTime = expireTime;
}
public Long getSourceOrderId() {
return sourceOrderId;
}
public void setSourceOrderId(Long sourceOrderId) {
this.sourceOrderId = sourceOrderId;
}
public LocalDateTime getPurchaseTime() {
return purchaseTime;
}
public void setPurchaseTime(LocalDateTime purchaseTime) {
this.purchaseTime = purchaseTime;
}
}
@@ -1,159 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.domain;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 22:47:31
*/
@Schema(description = "会员卡流水")
public class MemberCardTransactions extends BaseDomain {
//会员卡流水Id
@Schema(description = "会员卡流水Id",example = "1")
private Long memberCardTransactionsId;
//会员卡Id
@Schema(description = "会员卡Id",example = "1")
private Long memberCardId;
//会员Id
@Schema(description = "会员Id",example = "1")
private Long memberId;
//操作类型:PURCHASE(购买) / DEDUCT(扣次/扣费) / RENEW(续费) / REFUND(退款) / EXPIRE(过期)
@Schema(description = "操作类型",example = "PURCHASE")
private MemberCardTransactionsAction operationType;
//变动次数(次卡用)
@Schema(description = "变动次数(次卡用)",example = "1")
private Integer changeAmount;
//变动金额(储值卡用)
@Schema(description = "变动金额(储值卡用)",example = "1")
private Double changeBalance;
//变动后剩余次数
@Schema(description = "变动后剩余次数",example = "1")
private Integer afterRemainingCount;
//变动后剩余金额
@Schema(description = "变动后剩余金额",example = "500.0")
private Double afterRemainingBalance;
//关联业务类型
@Schema(description = "关联业务类型",example = "GROUP_CLASS")
private MemberCardTransactionsType relatedBizType;
//备注
@Schema(description = "备注",example = "预约团课:瑜伽课扣1次")
private String remark;
//关联订单ID
@Schema(description = "关联订单ID",example = "1")
private Long sourceOrderId;
//创建时间
@Schema(description = "创建时间",example = "2026-05-10 05:22:47")
private LocalDateTime createdAt;
public Long getMemberCardTransactionsId() {
return memberCardTransactionsId;
}
public void setMemberCardTransactionsId(Long memberCardTransactionsId) {
this.memberCardTransactionsId = memberCardTransactionsId;
}
public Long getMemberCardId() {
return memberCardId;
}
public void setMemberCardId(Long memberCardId) {
this.memberCardId = memberCardId;
}
public Long getMemberId() {
return memberId;
}
public void setMemberId(Long memberId) {
this.memberId = memberId;
}
public MemberCardTransactionsAction getOperationType() {
return operationType;
}
public void setOperationType(MemberCardTransactionsAction operationType) {
this.operationType = operationType;
}
public Integer getChangeAmount() {
return changeAmount;
}
public void setChangeAmount(Integer changeAmount) {
this.changeAmount = changeAmount;
}
public Double getChangeBalance() {
return changeBalance;
}
public void setChangeBalance(Double changeBalance) {
this.changeBalance = changeBalance;
}
public Integer getAfterRemainingCount() {
return afterRemainingCount;
}
public void setAfterRemainingCount(Integer afterRemainingCount) {
this.afterRemainingCount = afterRemainingCount;
}
public Double getAfterRemainingBalance() {
return afterRemainingBalance;
}
public void setAfterRemainingBalance(Double afterRemainingBalance) {
this.afterRemainingBalance = afterRemainingBalance;
}
public MemberCardTransactionsType getRelatedBizType() {
return relatedBizType;
}
public void setRelatedBizType(MemberCardTransactionsType relatedBizType) {
this.relatedBizType = relatedBizType;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public Long getSourceOrderId() {
return sourceOrderId;
}
public void setSourceOrderId(Long sourceOrderId) {
this.sourceOrderId = sourceOrderId;
}
public LocalDateTime getCreatedAt() {
return createdAt;
}
public void setCreatedAt(LocalDateTime createdAt) {
this.createdAt = createdAt;
}
}
@@ -1,127 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.domain;
import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
import io.swagger.v3.oas.annotations.media.Schema;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* 退款申请领域对象
*
* @author shizhounian
* @date 2026-05-23 21:11:46
*/
@Schema(description = "退款申请", example = "refund_application")
public class RefundApplication extends BaseDomain {
@Schema(description = "退款申请ID", example = "1")
private Long id;
@Schema(description = "会员卡记录ID", example = "1")
private Long recordId;
@Schema(description = "会员ID", example = "1")
private Long memberId;
@Schema(description = "状态:PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败", example = "PENDING")
private String status;
@Schema(description = "退款原因", example = "个人原因申请退款")
private String reason;
@Schema(description = "申请时间", example = "2026-05-23 21:09:14")
private LocalDateTime applyTime;
@Schema(description = "审核时间", example = "2026-05-24 10:00:00")
private LocalDateTime auditTime;
@Schema(description = "审核人ID", example = "1")
private Long auditorId;
@Schema(description = "审核备注", example = "同意退款")
private String auditRemark;
@Schema(description = "退款金额", example = "500.00")
private BigDecimal refundAmount;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getRecordId() {
return recordId;
}
public void setRecordId(Long recordId) {
this.recordId = recordId;
}
public Long getMemberId() {
return memberId;
}
public void setMemberId(Long memberId) {
this.memberId = memberId;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getReason() {
return reason;
}
public void setReason(String reason) {
this.reason = reason;
}
public LocalDateTime getApplyTime() {
return applyTime;
}
public void setApplyTime(LocalDateTime applyTime) {
this.applyTime = applyTime;
}
public LocalDateTime getAuditTime() {
return auditTime;
}
public void setAuditTime(LocalDateTime auditTime) {
this.auditTime = auditTime;
}
public Long getAuditorId() {
return auditorId;
}
public void setAuditorId(Long auditorId) {
this.auditorId = auditorId;
}
public String getAuditRemark() {
return auditRemark;
}
public void setAuditRemark(String auditRemark) {
this.auditRemark = auditRemark;
}
public BigDecimal getRefundAmount() {
return refundAmount;
}
public void setRefundAmount(BigDecimal refundAmount) {
this.refundAmount = refundAmount;
}
}
@@ -1,123 +0,0 @@
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
*/
@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;
public Long getMemberCardId() {
return memberCardId;
}
public void setMemberCardId(Long memberCardId) {
this.memberCardId = memberCardId;
}
public String getMemberCardName() {
return memberCardName;
}
public void setMemberCardName(String memberCardName) {
this.memberCardName = memberCardName;
}
public String getMemberCardType() {
return memberCardType;
}
public void setMemberCardType(String memberCardType) {
this.memberCardType = memberCardType;
}
public Double getMemberCardPrice() {
return memberCardPrice;
}
public void setMemberCardPrice(Double memberCardPrice) {
this.memberCardPrice = memberCardPrice;
}
public Integer getMemberCardValidityDays() {
return memberCardValidityDays;
}
public void setMemberCardValidityDays(Integer memberCardValidityDays) {
this.memberCardValidityDays = memberCardValidityDays;
}
public Integer getMemberCardTotalTimes() {
return memberCardTotalTimes;
}
public void setMemberCardTotalTimes(Integer memberCardTotalTimes) {
this.memberCardTotalTimes = memberCardTotalTimes;
}
public Double getMemberCardAmount() {
return memberCardAmount;
}
public void setMemberCardAmount(Double memberCardAmount) {
this.memberCardAmount = memberCardAmount;
}
public Integer getMemberCardStatus() {
return memberCardStatus;
}
public void setMemberCardStatus(Integer memberCardStatus) {
this.memberCardStatus = memberCardStatus;
}
public LocalDateTime getMemberCardCreateTime() {
return memberCardCreateTime;
}
public void setMemberCardCreateTime(LocalDateTime memberCardCreateTime) {
this.memberCardCreateTime = memberCardCreateTime;
}
}
@@ -1,124 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.entity;
import cn.novalon.gym.manage.db.entity.BaseEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import lombok.Data;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;
import java.time.LocalDateTime;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 22:47:31
*/
@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;
public Long getMemberCardRecordId() {
return memberCardRecordId;
}
public void setMemberCardRecordId(Long memberCardRecordId) {
this.memberCardRecordId = memberCardRecordId;
}
public Long getMemberId() {
return memberId;
}
public void setMemberId(Long memberId) {
this.memberId = memberId;
}
public Long getMemberCardId() {
return memberCardId;
}
public void setMemberCardId(Long memberCardId) {
this.memberCardId = memberCardId;
}
public MemberCardRecordStatus getStatus() {
return status;
}
public void setStatus(MemberCardRecordStatus status) {
this.status = status;
}
public Integer getRemainingTimes() {
return remainingTimes;
}
public void setRemainingTimes(Integer remainingTimes) {
this.remainingTimes = remainingTimes;
}
public Double getRemainingAmount() {
return remainingAmount;
}
public void setRemainingAmount(Double remainingAmount) {
this.remainingAmount = remainingAmount;
}
public LocalDateTime getExpireTime() {
return expireTime;
}
public void setExpireTime(LocalDateTime expireTime) {
this.expireTime = expireTime;
}
public Long getSourceOrderId() {
return sourceOrderId;
}
public void setSourceOrderId(Long sourceOrderId) {
this.sourceOrderId = sourceOrderId;
}
public LocalDateTime getPurchaseTime() {
return purchaseTime;
}
public void setPurchaseTime(LocalDateTime purchaseTime) {
this.purchaseTime = purchaseTime;
}
}
@@ -1,160 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.entity;
import cn.novalon.gym.manage.db.entity.BaseEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
import 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
*/
@Table("member_card_transactions")
public class MemberCardTransactionsEntity extends BaseEntity{
@Column("id")
private Long id;
@Column("member_card_record_id")
private Long memberCardRecordId;
@Column("member_id")
private Long memberId;
@Column("member_card_id")
private Long memberCardId;
@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("source_order_id")
private Long sourceOrderId;
@Column("remark")
private String remark;
@Column("created_at")
private LocalDateTime createdAt;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getMemberCardRecordId() {
return memberCardRecordId;
}
public void setMemberCardRecordId(Long memberCardRecordId) {
this.memberCardRecordId = memberCardRecordId;
}
public Long getMemberId() {
return memberId;
}
public void setMemberId(Long memberId) {
this.memberId = memberId;
}
public Long getMemberCardId() {
return memberCardId;
}
public void setMemberCardId(Long memberCardId) {
this.memberCardId = memberCardId;
}
public MemberCardTransactionsAction getOperationType() {
return operationType;
}
public void setOperationType(MemberCardTransactionsAction operationType) {
this.operationType = operationType;
}
public Integer getChangeAmount() {
return changeAmount;
}
public void setChangeAmount(Integer changeAmount) {
this.changeAmount = changeAmount;
}
public Double getChangeBalance() {
return changeBalance;
}
public void setChangeBalance(Double changeBalance) {
this.changeBalance = changeBalance;
}
public Integer getAfterRemainingCount() {
return afterRemainingCount;
}
public void setAfterRemainingCount(Integer afterRemainingCount) {
this.afterRemainingCount = afterRemainingCount;
}
public Double getAfterRemainingBalance() {
return afterRemainingBalance;
}
public void setAfterRemainingBalance(Double afterRemainingBalance) {
this.afterRemainingBalance = afterRemainingBalance;
}
public MemberCardTransactionsType getRelatedBizType() {
return relatedBizType;
}
public void setRelatedBizType(MemberCardTransactionsType relatedBizType) {
this.relatedBizType = relatedBizType;
}
public Long getSourceOrderId() {
return sourceOrderId;
}
public void setSourceOrderId(Long sourceOrderId) {
this.sourceOrderId = sourceOrderId;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public LocalDateTime getCreatedAt() {
return createdAt;
}
public void setCreatedAt(LocalDateTime createdAt) {
this.createdAt = createdAt;
}
}
@@ -1,127 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.entity;
import cn.novalon.gym.manage.db.entity.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* 退款申请实体类
*
* @author shizhounian
* @date 2026-05-23 21:09:14
*/
@Schema(description = "退款申请实体", example = "refund_application")
public class RefundApplicationEntity extends BaseEntity {
@Schema(description = "退款申请ID", example = "1")
private Long id;
@Schema(description = "会员卡记录ID", example = "1")
private Long recordId;
@Schema(description = "会员ID", example = "1")
private Long memberId;
@Schema(description = "状态:PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败", example = "PENDING")
private String status;
@Schema(description = "退款原因", example = "个人原因申请退款")
private String reason;
@Schema(description = "申请时间", example = "2026-05-23 21:09:14")
private LocalDateTime applyTime;
@Schema(description = "审核时间", example = "2026-05-24 10:00:00")
private LocalDateTime auditTime;
@Schema(description = "审核人ID", example = "1")
private Long auditorId;
@Schema(description = "审核备注", example = "同意退款")
private String auditRemark;
@Schema(description = "退款金额", example = "500.00")
private BigDecimal refundAmount;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getRecordId() {
return recordId;
}
public void setRecordId(Long recordId) {
this.recordId = recordId;
}
public Long getMemberId() {
return memberId;
}
public void setMemberId(Long memberId) {
this.memberId = memberId;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getReason() {
return reason;
}
public void setReason(String reason) {
this.reason = reason;
}
public LocalDateTime getApplyTime() {
return applyTime;
}
public void setApplyTime(LocalDateTime applyTime) {
this.applyTime = applyTime;
}
public LocalDateTime getAuditTime() {
return auditTime;
}
public void setAuditTime(LocalDateTime auditTime) {
this.auditTime = auditTime;
}
public Long getAuditorId() {
return auditorId;
}
public void setAuditorId(Long auditorId) {
this.auditorId = auditorId;
}
public String getAuditRemark() {
return auditRemark;
}
public void setAuditRemark(String auditRemark) {
this.auditRemark = auditRemark;
}
public BigDecimal getRefundAmount() {
return refundAmount;
}
public void setRefundAmount(BigDecimal refundAmount) {
this.refundAmount = refundAmount;
}
}
@@ -1,34 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.enums;
import io.swagger.v3.oas.annotations.media.Schema;
@Schema(description = "会员卡状态机事件")
public enum MemberCardEvent {
@Schema(description = "激活卡片")
ACTIVATE("激活卡片"),
@Schema(description = "使用卡片")
USE("使用卡片"),
@Schema(description = "续费")
RENEW("续费"),
@Schema(description = "过期")
EXPIRE("过期"),
@Schema(description = "退款")
REFUND("退款"),
@Schema(description = "禁用")
DISABLE("禁用");
private final String desc;
MemberCardEvent(String desc) {
this.desc = desc;
}
public String getDesc() {
return desc;
}
}
@@ -1,36 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.enums;
import io.swagger.v3.oas.annotations.media.Schema;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 23:59:29
*/
@Schema(description = "会员卡状态枚举")
public enum MemberCardRecordStatus {
//有效
@Schema(description = "有效")
ACTIVE("有效"),
//用完
@Schema(description = "用完")
USED_UP("用完"),
//过期
@Schema(description = "过期")
EXPIRED("过期"),
//已退款
@Schema(description = "已退款")
REFUNDED("已退款");
private final String desc;
MemberCardRecordStatus(String desc) {
this.desc = desc;
}
public String getDesc() {
return desc;
}
}
@@ -1,40 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.enums;
import io.swagger.v3.oas.annotations.media.Schema;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 23:59:29
*/
@Schema(description = "会员卡流水操作枚举")
public enum MemberCardTransactionsAction {
//购买
@Schema(description = "购买")
PURCHASE("购买"),
//扣次/扣费
@Schema(description = "扣次/扣费")
DEDUCT("扣次/扣费"),
//续费
@Schema(description = "续费")
RENEW("续费"),
//退款
@Schema(description = "退款")
REFUND("退款"),
//过期
@Schema(description = "过期")
EXPIRE("过期");
private final String desc;
MemberCardTransactionsAction(String desc) {
this.desc = desc;
}
public String getDesc() {
return desc;
}
}
@@ -1,32 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.enums;
import io.swagger.v3.oas.annotations.media.Schema;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 23:59:29
*/
@Schema(description = "会员卡流水关联业务类型枚举")
public enum MemberCardTransactionsType {
//团课
@Schema(description = "团课")
GROUP_CLASS("团课"),
//私教
@Schema(description = "私教")
PT_CLASS("私教"),
//签到
@Schema(description = "签到")
CHECK_IN("签到");
private final String desc;
MemberCardTransactionsType(String desc) {
this.desc = desc;
}
public String getDesc() {
return desc;
}
}
@@ -1,25 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.enums;
import io.swagger.v3.oas.annotations.media.Schema;
@Schema(description = "会员卡类型枚举")
public enum MemberCardType {
@Schema(description = "时长卡")
TIME_CARD("时长卡"),
@Schema(description = "次卡")
COUNT_CARD("次卡"),
@Schema(description = "储值卡")
STORED_VALUE_CARD("储值卡");
private final String desc;
MemberCardType(String desc) {
this.desc = desc;
}
public String getDesc() {
return desc;
}
}
@@ -1,50 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.handler;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;
/**
* 分布式锁服务(简化版,使用本地锁)
*
* @author shizhounian
* @date 2026-05-23
*/
@Component
public class DistributedLockService {
private final ConcurrentHashMap<String, ReentrantLock> locks = new ConcurrentHashMap<>();
/**
* 执行带锁的操作(业务操作)
*/
public <T> Mono<T> executeWithLock(String userId, String cardType, Mono<T> operation) {
String lockKey = "lock:member:card:operation:" + userId + ":" + cardType;
ReentrantLock lock = locks.computeIfAbsent(lockKey, k -> new ReentrantLock());
lock.lock();
try {
return operation.doFinally(signalType -> lock.unlock());
} catch (Exception e) {
lock.unlock();
return Mono.error(e);
}
}
/**
* 执行带锁的操作(通用/定时任务)
*/
public <T> Mono<T> executeWithLock(String lockKey, Mono<T> operation) {
ReentrantLock lock = locks.computeIfAbsent(lockKey, k -> new ReentrantLock());
lock.lock();
try {
return operation.doFinally(signalType -> lock.unlock());
} catch (Exception e) {
lock.unlock();
return Mono.error(e);
}
}
}
@@ -1,151 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.handler;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Range;
import org.springframework.data.redis.connection.RedisZSetCommands;
import org.springframework.data.redis.core.ReactiveStringRedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.UUID;
@Slf4j
@Component
@RequiredArgsConstructor
public class ExpirationReminderService {
private final ReactiveStringRedisTemplate redisTemplate;
private final ObjectMapper objectMapper;
private static final String REMINDER_QUEUE = "queue:member_card_expiration";
private static final String DEAD_LETTER_QUEUE = "queue:member_card_expiration_dead_letter";
private static final int REMINDER_DAYS_BEFORE = 7;
private static final long MAX_DELAY_MILLIS = Duration.ofDays(365).toMillis();
/**
* 设置到期提醒(购卡/续费时调用)
*/
public Mono<Void> scheduleExpirationReminder(MemberCardRecord record) {
if (record.getExpireTime() == null) {
return Mono.empty();
}
LocalDateTime now = LocalDateTime.now();
Flux<Void> reminderFlux = Flux.range(1, REMINDER_DAYS_BEFORE)
.flatMap(daysBefore -> {
LocalDateTime reminderTime = record.getExpireTime().minusDays(daysBefore);
if (reminderTime.isBefore(now)) {
log.debug("会员卡记录ID={} 的{}天前提醒时间已过,跳过",
record.getMemberCardRecordId(), daysBefore);
return Mono.empty();
}
long delayMillis = Duration.between(now, reminderTime).toMillis();
if (delayMillis > MAX_DELAY_MILLIS) {
log.warn("会员卡记录ID={} 的{}天后提醒时间超过1年,跳过",
record.getMemberCardRecordId(), daysBefore);
return Mono.empty();
}
try {
String messageId = UUID.randomUUID().toString();
String message = objectMapper.writeValueAsString(new ExpirationMessage(
messageId,
record.getMemberCardRecordId(),
record.getMemberId(),
record.getExpireTime(),
daysBefore
));
double executeTime = System.currentTimeMillis() + delayMillis;
return redisTemplate.opsForZSet()
.add(REMINDER_QUEUE, message, executeTime)
.doOnSuccess(v -> log.info("设置会员卡到期提醒: recordId={}, daysBefore={}, expireTime={}, executeTime={}",
record.getMemberCardRecordId(), daysBefore, record.getExpireTime(), executeTime))
.then();
} catch (Exception e) {
log.error("设置会员卡到期提醒失败: recordId={}, daysBefore={}",
record.getMemberCardRecordId(), daysBefore, e);
return Mono.error(e);
}
});
return reminderFlux.then();
}
/**
* 定时任务:每分钟扫描到期的提醒并发送
*/
@Scheduled(fixedRate = 60000)
public void processDueReminders() {
double now = System.currentTimeMillis();
redisTemplate.opsForZSet()
.rangeByScoreWithScores(
REMINDER_QUEUE,
Range.from(Range.Bound.inclusive(0.0))
.to(Range.Bound.inclusive(now)),
RedisZSetCommands.Limit.limit().count(100)
)
.flatMap(tuple -> {
String message = tuple.getValue();
if (message == null) {
return Mono.empty();
}
return Mono.fromCallable(() -> objectMapper.readValue(message, ExpirationMessage.class))
.flatMap(expirationMessage -> {
log.info("处理到期提醒: messageId={}, memberId={}, expireTime={}, daysBefore={}",
expirationMessage.messageId(),
expirationMessage.memberId(),
expirationMessage.expireTime(),
expirationMessage.daysBefore());
// TODO: 集成微信/短信通知服务
sendNotification(expirationMessage);
return redisTemplate.opsForZSet()
.remove(REMINDER_QUEUE, message)
.doOnSuccess(removed -> {
if (removed > 0) {
log.info("成功删除已处理的提醒消息");
}
});
})
.onErrorResume(e -> {
log.error("解析到期提醒消息失败,移至死信队列: message={}", message, e);
return redisTemplate.opsForZSet()
.add(DEAD_LETTER_QUEUE, message, System.currentTimeMillis())
.then(Mono.empty());
});
})
.then()
.subscribe();
}
private void sendNotification(ExpirationMessage reminder) {
// TODO: 实际项目中调用微信模板消息或短信API
log.info("[模拟发送] 会员卡到期提醒 - 会员ID: {}, 到期时间: {}, 提前天数: {}",
reminder.memberId(), reminder.expireTime(), reminder.daysBefore());
}
public record ExpirationMessage(
String messageId,
Long recordId,
Long memberId,
LocalDateTime expireTime,
int daysBefore
) {}
}
@@ -1,133 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.handler;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.PageRequest;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;
/**
* 会员卡管理处理器
*
* @author shizhounian
* @date 2026-05-23
*/
@Slf4j
@Component
@Tag(name = "会员卡管理", description = "会员卡类型管理和会员持卡管理")
public class MemberCardHandler {
private final IMemberCardService memberCardService;
public MemberCardHandler(IMemberCardService memberCardService) {
this.memberCardService = memberCardService;
}
@Operation(summary = "根据ID查询会员卡类型", description = "查询指定ID的会员卡类型详情")
public Mono<ServerResponse> getMemberCardById(ServerRequest request) {
Long id = Long.valueOf(request.pathVariable("id"));
return memberCardService.findByMemberCardIdAndDeletedAtIsNull(id)
.flatMap(card -> ServerResponse.ok().bodyValue(card))
.switchIfEmpty(ServerResponse.notFound().build());
}
@Operation(summary = "查询会员卡类型列表", description = "支持分页和条件查询")
public Mono<ServerResponse> listMemberCards(ServerRequest request) {
Integer status = request.queryParam("status").map(Integer::valueOf).orElse(null);
String name = request.queryParam("name").orElse(null);
String type = request.queryParam("type").orElse(null);
Double minPrice = request.queryParam("minPrice").map(Double::valueOf).orElse(null);
Double maxPrice = request.queryParam("maxPrice").map(Double::valueOf).orElse(null);
int page = request.queryParam("page").map(Integer::valueOf).orElse(0);
int size = request.queryParam("size").map(Integer::valueOf).orElse(10);
var pageable = PageRequest.of(page, size);
return ServerResponse.ok()
.body(memberCardService.findWithConditions(status, name, type, minPrice, maxPrice, pageable),
MemberCard.class);
}
@Operation(summary = "创建会员卡类型", description = "创建新的会员卡类型(时长卡、次卡或储值卡)")
public Mono<ServerResponse> createMemberCard(ServerRequest request) {
return request.bodyToMono(MemberCard.class)
.flatMap(memberCardService::save)
.flatMap(card -> ServerResponse.status(HttpStatus.CREATED).bodyValue(card));
}
@Operation(summary = "更新会员卡类型", description = "更新会员卡类型信息")
public Mono<ServerResponse> updateMemberCard(ServerRequest request) {
Long id = Long.valueOf(request.pathVariable("id"));
return request.bodyToMono(MemberCard.class)
.flatMap(card -> {
card.setMemberCardId(id);
return memberCardService.save(card);
})
.flatMap(updated -> ServerResponse.ok().bodyValue(updated))
.switchIfEmpty(ServerResponse.notFound().build());
}
@Operation(summary = "删除会员卡类型", description = "逻辑删除会员卡类型")
public Mono<ServerResponse> deleteMemberCard(ServerRequest request) {
Long id = Long.valueOf(request.pathVariable("id"));
return memberCardService.logicalDelete(id)
.flatMap(rows -> {
if (rows > 0) {
return ServerResponse.noContent().build();
}
return ServerResponse.notFound().build();
});
}
@Operation(summary = "购买会员卡", description = "会员购买会员卡,生成会员卡记录")
public Mono<ServerResponse> purchaseCard(ServerRequest request) {
Long memberId = Long.valueOf(request.queryParam("memberId").orElseThrow());
Long memberCardId = Long.valueOf(request.queryParam("memberCardId").orElseThrow());
Long sourceOrderId = request.queryParam("sourceOrderId").map(Long::valueOf).orElse(null);
return memberCardService.purchaseCard(memberId, memberCardId, sourceOrderId)
.flatMap(record -> ServerResponse.status(HttpStatus.CREATED).bodyValue(record));
}
@Operation(summary = "续费会员卡", description = "为已有会员卡续费")
public Mono<ServerResponse> renewCard(ServerRequest request) {
Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
Integer addTimes = request.queryParam("addTimes").map(Integer::valueOf).orElse(null);
Double addAmount = request.queryParam("addAmount").map(Double::valueOf).orElse(null);
Integer addDays = request.queryParam("addDays").map(Integer::valueOf).orElse(null);
Long sourceOrderId = request.queryParam("sourceOrderId").map(Long::valueOf).orElse(null);
return memberCardService.renewCard(recordId, addTimes, addAmount, addDays, sourceOrderId)
.flatMap(record -> ServerResponse.ok().bodyValue(record));
}
@Operation(summary = "使用会员卡", description = "扣减会员卡次数或余额")
public Mono<ServerResponse> useCard(ServerRequest request) {
Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
Integer deductTimes = request.queryParam("deductTimes").map(Integer::valueOf).orElse(null);
Double deductAmount = request.queryParam("deductAmount").map(Double::valueOf).orElse(null);
return memberCardService.useCard(recordId, deductTimes, deductAmount)
.flatMap(record -> ServerResponse.ok().bodyValue(record));
}
@Operation(summary = "退款会员卡", description = "申请会员卡退款")
public Mono<ServerResponse> refundCard(ServerRequest request) {
Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
return memberCardService.refundCard(recordId)
.then(ServerResponse.noContent().build());
}
@Operation(summary = "查询有效会员卡", description = "查询指定状态的会员卡类型")
public Mono<ServerResponse> getActiveCards(ServerRequest request) {
Integer status = request.queryParam("status").map(Integer::valueOf).orElse(1);
return ServerResponse.ok()
.body(memberCardService.findActiveCards(status), MemberCard.class);
}
}
@@ -1,112 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.handler;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardRecordService;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.Data;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;
@Component
@Tag(name = "会员卡记录管理", description = "会员卡购买、续费、使用、退款等核心业务")
public class MemberCardRecordHandler {
private final IMemberCardService memberCardService;
private final IMemberCardRecordService memberCardRecordService;
public MemberCardRecordHandler(IMemberCardService memberCardService,
IMemberCardRecordService memberCardRecordService) {
this.memberCardService = memberCardService;
this.memberCardRecordService = memberCardRecordService;
}
@Operation(summary = "购买会员卡", description = "支持时长卡、次卡、储值卡,自动设置到期提醒")
public Mono<ServerResponse> purchaseCard(ServerRequest request) {
return request.bodyToMono(PurchaseRequest.class)
.flatMap(body -> memberCardService.purchaseCard(
body.getMemberId(),
body.getMemberCardId(),
body.getSourceOrderId()))
.flatMap(record -> ServerResponse.ok().bodyValue(record))
.onErrorResume(e -> ServerResponse.badRequest().bodyValue("购买失败: " + e.getMessage()));
}
@Operation(summary = "续费会员卡", description = "累加剩余次数/余额,顺延到期日期,权益立即生效")
public Mono<ServerResponse> renewCard(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("recordId"));
return request.bodyToMono(RenewRequest.class)
.flatMap(body -> memberCardService.renewCard(recordId,
body.getAddTimes(),
body.getAddAmount(),
body.getAddDays(),
body.getSourceOrderId()))
.flatMap(record -> ServerResponse.ok().bodyValue(record))
.onErrorResume(e -> ServerResponse.badRequest().bodyValue("续费失败: " + e.getMessage()));
}
@Operation(summary = "使用会员卡", description = "预约团课或私教成功后扣减次数或余额")
public Mono<ServerResponse> useCard(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("recordId"));
return request.bodyToMono(UseCardRequest.class)
.flatMap(body -> memberCardService.useCard(recordId,
body.getDeductTimes(),
body.getDeductAmount()))
.flatMap(record -> ServerResponse.ok().bodyValue(record))
.onErrorResume(e -> ServerResponse.badRequest().bodyValue("使用失败: " + e.getMessage()));
}
@Operation(summary = "退款会员卡", description = "使用Saga模式执行退款流程,保证事务一致性")
public Mono<ServerResponse> refundCard(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("recordId"));
return memberCardService.refundCard(recordId)
.then(ServerResponse.ok().bodyValue("退款成功"))
.onErrorResume(e -> ServerResponse.badRequest().bodyValue("退款失败: " + e.getMessage()));
}
@Operation(summary = "查询会员卡记录详情", description = "根据记录ID查询详细信息")
public Mono<ServerResponse> getMemberCardRecordById(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("recordId"));
return memberCardRecordService.findById(recordId)
.flatMap(record -> ServerResponse.ok().bodyValue(record))
.switchIfEmpty(ServerResponse.notFound().build());
}
@Operation(summary = "会员我的卡包", description = "查询当前会员的所有有效卡")
public Mono<ServerResponse> getMyCards(ServerRequest request) {
Long memberId = Long.parseLong(request.pathVariable("memberId"));
return ServerResponse.ok().body(
memberCardRecordService.findActiveCardsByMemberId(memberId),
MemberCardRecord.class);
}
@Operation(summary = "处理过期会员卡", description = "定时任务调用,扫描并更新过期卡状态")
public Mono<ServerResponse> processExpiredCards(ServerRequest request) {
return memberCardService.processExpiredCards()
.flatMap(count -> ServerResponse.ok().bodyValue("处理完成,共处理" + count + ""));
}
@Data
public static class PurchaseRequest {
private Long memberId;
private Long memberCardId;
private Long sourceOrderId;
}
@Data
public static class UseCardRequest {
private Integer deductTimes;
private Double deductAmount;
}
@Data
public static class RenewRequest {
private Integer addTimes;
private Double addAmount;
private Integer addDays;
private Long sourceOrderId;
}
}
@@ -1,99 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.handler;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardEvent;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Slf4j
@Component
@RequiredArgsConstructor
public class MemberCardScheduledHandler {
private final IMemberCardRecordRepository recordRepository;
private final ExpirationReminderService expirationReminderService;
private final MemberCardStateMachine stateMachine;
private final DistributedLockService distributedLockService;
/**
* 每日凌晨2点检查过期会员卡
*/
@Scheduled(cron = "0 0 2 * * ?")
public void checkExpiredCards() {
String lockKey = "scheduled:check_expired_cards";
distributedLockService.executeWithLock("SYSTEM", "EXPIRE_CHECK",
Mono.fromRunnable(() -> {
log.info("开始执行会员卡过期检查任务");
LocalDateTime now = LocalDateTime.now();
recordRepository.findActiveRecords()
.filter(record -> record.getExpireTime() != null && record.getExpireTime().isBefore(now))
.flatMap(record ->
stateMachine.transition(record.getStatus(), MemberCardEvent.EXPIRE)
.flatMap(newState -> {
record.setStatus(newState);
return recordRepository.save(record);
})
.doOnSuccess(r -> log.info("会员卡记录ID={} 已标记为过期", r.getMemberCardRecordId()))
.onErrorResume(e -> {
log.error("处理会员卡过期失败: recordId={}", record.getMemberCardRecordId(), e);
return Mono.empty();
})
)
.then()
.subscribe();
})
).subscribe();
}
/**
* 每日凌晨3点检查是否有遗漏的到期提醒(兜底机制)
* 主要依赖购卡/续费时的主动调用和每分钟扫描任务,此任务仅用于异常恢复
*/
@Scheduled(cron = "0 0 3 * * ?")
public void checkAndSendExpirationReminders() {
String lockKey = "scheduled:expiration_reminder";
distributedLockService.executeWithLock("SYSTEM", "REMINDER_CHECK",
Mono.fromRunnable(() -> {
log.info("开始执行到期提醒兜底检查任务");
LocalDateTime now = LocalDateTime.now();
// 查询所有活跃的会员卡
recordRepository.findActiveRecords()
.filter(record -> record.getExpireTime() != null)
.flatMap(record -> {
try {
// 计算距离到期还有几天
long daysBetween = java.time.Duration.between(now, record.getExpireTime()).toDays();
// 如果到期时间在1-7天范围内,记录日志供人工检查
if (daysBetween >= 1 && daysBetween <= 7) {
log.warn("发现到期前{}天的会员卡记录ID={},请确认是否已发送提醒",
daysBetween, record.getMemberCardRecordId());
}
return Mono.empty();
} catch (Exception e) {
log.error("检查到期提醒失败: recordId={}", record.getMemberCardRecordId(), e);
return Mono.empty();
}
})
.then()
.subscribe();
})
).subscribe();
log.info("到期提醒兜底检查任务完成");
}
}
@@ -1,85 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.handler;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardEvent;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
import java.util.HashMap;
import java.util.Map;
@Slf4j
@Component
public class MemberCardStateMachine {
private final Map<MemberCardRecordStatus, Map<MemberCardEvent, MemberCardRecordStatus>> stateTransitionMap;
public MemberCardStateMachine() {
this.stateTransitionMap = buildStateTransitionMap();
}
private Map<MemberCardRecordStatus, Map<MemberCardEvent, MemberCardRecordStatus>> buildStateTransitionMap() {
Map<MemberCardRecordStatus, Map<MemberCardEvent, MemberCardRecordStatus>> map = new HashMap<>();
// ACTIVE 状态可以转换的事件
Map<MemberCardEvent, MemberCardRecordStatus> activeTransitions = new HashMap<>();
activeTransitions.put(MemberCardEvent.USE, MemberCardRecordStatus.ACTIVE);
activeTransitions.put(MemberCardEvent.RENEW, MemberCardRecordStatus.ACTIVE);
activeTransitions.put(MemberCardEvent.EXPIRE, MemberCardRecordStatus.EXPIRED);
activeTransitions.put(MemberCardEvent.REFUND, MemberCardRecordStatus.REFUNDED);
map.put(MemberCardRecordStatus.ACTIVE, activeTransitions);
// USED_UP 状态可以转换的事件
Map<MemberCardEvent, MemberCardRecordStatus> usedUpTransitions = new HashMap<>();
usedUpTransitions.put(MemberCardEvent.RENEW, MemberCardRecordStatus.ACTIVE);
usedUpTransitions.put(MemberCardEvent.REFUND, MemberCardRecordStatus.REFUNDED);
map.put(MemberCardRecordStatus.USED_UP, usedUpTransitions);
// EXPIRED 状态可以转换的事件
Map<MemberCardEvent, MemberCardRecordStatus> expiredTransitions = new HashMap<>();
expiredTransitions.put(MemberCardEvent.RENEW, MemberCardRecordStatus.ACTIVE);
map.put(MemberCardRecordStatus.EXPIRED, expiredTransitions);
// REFUNDED 状态是终态,不允许任何转换
return map;
}
public Mono<Boolean> canTransition(MemberCardRecordStatus currentState, MemberCardEvent event) {
return Mono.fromSupplier(() -> {
Map<MemberCardEvent, MemberCardRecordStatus> transitions = stateTransitionMap.get(currentState);
if (transitions == null) {
return false;
}
return transitions.containsKey(event);
});
}
public Mono<MemberCardRecordStatus> transition(MemberCardRecordStatus currentState, MemberCardEvent event) {
return Mono.fromSupplier(() -> {
Map<MemberCardEvent, MemberCardRecordStatus> transitions = stateTransitionMap.get(currentState);
if (transitions == null || !transitions.containsKey(event)) {
log.error("Invalid state transition: currentState={}, event={}", currentState, event);
throw new IllegalStateException(
String.format("不允许的状态转换: 当前状态=%s, 事件=%s", currentState, event));
}
MemberCardRecordStatus newState = transitions.get(event);
log.info("State transition: {} --({})--> {}", currentState, event, newState);
return newState;
});
}
public Mono<Void> validateTransition(MemberCardRecord card, MemberCardEvent event) {
return canTransition(card.getStatus(), event)
.flatMap(canTransition -> {
if (!canTransition) {
return Mono.error(new IllegalStateException(
String.format("会员卡记录ID=%d 不允许的状态转换: 当前状态=%s, 事件=%s",
card.getMemberCardRecordId(), card.getStatus(), event)));
}
return Mono.empty();
});
}
}
@@ -1,150 +0,0 @@
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));
}
}
@@ -1,126 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.handler;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardEvent;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardTransactionsService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
import java.util.ArrayList;
import java.util.List;
@Slf4j
@Component
@RequiredArgsConstructor
public class RefundSagaHandler {
private final IMemberCardRecordRepository recordRepository;
private final IMemberCardTransactionsService transactionsService;
private final MemberCardStateMachine stateMachine;
public Mono<Void> executeRefund(Long recordId) {
return recordRepository.findById(recordId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
.flatMap(record -> stateMachine.validateTransition(record, MemberCardEvent.REFUND)
.then(Mono.defer(() -> doExecuteRefund(recordId, record))));
}
private Mono<Void> doExecuteRefund(Long recordId, MemberCardRecord record) {
List<SagaStep> steps = new ArrayList<>();
List<SagaStep> rollbackSteps = new ArrayList<>();
SagaStep step1 = new SagaStep(
"更新会员卡状态为已退款",
updateCardStatus(recordId, MemberCardRecordStatus.REFUNDED),
Mono.defer(() -> updateCardStatus(recordId, record.getStatus()))
);
steps.add(step1);
rollbackSteps.add(0, step1);
SagaStep step2 = new SagaStep(
"记录退款流水",
createRefundTransaction(record),
createReversalTransaction(record)
);
steps.add(step2);
rollbackSteps.add(0, step2);
return executeSaga(steps, rollbackSteps);
}
private Mono<Void> updateCardStatus(Long recordId, MemberCardRecordStatus status) {
return recordRepository.updateStatus(recordId, status)
.flatMap(rows -> {
if (rows == 0) {
return Mono.error(new RuntimeException("更新会员卡状态失败"));
}
return Mono.empty();
});
}
private Mono<Void> createRefundTransaction(MemberCardRecord record) {
MemberCardTransactions transaction = new MemberCardTransactions();
transaction.setMemberId(record.getMemberId());
transaction.setMemberCardId(record.getMemberCardId());
transaction.setOperationType(MemberCardTransactionsAction.REFUND);
transaction.setChangeAmount(-record.getRemainingTimes());
transaction.setChangeBalance(-record.getRemainingAmount());
transaction.setAfterRemainingCount(0);
transaction.setAfterRemainingBalance(0.0);
transaction.setRemark("会员卡退款");
return transactionsService.createTransaction(transaction);
}
private Mono<Void> createReversalTransaction(MemberCardRecord record) {
MemberCardTransactions reversal = new MemberCardTransactions();
reversal.setMemberId(record.getMemberId());
reversal.setMemberCardId(record.getMemberCardId());
reversal.setOperationType(MemberCardTransactionsAction.REFUND);
reversal.setChangeAmount(record.getRemainingTimes());
reversal.setChangeBalance(record.getRemainingAmount());
reversal.setRemark("退款冲正");
return transactionsService.createTransaction(reversal);
}
private Mono<Void> executeSaga(List<SagaStep> steps, List<SagaStep> rollbackSteps) {
return executeStep(steps, 0, rollbackSteps);
}
private Mono<Void> executeStep(List<SagaStep> steps, int index, List<SagaStep> rollbackSteps) {
if (index >= steps.size()) {
return Mono.empty();
}
SagaStep currentStep = steps.get(index);
return currentStep.operation()
.then(Mono.defer(() -> executeStep(steps, index + 1, rollbackSteps)))
.onErrorResume(error -> {
log.error("Saga步骤执行失败: step={}, error={}", currentStep.description(), error.getMessage());
return rollback(rollbackSteps, 0).then(Mono.error(error));
});
}
private Mono<Void> rollback(List<SagaStep> rollbackSteps, int index) {
if (index >= rollbackSteps.size()) {
return Mono.empty();
}
SagaStep currentStep = rollbackSteps.get(index);
return currentStep.rollbackOperation()
.then(Mono.defer(() -> rollback(rollbackSteps, index + 1)))
.doOnError(error -> log.error("Saga回滚失败: step={}, error={}", currentStep.description(), error.getMessage()))
.onErrorResume(e -> Mono.empty());
}
private record SagaStep(String description, Mono<Void> operation, Mono<Void> rollbackOperation) {}
}
@@ -1,34 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.repository;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public interface IMemberCardRecordRepository {
Mono<MemberCardRecord> findById(Long id);
Mono<MemberCardRecord> save(MemberCardRecord record);
Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
Flux<MemberCardRecord> findActiveRecords();
Mono<Integer> updateStatus(Long id, MemberCardRecordStatus status);
Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, java.time.LocalDateTime newExpireTime);
Flux<MemberCardRecord> findExpiredCards();
Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
}
@@ -1,78 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.repository;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public interface IMemberCardRepository {
/**
* 根据会员卡ID查询会员卡详情(用于编辑前回显或小程序端展示)
* @param memberCardId 会员卡ID
* @return 会员卡完整信息,如果不存在或已删除则返回空
*/
Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
/**
* 条件查询会员卡列表(后台卡种列表展示,支持多条件组合+分页+排序)
* @param status 会员卡状态(上架/下架)
* @param name 会员卡名称(模糊查询)
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
Flux<MemberCard> findWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice, Pageable pageable);
/**
* 统计符合条件的会员卡总数(配合列表查询使用)
* @param status 会员卡状态
* @param name 会员卡名称(模糊查询)
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @return 符合条件的会员卡数量
*/
Mono<Long> countWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice);
/**
* 按状态查询会员卡列表(用于小程序端展示可购买卡列表,只展示上架的卡)
* @param status 会员卡状态(通常传上架状态)
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
/**
* 检查会员卡是否已被购买(用于删除前的校验)
* @param memberCardId 会员卡ID
* @return 如果存在关联的会员记录则返回true,否则返回false
*/
Mono<Boolean> existsPurchasedRecord(Long memberCardId);
/**
* 逻辑删除会员卡(下架卡种,防止已购会员数据异常)
* @param memberCardId 会员卡ID
* @return 受影响的行数
*/
Mono<Integer> logicalDelete(Long memberCardId);
/**
* 保存卡种信息(新增或更新)
* - 新增:entity.memberCardId 为 null 时,插入新记录
* - 更新:entity.memberCardId 不为 null 时,根据ID更新现有记录
* @param entity 卡种信息
* @return 保存后的实体对象
*/
Mono<MemberCard> save(MemberCard entity);
/**
* 批量查询上架的会员卡(用于小程序端展示)
* @param status 上架状态值
* @return 上架的会员卡列表
*/
Flux<MemberCard> findActiveCards(Integer status);
}
@@ -1,112 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.repository;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
public interface IMemberCardTransactionsRepository {
/**
* 记录每一次变动
* @param transactions 流水记录
* @return 插入的流水记录
*/
Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions);
/**
* 会员端"使用记录"
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
LocalDateTime endTime, Pageable pageable);
/**
* 后台"使用记录查询"
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime,
Pageable pageable);
/**
* 统计符合条件的流水总数
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @return 流水记录数量
*/
Mono<Long> countWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime);
/**
* 按会员卡ID查询所有流水记录
* @param memberCardId 会员卡ID
* @return 该卡的所有流水记录,按时间倒序
*/
Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId);
/**
* 数据统计 - 统计某卡种的总扣次数
* @param memberCardId 会员卡ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 总扣次数
*/
Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime);
/**
* 数据统计 - 统计某时间段的续费总金额
* @param startTime 开始时间
* @param endTime 结束时间
* @return 续费总金额
*/
Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
/**
* 数据统计 - 统计某会员的购卡总金额
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 购卡总金额
*/
Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
/**
* 保存流水记录
* @param transaction 流水记录
* @return 保存后的流水记录
*/
Mono<MemberCardTransactions> save(MemberCardTransactions transaction);
/**
* 按会员ID查询所有流水记录
* @param memberId 会员ID
* @return 该会员的所有流水记录,按时间倒序
*/
Flux<MemberCardTransactions> findByMemberId(Long memberId);
/**
* 按流水ID查询流水记录
* @param recordId 流水ID
* @return 该流水记录
*/
Flux<MemberCardTransactions> findByRecordId(Long recordId);
}
@@ -1,81 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.repository;
import cn.novalon.gym.manage.gymmembercard.domain.RefundApplication;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/**
* 退款申请仓储接口
*
* @author shizhounian
* @date 2026-05-23
*/
public interface IRefundApplicationRepository {
/**
* 创建退款申请
*
* @param application 退款申请对象
* @return 创建后的退款申请
*/
Mono<RefundApplication> create(RefundApplication application);
/**
* 根据ID查询退款申请
*
* @param id 退款申请ID
* @return 退款申请对象
*/
Mono<RefundApplication> findById(Long id);
/**
* 根据会员卡记录ID查询退款申请
*
* @param recordId 会员卡记录ID
* @return 退款申请对象
*/
Mono<RefundApplication> findByRecordId(Long recordId);
/**
* 根据会员ID查询退款申请列表
*
* @param memberId 会员ID
* @return 退款申请列表
*/
Flux<RefundApplication> findByMemberId(Long memberId);
/**
* 根据状态查询退款申请列表
*
* @param status 状态
* @return 退款申请列表
*/
Flux<RefundApplication> findByStatus(String status);
/**
* 更新退款申请
*
* @param application 退款申请对象
* @return 更新后的退款申请
*/
Mono<RefundApplication> update(RefundApplication application);
/**
* 审核退款申请
*
* @param id 退款申请ID
* @param status 审核状态(APPROVED/REJECTED
* @param auditorId 审核人ID
* @param auditRemark 审核备注
* @return 更新后的退款申请
*/
Mono<RefundApplication> approve(Long id, String status, Long auditorId, String auditRemark);
/**
* 删除退款申请(逻辑删除)
*
* @param id 退款申请ID
* @return 受影响的行数
*/
Mono<Integer> delete(Long id);
}
@@ -1,105 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.repository.impl;
import cn.novalon.gym.manage.gymmembercard.dao.MemberCardRecordDao;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardRecordEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@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;
}
@Override
public Mono<MemberCardRecord> findById(Long id) {
return memberCardRecordDao.findById(id)
.map(e -> beanConvertUtil.toBean(e, MemberCardRecord.class));
}
@Override
public Mono<MemberCardRecord> save(MemberCardRecord record) {
MemberCardRecordEntity entity = beanConvertUtil.toBean(record, MemberCardRecordEntity.class);
return memberCardRecordDao.save(entity)
.map(e -> beanConvertUtil.toBean(e, MemberCardRecord.class));
}
@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));
}
@Override
public Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable) {
return memberCardRecordDao.findByMemberId(memberId, pageable)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
}
@Override
public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
return memberCardRecordDao.findActiveCardsByMemberId(memberId)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
}
@Override
public Flux<MemberCardRecord> findActiveRecords() {
return memberCardRecordDao.findActiveRecords()
.map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
}
@Override
public Mono<Integer> updateStatus(Long id, MemberCardRecordStatus status) {
return memberCardRecordDao.updateStatus(id, status);
}
@Override
public Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount) {
return memberCardRecordDao.deductUsage(recordId, deductTimes, deductAmount);
}
@Override
public Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, java.time.LocalDateTime newExpireTime) {
return memberCardRecordDao.renewCard(recordId, addTimes, addAmount, newExpireTime);
}
@Override
public Flux<MemberCardRecord> findExpiredCards() {
return memberCardRecordDao.findExpiredCards()
.map(e -> beanConvertUtil.toBean(e, MemberCardRecord.class));
}
@Override
public Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes) {
return memberCardRecordDao.validateCountCard(recordId, requiredTimes)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
}
@Override
public Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount) {
return memberCardRecordDao.validateStoredCard(recordId, requiredAmount)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
}
}
@@ -1,146 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.repository.impl;
import cn.novalon.gym.manage.gymmembercard.dao.MemberCardDao;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardEntity;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRepository;
import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@Repository
public class MemberCardRepositoryImpl implements IMemberCardRepository {
private final MemberCardDao memberCardDao;
private final BeanConvertUtil beanConvertUtil;
private final R2dbcEntityTemplate r2dbcEntityTemplate;
//构造函数,初始化
public MemberCardRepositoryImpl(MemberCardDao memberCardDao, BeanConvertUtil beanConvertUtil, R2dbcEntityTemplate r2dbcEntityTemplate) {
this.memberCardDao = memberCardDao;
this.beanConvertUtil = beanConvertUtil;
this.r2dbcEntityTemplate = r2dbcEntityTemplate;
}
/**
* 根据会员卡ID查询会员卡详情(用于编辑前回显或小程序端展示)
* @param memberCardId 会员卡ID
* @return 会员卡完整信息,如果不存在或已删除则返回空
*/
@Override
public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
return memberCardDao.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
.map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
}
/**
* 条件查询会员卡列表(后台卡种列表展示,支持多条件组合+分页+排序)
* @param status 会员卡状态(上架/下架)
* @param name 会员卡名称(模糊查询)
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
@Override
public Flux<MemberCard> findWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice, Pageable pageable) {
return memberCardDao.findWithConditions(status, name, type, minPrice, maxPrice, pageable)
.map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
}
/**
* 统计符合条件的会员卡总数(配合列表查询使用)
* @param status 会员卡状态
* @param name 会员卡名称(模糊查询)
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @return 符合条件的会员卡数量
*/
@Override
public Mono<Long> countWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice) {
return memberCardDao.countWithConditions(status, name, type, minPrice, maxPrice);
}
/**
* 按状态查询会员卡列表(用于小程序端展示可购买卡列表,只展示上架的卡)
* @param status 会员卡状态(通常传上架状态)
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
@Override
public Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable) {
return memberCardDao.findByMemberCardStatusAndDeletedAtIsNull(status, pageable)
.map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
}
/**
* 检查会员卡是否已被购买(用于删除前的校验)
* @param memberCardId 会员卡ID
* @return 如果存在关联的会员记录则返回true,否则返回false
*/
@Override
public Mono<Boolean> existsPurchasedRecord(Long memberCardId) {
return memberCardDao.existsPurchasedRecord(memberCardId);
}
/**
* 逻辑删除会员卡(下架卡种,防止已购会员数据异常)
* @param memberCardId 会员卡ID
* @return 受影响的行数
*/
@Override
public Mono<Integer> logicalDelete(Long memberCardId) {
return memberCardDao.logicalDelete(memberCardId);
}
/**
* 安全更新会员卡信息(不覆盖不允许修改的字段)
* @param memberCardId 会员卡ID
* @param updateData 需要更新的卡种信息
* @return 受影响的行数
*/
public Mono<Integer> updateSafe(Long memberCardId, MemberCard updateData) {
MemberCardEntity memberCardEntity = beanConvertUtil.toBean(updateData, MemberCardEntity.class);
return memberCardDao.updateSafe(
memberCardId,
memberCardEntity.getMemberCardName(),
memberCardEntity.getMemberCardPrice(),
memberCardEntity.getMemberCardValidityDays(),
memberCardEntity.getMemberCardTotalTimes(),
memberCardEntity.getMemberCardAmount(),
memberCardEntity.getMemberCardStatus()
);
}
/**
* 保存卡种信息(新增或更新)
* - 新增:entity.memberCardId 为 null 时,插入新记录
* - 更新:entity.memberCardId 不为 null 时,根据ID更新现有记录
* 建议:更新时优先使用 updateSafe 方法避免全字段覆盖
* @param entity 卡种信息
* @return 保存后的实体对象
*/
@Override
public Mono<MemberCard> save(MemberCard entity) {
MemberCardEntity cardEntity = beanConvertUtil.toBean(entity, MemberCardEntity.class);
return memberCardDao.save(cardEntity)
.map(savedEntity -> beanConvertUtil.toBean(savedEntity, MemberCard.class));
}
/**
* 批量查询上架的会员卡(用于小程序端展示)
* @param status 上架状态值
* @return 上架的会员卡列表
*/
@Override
public Flux<MemberCard> findActiveCards(Integer status) {
return memberCardDao.findActiveCards(status)
.map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
}
}
@@ -1,170 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.repository.impl;
import cn.novalon.gym.manage.gymmembercard.dao.MemberCardTransactionsDao;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardTransactionsEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardTransactionsRepository;
import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Repository
public class MemberCardTransactionsRepositoryImpl implements IMemberCardTransactionsRepository {
private final MemberCardTransactionsDao memberCardTransactionsDao;
private final BeanConvertUtil beanConvertUtil;
private final R2dbcEntityTemplate r2dbcEntityTemplate;
public MemberCardTransactionsRepositoryImpl(MemberCardTransactionsDao memberCardTransactionsDao, BeanConvertUtil beanConvertUtil, R2dbcEntityTemplate r2dbcEntityTemplate) {
this.memberCardTransactionsDao = memberCardTransactionsDao;
this.beanConvertUtil = beanConvertUtil;
this.r2dbcEntityTemplate = r2dbcEntityTemplate;
}
/**
* 记录每一次变动
* @param transactions 流水记录
* @return 插入的流水记录
*/
@Override
public Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions) {
MemberCardTransactionsEntity entity = beanConvertUtil.toBean(transactions, MemberCardTransactionsEntity.class);
return memberCardTransactionsDao.insertTransaction(
entity.getMemberCardId(),
entity.getMemberId(),
entity.getOperationType(),
entity.getChangeAmount(),
entity.getChangeBalance(),
entity.getAfterRemainingCount(),
entity.getAfterRemainingBalance(),
entity.getRelatedBizType(),
entity.getRemark())
.map(e -> beanConvertUtil.toBean(e, MemberCardTransactions.class));
}
/**
* 会员端"使用记录"
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
@Override
public Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
LocalDateTime endTime, Pageable pageable) {
return memberCardTransactionsDao.findByMemberIdAndTimeRange(memberId, startTime, endTime, pageable)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
}
/**
* 后台"使用记录查询"
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
@Override
public Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime,
Pageable pageable) {
return memberCardTransactionsDao.findWithConditions(memberId, memberCardId, operationType,
startTime, endTime, pageable)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
}
/**
* 统计符合条件的流水总数
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @return 流水记录数量
*/
@Override
public Mono<Long> countWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsDao.countWithConditions(memberId, memberCardId,
operationType, startTime, endTime);
}
/**
* 按会员卡ID查询所有流水记录
* @param memberCardId 会员卡ID
* @return 该卡的所有流水记录,按时间倒序
*/
@Override
public Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId) {
return memberCardTransactionsDao.findByMemberCardId(memberCardId)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
}
/**
* 数据统计 - 统计某卡种的总扣次数
* @param memberCardId 会员卡ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 总扣次数
*/
@Override
public Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsDao.sumDeductCountByCardId(memberCardId, startTime, endTime);
}
/**
* 数据统计 - 统计某时间段的续费总金额
* @param startTime 开始时间
* @param endTime 结束时间
* @return 续费总金额
*/
@Override
public Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsDao.sumRenewAmountByTimeRange(startTime, endTime);
}
/**
* 数据统计 - 统计某会员的购卡总金额
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 购卡总金额
*/
@Override
public Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsDao.sumPurchaseAmountByMemberId(memberId, startTime, endTime);
}
/**
* 保存流水记录
* @param transaction 流水记录
* @return 保存后的流水记录
*/
@Override
public Mono<MemberCardTransactions> save(MemberCardTransactions transaction) {
MemberCardTransactionsEntity entity = beanConvertUtil.toBean(transaction, MemberCardTransactionsEntity.class);
return memberCardTransactionsDao.save(entity)
.map(savedEntity -> beanConvertUtil.toBean(savedEntity, MemberCardTransactions.class));
}
@Override
public Flux<MemberCardTransactions> findByMemberId(Long memberId) {
return memberCardTransactionsDao.findByMemberId(memberId)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
}
@Override
public Flux<MemberCardTransactions> findByRecordId(Long recordId) {
return memberCardTransactionsDao.findByRecordId(recordId)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
}
}
@@ -1,125 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.repository.impl;
import cn.novalon.gym.manage.gymmembercard.dao.RefundApplicationDao;
import cn.novalon.gym.manage.gymmembercard.domain.RefundApplication;
import cn.novalon.gym.manage.gymmembercard.entity.RefundApplicationEntity;
import cn.novalon.gym.manage.gymmembercard.repository.IRefundApplicationRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
/**
* 退款申请仓储实现类
*
* @author shizhounian
* @date 2026-05-23 21:16:36
*/
@Repository
@RequiredArgsConstructor
public class RefundApplicationRepositoryImpl implements IRefundApplicationRepository {
private final RefundApplicationDao refundApplicationDao;
@Override
public Mono<RefundApplication> create(RefundApplication application) {
RefundApplicationEntity entity = new RefundApplicationEntity();
entity.setRecordId(application.getRecordId());
entity.setMemberId(application.getMemberId());
entity.setStatus(application.getStatus() != null ? application.getStatus() : "PENDING");
entity.setReason(application.getReason());
entity.setApplyTime(application.getApplyTime() != null ? application.getApplyTime() : LocalDateTime.now());
entity.setRefundAmount(application.getRefundAmount());
return refundApplicationDao.save(entity)
.map(this::convertToDomain);
}
@Override
public Mono<RefundApplication> findById(Long id) {
return refundApplicationDao.findById(id)
.map(this::convertToDomain);
}
@Override
public Mono<RefundApplication> findByRecordId(Long recordId) {
return refundApplicationDao.findByRecordId(recordId)
.map(this::convertToDomain);
}
@Override
public Flux<RefundApplication> findByMemberId(Long memberId) {
return refundApplicationDao.findByMemberId(memberId)
.map(this::convertToDomain);
}
@Override
public Flux<RefundApplication> findByStatus(String status) {
return refundApplicationDao.findByStatus(status)
.map(this::convertToDomain);
}
@Override
public Mono<RefundApplication> update(RefundApplication application) {
return refundApplicationDao.findById(application.getId())
.flatMap(entity -> {
if (application.getStatus() != null) {
entity.setStatus(application.getStatus());
}
if (application.getReason() != null) {
entity.setReason(application.getReason());
}
if (application.getAuditTime() != null) {
entity.setAuditTime(application.getAuditTime());
}
if (application.getAuditorId() != null) {
entity.setAuditorId(application.getAuditorId());
}
if (application.getAuditRemark() != null) {
entity.setAuditRemark(application.getAuditRemark());
}
if (application.getRefundAmount() != null) {
entity.setRefundAmount(application.getRefundAmount());
}
return refundApplicationDao.save(entity);
})
.map(this::convertToDomain);
}
@Override
public Mono<RefundApplication> approve(Long id, String status, Long auditorId, String auditRemark) {
return refundApplicationDao.approve(id, status, auditorId, auditRemark)
.flatMap(rows -> {
if (rows > 0) {
return refundApplicationDao.findById(id)
.map(this::convertToDomain);
}
return Mono.empty();
});
}
@Override
public Mono<Integer> delete(Long id) {
return refundApplicationDao.logicalDelete(id);
}
/**
* Entity转Domain
*/
private RefundApplication convertToDomain(RefundApplicationEntity entity) {
RefundApplication domain = new RefundApplication();
domain.setId(entity.getId());
domain.setRecordId(entity.getRecordId());
domain.setMemberId(entity.getMemberId());
domain.setStatus(entity.getStatus());
domain.setReason(entity.getReason());
domain.setApplyTime(entity.getApplyTime());
domain.setAuditTime(entity.getAuditTime());
domain.setAuditorId(entity.getAuditorId());
domain.setAuditRemark(entity.getAuditRemark());
domain.setRefundAmount(entity.getRefundAmount());
return domain;
}
}
@@ -1,29 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.sevice;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public interface IMemberCardRecordService {
Mono<MemberCardRecord> findById(Long id);
Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, java.time.LocalDateTime newExpireTime);
Mono<Integer> updateStatus(Long recordId, cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus status);
Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
Flux<MemberCardRecord> findExpiredCards();
}
@@ -1,38 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.sevice;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public interface IMemberCardService {
Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
Flux<MemberCard> findWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice, Pageable pageable);
Mono<Long> countWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice);
Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
Mono<Boolean> existsPurchasedRecord(Long memberCardId);
Mono<Integer> logicalDelete(Long memberCardId);
Flux<MemberCard> findActiveCards(Integer status);
Mono<MemberCard> save(MemberCard entity);
Mono<MemberCardRecord> purchaseCard(Long memberId, Long memberCardId, Long sourceOrderId);
Mono<MemberCardRecord> renewCard(Long recordId, Integer addTimes, Double addAmount, Integer addDays, Long sourceOrderId);
Mono<MemberCardRecord> useCard(Long recordId, Integer deductTimes, Double deductAmount);
Mono<Void> refundCard(Long recordId);
Mono<Integer> processExpiredCards();
}
@@ -1,112 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.sevice;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
public interface IMemberCardTransactionsService {
/**
* 记录每一次变动
* @param transactions 流水记录
* @return 插入的流水记录
*/
Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions);
/**
* 会员端"使用记录"
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
LocalDateTime endTime, Pageable pageable);
/**
* 后台"使用记录查询"
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime,
Pageable pageable);
/**
* 统计符合条件的流水总数
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @return 流水记录数量
*/
Mono<Long> countWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime);
/**
* 按会员卡ID查询所有流水记录
* @param memberCardId 会员卡ID
* @return 该卡的所有流水记录,按时间倒序
*/
Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId);
/**
* 数据统计 - 统计某卡种的总扣次数
* @param memberCardId 会员卡ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 总扣次数
*/
Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime);
/**
* 数据统计 - 统计某时间段的续费总金额
* @param startTime 开始时间
* @param endTime 结束时间
* @return 续费总金额
*/
Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
/**
* 数据统计 - 统计某会员的购卡总金额
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 购卡总金额
*/
Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
/**
* 创建交易记录
* @param transaction 交易记录
* @return 创建的交易记录
*/
Mono<Void> createTransaction(MemberCardTransactions transaction);
/**
* 查询会员的交易记录
* @param memberId 会员ID
* @return 交易记录列表
*/
Flux<MemberCardTransactions> findByMemberId(Long memberId);
/**
* 查询会员卡记录的交易历史
* @param recordId 会员卡记录ID
* @return 交易记录列表
*/
Flux<MemberCardTransactions> findByRecordId(Long recordId);
}
@@ -1,33 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.sevice;
import cn.novalon.gym.manage.gymmembercard.domain.RefundApplication;
import reactor.core.publisher.Mono;
/**
* 退款申请服务
*
* @author shizhounian
* @date 2026-05-23
*/
public interface IRefundApplicationService {
/**
* 创建退款申请
*/
Mono<RefundApplication> create(Long recordId, String reason);
/**
* 审核退款申请
*/
Mono<RefundApplication> approve(Long applicationId, Long auditorId, String remark);
/**
* 拒绝退款申请
*/
Mono<RefundApplication> reject(Long applicationId, Long auditorId, String remark);
/**
* 根据记录ID查询申请
*/
Mono<RefundApplication> findByRecordId(Long recordId);
}
@@ -1,72 +0,0 @@
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();
}
@Override
public Mono<MemberCardRecord> findById(Long recordId) {
return memberCardRecordRepository.findById(recordId);
}
}
@@ -1,317 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.sevice.impl;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardEvent;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardType;
import cn.novalon.gym.manage.gymmembercard.handler.DistributedLockService;
import cn.novalon.gym.manage.gymmembercard.handler.ExpirationReminderService;
import cn.novalon.gym.manage.gymmembercard.handler.MemberCardStateMachine;
import cn.novalon.gym.manage.gymmembercard.handler.RefundSagaHandler;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRepository;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardService;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardTransactionsService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Slf4j
@Service
public class MemberCardServiceImpl implements IMemberCardService {
private final IMemberCardRepository memberCardRepository;
private final IMemberCardRecordRepository recordRepository;
private final IMemberCardTransactionsService transactionsService;
private final MemberCardStateMachine stateMachine;
private final DistributedLockService distributedLockService;
private final ExpirationReminderService expirationReminderService;
private final RefundSagaHandler refundSagaHandler;
public MemberCardServiceImpl(IMemberCardRepository memberCardRepository,
IMemberCardRecordRepository recordRepository,
IMemberCardTransactionsService transactionsService,
MemberCardStateMachine stateMachine,
DistributedLockService distributedLockService,
ExpirationReminderService expirationReminderService,
RefundSagaHandler refundSagaHandler) {
this.memberCardRepository = memberCardRepository;
this.recordRepository = recordRepository;
this.transactionsService = transactionsService;
this.stateMachine = stateMachine;
this.distributedLockService = distributedLockService;
this.expirationReminderService = expirationReminderService;
this.refundSagaHandler = refundSagaHandler;
}
@Override
public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId);
}
@Override
public Flux<MemberCard> findWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice, Pageable pageable) {
return memberCardRepository.findWithConditions(status, name, type, minPrice, maxPrice, pageable);
}
@Override
public Mono<Long> countWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice) {
return memberCardRepository.countWithConditions(status, name, type, minPrice, maxPrice);
}
@Override
public Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable) {
return memberCardRepository.findByMemberCardStatusAndDeletedAtIsNull(status, pageable);
}
@Override
public Mono<Boolean> existsPurchasedRecord(Long memberCardId) {
return memberCardRepository.existsPurchasedRecord(memberCardId);
}
@Override
public Mono<Integer> logicalDelete(Long memberCardId) {
return memberCardRepository.logicalDelete(memberCardId);
}
@Override
public Flux<MemberCard> findActiveCards(Integer status) {
return memberCardRepository.findActiveCards(status);
}
@Override
public Mono<MemberCard> save(MemberCard entity) {
return memberCardRepository.save(entity);
}
@Override
public Mono<MemberCardRecord> purchaseCard(Long memberId, Long memberCardId, Long sourceOrderId) {
return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
.flatMap(card -> {
if (card.getMemberCardStatus() != null && card.getMemberCardStatus() == 1) {
return Mono.error(new RuntimeException("该会员卡已禁用"));
}
MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
return distributedLockService.executeWithLock(
memberId.toString(),
cardType.name(),
Mono.defer(() -> createCardRecord(memberId, memberCardId, sourceOrderId, card))
);
})
.flatMap(record -> createTransaction(record, MemberCardTransactionsAction.PURCHASE, "购买会员卡")
.thenReturn(record))
.flatMap(record -> expirationReminderService.scheduleExpirationReminder(record)
.then(Mono.just(record)));
}
private Mono<MemberCardRecord> createCardRecord(Long memberId, Long memberCardId,
Long sourceOrderId, MemberCard card) {
return Mono.defer(() -> {
MemberCardRecord record = new MemberCardRecord();
record.setMemberId(memberId);
record.setMemberCardId(memberCardId);
record.setSourceOrderId(sourceOrderId);
record.setPurchaseTime(LocalDateTime.now());
record.setStatus(MemberCardRecordStatus.ACTIVE);
MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
LocalDateTime now = LocalDateTime.now();
switch (cardType) {
case TIME_CARD:
record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
record.setRemainingTimes(0);
record.setRemainingAmount(0.0);
break;
case COUNT_CARD:
record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
record.setRemainingTimes(card.getMemberCardTotalTimes());
record.setRemainingAmount(0.0);
break;
case STORED_VALUE_CARD:
record.setExpireTime(now.plusYears(1));
record.setRemainingTimes(0);
record.setRemainingAmount(card.getMemberCardAmount());
break;
default:
return Mono.error(new RuntimeException("不支持的会员卡类型"));
}
return recordRepository.insertActiveRecord(record);
});
}
@Override
public Mono<MemberCardRecord> renewCard(Long recordId, Integer addTimes, Double addAmount,
Integer addDays, Long sourceOrderId) {
return recordRepository.findById(recordId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
.flatMap(originalRecord -> stateMachine.validateTransition(originalRecord, MemberCardEvent.RENEW)
.then(Mono.just(originalRecord)))
.flatMap(originalRecord -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(originalRecord.getMemberCardId())
.switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
.flatMap(card -> {
MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
return distributedLockService.executeWithLock(
originalRecord.getMemberId().toString(),
cardType.name(),
Mono.defer(() -> doRenewCard(originalRecord, card, addTimes, addAmount, addDays))
);
}));
}
private Mono<MemberCardRecord> doRenewCard(MemberCardRecord record, MemberCard card,
Integer addTimes, Double addAmount, Integer addDays) {
LocalDateTime now = LocalDateTime.now();
MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
switch (cardType) {
case TIME_CARD:
LocalDateTime currentExpire = record.getExpireTime();
LocalDateTime baseTime = (currentExpire != null && currentExpire.isAfter(now)) ? currentExpire : now;
int daysToAdd = addDays != null ? addDays : card.getMemberCardValidityDays();
record.setExpireTime(baseTime.plusDays(daysToAdd));
break;
case COUNT_CARD:
int currentTimes = record.getRemainingTimes() != null ? record.getRemainingTimes() : 0;
int timesToAdd = addTimes != null ? addTimes : card.getMemberCardTotalTimes();
record.setRemainingTimes(currentTimes + timesToAdd);
if (record.getStatus() == MemberCardRecordStatus.USED_UP) {
record.setStatus(MemberCardRecordStatus.ACTIVE);
}
break;
case STORED_VALUE_CARD:
double currentAmount = record.getRemainingAmount() != null ? record.getRemainingAmount() : 0.0;
double amountToAdd = addAmount != null ? addAmount : card.getMemberCardAmount();
record.setRemainingAmount(currentAmount + amountToAdd);
if (record.getStatus() == MemberCardRecordStatus.USED_UP) {
record.setStatus(MemberCardRecordStatus.ACTIVE);
}
break;
default:
return Mono.error(new RuntimeException("不支持的会员卡类型"));
}
return recordRepository.save(record)
.flatMap(updatedRecord -> createTransaction(updatedRecord, MemberCardTransactionsAction.RENEW, "续费会员卡")
.then(expirationReminderService.scheduleExpirationReminder(updatedRecord))
.thenReturn(updatedRecord));
}
@Override
public Mono<MemberCardRecord> useCard(Long recordId, Integer deductTimes, Double deductAmount) {
return recordRepository.findById(recordId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
.flatMap(record -> stateMachine.validateTransition(record, MemberCardEvent.USE)
.then(Mono.just(record)))
.flatMap(record -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
.switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
.flatMap(card -> {
MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
return distributedLockService.executeWithLock(
record.getMemberId().toString(),
cardType.name(),
Mono.defer(() -> doUseCard(record, card, deductTimes, deductAmount))
);
}));
}
private Mono<MemberCardRecord> doUseCard(MemberCardRecord record, MemberCard card,
Integer deductTimes, Double deductAmount) {
if (record.getStatus() != MemberCardRecordStatus.ACTIVE) {
return Mono.error(new RuntimeException("会员卡状态不正确"));
}
MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
LocalDateTime now = LocalDateTime.now();
switch (cardType) {
case TIME_CARD:
if (record.getExpireTime() != null && record.getExpireTime().isBefore(now)) {
return Mono.error(new RuntimeException("会员卡已过期"));
}
break;
case COUNT_CARD:
int currentTimes = record.getRemainingTimes() != null ? record.getRemainingTimes() : 0;
int timesToDeduct = deductTimes != null ? deductTimes : 1;
if (currentTimes < timesToDeduct) {
return Mono.error(new RuntimeException("剩余次数不足"));
}
record.setRemainingTimes(currentTimes - timesToDeduct);
if (record.getRemainingTimes() == 0) {
record.setStatus(MemberCardRecordStatus.USED_UP);
}
break;
case STORED_VALUE_CARD:
double currentAmount = record.getRemainingAmount() != null ? record.getRemainingAmount() : 0.0;
double amountToDeduct = deductAmount != null ? deductAmount : 0.0;
if (currentAmount < amountToDeduct) {
return Mono.error(new RuntimeException("余额不足"));
}
record.setRemainingAmount(currentAmount - amountToDeduct);
if (record.getRemainingAmount() == 0) {
record.setStatus(MemberCardRecordStatus.USED_UP);
}
break;
default:
return Mono.error(new RuntimeException("不支持的会员卡类型"));
}
return recordRepository.save(record)
.flatMap(updatedRecord -> createTransaction(updatedRecord, MemberCardTransactionsAction.DEDUCT, "使用会员卡")
.thenReturn(updatedRecord));
}
@Override
public Mono<Void> refundCard(Long recordId) {
return recordRepository.findById(recordId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
.flatMap(record -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
.switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
.flatMap(card -> {
MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
return distributedLockService.executeWithLock(
record.getMemberId().toString(),
cardType.name(),
refundSagaHandler.executeRefund(recordId)
);
}));
}
@Override
public Mono<Integer> processExpiredCards() {
return recordRepository.findExpiredCards()
.flatMap(record -> stateMachine.transition(record.getStatus(), MemberCardEvent.EXPIRE)
.flatMap(newState -> recordRepository.updateStatus(
record.getMemberCardRecordId(), newState)))
.reduce(0, Integer::sum)
.doOnSuccess(count -> log.info("处理过期会员卡完成,共处理{}条", count));
}
private Mono<Void> createTransaction(MemberCardRecord record, MemberCardTransactionsAction action, String remark) {
MemberCardTransactions transaction = new MemberCardTransactions();
transaction.setMemberId(record.getMemberId());
transaction.setMemberCardId(record.getMemberCardId());
transaction.setOperationType(action);
transaction.setChangeAmount(record.getRemainingTimes());
transaction.setChangeBalance(record.getRemainingAmount());
transaction.setAfterRemainingCount(record.getRemainingTimes());
transaction.setAfterRemainingBalance(record.getRemainingAmount());
transaction.setRemark(remark);
return transactionsService.createTransaction(transaction);
}
}
@@ -1,89 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.sevice.impl;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardTransactionsRepository;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardTransactionsService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Slf4j
@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);
}
@Override
public Mono<Void> createTransaction(MemberCardTransactions transaction) {
return memberCardTransactionsRepository.save(transaction)
.then()
.doOnSuccess(v -> log.info("创建会员卡交易记录: memberId={}, cardId={}, type={}",
transaction.getMemberId(), transaction.getMemberCardId(), transaction.getOperationType()));
}
@Override
public Flux<MemberCardTransactions> findByMemberId(Long memberId) {
return memberCardTransactionsRepository.findByMemberId(memberId);
}
@Override
public Flux<MemberCardTransactions> findByRecordId(Long recordId) {
return memberCardTransactionsRepository.findByRecordId(recordId);
}
}
@@ -1,85 +0,0 @@
package cn.novalon.gym.manage.gymmembercard.sevice.impl;
import cn.novalon.gym.manage.gymmembercard.domain.RefundApplication;
import cn.novalon.gym.manage.gymmembercard.repository.IRefundApplicationRepository;
import cn.novalon.gym.manage.gymmembercard.sevice.IRefundApplicationService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
/**
* 退款申请服务实现类
*
* @author shizhounian
* @date 2026-05-23 21:18:33
*/
@Slf4j
@Service
public class RefundApplicationServiceImpl implements IRefundApplicationService {
private final IRefundApplicationRepository refundApplicationRepository;
public RefundApplicationServiceImpl(IRefundApplicationRepository refundApplicationRepository) {
this.refundApplicationRepository = refundApplicationRepository;
}
@Override
public Mono<RefundApplication> create(Long recordId, String reason) {
return refundApplicationRepository.findByRecordId(recordId)
.flatMap(existing -> {
if (existing != null) {
return Mono.error(new RuntimeException("该会员卡记录已有退款申请"));
}
return Mono.empty();
})
.then(Mono.defer(() -> {
RefundApplication application = new RefundApplication();
application.setRecordId(recordId);
application.setReason(reason);
application.setStatus("PENDING");
application.setApplyTime(LocalDateTime.now());
return refundApplicationRepository.create(application)
.doOnSuccess(app -> log.info("创建退款申请成功: applicationId={}, recordId={}",
app.getId(), recordId));
}));
}
@Override
public Mono<RefundApplication> approve(Long applicationId, Long auditorId, String remark) {
return refundApplicationRepository.findById(applicationId)
.switchIfEmpty(Mono.error(new RuntimeException("退款申请不存在")))
.flatMap(application -> {
if (!"PENDING".equals(application.getStatus())) {
return Mono.error(new RuntimeException("退款申请状态不正确,当前状态: " + application.getStatus()));
}
return refundApplicationRepository.approve(applicationId, "APPROVED", auditorId, remark)
.doOnSuccess(app -> log.info("批准退款申请成功: applicationId={}, auditorId={}",
applicationId, auditorId));
});
}
@Override
public Mono<RefundApplication> reject(Long applicationId, Long auditorId, String remark) {
return refundApplicationRepository.findById(applicationId)
.switchIfEmpty(Mono.error(new RuntimeException("退款申请不存在")))
.flatMap(application -> {
if (!"PENDING".equals(application.getStatus())) {
return Mono.error(new RuntimeException("退款申请状态不正确,当前状态: " + application.getStatus()));
}
return refundApplicationRepository.approve(applicationId, "REJECTED", auditorId, remark)
.doOnSuccess(app -> log.info("拒绝退款申请成功: applicationId={}, auditorId={}",
applicationId, auditorId));
});
}
@Override
public Mono<RefundApplication> findByRecordId(Long recordId) {
return refundApplicationRepository.findByRecordId(recordId);
}
}
@@ -1,49 +0,0 @@
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;
}
}
@@ -1,132 +0,0 @@
-- ============================================
-- 会员卡类型表
-- ============================================
CREATE TABLE IF NOT EXISTS member_card (
member_card_id BIGSERIAL PRIMARY KEY,
member_card_name VARCHAR(100) NOT NULL,
member_card_type VARCHAR(20) NOT NULL,
member_card_price DECIMAL(10, 2) NOT NULL,
member_card_validity_days INTEGER,
member_card_total_times INTEGER,
member_card_amount DECIMAL(10, 2),
member_card_status INTEGER DEFAULT 1 NOT NULL,
extra_config JSONB DEFAULT '{}'::jsonb,
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW(),
deleted_at TIMESTAMPTZ
);
COMMENT ON TABLE member_card IS '会员卡类型表';
COMMENT ON COLUMN member_card.member_card_id IS '会员卡ID';
COMMENT ON COLUMN member_card.member_card_name IS '会员卡名称';
COMMENT ON COLUMN member_card.member_card_type IS '会员卡类型:TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡';
COMMENT ON COLUMN member_card.member_card_price IS '会员卡价格';
COMMENT ON COLUMN member_card.member_card_validity_days IS '有效天数(时长卡用)';
COMMENT ON COLUMN member_card.member_card_total_times IS '总次数(次卡用)';
COMMENT ON COLUMN member_card.member_card_amount IS '面额(储值卡用)';
COMMENT ON COLUMN member_card.member_card_status IS '状态:0-下架, 1-上架';
COMMENT ON COLUMN member_card.extra_config IS '扩展配置(JSON格式,用于未来组合卡等)';
-- ============================================
-- 会员卡记录表(会员持有的卡)
-- ============================================
CREATE TABLE IF NOT EXISTS member_card_record (
member_card_record_id BIGSERIAL PRIMARY KEY,
member_id BIGINT NOT NULL,
member_card_id BIGINT NOT NULL,
status VARCHAR(20) NOT NULL DEFAULT 'ACTIVE',
remaining_times INTEGER DEFAULT 0,
remaining_amount DECIMAL(10, 2) DEFAULT 0.00,
expire_time TIMESTAMPTZ,
source_order_id BIGINT,
purchase_time TIMESTAMPTZ DEFAULT NOW(),
version INTEGER DEFAULT 0 NOT NULL,
card_composition JSONB DEFAULT NULL,
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW(),
deleted_at TIMESTAMPTZ
-- 移除外键约束,改用应用层验证
);
-- 索引优化
CREATE INDEX idx_member_card_record_member_id ON member_card_record(member_id);
CREATE INDEX idx_member_card_record_status ON member_card_record(status);
CREATE INDEX idx_member_card_record_expire_time ON member_card_record(expire_time);
CREATE INDEX idx_member_card_record_member_status ON member_card_record(member_id, status);
CREATE INDEX idx_member_card_record_status_expire ON member_card_record(status, expire_time)
WHERE status = 'ACTIVE';
COMMENT ON TABLE member_card_record IS '会员卡记录表';
COMMENT ON COLUMN member_card_record.member_card_record_id IS '会员卡记录ID';
COMMENT ON COLUMN member_card_record.member_id IS '会员ID';
COMMENT ON COLUMN member_card_record.member_card_id IS '会员卡类型ID';
COMMENT ON COLUMN member_card_record.status IS '状态:ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款';
COMMENT ON COLUMN member_card_record.remaining_times IS '剩余次数';
COMMENT ON COLUMN member_card_record.remaining_amount IS '剩余金额';
COMMENT ON COLUMN member_card_record.expire_time IS '到期时间';
COMMENT ON COLUMN member_card_record.source_order_id IS '来源订单ID';
COMMENT ON COLUMN member_card_record.purchase_time IS '购买时间';
COMMENT ON COLUMN member_card_record.version IS '乐观锁版本号';
COMMENT ON COLUMN member_card_record.card_composition IS '卡片组成(JSON格式,用于组合卡)';
-- ============================================
-- 会员卡交易流水表
-- ============================================
CREATE TABLE IF NOT EXISTS member_card_transactions (
id BIGSERIAL PRIMARY KEY,
member_card_record_id BIGINT NOT NULL,
member_id BIGINT NOT NULL,
member_card_id BIGINT NOT NULL,
operation_type VARCHAR(20) NOT NULL,
change_amount INTEGER DEFAULT 0,
change_balance DECIMAL(10, 2) DEFAULT 0.00,
after_remaining_count INTEGER DEFAULT 0,
after_remaining_balance DECIMAL(10, 2) DEFAULT 0.00,
related_biz_type VARCHAR(20),
source_order_id BIGINT,
remark VARCHAR(500),
is_archived BOOLEAN DEFAULT FALSE NOT NULL,
archived_at TIMESTAMPTZ,
created_at TIMESTAMPTZ DEFAULT NOW()
-- 移除外键约束,改用应用层验证
);
-- 退款申请表
CREATE TABLE IF NOT EXISTS refund_application (
id BIGSERIAL PRIMARY KEY,
record_id BIGINT NOT NULL,
member_id BIGINT NOT NULL,
status VARCHAR(20) NOT NULL DEFAULT 'PENDING', -- PENDING/APPROVED/REJECTED/PROCESSING/SUCCESS/FAILED
reason VARCHAR(500),
apply_time TIMESTAMPTZ DEFAULT NOW(),
audit_time TIMESTAMPTZ,
auditor_id BIGINT,
audit_remark VARCHAR(500),
refund_amount DECIMAL(10, 2),
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE INDEX idx_refund_application_record_id ON refund_application(record_id);
CREATE INDEX idx_refund_application_status ON refund_application(status);
COMMENT ON TABLE refund_application IS '退款申请表';
COMMENT ON COLUMN refund_application.status IS '状态:PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败';
-- 索引优化
CREATE INDEX idx_member_card_transactions_member_id ON member_card_transactions(member_id);
CREATE INDEX idx_member_card_transactions_record_id ON member_card_transactions(member_card_record_id);
CREATE INDEX idx_member_card_transactions_created_at ON member_card_transactions(created_at);
CREATE INDEX idx_member_card_transactions_member_type_time
ON member_card_transactions(member_id, operation_type, created_at);
COMMENT ON TABLE member_card_transactions IS '会员卡交易流水表';
COMMENT ON COLUMN member_card_transactions.operation_type IS '操作类型:PURCHASE-购买, DEDUCT-扣次/扣费, RENEW-续费, REFUND-退款, EXPIRE-过期';
COMMENT ON COLUMN member_card_transactions.change_amount IS '变动次数';
COMMENT ON COLUMN member_card_transactions.change_balance IS '变动金额';
COMMENT ON COLUMN member_card_transactions.after_remaining_count IS '变动后剩余次数';
COMMENT ON COLUMN member_card_transactions.after_remaining_balance IS '变动后剩余金额';
COMMENT ON COLUMN member_card_transactions.related_biz_type IS '关联业务类型:GROUP_CLASS-团课, PT_CLASS-私教, CHECK_IN-签到';
COMMENT ON COLUMN member_card_transactions.is_archived IS '是否已归档';
COMMENT ON COLUMN member_card_transactions.archived_at IS '归档时间';
+47
View File
@@ -0,0 +1,47 @@
target/
!.mvn/wrapper/maven-wrapper.jar
!**/src/main/**/target/
!**/src/test/**/target/
### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
build/
!**/src/main/**/build/
!**/src/test/**/build/
### VS Code ###
.vscode/
### Maven ###
pom.xml.tag
pom.xml.releaseBackup
pom.xml.versionsBackup
pom.xml.next
release.properties
dependency-reduced-pom.xml
buildNumber.properties
.mvn/timing.properties
.mvn/wrapper/maven-wrapper.jar
### System Files ###
.DS_Store
Thumbs.db
@@ -0,0 +1,58 @@
-- ============================================
-- member_user 表 - 简洁版建表语句
-- ============================================
-- 用途:直接复制执行,快速创建会员表
-- ============================================
CREATE TABLE IF NOT EXISTS member_user (
-- 主键和基础字段
id BIGSERIAL PRIMARY KEY,
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-- 会员核心字段
member_no VARCHAR(50) NOT NULL UNIQUE,
nickname VARCHAR(100),
phone VARCHAR(255),
gender INTEGER DEFAULT 0,
birthday TIMESTAMP,
address VARCHAR(500),
avatar VARCHAR(500),
subscribed BOOLEAN DEFAULT FALSE,
last_login_at TIMESTAMP,
-- 微信相关字段
union_id VARCHAR(100),
miniapp_open_id VARCHAR(100),
official_open_id VARCHAR(100),
-- 软删除字段
is_deleted BOOLEAN DEFAULT FALSE
);
-- 创建索引
CREATE UNIQUE INDEX IF NOT EXISTS idx_member_user_member_no ON member_user(member_no);
CREATE INDEX IF NOT EXISTS idx_member_user_union_id ON member_user(union_id);
CREATE INDEX IF NOT EXISTS idx_member_user_miniapp_openid ON member_user(miniapp_open_id);
CREATE INDEX IF NOT EXISTS idx_member_user_official_openid ON member_user(official_open_id);
CREATE INDEX IF NOT EXISTS idx_member_user_phone ON member_user(phone);
CREATE INDEX IF NOT EXISTS idx_member_user_is_deleted ON member_user(is_deleted);
-- 添加注释
COMMENT ON TABLE member_user IS '会员表';
COMMENT ON COLUMN member_user.id IS '主键ID';
COMMENT ON COLUMN member_user.created_at IS '创建时间';
COMMENT ON COLUMN member_user.updated_at IS '更新时间';
COMMENT ON COLUMN member_user.member_no IS '会员编号(唯一)';
COMMENT ON COLUMN member_user.nickname IS '昵称';
COMMENT ON COLUMN member_user.phone IS '手机号(AES加密存储)';
COMMENT ON COLUMN member_user.gender IS '性别:0-未知,1-男,2-女';
COMMENT ON COLUMN member_user.birthday IS '生日';
COMMENT ON COLUMN member_user.address IS '地址';
COMMENT ON COLUMN member_user.avatar IS '头像URL';
COMMENT ON COLUMN member_user.subscribed IS '是否关注服务号';
COMMENT ON COLUMN member_user.last_login_at IS '最后登录时间';
COMMENT ON COLUMN member_user.union_id IS '微信UnionID(跨应用唯一标识)';
COMMENT ON COLUMN member_user.miniapp_open_id IS '小程序OpenID';
COMMENT ON COLUMN member_user.official_open_id IS '服务号OpenID';
COMMENT ON COLUMN member_user.is_deleted IS '是否删除(软删除标记)';
+245
View File
@@ -0,0 +1,245 @@
<?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>
@@ -0,0 +1,22 @@
package cn.novalon.gym.manage.member.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;
/**
* HTTP 客户端配置
*
* @author 付嘉
* @date 2026-05-01
*/
@Configuration
public class HttpClientConfig {
// WebClient Bean,用于调用微信 API
@Bean
public WebClient webClient() {
return WebClient.builder().build();
}
}
@@ -0,0 +1,63 @@
package cn.novalon.gym.manage.member.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* 微信配置
*
* @author 付嘉
* @date 2026-05-01
*/
@Data
@Component
@ConfigurationProperties(prefix = "wechat")
public class WechatProperties {
// 小程序配置
private MiniApp miniapp = new MiniApp();
// 服务号配置
private Mp mp = new Mp();
// 手机号加密配置
private PhoneEncryption phoneEncryption = new PhoneEncryption();
@Data
public static class MiniApp {
// 小程序 AppID
private String appId;
// 小程序 AppSecret
private String appSecret;
}
@Data
public static class Mp {
// 服务号 AppID
private String appId;
// 服务号 AppSecret
private String appSecret;
// Token 验证信息
private String token;
// EncodingAESKey
private String aesKey;
// 回调地址(微信服务号事件推送 URL)
private String callbackUrl;
}
@Data
public static class PhoneEncryption {
// 手机号加密密钥
private String secretKey;
// 初始化向量 IV
private String iv;
}
}
@@ -0,0 +1,17 @@
package cn.novalon.gym.manage.member.dto;
import lombok.Data;
/**
* 更新手机号Dto
*
* @author 付嘉
* @date 2026-05-01
*/
@Data
public class AdminUpdatePhoneDto {
// 手机号
private String phone;
}
@@ -0,0 +1,23 @@
package cn.novalon.gym.manage.member.dto;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SearchMemberDto {
// 搜索字段 - 包括 会员号、昵称、手机号
private String searchValue;
// 排序
private String filter;
// 页码
private Integer pageNum = 1;
// 页大小
private Integer pageSize = 10;
}
@@ -0,0 +1,30 @@
package cn.novalon.gym.manage.member.dto;
import lombok.Data;
import java.util.Date;
/**
* 更新会员信息Dto
*
* @author 付嘉
* @date 2026-05-10
*/
@Data
public class UpdateMemberInfoDto {
// 昵称
private String nickname;
// 性别
private Integer gender;
// 生日
private Date birthday;
// 头像
private String avatar;
// 地址
private String address;
}
@@ -0,0 +1,29 @@
package cn.novalon.gym.manage.member.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.validation.constraints.NotBlank;
/**
* 微信小程序登录 DTO
*
* @author 付嘉
* @date 2026-05-01
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class WechatLoginDto {
// 微信小程序登录 code
@NotBlank(message = "登录code不能为空")
private String code;
// 手机号code
private String phoneCode;
}
@@ -0,0 +1,35 @@
package cn.novalon.gym.manage.member.dto;
import lombok.Data;
/**
* 微信服务号事件 DTO
*
* @author 付嘉
* @date 2026-05-01
*/
@Data
public class WechatOfficialEventDto {
// 微信号
private String toUserName;
// 发送方帐号(一个 OpenID
private String fromUserName;
// 消息创建时间(整型)
private Long createTime;
// 消息类型,event
private String msgType;
// 事件类型:subscribe(关注)/ unsubscribe(取消关注)
private String event;
// 事件 KEY
private String eventKey;
// 二维码 ticket(获取二维码图片)
private String ticket;
}
@@ -0,0 +1,41 @@
package cn.novalon.gym.manage.member.entity;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.domain.Persistable;
import org.springframework.data.relational.core.mapping.Column;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 会员模块实体基类
*
* @author 付嘉
* @date 2026-05-08
*/
@Data
public abstract class BaseEntity implements Persistable<Long> {
// ID
@Id
private Long id;
// 创建时间
@CreatedDate
@Column("created_at")
private LocalDateTime createdAt;
// 更新时间
@LastModifiedDate
@Column("updated_at")
private LocalDateTime updatedAt;
// 判断当前实体是否是新建的
@Override
public boolean isNew() {
return createdAt == null;
}
}
@@ -0,0 +1,81 @@
package cn.novalon.gym.manage.member.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;
import java.time.LocalDateTime;
import java.util.Date;
/**
* 会员实体类 - 对应 member_user 表
*
* @author 付嘉
* @date 2026-05-01
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("member_user")
public class Member extends BaseEntity {
//会员号
@Column("member_no")
private String memberNo;
//昵称
@Column("nickname")
private String nickname;
//手机号(AES 加密存储
@Column("phone")
private String phone;
//性别
@Column("gender")
private Integer gender;
//生日
@Column("birthday")
private Date birthday;
//地址
@Column("address")
private String address;
//是否关注服务号
@Column("subscribed")
private Boolean subscribed;
// 最后登录时间
@Column("last_login_at")
private LocalDateTime lastLoginAt;
// 头像
@Column("avatar")
private String avatar;
// 微信UnionID
@Column("union_id")
private String unionId;
// 微信OpenID小程序
@Column("miniapp_open_id")
private String miniappOpenId;
// 服务号openid
@Column("official_open_id")
private String officialOpenId;
// 软删除
@Column("is_deleted")
private Boolean isDeleted;
}
@@ -0,0 +1,38 @@
package cn.novalon.gym.manage.member.entity;
import lombok.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;
import java.time.LocalDate;
import java.time.LocalDateTime;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Table("sign_in_record")
public class SignInRecord {
@Id
private Long id;
// 会员ID
@Column("member_id")
private Long memberId;
// 签到日期
@Column("sign_in_date")
private LocalDate signInDate;
// 签到时间
@Column("sign_in_time")
private LocalDateTime signInTime;
// 创建时间
@CreatedDate
@Column("created_at")
private LocalDateTime createdAt;
}
@@ -0,0 +1,55 @@
package cn.novalon.gym.manage.member.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;
import java.time.LocalDateTime;
/**
* 微信用户信息
*
* @author 付嘉
* @date 2026-05-01
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("wechat_user")
public class WechatUser extends BaseEntity {
// 会员 ID
@Column("member_id")
private Long memberId;
// 微信 UnionID
@Column("union_id")
private String unionId;
// 小程序 OpenID
@Column("miniapp_openid")
private String miniappOpenid;
// 服务号 OpenID
@Column("mp_openid")
private String mpOpenid;
// 是否关注服务号
@Column("is_subscribed")
private Boolean isSubscribed;
// 首次关注时间公众号的时间
@Column("subscribe_time")
private LocalDateTime subscribeTime;
// 最后一次取消关注的时间
@Column("unsubscribe_time")
private LocalDateTime unsubscribeTime;
}
@@ -0,0 +1,35 @@
package cn.novalon.gym.manage.member.es.entity;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
@Data
@Document(indexName = "gym_members")
public class MemberES {
@Id
private String id;
// 会员号 - 需要搜索(精确匹配)
@Field(type = FieldType.Keyword)
private String memberNo;
// 昵称 - 需要搜索(模糊搜索)
@Field(type = FieldType.Text)
private String nickname;
// 手机号 - 需要搜索(精确匹配)
@Field(type = FieldType.Keyword)
private String phone;
// 性别 - 用于筛选
@Field(type = FieldType.Integer)
private Integer gender;
// 头像 - 列表展示
@Field(type = FieldType.Keyword)
private String avatar;
}
@@ -0,0 +1,20 @@
package cn.novalon.gym.manage.member.es.repository;
import cn.novalon.gym.manage.member.es.entity.MemberES;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.repository.ReactiveElasticsearchRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
/**
* ES 会员数据访问层
*/
@Repository
public interface MemberESRepository extends ReactiveElasticsearchRepository<MemberES, String> {
/**
* 前台通用搜索:会员号(精确匹配) 或 昵称(模糊匹配) 或 手机号(精确匹配)并且 性别筛选(精确匹配)
*/
Flux<MemberES> findByMemberNoOrPhoneOrNicknameContainingAndGender(
String memberNo, String phone, String nickname,String gender, Pageable pageable);
}
@@ -0,0 +1,281 @@
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.member.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: X-Member-Id: 123
*/
public Mono<ServerResponse> getMemberInfo(ServerRequest request) {
Long memberId = authUtil.getMemberIdOrThrow(request);
log.info("获取会员信息, memberId: {}", memberId);
return memberService.getMemberInfo(memberId)
.flatMap(info -> {
return ServerResponse.ok()
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(info);
});
}
/**
* 更新会员信息
*
* PUT /api/member/info
* Header: X-Member-Id: 123
* 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));
}
/**
* 绑定手机号(微信小程序)
*
* POST /api/member/phone/bind?code=PHONE_CODE
* Header: X-Member-Id: 123
*/
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
* Header: X-Member-Id: 123
*
*/
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
* 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格式错误");
// 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格式错误");
// 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);
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);
return memberService.findAll(pageNum, pageSize)
.map(member -> {
// 解密手机号
if (member.getPhone() != null && !member.getPhone().isEmpty()) {
try {
String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
String iv = wechatProperties.getPhoneEncryption().getIv();
String decryptedPhone = AesUtil.decrypt(member.getPhone(), secretKey, iv);
member.setPhone(decryptedPhone);
} catch (Exception e) {
log.error("手机号解密失败, memberId: {}", member.getId(), e);
member.setPhone(null);
}
}
return member;
})
.collectList()
.flatMap(list -> ServerResponse.ok().bodyValue(list));
}
}
@@ -0,0 +1,68 @@
package cn.novalon.gym.manage.member.handler;
import cn.novalon.gym.manage.member.dto.WechatLoginDto;
import cn.novalon.gym.manage.member.service.WechatAuthService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;
/**
* 微信认证
*
* @author 付嘉
* @date 2026-05-01
*/
@Slf4j
@Component
@RequiredArgsConstructor
public class WechatAuthHandler {
private final WechatAuthService wechatAuthService;
private final WechatOfficialEventHandler wechatOfficialEventHandler;
/**
* 小程序更新
*
* POST /api/member/auth/miniapp/login
* Body: {"code": "wx_login_code"}
*
* @param request ServerRequest
* @return Mono<ServerResponse> 登录响应
*/
public Mono<ServerResponse> miniappLogin(ServerRequest request) {
log.info("收到小程序登录请求");
return request.bodyToMono(WechatLoginDto.class)
.flatMap(loginRequest -> {
log.info("开始微信AuthService, code: {}", loginRequest.getCode());
return wechatAuthService.miniappLogin(loginRequest);
})
.flatMap(response -> {
log.info("更新成功, memberId: {}", response.getMemberId());
return ServerResponse.ok()
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(response);
});
}
/**
* 公众号回调
*
* POST /api/member/auth/mp/callback
* Body: <xml><Event>subscribe</Event><FromUserName>openid</FromUserName></xml>
*
*/
public Mono<ServerResponse> mpCallback(ServerRequest request) {
return wechatOfficialEventHandler.handleEvent(request);
}
// 验证微信公众号签名
public Mono<ServerResponse> verifyMpSignature(ServerRequest request) {
return wechatOfficialEventHandler.verifySignature(request);
}
}
@@ -0,0 +1,218 @@
package cn.novalon.gym.manage.member.handler;
import cn.novalon.gym.manage.member.config.WechatProperties;
import cn.novalon.gym.manage.member.service.WechatOfficialService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Arrays;
/**
* 微信公众号事件处理器
*
* @author 付嘉
* @date 2026-05-01
*/
@Slf4j
@Component
@RequiredArgsConstructor
public class WechatOfficialEventHandler {
private final WechatOfficialService wechatOfficialService;
private final WechatProperties wechatProperties;
/**
* 处理微信公众号事件
*
* 请求格式:XML
* 响应格式:success 或 回复消息内容
*/
public Mono<ServerResponse> handleEvent(ServerRequest request) {
return request.bodyToMono(String.class)
.flatMap(xmlBody -> {
log.info("收到微信公众号事件 {}", xmlBody);
// TODO: 将XML解析为WechatOfficialEventDto
// 目前简化处理直接获取openId和event
String openId = extractOpenId(xmlBody);
String event = extractEvent(xmlBody);
if (openId == null || event == null) {
log.error("无法解析微信公众号事件");
return ServerResponse.badRequest().bodyValue("error");
}
log.info("处理事件 openId={}, event={}", openId, event);
// 根据事件类型处理
if ("subscribe".equals(event)) {
return wechatOfficialService.handleSubscribeEvent(openId)
.then(ServerResponse.ok()
.contentType(MediaType.TEXT_PLAIN)
.bodyValue("success"));
} else if ("unsubscribe".equals(event)) {
return wechatOfficialService.handleUnsubscribeEvent(openId)
.then(ServerResponse.ok()
.contentType(MediaType.TEXT_PLAIN)
.bodyValue("success"));
} else {
log.warn("未知事件类型: {}", event);
return ServerResponse.ok()
.contentType(MediaType.TEXT_PLAIN)
.bodyValue("success");
}
})
.onErrorResume(e -> {
log.error("处理微信公众号事件失败", e);
return ServerResponse.ok()
.contentType(MediaType.TEXT_PLAIN)
.bodyValue("success"); // 即使处理失败也返回success避免微信重试
});
}
/**
* 验证微信公众号签名
*
* GET请求用于验证服务器地址
*/
public Mono<ServerResponse> verifySignature(ServerRequest request) {
String signature = request.queryParam("signature").orElse("");
String timestamp = request.queryParam("timestamp").orElse("");
String nonce = request.queryParam("nonce").orElse("");
String echostr = request.queryParam("echostr").orElse("");
log.info("========== 微信公众号签名验证 ==========");
log.info("收到的参数:");
log.info(" signature: {}", signature);
log.info(" timestamp: {}", timestamp);
log.info(" nonce: {}", nonce);
log.info(" echostr: {}", echostr);
// 获取配置的Token
String token = wechatProperties.getMp().getToken();
log.info("配置的Token: {}", token);
// 验证签名
if (checkSignature(signature, timestamp, nonce, token)) {
log.info("签名验证成功,返回echostr: {}", echostr);
log.info("========== 微信公众号签名验证结束 ==========");
return ServerResponse.ok()
.contentType(MediaType.TEXT_PLAIN)
.bodyValue(echostr);
} else {
log.warn("签名验证失败");
log.info("========== 微信公众号签名验证结束 ==========");
return ServerResponse.badRequest()
.contentType(MediaType.TEXT_PLAIN)
.bodyValue("error");
}
}
/**
* 验证签名
*
* @param signature 微信加密签名
* @param timestamp 时间戳
* @param nonce 随机数
* @param token Token
* @return 是否验证通过
*/
private boolean checkSignature(String signature, String timestamp, String nonce, String token) {
// 1. 将token、timestamp、nonce三个参数进行字典序排序
String[] arr = new String[]{token, timestamp, nonce};
Arrays.sort(arr);
// 2. 将三个参数字符串拼接成一个字符串
StringBuilder sb = new StringBuilder();
for (String str : arr) {
sb.append(str);
}
// 3. 将拼接后的字符串进行sha1加密
String encrypted = sha1(sb.toString());
log.debug("计算的签名 {}", encrypted);
// 4. 将加密后的字符串与signature对比
return encrypted != null && encrypted.equalsIgnoreCase(signature);
}
/**
* SHA1加密
*
* @param str 待加密字符串
* @return 加密后字符串
*/
private String sha1(String str) {
try {
MessageDigest md = MessageDigest.getInstance("SHA-1");
byte[] digest = md.digest(str.getBytes(StandardCharsets.UTF_8));
StringBuilder hexString = new StringBuilder();
for (byte b : digest) {
String hex = Integer.toHexString(0xff & b);
if (hex.length() == 1) {
hexString.append('0');
}
hexString.append(hex);
}
return hexString.toString();
} catch (Exception e) {
log.error("SHA1加密失败", e);
return null;
}
}
/**
* 从XML中提取OpenID
*/
private String extractOpenId(String xml) {
int start = xml.indexOf("<FromUserName>");
int end = xml.indexOf("</FromUserName>");
if (start != -1 && end != -1) {
String value = xml.substring(start + 14, end);
// 去除 CDATA 标记
return cleanCdata(value);
}
return null;
}
/**
* 从XML中获取事件类型
*/
private String extractEvent(String xml) {
int start = xml.indexOf("<Event>");
int end = xml.indexOf("</Event>");
if (start != -1 && end != -1) {
String value = xml.substring(start + 7, end);
// 去除 CDATA 标记
return cleanCdata(value);
}
return null;
}
/**
* 清理 CDATA 标记
* 例如: <![CDATA[subscribe]]> -> subscribe
*/
private String cleanCdata(String value) {
if (value == null) {
return null;
}
// 去除前后空白
value = value.trim();
// 提取 CDATA 中间内容
// 格式: <![CDATA[xxx]]>
if (value.startsWith("<![CDATA[") && value.endsWith("]]>")) {
return value.substring(9, value.length() - 3);
}
return value;
}
}
@@ -0,0 +1,36 @@
package cn.novalon.gym.manage.member.repository;
import cn.novalon.gym.manage.member.entity.Member;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/**
* 会员Repository
* @author 付嘉
* @date 2026-05-01
*/
@Repository
public interface IMemberRepository extends R2dbcRepository<Member, Long> {
// UnionID查询会员
Mono<Member> findByUnionId(String unionId);
// 小程序OpenID查询会员
Mono<Member> findByMiniappOpenId(String miniappOpenId);
// 服务号OpenID查询会员
Mono<Member> findByOfficialOpenId(String officialOpenId);
// 手机号查询
Mono<Member> findByPhone(String phone);
/**
* 分页查询所有会员
* 方法名 findAllBy 是 Spring Data 的约定,表示按条件查询所有
*/
Flux<Member> findAllBy(Pageable pageable);
}
@@ -0,0 +1,29 @@
package cn.novalon.gym.manage.member.repository;
import cn.novalon.gym.manage.member.entity.WechatUser;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Mono;
/**
* 微信用户Repository
*
* @author 付嘉
* @date 2026-05-01
*/
@Repository
public interface WechatUserRepository extends R2dbcRepository<WechatUser, Long> {
// 通过UnionID查询微信用户
Mono<WechatUser> findByUnionId(String unionId);
// 通过小程序OpenID查询微信用户
Mono<WechatUser> findByMiniappOpenid(String miniappOpenid);
// 通过服务号OpenID查询微信用户
Mono<WechatUser> findByMpOpenid(String mpOpenid);
// 通过会员ID查询微信用户
Mono<WechatUser> findByMemberId(Long memberId);
}
@@ -0,0 +1,61 @@
package cn.novalon.gym.manage.member.service;
import cn.novalon.gym.manage.member.dto.SearchMemberDto;
import cn.novalon.gym.manage.member.dto.UpdateMemberInfoDto;
import cn.novalon.gym.manage.member.entity.Member;
import cn.novalon.gym.manage.member.es.entity.MemberES;
import cn.novalon.gym.manage.member.vo.MemberInfoVO;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/**
* 会员服务接口
*
* @author 付嘉
* @date 2026-05-01
*/
public interface MemberService {
/**
* 获取会员信息
*
* @param memberId 会员ID
* @return 会员信息
*/
Mono<MemberInfoVO> getMemberInfo(Long memberId);
/**
* 会员更新个人信息
*
* @param memberId 会员ID
* @param updateDto 更新信息DTO
* @return 更新后的会员信息
*/
Mono<MemberInfoVO> updateMemberInfo(Long memberId, UpdateMemberInfoDto updateDto);
/**
* 管理端更新会员手机号
*
* @param memberId 会员ID
* @param phone 明文手机号
* @return 是否成功
*/
Mono<Boolean> adminUpdatePhone(Long memberId, String phone);
/**
* 管理端查询会员(es查询)
*
* @param searchMemberDto 会员信息dto
* @return 会员信息
*/
Flux<MemberES> searchMember(SearchMemberDto searchMemberDto);
/**
* 管理端查询所有会员
*
* @param pageNum 页码
* @param pageSize 页大小
* @return 所有会员信息
*/
Flux<Member> findAll(Integer pageNum, Integer pageSize);
}
@@ -0,0 +1,48 @@
package cn.novalon.gym.manage.member.service;
import reactor.core.publisher.Mono;
import java.util.Map;
/**
* 微信API服务接口
*
* @author 付嘉
* @date 2026-05-01
*/
public interface WechatApiService {
/**
* 小程序- 通过code获取session_key/openid
*
* @param code 小程序登录的code
* @return Mono<Map<String, String>> session_keyopenidunionid
*/
Mono<Map<String, String>> jsCode2Session(String code);
/**
* 获取手机号- 通过code获取手机号
*
* @param code 小程序登录的code
* @return Mono<String> ܺ手机号
*/
Mono<String> getPhoneNumber(String code);
/**
* 获取Access Token
*
* @param appType 应用类型miniapp-小程序mp
* @return Mono<String> access_token
*/
Mono<String> getAccessToken(String appType);
/**
* 验证签名
*
* @param signature 微信签名
* @param timestamp 创建时间
* @param nonce 随机字符串
* @return boolean 签名是否有效
*/
boolean checkSignature(String signature, String timestamp, String nonce);
}
@@ -0,0 +1,31 @@
package cn.novalon.gym.manage.member.service;
import cn.novalon.gym.manage.member.dto.WechatLoginDto;
import cn.novalon.gym.manage.member.vo.WechatLoginVO;
import reactor.core.publisher.Mono;
/**
* 微信授权服务接口
*
* @author 付嘉
* @date 2026-05-01
*/
public interface WechatAuthService {
/**
* 小程序
*
* @param request 小程序登录请求
* @return 小程序登录响应
*/
Mono<WechatLoginVO> miniappLogin(WechatLoginDto request);
/**
* 手机号
*
* @param memberId 会员ID
* @param code 微信手机号code
* @return 是否绑定成功
*/
Mono<Boolean> bindPhone(Long memberId, String code);
}
@@ -0,0 +1,54 @@
package cn.novalon.gym.manage.member.service;
import cn.novalon.gym.manage.member.vo.WechatUserInfoVO;
import reactor.core.publisher.Mono;
/**
* 微信公众号服务接口
*
* @author 付嘉
* @date 2026-05-01
*/
public interface WechatOfficialService {
/**
* 处理订阅事件
*
* @param openId OpenID
* @return Mono<Void>
*/
Mono<Void> handleSubscribeEvent(String openId);
/**
* 处理取消订阅事件
*
* @param openId OpenID
* @return Mono<Void>
*/
Mono<Void> handleUnsubscribeEvent(String openId);
/**
* 获取微信用户信息
*
* @param openId OpenID
* @return Mono<WechatUserInfoVO> 用户信息
*/
Mono<WechatUserInfoVO> getUserInfo(String openId);
/**
* 通过 UnionID 关联小程序用户
*
* @param unionId 微信 UnionID
* @param officialOpenId OpenID
* @return Mono<Boolean> 是否关联成功
*/
Mono<Boolean> linkByUnionId(String unionId, String officialOpenId);
/**
* 查询会员订阅状态
*
* @param memberId 会员ID
* @return Mono<Boolean> true=已订阅false=未订阅
*/
Mono<Boolean> checkSubscribeStatus(Long memberId);
}
@@ -0,0 +1,213 @@
package cn.novalon.gym.manage.member.service.impl;
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.beans.factory.annotation.Value;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ResponseStatusException;
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);
}
@Value("${wechat.aes.secret-key:}")
private String aesSecretKey;
@Value("${wechat.aes.iv:}")
private String aesIv;
@Override
public Mono<MemberInfoVO> getMemberInfo(Long memberId) {
return memberRepository.findById(memberId)
.map(this::buildMemberInfoResponse);
}
@Override
public Mono<MemberInfoVO> updateMemberInfo(Long memberId, UpdateMemberInfoDto updateDto) {
log.info("会员更新个人信息, memberId: {}", memberId);
return memberRepository.findById(memberId)
.switchIfEmpty(Mono.defer(() -> {
log.error("会员不存在: memberId={}", memberId);
return Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND, "会员不存在"));
}))
.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);
});
}
// 会员信息响应
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 {
encryptedPhone = AesUtil.encrypt(phone, aesSecretKey, aesIv);
log.info("手机号加密成功");
} catch (Exception e) {
log.error("手机号加密失败", e);
return Mono.error(new ResponseStatusException(
HttpStatus.INTERNAL_SERVER_ERROR,
"手机号加密失败: " + e.getMessage()
));
}
return memberRepository.findByPhone(encryptedPhone)
.<Boolean>flatMap(existingMember -> {
if (existingMember.getId().equals(memberId)) {
log.warn("手机号已是当前用户的: memberId={}", memberId);
return Mono.error(new ResponseStatusException(
HttpStatus.CONFLICT,
"重复绑定"
));
} else {
log.warn("手机号已被其他用户绑定: memberId={}, existingMemberId={}",
memberId, existingMember.getId());
return Mono.error(new ResponseStatusException(
HttpStatus.CONFLICT,
"该手机号已被其他会员绑定"
));
}
})
.switchIfEmpty(Mono.defer(() -> {
log.info("手机号未被占用,可以绑定");
return updateMemberPhone(memberId, encryptedPhone);
}));
}
@Override
public Flux<MemberES> searchMember(SearchMemberDto searchMemberDto) {
String searchValue = searchMemberDto.getSearchValue();
// 1. 处理手机号加密
if(searchValue != null && searchValue.matches("^1[3-9]\\d{9}$")){
String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
String iv = wechatProperties.getPhoneEncryption().getIv();
searchValue = AesUtil.encrypt(searchValue,secretKey,iv);
}
// 2. 分页参数
Pageable pageable = PageRequest.of(
searchMemberDto.getPageNum() - 1,
searchMemberDto.getPageSize(),
Sort.by(Sort.Direction.DESC, "update_at")
);
// 3. 调用 Repository 查询
return memberESRepository.findByMemberNoOrPhoneOrNicknameContainingAndGender(
searchValue,
searchValue,
searchValue,
searchMemberDto.getFilter() ,
pageable
);
}
@Override
public Flux<Member> findAll(Integer pageNum, Integer 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.defer(() -> {
log.error("会员不存在: memberId={}", memberId);
return Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND, "会员不存在"));
}));
}
}
@@ -0,0 +1,260 @@
package cn.novalon.gym.manage.member.service.impl;
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;
/**
* WebClient实例 - 用于发送HTTP请求
* 最大内存大小为10MB
*/
private final WebClient webClient = WebClient.builder()
.baseUrl("https://api.weixin.qq.com")
.codecs(configurer -> configurer.defaultCodecs().maxInMemorySize(10 * 1024 * 1024))
.build();
/**
* 小程序
*
* @param code 小程序登录的code
* @return Mono<Map<String, String>> session_keyopenidunionid响应格式
*/
@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
.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);
// 解析JSON响应
Map<String, Object> response;
try {
// 使用Jackson解析JSON响应
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 RuntimeException("微信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 RuntimeException("微信API失败 [" + errcode + "]: " + errmsg);
}
// 获取session_keyopenidunionid
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());
}
return Mono.error(new RuntimeException("微信API响应异常 " + e.getMessage()));
});
}
/**
* 获取手机号
*
* @param code 手机号或获取手机号的code
* @return Mono<String> 手机号
*/
@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 RuntimeException("获取手机号失败 " + errmsg);
}
});
})
//
.onErrorResume(e -> {
log.error("获取手机号失败", e);
return Mono.error(new RuntimeException("获取手机号失败 " + e.getMessage()));
});
}
/**
* 获取Access Token
*
* @param appType 应用类型
* @return Mono<String> access_token
*/
@Override
public Mono<String> getAccessToken(String appType) {
log.debug("获取access_token, appType: {}", appType);
// TODO: 实现缓存逻辑
// 使用 Caffeine 或 Redis 缓存
// 目前直接调用微信API
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);
// TODO: 加入缓存
// cache.put("wechat:token:" + appType, accessToken, expiresIn - 200, TimeUnit.SECONDS);
return accessToken;
} else {
String errmsg = (String) response.get("errmsg");
log.error("获取access_token失败: {}", errmsg);
throw new RuntimeException("获取access_token失败: " + errmsg);
}
});
}
/**
* 验证微信消息签名
*
* @param signature 微信消息签名
* @param timestamp 创建时间戳
* @param nonce 随机字符串
* @return boolean true-签名有效false-签名无效
*/
@Override
public boolean checkSignature(String signature, String timestamp, String nonce) {
log.debug("验证微信消息签名, signature: {}, timestamp: {}, nonce: {}",
signature, timestamp, nonce);
try {
String token = wechatProperties.getMp().getToken();
String[] arr = new String[]{token, timestamp, nonce};
Arrays.sort(arr);
StringBuilder content = new StringBuilder();
for (String s : arr) {
content.append(s);
}
MessageDigest md = MessageDigest.getInstance("SHA-1");
byte[] digest = md.digest(content.toString().getBytes(StandardCharsets.UTF_8));
StringBuilder hexString = new StringBuilder();
for (byte b : digest) {
String hex = Integer.toHexString(0xff & b);
if (hex.length() == 1) {
hexString.append('0');
}
hexString.append(hex);
}
String calculatedSignature = hexString.toString();
boolean isValid = calculatedSignature.equals(signature);
log.debug("验证微信消息签名结果: {}", isValid ? "通过" : "失败");
return isValid;
} catch (Exception e) {
log.error("验证微信消息签名异常", e);
return false;
}
}
}
@@ -0,0 +1,349 @@
package cn.novalon.gym.manage.member.service.impl;
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);
}
/**
* 小程序登录 - 通过微信 code 完成登录
*
* @param request 微信登录请求
* @return Mono<WechatLoginVO> 微信登录响应
*/
@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);
return Mono.error(new RuntimeException("登录失败: " + e.getMessage()));
});
}
/**
* 绑定手机号 - 通过微信 code 获取并绑定手机号
*
* @param memberId 会员 ID
* @param code 微信手机号 code
* @return Mono<Boolean>
*/
@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());
return Mono.error(new RuntimeException("手机号已被其他会员绑定"));
} 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);
return Mono.error(new RuntimeException("绑定失败: " + e.getMessage()));
});
}
/**
* 更新会员手机号
*
* @param memberId 会员 ID
* @param encryptedPhone 加密后的手机号(Base64 编码)
* @return Mono<Boolean> 是否更新成功
*/
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.defer(() -> {
log.error("会员不存在, memberId={}", memberId);
return Mono.error(new RuntimeException("会员不存在"));
}));
}
/**
* 手机号加密
*
* @param phoneNumber 明文手机号
* @return 加密后的手机号(Base64 编码)
*/
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 RuntimeException("手机号加密失败 " + e.getMessage());
}
}
/**
* AES 解密手机号
*
* @param encryptedPhone 加密后的手机号(Base64 编码)
* @return 明文手机号
*/
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 RuntimeException("手机号解密失败 " + e.getMessage());
}
}
/**
* 创建新会员(首次登录)
*
* @param unionId 微信 UnionID
* @param openid 小程序 OpenID
* @param sessionKey 会话密钥
* @param phoneCode 手机号 code(可选,前端调用 wx.getPhoneNumber()
* @return Mono<WechatLoginVO> 登录响应
*/
private Mono<WechatLoginVO> createNewMember(String unionId, String openid, String sessionKey, String phoneCode) {
log.info("开始创建新会员, unionId: {}, openid: {}", unionId, openid);
// Step 1: 生成会员号
String memberNo = MemberNoGenerator.generate();
log.info("生成会员号: {}", memberNo);
// Step 2: 构建 Member 实体(仅保存标识信息)
Member member = Member.builder()
.memberNo(memberNo) // 小程序注册时自动生成会员号
.unionId(unionId) // 存储 UnionID 用于统一身份
.miniappOpenId(openid) // 存储小程序 OpenID
.lastLoginAt(LocalDateTime.now()) // 记录首次登录时间
.build();
log.info("用户未注册,创建新会员(仅保存标识信息)");
// Step 3: 保存 Member
return memberRepository.save(member)
.doOnSuccess(memberSyncer::sync)
.flatMap(savedMember -> {
log.info("保存 Member 成功, id: {}, memberNo: {}", savedMember.getId(), savedMember.getMemberNo());
// Step 4: 如果有 phoneCode,尝试获取手机号
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 {
// 没有 phoneCode,直接返回
return Mono.just(buildLoginResponse(savedMember, true, sessionKey));
}
});
}
/**
* 构建登录响应 - 封装返回数据(前端调用)
*
* @param member 会员实体
* @param isNewUser 是否为新用户
* @param sessionKey 会话密钥(后续可用于解密)
* @return WechatLoginVO 登录响应
*/
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 ? "已绑定" : "未绑定");
}
// 统一使用 JwtTokenProvider 生成 Token
// 使用空的角色列表,会员不需要角色
List<String> roles = new ArrayList<>();
String accessToken = jwtTokenProvider.generateToken(String.valueOf(member.getId()), member.getId(), roles);
log.info("JWT Token 生成成功, memberId: {}", member.getId());
// 使用 JwtTokenProvider 默认过期时间(86400 秒)
int expiresIn = 86400;
return WechatLoginVO.builder()
.memberId(member.getId())
.accessToken(accessToken)
.refreshToken(accessToken)
.expiresIn(expiresIn)
.isNewUser(isNewUser)
.needCompleteInfo(needCompleteInfo)
.build();
}
}
@@ -0,0 +1,334 @@
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) {
return memberRepository.findById(memberId)
.map(member -> {
Boolean subscribed = member.getSubscribed();
return subscribed != null && subscribed;
})
.defaultIfEmpty(false);
}
/**
* 从服务号用户信息创建新会员
*/
private Mono<Void> createNewMemberFromOfficial(String unionId, String openId) {
Member member = Member.builder()
.unionId(unionId)
.officialOpenId(openId)
.subscribed(true)
.lastLoginAt(LocalDateTime.now())
.build();
log.info("新用户关注服务号,仅保存标识信息(UnionID和OpenID");
return memberRepository.save(member)
.doOnSuccess(memberSyncer::sync)
.doOnSuccess(savedMember -> {
log.info("从服务号创建新会员成功, memberId: {}", savedMember.getId());
})
.then();
}
/**
* 获取微信AccessToken
*
* TODO: 应该使用缓存,避免频繁请求
*/
private Mono<String> getAccessToken() {
String appId = wechatProperties.getMp().getAppId();
String appSecret = wechatProperties.getMp().getAppSecret();
String url = "https://api.weixin.qq.com/cgi-bin/token"
+ "?grant_type=client_credential"
+ "&appid=" + appId
+ "&secret=" + appSecret;
return webClient.get()
.uri(url)
.accept(MediaType.APPLICATION_JSON)
.retrieve()
.bodyToMono(Map.class)
.map(response -> {
if (response.containsKey("errcode")) {
throw new RuntimeException("获取AccessToken失败: " + response.get("errmsg"));
}
return (String) response.get("access_token");
});
}
/**
* 发送欢迎消息给用户
*/
private Mono<Void> sendWelcomeMessage(String openId) {
log.info("发送欢迎消息给 openId: {}", openId);
// 真正调用微信 API 发送消息(测试模式和生产模式都执行)
return getAccessToken()
.flatMap(accessToken -> {
String url = "https://api.weixin.qq.com/cgi-bin/message/custom/send"
+ "?access_token=" + accessToken;
// 构建客服消息?
Map<String, Object> messageBody = new HashMap<>();
messageBody.put("touser", openId);
messageBody.put("msgtype", "text");
Map<String, String> text = new HashMap<>();
text.put("content", "欢迎使用");
messageBody.put("text", text);
return webClient.post()
.uri(url)
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(messageBody)
.retrieve()
.bodyToMono(Map.class)
.doOnSuccess(response -> {
if (response.containsKey("errcode") && !"0".equals(String.valueOf(response.get("errcode")))) {
log.error("发送欢迎消息失败: {}", response.get("errmsg"));
} else {
log.info("欢迎消息发送成功, openId: {}", openId);
}
})
.doOnError(error -> log.error("发送欢迎消息异常", error))
.then();
})
.onErrorResume(e -> {
log.error("发送欢迎消息失败, openId: {}", openId, e);
return Mono.empty(); // 即使发送失败也不影响主流程
});
}
}
@@ -0,0 +1,77 @@
package cn.novalon.gym.manage.member.util;
import lombok.extern.slf4j.Slf4j;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
/**
* AES加密工具类
*
* @author 付嘉
* @date 2026-05-01
*/
@Slf4j
public class AesUtil {
private static final String ALGORITHM = "AES";
private static final String TRANSFORMATION = "AES/CBC/PKCS5Padding";
/**
* AES 解密
*
* @param encryptedData 加密数据,Base64编码
* @param key AES密钥,Base64编码(32字节)
* @param iv 初始化向量IV,Base64编码(16字节)
* @return 解密后的字符串
*/
public static String decrypt(String encryptedData, String key, String iv) {
try {
byte[] dataByte = Base64.getDecoder().decode(encryptedData);
byte[] keyByte = Base64.getDecoder().decode(key);
byte[] ivByte = Base64.getDecoder().decode(iv);
Cipher cipher = Cipher.getInstance(TRANSFORMATION);
SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte, ALGORITHM);
IvParameterSpec ivParameterSpec = new IvParameterSpec(ivByte);
cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
byte[] resultByte = cipher.doFinal(dataByte);
return new String(resultByte, StandardCharsets.UTF_8);
} catch (Exception e) {
log.error("AES解密失败", e);
throw new RuntimeException("解密失败", e);
}
}
/**
* AES 加密
*
* @param data 原始数据
* @param key AES密钥,Base64编码(32字节)
* @param iv 初始化向量IVBase64编码(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);
}
}
}
@@ -0,0 +1,32 @@
package cn.novalon.gym.manage.member.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);
}
}
@@ -0,0 +1,159 @@
package cn.novalon.gym.manage.member.util;
import cn.hutool.core.bean.BeanUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.elasticsearch.repository.ReactiveElasticsearchRepository;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
/**
* 通用 ES 同步工具类
*
* 使用方式:
*
* 1. 注入工具类
* @Autowired private EsSyncUtils esSyncUtils;
*
* 2. 同步数据到 ES(不返回结果,适合 doOnSuccess
* esSyncUtils.sync(Member.class, MemberES.class, member, memberESRepository);
*
* 3. 同步数据到 ES(返回 Mono,适合链式调用)
* esSyncUtils.syncToES(Member.class, MemberES.class, member, memberESRepository).subscribe();
*
* 4. 如果 Repository 是单例,可以先绑定
* var syncer = esSyncUtils.bind(Member.class, MemberES.class, memberESRepository);
* syncer.sync(member);
*/
@Slf4j
@Component
@RequiredArgsConstructor
public class EsSyncUtils {
/**
* 同步实体到 ES(不返回结果,适合 doOnSuccess
*
* @param sourceClass 源实体类(如 Member.class
* @param targetClass 目标ES实体类(如 MemberES.class
* @param source 源实体对象
* @param repository ES Repository
* @param <S> 源实体类型
* @param <T> ES实体类型
* @param <ID> ID类型
*/
public <S, T, ID> void sync(Class<S> sourceClass, Class<T> targetClass,
S source, ReactiveElasticsearchRepository<T, ID> repository) {
if (source == null) {
log.warn("同步 ES 失败:源实体为空");
return;
}
try {
T target = BeanUtil.toBean(source, targetClass);
repository.save(target).subscribe(
success -> log.debug("同步到 ES 成功, 类型: {}", targetClass.getSimpleName()),
error -> log.error("同步到 ES 失败, 类型: {}", targetClass.getSimpleName(), error)
);
} catch (Exception e) {
log.error("转换 ES 实体失败, 源类型: {}, 目标类型: {}",
sourceClass.getSimpleName(), targetClass.getSimpleName(), e);
}
}
/**
* 同步实体到 ES(返回 Mono,适合链式调用)
*
* @param sourceClass 源实体类
* @param targetClass 目标ES实体类
* @param source 源实体对象
* @param repository ES Repository
* @return Mono<Void>
*/
public <S, T, ID> Mono<Void> syncToES(Class<S> sourceClass, Class<T> targetClass,
S source, ReactiveElasticsearchRepository<T, ID> repository) {
if (source == null) {
log.warn("同步 ES 失败:源实体为空");
return Mono.empty();
}
try {
T target = BeanUtil.toBean(source, targetClass);
return repository.save(target)
.doOnSuccess(t -> log.debug("同步到 ES 成功, 类型: {}", targetClass.getSimpleName()))
.doOnError(e -> log.error("同步到 ES 失败, 类型: {}", targetClass.getSimpleName(), e))
.then();
} catch (Exception e) {
log.error("转换 ES 实体失败, 源类型: {}, 目标类型: {}",
sourceClass.getSimpleName(), targetClass.getSimpleName(), e);
return Mono.empty();
}
}
/**
* 绑定 Repository,返回一个针对特定实体类型的同步器
*
* @param sourceClass 源实体类
* @param targetClass 目标ES实体类
* @param repository ES Repository
* @return 实体同步器
*/
public <S, T, ID> EntitySyncer<S, T, ID> bind(Class<S> sourceClass, Class<T> targetClass,
ReactiveElasticsearchRepository<T, ID> repository) {
return new EntitySyncer<>(sourceClass, targetClass, repository);
}
/**
* 实体同步器(绑定特定类型的同步器,避免重复传 Class)
*
* @param <S> 源实体类型
* @param <T> ES实体类型
* @param <ID> ID类型
*/
public static class EntitySyncer<S, T, ID> {
private final Class<S> sourceClass;
private final Class<T> targetClass;
private final ReactiveElasticsearchRepository<T, ID> repository;
public EntitySyncer(Class<S> sourceClass, Class<T> targetClass,
ReactiveElasticsearchRepository<T, ID> repository) {
this.sourceClass = sourceClass;
this.targetClass = targetClass;
this.repository = repository;
}
/**
* 同步(不返回结果)
*/
public void sync(S source) {
if (source == null) return;
try {
T target = BeanUtil.toBean(source, targetClass);
repository.save(target).subscribe(
success -> log.debug("同步到 ES 成功, 类型: {}", targetClass.getSimpleName()),
error -> log.error("同步到 ES 失败, 类型: {}", targetClass.getSimpleName(), error)
);
} catch (Exception e) {
log.error("转换 ES 实体失败, 源类型: {}, 目标类型: {}",
sourceClass.getSimpleName(), targetClass.getSimpleName(), e);
}
}
/**
* 同步(返回 Mono)
*/
public Mono<Void> syncMono(S source) {
if (source == null) return Mono.empty();
try {
T target = BeanUtil.toBean(source, targetClass);
return repository.save(target)
.doOnSuccess(t -> log.debug("同步到 ES 成功, 类型: {}", targetClass.getSimpleName()))
.doOnError(e -> log.error("同步到 ES 失败, 类型: {}", targetClass.getSimpleName(), e))
.then();
} catch (Exception e) {
log.error("转换 ES 实体失败, 源类型: {}, 目标类型: {}",
sourceClass.getSimpleName(), targetClass.getSimpleName(), e);
return Mono.empty();
}
}
}
}
@@ -0,0 +1,53 @@
package cn.novalon.gym.manage.member.util;
import lombok.extern.slf4j.Slf4j;
import java.security.SecureRandom;
/**
* 会员号生成器
*
* @author 付嘉
* @date 2026-05-01
*/
@Slf4j
public class MemberNoGenerator {
// 会员号前缀
private static final String PREFIX = "GYM";
// 随机数长度
private static final int RANDOM_LENGTH = 8;
// 字符集(排除易混淆字符 0/O, 1/I/l
private static final String CHARACTERS = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
// SecureRandom 实例(线程安全)
private static final SecureRandom SECURE_RANDOM = new SecureRandom();
// 生成会员号
public static String generate() {
StringBuilder sb = new StringBuilder(PREFIX);
for (int i = 0; i < RANDOM_LENGTH; i++) {
int index = SECURE_RANDOM.nextInt(CHARACTERS.length());
sb.append(CHARACTERS.charAt(index));
}
String memberNo = sb.toString();
log.debug("生成会员号: {}", memberNo);
return memberNo;
}
// 批量生成会员号
// count 生成数量
public static String[] generateBatch(int count) {
String[] memberNos = new String[count];
for (int i = 0; i < count; i++) {
memberNos[i] = generate();
}
return memberNos;
}
}
@@ -0,0 +1,65 @@
package cn.novalon.gym.manage.member.util;
import cn.novalon.gym.manage.member.service.WechatApiService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
/**
* 微信手机号获取工具类
*
* @author 付嘉
* @date 2026-05-01
*/
@Slf4j
@Component
@RequiredArgsConstructor
public class WechatPhoneUtil {
private final WechatApiService wechatApiService;
/**
* 通过phoneCode获取手机号
*
* @param phoneCode 手机号 code
* @return Mono<String> 手机号,获取失败则返回 null
*/
public Mono<String> getPhoneNumber(String phoneCode) {
if (phoneCode == null || phoneCode.isEmpty()) {
log.debug("未提供phoneCode获取手机号");
return Mono.empty();
}
log.info("开始获取手机号, phoneCode: {}", phoneCode);
return wechatApiService.getPhoneNumber(phoneCode)
.doOnSuccess(phoneNumber -> {
if (phoneNumber != null && !phoneNumber.isEmpty()) {
log.info("获取手机号成功: {}", maskPhone(phoneNumber));
} else {
log.warn("获取手机号失败");
}
})
.doOnError(e -> {
log.warn("获取手机号失败 {}", e.getMessage());
})
.onErrorResume(e -> {
return Mono.empty();
});
}
/**
* 手机号脱敏处理
*
* @param phone 手机号
* @return 脱敏后的手机号,如:138****8000
*/
private String maskPhone(String phone) {
if (phone == null || phone.length() < 7) {
return "***";
}
return phone.substring(0, 3) + "****" + phone.substring(7);
}
}
@@ -0,0 +1,46 @@
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;
}
@@ -0,0 +1,38 @@
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;
}
@@ -0,0 +1,72 @@
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;
}
@@ -0,0 +1 @@
cn.novalon.gym.manage.member.config.WechatProperties
@@ -0,0 +1,138 @@
-- ============================================
-- 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 '最后一次取消关注时间';
@@ -0,0 +1,22 @@
# 微信配置(测试环境使用模拟数据)
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 服务器地址(支持多个,逗号分隔)
@@ -1,13 +1,16 @@
package cn.novalon.gym.manage.gymmembercard;
package cn.novalon.gym.manage.member;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
/**
* 会员模块测试类
*/
@SpringBootTest
class GymMemberCardApplicationTests {
public class MemberModuleTest {
@Test
void contextLoads() {
// 测试Spring上下文是否能正常加载
}
}
+10 -6
View File
@@ -38,6 +38,16 @@
<artifactId>manage-db</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-member</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-checkIn</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
@@ -133,12 +143,6 @@
<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>
@@ -7,9 +7,8 @@ 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.context.annotation.ComponentScan;
import org.springframework.data.elasticsearch.repository.config.EnableReactiveElasticsearchRepositories;
import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
import org.springframework.web.server.WebFilter;
@@ -17,9 +16,12 @@ import java.util.List;
@SpringBootApplication(scanBasePackages = "cn.novalon.gym.manage", exclude = {
ReactiveUserDetailsServiceAutoConfiguration.class })
@EnableR2dbcRepositories(basePackages = { "cn.novalon.gym.manage.db.dao",
"cn.novalon.gym.manage.sys.audit.repository" ,
"cn.novalon.gym.manage.gymmembercard.dao"})
@EnableR2dbcRepositories(basePackages = {
"cn.novalon.gym.manage.db.dao",
"cn.novalon.gym.manage.sys.audit.repository",
"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);
@@ -1,8 +1,5 @@
package cn.novalon.gym.manage.app.config;
import cn.novalon.gym.manage.gymmembercard.handler.MemberCardHandler;
import cn.novalon.gym.manage.gymmembercard.handler.MemberCardRecordHandler;
import cn.novalon.gym.manage.gymmembercard.handler.MemberCardTransactionHandler;
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;
@@ -18,6 +15,8 @@ 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 cn.novalon.gym.manage.member.handler.WechatAuthHandler;
import cn.novalon.gym.manage.member.handler.MemberHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.server.RouterFunction;
@@ -31,7 +30,7 @@ import static org.springframework.web.reactive.function.server.RouterFunctions.r
* 文件定义:配置WebFlux函数式路由,将HTTP请求映射到对应的Handler方法
* 涉及业务:用户、角色、字典、菜单、公告、文件等所有RESTful API路由
* 算法:使用RouterFunctions.route()构建函数式路由规则
*
*
* @author 张翔
* @date 2026-03-13
*/
@@ -54,15 +53,14 @@ public class SystemRouter {
SysUserMessageHandler messageHandler,
SysFileHandler fileHandler,
SysPermissionHandler permissionHandler,
PasswordDiagnosticHandler passwordDiagnosticHandler,
MemberCardHandler memberCardHandler,
MemberCardRecordHandler memberCardRecordHandler,
MemberCardTransactionHandler memberCardTransactionHandler) {
MemberHandler memberHandler,
WechatAuthHandler wechatAuthHandler,
PasswordDiagnosticHandler passwordDiagnosticHandler) {
return route()
// ========== 诊断路由 ==========
.GET("/api/diagnostic/password", passwordDiagnosticHandler::diagnose)
// ========== 字典路由 ==========
.GET("/api/dictionaries", dictionaryHandler::getAllDictionaries)
.GET("/api/dictionaries/{id}", dictionaryHandler::getDictionaryById)
@@ -71,7 +69,7 @@ public class SystemRouter {
.POST("/api/dictionaries", dictionaryHandler::createDictionary)
.PUT("/api/dictionaries/{id}", dictionaryHandler::updateDictionary)
.DELETE("/api/dictionaries/{id}", dictionaryHandler::deleteDictionary)
// ========== 用户路由 ==========
.GET("/api/users", userHandler::getAllUsers)
.GET("/api/users/page", userHandler::getUsersByPage)
@@ -90,7 +88,7 @@ public class SystemRouter {
.POST("/api/users/{id}/action/restore", userHandler::restoreUser)
.GET("/api/users/{id}/roles", userHandler::getUserRoles)
.POST("/api/users/{id}/roles", userHandler::assignRoles)
// ========== 菜单路由 ==========
.GET("/api/menus", menuHandler::getAllMenus)
.GET("/api/menus/tree", menuHandler::getMenuTree)
@@ -98,7 +96,7 @@ public class SystemRouter {
.POST("/api/menus", menuHandler::createMenu)
.PUT("/api/menus/{id}", menuHandler::updateMenu)
.DELETE("/api/menus/{id}", menuHandler::deleteMenu)
// ========== 角色路由 ==========
.GET("/api/roles", roleHandler::getAllRoles)
.GET("/api/roles/page", roleHandler::getRolesByPage)
@@ -112,7 +110,7 @@ public class SystemRouter {
.POST("/api/roles/{id}/restore", roleHandler::restoreRole)
.GET("/api/roles/{id}/permissions", permissionHandler::getPermissionsByRoleId)
.POST("/api/roles/{id}/permissions", permissionHandler::assignPermissionsToRole)
// ========== 配置路由 ==========
.GET("/api/config", configHandler::getAllConfigs)
.GET("/api/config/{id}", configHandler::getConfigById)
@@ -120,7 +118,7 @@ public class SystemRouter {
.POST("/api/config", configHandler::createConfig)
.PUT("/api/config/{id}", configHandler::updateConfig)
.DELETE("/api/config/{id}", configHandler::deleteConfig)
// ========== 日志路由 ==========
.GET("/api/logs/login", logHandler::getAllLoginLogs)
.GET("/api/logs/login/page", logHandler::getLoginLogsByPage)
@@ -140,15 +138,15 @@ public class SystemRouter {
.GET("/api/logs/operation/count", operationLogHandler::getOperationLogCount)
.GET("/api/logs/operation/{id}", operationLogHandler::getOperationLogById)
.POST("/api/logs/operation", operationLogHandler::createOperationLog)
// ========== 认证路由 ==========
.POST("/api/auth/login", authHandler::login)
.POST("/api/auth/register", authHandler::register)
.POST("/api/auth/logout", authHandler::logout)
// ========== 统计路由 ==========
.GET("/api/stats/overview", statsHandler::getOverview)
// ========== 数据字典路由 ==========
.GET("/api/dict/types", dictHandler::getAllDictTypes)
.GET("/api/dict/types/{id}", dictHandler::getDictTypeById)
@@ -162,7 +160,7 @@ public class SystemRouter {
.POST("/api/dict/data", dictHandler::createDictData)
.PUT("/api/dict/data/{id}", dictHandler::updateDictData)
.DELETE("/api/dict/data/{id}", dictHandler::deleteDictData)
// ========== 公告路由 ==========
.GET("/api/notices", noticeHandler::getAllNotices)
.GET("/api/notices/{id}", noticeHandler::getNoticeById)
@@ -170,7 +168,7 @@ public class SystemRouter {
.POST("/api/notices", noticeHandler::createNotice)
.PUT("/api/notices/{id}", noticeHandler::updateNotice)
.DELETE("/api/notices/{id}", noticeHandler::deleteNotice)
// ========== 消息路由 ==========
.GET("/api/messages/user/{userId}", messageHandler::getMessagesByUser)
.GET("/api/messages/user/{userId}/unread", messageHandler::getUnreadCount)
@@ -178,7 +176,7 @@ public class SystemRouter {
.POST("/api/messages", messageHandler::createMessage)
.PUT("/api/messages/{id}/read", messageHandler::markAsRead)
.DELETE("/api/messages/{id}", messageHandler::deleteMessage)
// ========== 文件路由 ==========
.GET("/api/files", fileHandler::getAllFiles)
.GET("/api/files/{id}", fileHandler::getFileById)
@@ -188,7 +186,7 @@ public class SystemRouter {
.GET("/api/files/{id}/preview", fileHandler::previewFile)
.GET("/api/files/preview/{fileName}", fileHandler::previewFileByName)
.DELETE("/api/files/{id}", fileHandler::deleteFile)
// ========== 权限路由 ==========
.GET("/api/permissions", permissionHandler::getAllPermissions)
.GET("/api/permissions/{id}", permissionHandler::getPermissionById)
@@ -199,33 +197,23 @@ public class SystemRouter {
.PUT("/api/permissions/{id}", permissionHandler::updatePermission)
.DELETE("/api/permissions/{id}", permissionHandler::deletePermission)
// ========================================
// ========== 会员卡管理路由 ==============
// ========================================
// ===== 会员卡类型管理 =====
.GET("/api/member-cards/active", memberCardHandler::getActiveCards)
.GET("/api/member-cards/{memberCardId}", memberCardHandler::getMemberCardById)
.POST("/api/member-cards", memberCardHandler::createMemberCard)
// ===== 会员卡记录管理(核心业务)=====
.POST("/api/member-card-records/purchase", memberCardRecordHandler::purchaseCard)
.POST("/api/member-card-records/{recordId}/renew", memberCardRecordHandler::renewCard)
.POST("/api/member-card-records/{recordId}/use", memberCardRecordHandler::useCard)
.POST("/api/member-card-records/{recordId}/refund", memberCardRecordHandler::refundCard)
.GET("/api/member-card-records/my-cards/{memberId}", memberCardRecordHandler::getMyCards)
.GET("/api/member-card-records/{recordId}", memberCardRecordHandler::getMemberCardRecordById)
.POST("/api/member-card-records/process-expired", memberCardRecordHandler::processExpiredCards)
// ===== 会员卡交易流水管理 =====
.POST("/api/member-card-transactions", memberCardTransactionHandler::insertTransaction)
.GET("/api/member-card-transactions", memberCardTransactionHandler::getTransactionsWithConditions)
.GET("/api/member-card-transactions/member/{memberId}", memberCardTransactionHandler::getMemberTransactions)
.GET("/api/member-card-transactions/card/{cardId}", memberCardTransactionHandler::getTransactionsByCardId)
.GET("/api/member-card-transactions/statistics/deduct/{cardId}", memberCardTransactionHandler::getDeductCountByCardId)
.GET("/api/member-card-transactions/statistics/renew", memberCardTransactionHandler::getRenewAmountByTimeRange)
.GET("/api/member-card-transactions/statistics/purchase/{memberId}", memberCardTransactionHandler::getPurchaseAmountByMember)
// ========== 会员模块路由 - 微信认证 ==========
.POST("/api/member/auth/miniapp/login", wechatAuthHandler::miniappLogin)
.GET("/api/member/auth/mp/callback", wechatAuthHandler::verifyMpSignature)
.POST("/api/member/auth/mp/callback", wechatAuthHandler::mpCallback)
// ========== 会员模块路由 - 会员信息 ==========
.GET("/api/member/info", memberHandler::getMemberInfo)
.PUT("/api/member/info", memberHandler::updateMemberInfo)
.POST("/api/member/phone/bind", memberHandler::bindPhone)
.GET("/api/member/subscribe/status", memberHandler::checkSubscribeStatus)
// ========== 会员模块路由 - 管理端 ==========
.POST("/api/admin/member/{id}/phone", memberHandler::adminUpdatePhone)
.GET("/api/admin/member/{id}", memberHandler::adminGetMemberInfo)
.PUT("/api/admin/member/{id}", memberHandler::adminUpdateMemberInfo)
.GET("/api/admin/members", memberHandler::searchMembers)
.GET("/api/admin/members/all", memberHandler::getAllMembers)
.build();
}
}
@@ -12,11 +12,15 @@ spring:
max-life-time: 30m
acquire-timeout: 3s
flyway:
enabled: true
url: jdbc:postgresql://localhost:55432/manage_system
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
@@ -19,7 +19,7 @@ spring:
password: 123456
driver-class-name: org.postgresql.Driver
flyway:
enabled: true
enabled: false
locations: classpath:db/migration
baseline-on-migrate: true
baseline-version: 0
@@ -15,7 +15,7 @@ spring:
max-life-time: 1h
acquire-timeout: 5s
flyway:
enabled: true
enabled: false
locations: classpath:db/migration
baseline-on-migrate: true
validate-on-migrate: true
@@ -15,8 +15,8 @@ spring:
- org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration
r2dbc:
url: r2dbc:postgresql://${DB_HOST:localhost}:${DB_PORT:55432}/${DB_NAME:manage_system}
username: ${DB_USERNAME:postgres}
password: ${DB_PASSWORD:postgres}
username: ${DB_USERNAME:novalon}
password: ${DB_PASSWORD:novalon123}
pool:
initial-size: 10
max-size: 50
@@ -24,12 +24,12 @@ spring:
max-life-time: 1h
acquire-timeout: 5s
datasource:
url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:55432}/${DB_NAME:manage_system}
username: ${DB_USERNAME:postgres}
password: ${DB_PASSWORD:postgres}
url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:5432}/${DB_NAME:manage_system}
username: ${DB_USERNAME:novalon}
password: ${DB_PASSWORD:novalon123}
driver-class-name: org.postgresql.Driver
flyway:
enabled: true
enabled: false
locations: classpath:db/migration
baseline-on-migrate: true
baseline-version: 0
@@ -38,6 +38,10 @@ spring:
user:
name: disabled
password: disabled
profiles:
active: dev
config:
import: classpath:member-config.yml
management:
endpoints:
@@ -47,6 +47,7 @@ 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();
@@ -57,6 +58,9 @@ 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");
}
@@ -9,27 +9,27 @@ spring:
cloud:
gateway:
routes:
- id: manage-app
uri: http://localhost:8084
predicates:
- Path=/api/**
- id: manage-app
uri: http://localhost:8084
predicates:
- Path=/api/**
default-filters:
- name: JwtAuthentication
- name: RbacAuthorization
- name: Retry
args:
retries: 3
statuses: BAD_GATEWAY,SERVICE_UNAVAILABLE
methods: GET,POST
backoff:
firstBackoff: 10ms
maxBackoff: 50ms
factor: 2
basedOnPreviousValue: false
- name: DedupeResponseHeader
args:
name: Content-Encoding
strategy: RETAIN_FIRST
- name: JwtAuthentication
- name: RbacAuthorization
- name: Retry
args:
retries: 3
statuses: BAD_GATEWAY,SERVICE_UNAVAILABLE
methods: GET,POST
backoff:
firstBackoff: 10ms
maxBackoff: 50ms
factor: 2
basedOnPreviousValue: false
- name: DedupeResponseHeader
args:
name: Content-Encoding
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}
paths: ${SIGNATURE_WHITELIST_PATHS:/actuator/health,/actuator/info,/api/auth/login,/api/auth/register,/api/member/auth/miniapp/login,/api/member/auth/mp/callback}
resilience:
enabled: ${RESILIENCE_ENABLED:true}
@@ -1,7 +1,6 @@
package cn.novalon.gym.manage.sys.dto.request;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.Email;
/**
* 用户更新请求DTO
@@ -24,7 +23,6 @@ public class UserUpdateRequest {
@Schema(description = "是否清除角色关联", example = "false")
private Boolean clearRole;
@Email(message = "邮箱格式不正确")
public String getEmail() {
return email;
}
+3 -2
View File
@@ -36,14 +36,15 @@
<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>
</modules>
<module>gym-member</module>
<module>gym-checkIn</module>
</modules>
<dependencyManagement>
<dependencies>
+18 -18
View File
@@ -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.46.2))(vue@3.5.30(typescript@5.9.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))
'@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.46.2
version: 5.48.0
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.46.2)
version: 7.3.1(@types/node@20.19.37)(terser@5.48.0)
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.46.2))
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))
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.46.2:
resolution: {integrity: sha512-uxfo9fPcSgLDYob/w1FuL0c99MWiJDnv+5qXSQc5+Ki5NjVNsYi66INnMFBjf6uFz6OnX12piJQPF4IpjJTNTw==}
terser@5.48.0:
resolution: {integrity: sha512-J/9An6vs9Us6wKRriSFXBWdRZapREHqFzdNUKk0pmu804EMR6dr6winwo7e5JDxN4xahxQsuysyYFwlwj4XN/Q==}
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.46.2))(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.48.0))(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.46.2)
vite: 7.3.1(@types/node@20.19.37)(terser@5.48.0)
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.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/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.46.2))':
'@vitest/mocker@4.1.0(vite@7.3.1(@types/node@20.19.37)(terser@5.48.0))':
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.46.2)
vite: 7.3.1(@types/node@20.19.37)(terser@5.48.0)
'@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.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/utils@4.1.0':
dependencies:
@@ -3555,7 +3555,7 @@ snapshots:
symbol-tree@3.2.4: {}
terser@5.46.2:
terser@5.48.0:
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.46.2):
vite@7.3.1(@types/node@20.19.37)(terser@5.48.0):
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.46.2
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@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)):
dependencies:
'@vitest/expect': 4.1.0
'@vitest/mocker': 4.1.0(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
'@vitest/mocker': 4.1.0(vite@7.3.1(@types/node@20.19.37)(terser@5.48.0))
'@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.46.2)
vite: 7.3.1(@types/node@20.19.37)(terser@5.48.0)
why-is-node-running: 2.3.0
optionalDependencies:
'@types/node': 20.19.37