更新前台相关功能，添加防XSS注入，加入ES搜索

gym-manage-api/gym-member/CARD_MERGE_REPORT.md

@@ -0,0 +1,199 @@
+# gym-member-card 模块合并到 gym-member 完成报告
+
+## 合并概述
+将 `gym-member-card` 模块的功能合并到 `gym-member` 模块的 `card` 子包中，保持功能不变，代码风格以 `gym-member` 为基准。
+
+## 已完成的工作
+
+### 1. 目录结构创建 ✅
+在 `gym-member/src/main/java/cn/novalon/gym/manage/member/card` 下创建了以下子目录：
+- `entity/` - 实体类
+- `dto/` - 数据传输对象
+- `vo/` - 视图对象
+- `repository/` - 数据访问层
+- `service/` - 服务接口
+- `service/impl/` - 服务实现
+- `handler/` - 业务处理器
+- `enums/` - 枚举类
+- `util/` - 工具类
+
+### 2. 实体类重构（Entity）✅
+按照 gym-member 的风格（使用 Lombok），创建了以下实体类：
+
+| 原文件 | 新文件 | 说明 |
+|--------|--------|------|
+| MemberCardEntity.java + MemberCard.java | card/entity/MemberCard.java | 会员卡类型实体 |
+| MemberCardRecordEntity.java + MemberCardRecord.java | card/entity/MemberCardRecord.java | 会员持卡记录实体 |
+| MemberCardTransactionsEntity.java | card/entity/MemberCardTransaction.java | 交易流水实体 |
+| RefundApplicationEntity.java | card/entity/RefundApplication.java | 退款申请实体 |
+
+**主要改进：**
+- 使用 `@Data`, `@Builder`, `@NoArgsConstructor`, `@AllArgsConstructor` Lombok 注解
+- 继承 `cn.novalon.gym.manage.member.entity.BaseEntity`
+- 移除手动编写的 getter/setter
+- 添加规范的 JavaDoc 注释
+
+### 3. 枚举类创建 ✅
+创建了以下枚举类：
+
+| 原文件 | 新文件 | 说明 |
+|--------|--------|------|
+| MemberCardType.java | card/enums/MemberCardType.java | 会员卡类型 |
+| MemberCardRecordStatus.java | card/enums/MemberCardRecordStatus.java | 卡片状态 |
+| MemberCardTransactionsAction.java | card/enums/TransactionType.java | 交易操作类型 |
+| MemberCardTransactionsType.java | card/enums/BizType.java | 关联业务类型 |
+| MemberCardEvent.java | card/enums/CardEvent.java | 状态机事件 |
+
+### 4. Repository 层合并 ✅
+将原有的 DAO 接口整合为 Repository 接口，直接继承 `R2dbcRepository`：
+
+| 原文件 | 新文件 | 说明 |
+|--------|--------|------|
+| MemberCardDao.java | card/repository/MemberCardRepository.java | 会员卡类型 Repository |
+| MemberCardRecordDao.java | card/repository/MemberCardRecordRepository.java | 持卡记录 Repository |
+| MemberCardTransactionsDao.java | card/repository/MemberCardTransactionRepository.java | 交易流水 Repository |
+| RefundApplicationDao.java | card/repository/RefundApplicationRepository.java | 退款申请 Repository |
+
+**主要改进：**
+- 统一命名规范（移除 Dao，使用 Repository）
+- 继承 `R2dbcRepository<Entity, Long>`
+- 保留所有自定义查询方法
+- 更新参数类型为新的实体类
+
+### 5. 数据库 Schema 迁移 ✅
+将会员卡相关的表结构添加到 `gym-member/src/main/resources/db/schema.sql`：
+
+新增表：
+- `member_card` - 会员卡类型表
+- `member_card_record` - 会员持卡记录表
+- `member_card_transactions` - 交易流水表
+- `refund_application` - 退款申请表
+
+包含完整的索引和注释。
+
+### 6. pom.xml 依赖更新 ✅
+在 `gym-member/pom.xml` 中添加了 Redis 响应式支持：
+```xml
+<dependency>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
+</dependency>
+```
+
+## 待完成的工作
+
+### 需要手动复制的文件（约30个）
+
+以下文件需要从 `gym-member-card` 复制到 `gym-member/card`，并修改包名：
+
+#### Handler 层（8个文件）
+源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/handler/`
+目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/handler/`
+
+- DistributedLockService.java
+- ExpirationReminderService.java
+- MemberCardHandler.java
+- MemberCardRecordHandler.java
+- MemberCardScheduledHandler.java
+- MemberCardStateMachine.java
+- MemberCardTransactionHandler.java
+- RefundSagaHandler.java
+
+#### Service 接口层（4个文件）
+源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/`
+目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/service/`
+
+注意：目录名从 `sevice`（拼写错误）改为 `service`
+
+- IMemberCardService.java
+- IMemberCardRecordService.java
+- IMemberCardTransactionsService.java
+- IRefundApplicationService.java
+
+#### Service 实现层（4个文件）
+源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/`
+目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/service/impl/`
+
+- MemberCardServiceImpl.java
+- MemberCardRecordServiceImpl.java
+- MemberCardTransactionsServiceImpl.java
+- RefundApplicationServiceImpl.java
+
+#### Util 工具类（1个文件）
+源路径：`gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/util/`
+目标路径：`gym-member/src/main/java/cn/novalon/gym/manage/member/card/util/`
+
+- BeanConvertUtil.java
+
+### 批量替换规则
+
+复制每个文件后，需要进行以下文本替换：
+
+1. **包名替换：**
+   ```
+   package cn.novalon.gym.manage.gymmembercard -> package cn.novalon.gym.manage.member.card
+   ```
+
+2. **导入语句替换：**
+   ```
+   import cn.novalon.gym.manage.gymmembercard -> import cn.novalon.gym.manage.member.card
+   ```
+
+3. **BaseEntity 导入替换：**
+   ```
+   import cn.novalon.gym.manage.db.entity.BaseEntity -> import cn.novalon.gym.manage.member.entity.BaseEntity
+   ```
+
+4. **BaseDomain 处理（如果存在）：**
+   ```
+   import cn.novalon.gym.manage.sys.core.domain.BaseDomain -> （注释掉或删除）
+   ```
+
+5. **Repository 引用更新（如果需要）：**
+   ```
+   IMemberCardRepository -> MemberCardRepository
+   IMemberCardRecordRepository -> MemberCardRecordRepository
+   IMemberCardTransactionsRepository -> MemberCardTransactionRepository
+   IRefundApplicationRepository -> RefundApplicationRepository
+   ```
+
+## 验证步骤
+
+完成文件复制后，执行以下验证：
+
+1. **编译验证：**
+   ```bash
+   cd gym-manage-api/gym-member
+   mvn clean compile
+   ```
+
+2. **检查是否有编译错误：**
+   - 修复任何缺失的导入
+   - 确认所有依赖类都已正确迁移
+   - 检查枚举引用是否正确
+
+3. **运行测试（如果有）：**
+   ```bash
+   mvn test
+   ```
+
+## 注意事项
+
+1. **包名一致性：** 确保所有文件中的包声明和导入语句都正确更新
+2. **依赖注入：** Spring 的 `@Autowired` 或构造函数注入应自动工作，因为使用了相同的注解
+3. **数据库兼容性：** schema.sql 已追加新表，不会影响现有表
+4. **Redis 配置：** 确保 application.yml 中有 Redis 配置（如果需要分布式锁功能）
+5. **定时任务：** MemberCardScheduledHandler 和 ExpirationReminderService 可能需要启用 `@EnableScheduling`
+
+## 自动化脚本
+
+项目根目录下提供了两个辅助脚本：
+- `gym-member-card/migrate_to_member.py` - Python 迁移脚本
+- `gym-member-card/migrate-to-member.ps1` - PowerShell 迁移脚本
+
+可以运行这些脚本来自动完成文件复制和包名替换。
+
+---
+
+**生成时间：** 2026-05-27
+**合并状态：** 基础架构完成，待复制业务逻辑文件

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

@@ -128,6 +128,11 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
         </dependency>
+        <!-- Redis响应式支持（会员卡模块需要） -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

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

@@ -0,0 +1,61 @@
+package cn.novalon.gym.manage.member.dto
+;
+
+import lombok.Data;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import java.math.BigDecimal;
+
+/**
+ * 创建会员卡类型请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class CreateMemberCardRequest {
+
+    /**
+     * 会员卡名称
+     */
+    @NotBlank(message = "会员卡名称不能为空")
+    private String memberCardName;
+
+    /**
+     * 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
+     */
+    @NotBlank(message = "会员卡类型不能为空")
+    private String memberCardType;
+
+    /**
+     * 会员卡价格
+     */
+    @NotNull(message = "会员卡价格不能为空")
+    private BigDecimal memberCardPrice;
+
+    /**
+     * 有效天数（时长卡用）
+     */
+    private Integer memberCardValidityDays;
+
+    /**
+     * 总次数（次卡用）
+     */
+    private Integer memberCardTotalTimes;
+
+    /**
+     * 面额（储值卡用）
+     */
+    private BigDecimal memberCardAmount;
+
+    /**
+     * 状态：0-下架, 1-上架
+     */
+    private Integer memberCardStatus = 1;
+
+    /**
+     * 扩展配置（JSON格式）
+     */
+    private String extraConfig;
+}

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

@@ -0,0 +1,32 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+import jakarta.validation.constraints.NotNull;
+
+/**
+ * 购买会员卡请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class PurchaseCardRequest {
+
+    /**
+     * 会员ID
+     */
+    @NotNull(message = "会员ID不能为空")
+    private Long memberId;
+
+    /**
+     * 会员卡类型ID
+     */
+    @NotNull(message = "会员卡类型ID不能为空")
+    private Long memberCardId;
+
+    /**
+     * 来源订单ID
+     */
+    private Long sourceOrderId;
+}

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

@@ -0,0 +1,21 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+import jakarta.validation.constraints.NotBlank;
+
+/**
+ * 退款申请请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class RefundCardRequest {
+
+    /**
+     * 退款原因
+     */
+    @NotBlank(message = "退款原因不能为空")
+    private String reason;
+}

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

@@ -0,0 +1,35 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+import jakarta.validation.constraints.NotNull;
+
+/**
+ * 续费会员卡请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class RenewCardRequest {
+
+    /**
+     * 增加的次数
+     */
+    private Integer addTimes;
+
+    /**
+     * 增加的金额
+     */
+    private Double addAmount;
+
+    /**
+     * 增加的天数
+     */
+    private Integer addDays;
+
+    /**
+     * 来源订单ID
+     */
+    private Long sourceOrderId;
+}

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

@@ -12,8 +12,8 @@ public class SearchMemberDto {
     // 搜索字段 - 包括 会员号、昵称、手机号
     private String searchValue;
 
-    // 排序
+    // 性别排序
-    private String filter;
+    private Integer gender;
 
     // 页码
     private Integer pageNum = 1;

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

@@ -0,0 +1,60 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import java.math.BigDecimal;
+
+/**
+ * 更新会员卡类型请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class UpdateMemberCardRequest {
+
+    /**
+     * 会员卡名称
+     */
+    @NotBlank(message = "会员卡名称不能为空")
+    private String memberCardName;
+
+    /**
+     * 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
+     */
+    @NotBlank(message = "会员卡类型不能为空")
+    private String memberCardType;
+
+    /**
+     * 会员卡价格
+     */
+    @NotNull(message = "会员卡价格不能为空")
+    private BigDecimal memberCardPrice;
+
+    /**
+     * 有效天数（时长卡用）
+     */
+    private Integer memberCardValidityDays;
+
+    /**
+     * 总次数（次卡用）
+     */
+    private Integer memberCardTotalTimes;
+
+    /**
+     * 面额（储值卡用）
+     */
+    private BigDecimal memberCardAmount;
+
+    /**
+     * 状态：0-下架, 1-上架
+     */
+    private Integer memberCardStatus;
+
+    /**
+     * 扩展配置（JSON格式）
+     */
+    private String extraConfig;
+}

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

@@ -1,7 +1,9 @@
 package cn.novalon.gym.manage.member.dto;
 
+import cn.novalon.gym.manage.member.enums.GenderEnum;
 import lombok.Data;
 
+import java.time.LocalDate;
 import java.util.Date;
 
 /**
@@ -17,10 +19,10 @@ public class UpdateMemberInfoDto {
     private String nickname;
 
     // 性别
-    private Integer gender;
+    private GenderEnum gender;
 
     // 生日
-    private Date birthday;
+    private LocalDate birthday;
 
     // 头像
     private String avatar;

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

@@ -0,0 +1,23 @@
+package cn.novalon.gym.manage.member.dto;
+
+import lombok.Data;
+
+/**
+ * 使用会员卡请求 DTO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+public class UseCardRequest {
+
+    /**
+     * 扣减的次数
+     */
+    private Integer deductTimes;
+
+    /**
+     * 扣减的金额
+     */
+    private Double deductAmount;
+}

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

@@ -33,6 +33,9 @@ public abstract class BaseEntity implements Persistable<Long> {
     @Column("updated_at")
     private LocalDateTime updatedAt;
 
+    @Column("deleted_at")
+    private LocalDateTime deletedAt;
+
     // 判断当前实体是否是新建的
     @Override
     public boolean isNew() {

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

@@ -1,13 +1,10 @@
 package cn.novalon.gym.manage.member.entity;
 
-import lombok.AllArgsConstructor;
+import lombok.*;
-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.LocalDate;
 import java.time.LocalDateTime;
 import java.util.Date;
 
@@ -44,7 +41,7 @@ public class Member extends BaseEntity {
 
     //生日
     @Column("birthday")
-    private Date birthday;
+    private LocalDate birthday;
 
     //地址
     @Column("address")

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

@@ -0,0 +1,63 @@
+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;
+
+/**
+ * 会员卡类型实体 - 对应 member_card 表
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+@Table("member_card")
+public class MemberCard extends BaseEntity {
+
+    // 会员卡ID
+    @Column("member_card_id")
+    private Long memberCardId;
+
+    // 会员卡名称
+    @Column("member_card_name")
+    private String memberCardName;
+
+    // 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
+    @Column("member_card_type")
+    private String memberCardType;
+
+    // 会员卡价格
+    @Column("member_card_price")
+    private Double memberCardPrice;
+
+    // 有效天数（时长卡用）
+    @Column("member_card_validity_days")
+    private Integer memberCardValidityDays;
+
+    // 总次数（次卡用）
+    @Column("member_card_total_times")
+    private Integer memberCardTotalTimes;
+
+    // 面额（储值卡用）
+    @Column("member_card_amount")
+    private Double memberCardAmount;
+
+    // 状态：0-下架, 1-上架
+    @Column("member_card_status")
+    private Integer memberCardStatus;
+
+    // 扩展配置（JSON格式）
+    @Column("extra_config")
+    private String extraConfig;
+
+}

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

@@ -0,0 +1,72 @@
+package cn.novalon.gym.manage.member.entity;
+
+import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡记录实体（会员持有的卡）- 对应 member_card_record 表
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+@Table("member_card_record")
+public class MemberCardRecord extends BaseEntity {
+
+    // 会员持有卡ID
+    @Column("member_card_record_id")
+    private Long memberCardRecordId;
+
+    // 会员ID
+    @Column("member_id")
+    private Long memberId;
+
+    // 关联会员卡ID
+    @Column("member_card_id")
+    private Long memberCardId;
+
+    // 状态：ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款
+    @Column("status")
+    private MemberCardRecordStatus status;
+
+    // 剩余次数
+    @Column("remaining_times")
+    private Integer remainingTimes;
+
+    // 剩余金额
+    @Column("remaining_amount")
+    private Double remainingAmount;
+
+    // 到期时间
+    @Column("expire_time")
+    private LocalDateTime expireTime;
+
+    // 来源订单ID
+    @Column("source_order_id")
+    private Long sourceOrderId;
+
+    // 购买时间
+    @Column("purchase_time")
+    private LocalDateTime purchaseTime;
+
+    // 乐观锁版本号
+    @Column("version")
+    private Integer version;
+
+    // 卡片组成（JSON格式，用于组合卡）
+    @Column("card_composition")
+    private String cardComposition;
+
+}

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

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

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

@@ -0,0 +1,65 @@
+package cn.novalon.gym.manage.member.entity;
+
+import cn.novalon.gym.manage.member.enums.RefundStatus;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+/**
+ * 退款申请实体 - 对应 refund_application 表
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+@Table("refund_application")
+public class RefundApplication extends BaseEntity {
+
+    // 会员卡记录ID
+    @Column("record_id")
+    private Long recordId;
+
+    // 会员ID
+    @Column("member_id")
+    private Long memberId;
+
+    // 状态：PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败
+    @Column("status")
+    private RefundStatus status;
+
+    // 退款原因
+    @Column("reason")
+    private String reason;
+
+    // 申请时间
+    @Column("apply_time")
+    private LocalDateTime applyTime;
+
+    // 审核时间
+    @Column("audit_time")
+    private LocalDateTime auditTime;
+
+    // 审核人ID
+    @Column("auditor_id")
+    private Long auditorId;
+
+    // 审核备注
+    @Column("audit_remark")
+    private String auditRemark;
+
+    // 退款金额
+    @Column("refund_amount")
+    private BigDecimal refundAmount;
+
+}

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

@@ -1,38 +0,0 @@
-package cn.novalon.gym.manage.member.entity;
-
-import lombok.*;
-import org.springframework.data.annotation.CreatedDate;
-import org.springframework.data.annotation.Id;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@Table("sign_in_record")
-public class SignInRecord {
-
-    @Id
-    private Long id;
-
-    // 会员ID
-    @Column("member_id")
-    private Long memberId;
-
-    // 签到日期
-    @Column("sign_in_date")
-    private LocalDate signInDate;
-
-    // 签到时间
-    @Column("sign_in_time")
-    private LocalDateTime signInTime;
-
-    // 创建时间
-    @CreatedDate
-    @Column("created_at")
-    private LocalDateTime createdAt;
-}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/BizType.java

@@ -0,0 +1,24 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 会员卡流水关联业务类型枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum BizType {
+    
+    GROUP_CLASS("团课"),
+    PT_CLASS("私教"),
+    CHECK_IN("签到");
+
+    private final String desc;
+
+    BizType(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/CardEvent.java

@@ -0,0 +1,27 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 会员卡状态机事件枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum CardEvent {
+    
+    ACTIVATE("激活卡片"),
+    USE("使用卡片"),
+    RENEW("续费"),
+    EXPIRE("过期"),
+    REFUND("退款"),
+    DISABLE("禁用");
+
+    private final String desc;
+
+    CardEvent(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/GenderEnum.java

@@ -0,0 +1,37 @@
+package cn.novalon.gym.manage.member.enums;
+
+import lombok.Getter;
+
+/**
+ * 性别枚举
+ *
+ * @author 付嘉
+ * @date 2026-05-29
+ */
+@Getter
+public enum GenderEnum {
+
+    UNKNOWN(0, "未知"),
+    MALE(1, "男"),
+    FEMALE(2, "女");
+
+    private final Integer code;
+    private final String desc;
+
+    GenderEnum(Integer code, String desc) {
+        this.code = code;
+        this.desc = desc;
+    }
+
+    public static GenderEnum fromCode(Integer code) {
+        if (code == null) {
+            return UNKNOWN;
+        }
+        for (GenderEnum gender : values()) {
+            if (gender.code.equals(code)) {
+                return gender;
+            }
+        }
+        return UNKNOWN;
+    }
+}

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

@@ -0,0 +1,25 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 会员卡记录状态枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum MemberCardRecordStatus {
+    
+    ACTIVE("有效"),
+    USED_UP("用完"),
+    EXPIRED("过期"),
+    REFUNDED("已退款");
+
+    private final String desc;
+
+    MemberCardRecordStatus(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/MemberCardType.java

@@ -0,0 +1,24 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 会员卡类型枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum MemberCardType {
+    
+    TIME_CARD("时长卡"),
+    COUNT_CARD("次卡"),
+    STORED_VALUE_CARD("储值卡");
+
+    private final String desc;
+
+    MemberCardType(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/RefundStatus.java

@@ -0,0 +1,27 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 退款申请状态枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum RefundStatus {
+    
+    PENDING("待审核"),
+    APPROVED("已批准"),
+    REJECTED("已拒绝"),
+    PROCESSING("处理中"),
+    SUCCESS("成功"),
+    FAILED("失败");
+
+    private final String desc;
+
+    RefundStatus(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/TransactionType.java

@@ -0,0 +1,26 @@
+package cn.novalon.gym.manage.member.enums;
+
+/**
+ * 会员卡流水操作类型枚举
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public enum TransactionType {
+    
+    PURCHASE("购买"),
+    DEDUCT("扣次/扣费"),
+    RENEW("续费"),
+    REFUND("退款"),
+    EXPIRE("过期");
+
+    private final String desc;
+
+    TransactionType(String desc) {
+        this.desc = desc;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

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

@@ -1,12 +1,18 @@
 package cn.novalon.gym.manage.member.es.entity;
 
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 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;
 
+import java.time.LocalDateTime;
+
 @Data
+@NoArgsConstructor
+@AllArgsConstructor
 @Document(indexName = "gym_members")
 public class MemberES {
 

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

@@ -2,6 +2,7 @@ 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.annotations.Query;
 import org.springframework.data.elasticsearch.repository.ReactiveElasticsearchRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
@@ -15,6 +16,6 @@ public interface MemberESRepository extends ReactiveElasticsearchRepository<Memb
     /**
      * 前台通用搜索：会员号（精确匹配） 或 昵称（模糊匹配） 或 手机号（精确匹配）并且 性别筛选（精确匹配）
      */
-    Flux<MemberES> findByMemberNoOrPhoneOrNicknameContainingAndGender(
+    Flux<MemberES> findByMemberNoOrPhoneOrNicknameContaining(
-            String memberNo, String phone, String nickname,String gender, Pageable pageable);
+            String memberNo, String phone, String nickname, Pageable pageable);
 }

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

@@ -0,0 +1,50 @@
+package cn.novalon.gym.manage.member.handler;
+
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * 分布式锁服务（简化版，使用本地锁）
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Component
+public class DistributedLockService {
+
+    private final ConcurrentHashMap<String, ReentrantLock> locks = new ConcurrentHashMap<>();
+
+    /**
+     * 执行带锁的操作（业务操作）
+     */
+    public <T> Mono<T> executeWithLock(String userId, String cardType, Mono<T> operation) {
+        String lockKey = "lock:member:card:operation:" + userId + ":" + cardType;
+        ReentrantLock lock = locks.computeIfAbsent(lockKey, k -> new ReentrantLock());
+
+        lock.lock();
+        try {
+            return operation.doFinally(signalType -> lock.unlock());
+        } catch (Exception e) {
+            lock.unlock();
+            return Mono.error(e);
+        }
+    }
+
+    /**
+     * 执行带锁的操作（通用/定时任务）
+     */
+    public <T> Mono<T> executeWithLock(String lockKey, Mono<T> operation) {
+        ReentrantLock lock = locks.computeIfAbsent(lockKey, k -> new ReentrantLock());
+
+        lock.lock();
+        try {
+            return operation.doFinally(signalType -> lock.unlock());
+        } catch (Exception e) {
+            lock.unlock();
+            return Mono.error(e);
+        }
+    }
+}

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

@@ -0,0 +1,157 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Range;
+import org.springframework.data.redis.connection.RedisZSetCommands;
+import org.springframework.data.redis.core.ReactiveStringRedisTemplate;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+/**
+ * 会员卡到期提醒服务
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class ExpirationReminderService {
+
+    private final ReactiveStringRedisTemplate redisTemplate;
+    private final ObjectMapper objectMapper;
+
+    private static final String REMINDER_QUEUE = "queue:member_card_expiration";
+    private static final String DEAD_LETTER_QUEUE = "queue:member_card_expiration_dead_letter";
+    private static final int REMINDER_DAYS_BEFORE = 7;
+    private static final long MAX_DELAY_MILLIS = Duration.ofDays(365).toMillis();
+
+    /**
+     * 设置到期提醒（购卡/续费时调用）
+     */
+    public Mono<Void> scheduleExpirationReminder(MemberCardRecord record) {
+        if (record.getExpireTime() == null) {
+            return Mono.empty();
+        }
+
+        LocalDateTime now = LocalDateTime.now();
+
+        Flux<Void> reminderFlux = Flux.range(1, REMINDER_DAYS_BEFORE)
+            .flatMap(daysBefore -> {
+                LocalDateTime reminderTime = record.getExpireTime().minusDays(daysBefore);
+
+                if (reminderTime.isBefore(now)) {
+                    log.debug("会员卡记录ID={} 的{}天前提醒时间已过，跳过",
+                        record.getMemberCardRecordId(), daysBefore);
+                    return Mono.empty();
+                }
+
+                long delayMillis = Duration.between(now, reminderTime).toMillis();
+
+                if (delayMillis > MAX_DELAY_MILLIS) {
+                    log.warn("会员卡记录ID={} 的{}天后提醒时间超过1年，跳过",
+                        record.getMemberCardRecordId(), daysBefore);
+                    return Mono.empty();
+                }
+
+                try {
+                    String messageId = UUID.randomUUID().toString();
+                    String message = objectMapper.writeValueAsString(new ExpirationMessage(
+                            messageId,
+                            record.getMemberCardRecordId(),
+                            record.getMemberId(),
+                            record.getExpireTime(),
+                            daysBefore
+                    ));
+
+                    double executeTime = System.currentTimeMillis() + delayMillis;
+
+                    return redisTemplate.opsForZSet()
+                            .add(REMINDER_QUEUE, message, executeTime)
+                            .doOnSuccess(v -> log.info("设置会员卡到期提醒: recordId={}, daysBefore={}, expireTime={}, executeTime={}",
+                                    record.getMemberCardRecordId(), daysBefore, record.getExpireTime(), executeTime))
+                            .then();
+                } catch (Exception e) {
+                    log.error("设置会员卡到期提醒失败: recordId={}, daysBefore={}",
+                        record.getMemberCardRecordId(), daysBefore, e);
+                    return Mono.error(e);
+                }
+            });
+
+        return reminderFlux.then();
+    }
+
+    /**
+     * 定时任务：每分钟扫描到期的提醒并发送
+     */
+    @Scheduled(fixedRate = 60000)
+    public void processDueReminders() {
+        double now = System.currentTimeMillis();
+
+        redisTemplate.opsForZSet()
+                .rangeByScoreWithScores(
+                        REMINDER_QUEUE,
+                        Range.from(Range.Bound.inclusive(0.0))
+                                .to(Range.Bound.inclusive(now)),
+                        RedisZSetCommands.Limit.limit().count(100)
+                )
+                .flatMap(tuple -> {
+                    String message = tuple.getValue();
+                    if (message == null) {
+                        return Mono.empty();
+                    }
+
+                    return Mono.fromCallable(() -> objectMapper.readValue(message, ExpirationMessage.class))
+                        .flatMap(expirationMessage -> {
+                            log.info("处理到期提醒: messageId={}, memberId={}, expireTime={}, daysBefore={}",
+                                    expirationMessage.messageId(),
+                                    expirationMessage.memberId(),
+                                    expirationMessage.expireTime(),
+                                    expirationMessage.daysBefore());
+
+                            // TODO: 集成微信/短信通知服务
+                            sendNotification(expirationMessage);
+
+                            return redisTemplate.opsForZSet()
+                                .remove(REMINDER_QUEUE, message)
+                                .doOnSuccess(removed -> {
+                                    if (removed > 0) {
+                                        log.info("成功删除已处理的提醒消息");
+                                    }
+                                });
+                        })
+                        .onErrorResume(e -> {
+                            log.error("解析到期提醒消息失败，移至死信队列: message={}", message, e);
+                            return redisTemplate.opsForZSet()
+                                .add(DEAD_LETTER_QUEUE, message, System.currentTimeMillis())
+                                .then(Mono.empty());
+                        });
+                })
+                .then()
+                .subscribe();
+    }
+
+
+    private void sendNotification(ExpirationMessage reminder) {
+        // TODO: 实际项目中调用微信模板消息或短信API
+        log.info("[模拟发送] 会员卡到期提醒 - 会员ID: {}, 到期时间: {}, 提前天数: {}",
+            reminder.memberId(), reminder.expireTime(), reminder.daysBefore());
+    }
+
+    public record ExpirationMessage(
+            String messageId,
+            Long recordId,
+            Long memberId,
+            LocalDateTime expireTime,
+            int daysBefore
+    ) {}
+}

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

@@ -0,0 +1,132 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.service.IMemberCardService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import reactor.core.publisher.Mono;
+
+/**
+ * 会员卡管理处理器
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Slf4j
+@Component
+@Tag(name = "会员卡管理", description = "会员卡类型管理和会员持卡管理")
+public class MemberCardHandler {
+
+    private final IMemberCardService memberCardService;
+
+    public MemberCardHandler(IMemberCardService memberCardService) {
+        this.memberCardService = memberCardService;
+    }
+
+    @Operation(summary = "根据ID查询会员卡类型", description = "查询指定ID的会员卡类型详情")
+    public Mono<ServerResponse> getMemberCardById(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+        return memberCardService.findByMemberCardIdAndDeletedAtIsNull(id)
+                .flatMap(card -> ServerResponse.ok().bodyValue(card))
+                .switchIfEmpty(ServerResponse.notFound().build());
+    }
+
+    @Operation(summary = "查询会员卡类型列表", description = "支持分页和条件查询")
+    public Mono<ServerResponse> listMemberCards(ServerRequest request) {
+        Integer status = request.queryParam("status").map(Integer::valueOf).orElse(null);
+        String name = request.queryParam("name").orElse(null);
+        String type = request.queryParam("type").orElse(null);
+        Double minPrice = request.queryParam("minPrice").map(Double::valueOf).orElse(null);
+        Double maxPrice = request.queryParam("maxPrice").map(Double::valueOf).orElse(null);
+        int page = request.queryParam("page").map(Integer::valueOf).orElse(0);
+        int size = request.queryParam("size").map(Integer::valueOf).orElse(10);
+
+        var pageable = PageRequest.of(page, size);
+        return ServerResponse.ok()
+                .body(memberCardService.findWithConditions(status, name, type, minPrice, maxPrice, pageable),
+                        MemberCard.class);
+    }
+
+    @Operation(summary = "创建会员卡类型", description = "创建新的会员卡类型（时长卡、次卡或储值卡）")
+    public Mono<ServerResponse> createMemberCard(ServerRequest request) {
+        return request.bodyToMono(MemberCard.class)
+                .flatMap(memberCardService::save)
+                .flatMap(card -> ServerResponse.status(HttpStatus.CREATED).bodyValue(card));
+    }
+
+    @Operation(summary = "更新会员卡类型", description = "更新会员卡类型信息")
+    public Mono<ServerResponse> updateMemberCard(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+        return request.bodyToMono(MemberCard.class)
+                .flatMap(card -> {
+                    card.setMemberCardId(id);
+                    return memberCardService.save(card);
+                })
+                .flatMap(updated -> ServerResponse.ok().bodyValue(updated))
+                .switchIfEmpty(ServerResponse.notFound().build());
+    }
+
+    @Operation(summary = "删除会员卡类型", description = "逻辑删除会员卡类型")
+    public Mono<ServerResponse> deleteMemberCard(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+        return memberCardService.logicalDelete(id)
+                .flatMap(rows -> {
+                    if (rows > 0) {
+                        return ServerResponse.noContent().build();
+                    }
+                    return ServerResponse.notFound().build();
+                });
+    }
+
+    @Operation(summary = "购买会员卡", description = "会员购买会员卡，生成会员卡记录")
+    public Mono<ServerResponse> purchaseCard(ServerRequest request) {
+        Long memberId = Long.valueOf(request.queryParam("memberId").orElseThrow());
+        Long memberCardId = Long.valueOf(request.queryParam("memberCardId").orElseThrow());
+        Long sourceOrderId = request.queryParam("sourceOrderId").map(Long::valueOf).orElse(null);
+
+        return memberCardService.purchaseCard(memberId, memberCardId, sourceOrderId)
+                .flatMap(record -> ServerResponse.status(HttpStatus.CREATED).bodyValue(record));
+    }
+
+    @Operation(summary = "续费会员卡", description = "为已有会员卡续费")
+    public Mono<ServerResponse> renewCard(ServerRequest request) {
+        Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
+        Integer addTimes = request.queryParam("addTimes").map(Integer::valueOf).orElse(null);
+        Double addAmount = request.queryParam("addAmount").map(Double::valueOf).orElse(null);
+        Integer addDays = request.queryParam("addDays").map(Integer::valueOf).orElse(null);
+        Long sourceOrderId = request.queryParam("sourceOrderId").map(Long::valueOf).orElse(null);
+
+        return memberCardService.renewCard(recordId, addTimes, addAmount, addDays, sourceOrderId)
+                .flatMap(record -> ServerResponse.ok().bodyValue(record));
+    }
+
+    @Operation(summary = "使用会员卡", description = "扣减会员卡次数或余额")
+    public Mono<ServerResponse> useCard(ServerRequest request) {
+        Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
+        Integer deductTimes = request.queryParam("deductTimes").map(Integer::valueOf).orElse(null);
+        Double deductAmount = request.queryParam("deductAmount").map(Double::valueOf).orElse(null);
+
+        return memberCardService.useCard(recordId, deductTimes, deductAmount)
+                .flatMap(record -> ServerResponse.ok().bodyValue(record));
+    }
+
+    @Operation(summary = "退款会员卡", description = "申请会员卡退款")
+    public Mono<ServerResponse> refundCard(ServerRequest request) {
+        Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
+        return memberCardService.refundCard(recordId)
+                .then(ServerResponse.noContent().build());
+    }
+
+    @Operation(summary = "查询有效会员卡", description = "查询指定状态的会员卡类型")
+    public Mono<ServerResponse> getActiveCards(ServerRequest request) {
+        Integer status = request.queryParam("status").map(Integer::valueOf).orElse(1);
+        return ServerResponse.ok()
+                .body(memberCardService.findActiveCards(status), MemberCard.class);
+    }
+}

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

@@ -0,0 +1,118 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
+import cn.novalon.gym.manage.member.service.IMemberCardService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.Data;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import reactor.core.publisher.Mono;
+
+/**
+ * 会员卡记录管理处理器
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Component
+@Tag(name = "会员卡记录管理", description = "会员卡购买、续费、使用、退款等核心业务")
+public class MemberCardRecordHandler {
+
+    private final IMemberCardService memberCardService;
+    private final IMemberCardRecordService memberCardRecordService;
+
+    public MemberCardRecordHandler(IMemberCardService memberCardService,
+                                   IMemberCardRecordService memberCardRecordService) {
+        this.memberCardService = memberCardService;
+        this.memberCardRecordService = memberCardRecordService;
+    }
+
+    @Operation(summary = "购买会员卡", description = "支持时长卡、次卡、储值卡，自动设置到期提醒")
+    public Mono<ServerResponse> purchaseCard(ServerRequest request) {
+        return request.bodyToMono(PurchaseRequest.class)
+                .flatMap(body -> memberCardService.purchaseCard(
+                        body.getMemberId(),
+                        body.getMemberCardId(),
+                        body.getSourceOrderId()))
+                .flatMap(record -> ServerResponse.ok().bodyValue(record))
+                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("购买失败: " + e.getMessage()));
+    }
+
+    @Operation(summary = "续费会员卡", description = "累加剩余次数/余额，顺延到期日期，权益立即生效")
+    public Mono<ServerResponse> renewCard(ServerRequest request) {
+        Long recordId = Long.parseLong(request.pathVariable("recordId"));
+        return request.bodyToMono(RenewRequest.class)
+                .flatMap(body -> memberCardService.renewCard(recordId,
+                        body.getAddTimes(),
+                        body.getAddAmount(),
+                        body.getAddDays(),
+                        body.getSourceOrderId()))
+                .flatMap(record -> ServerResponse.ok().bodyValue(record))
+                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("续费失败: " + e.getMessage()));
+    }
+
+    @Operation(summary = "使用会员卡", description = "预约团课或私教成功后扣减次数或余额")
+    public Mono<ServerResponse> useCard(ServerRequest request) {
+        Long recordId = Long.parseLong(request.pathVariable("recordId"));
+        return request.bodyToMono(UseCardRequest.class)
+                .flatMap(body -> memberCardService.useCard(recordId,
+                        body.getDeductTimes(),
+                        body.getDeductAmount()))
+                .flatMap(record -> ServerResponse.ok().bodyValue(record))
+                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("使用失败: " + e.getMessage()));
+    }
+
+    @Operation(summary = "退款会员卡", description = "使用Saga模式执行退款流程，保证事务一致性")
+    public Mono<ServerResponse> refundCard(ServerRequest request) {
+        Long recordId = Long.parseLong(request.pathVariable("recordId"));
+        return memberCardService.refundCard(recordId)
+                .then(ServerResponse.ok().bodyValue("退款成功"))
+                .onErrorResume(e -> ServerResponse.badRequest().bodyValue("退款失败: " + e.getMessage()));
+    }
+
+    @Operation(summary = "查询会员卡记录详情", description = "根据记录ID查询详细信息")
+    public Mono<ServerResponse> getMemberCardRecordById(ServerRequest request) {
+        Long recordId = Long.parseLong(request.pathVariable("recordId"));
+        return memberCardRecordService.findById(recordId)
+                .flatMap(record -> ServerResponse.ok().bodyValue(record))
+                .switchIfEmpty(ServerResponse.notFound().build());
+    }
+
+    @Operation(summary = "会员我的卡包", description = "查询当前会员的所有有效卡")
+    public Mono<ServerResponse> getMyCards(ServerRequest request) {
+        Long memberId = Long.parseLong(request.pathVariable("memberId"));
+        return ServerResponse.ok().body(
+                memberCardRecordService.findActiveCardsByMemberId(memberId),
+                MemberCardRecord.class);
+    }
+
+    @Operation(summary = "处理过期会员卡", description = "定时任务调用，扫描并更新过期卡状态")
+    public Mono<ServerResponse> processExpiredCards(ServerRequest request) {
+        return memberCardService.processExpiredCards()
+                .flatMap(count -> ServerResponse.ok().bodyValue("处理完成，共处理" + count + "条"));
+    }
+
+    @Data
+    public static class PurchaseRequest {
+        private Long memberId;
+        private Long memberCardId;
+        private Long sourceOrderId;
+    }
+
+    @Data
+    public static class UseCardRequest {
+        private Integer deductTimes;
+        private Double deductAmount;
+    }
+
+    @Data
+    public static class RenewRequest {
+        private Integer addTimes;
+        private Double addAmount;
+        private Integer addDays;
+        private Long sourceOrderId;
+    }
+}

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

@@ -0,0 +1,102 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.enums.CardEvent;
+import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡定时任务处理器
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class MemberCardScheduledHandler {
+
+    private final MemberCardRecordRepository recordRepository;
+    private final ExpirationReminderService expirationReminderService;
+    private final MemberCardStateMachine stateMachine;
+    private final DistributedLockService distributedLockService;
+
+    /**
+     * 每日凌晨2点检查过期会员卡
+     */
+    @Scheduled(cron = "0 0 2 * * ?")
+    public void checkExpiredCards() {
+        String lockKey = "scheduled:check_expired_cards";
+
+        distributedLockService.executeWithLock("SYSTEM", "EXPIRE_CHECK",
+            Mono.fromRunnable(() -> {
+                log.info("开始执行会员卡过期检查任务");
+
+                LocalDateTime now = LocalDateTime.now();
+
+                recordRepository.findActiveRecords()
+                    .filter(record -> record.getExpireTime() != null && record.getExpireTime().isBefore(now))
+                    .flatMap(record ->
+                            stateMachine.transition(record.getStatus(), CardEvent.EXPIRE)
+                                    .flatMap(newState -> {
+                                        record.setStatus(newState);
+                                        return recordRepository.save(record);
+                                    })
+                                .doOnSuccess(r -> log.info("会员卡记录ID={} 已标记为过期", r.getMemberCardRecordId()))
+                                .onErrorResume(e -> {
+                                    log.error("处理会员卡过期失败: recordId={}", record.getMemberCardRecordId(), e);
+                                    return Mono.empty();
+                                })
+                        )
+                        .then()
+                        .subscribe();
+            })
+        ).subscribe();
+    }
+
+    /**
+     * 每日凌晨3点检查是否有遗漏的到期提醒（兜底机制）
+     */
+    @Scheduled(cron = "0 0 3 * * ?")
+    public void checkAndSendExpirationReminders() {
+        String lockKey = "scheduled:expiration_reminder";
+
+        distributedLockService.executeWithLock("SYSTEM", "REMINDER_CHECK",
+            Mono.fromRunnable(() -> {
+                log.info("开始执行到期提醒兜底检查任务");
+
+                LocalDateTime now = LocalDateTime.now();
+
+                // 查询所有活跃的会员卡
+                recordRepository.findActiveRecords()
+                    .filter(record -> record.getExpireTime() != null)
+                    .flatMap(record -> {
+                        try {
+                            // 计算距离到期还有几天
+                            long daysBetween = java.time.Duration.between(now, record.getExpireTime()).toDays();
+
+                            // 如果到期时间在1-7天范围内，记录日志供人工检查
+                            if (daysBetween >= 1 && daysBetween <= 7) {
+                                log.warn("发现到期前{}天的会员卡记录ID={}，请确认是否已发送提醒",
+                                    daysBetween, record.getMemberCardRecordId());
+                            }
+
+                            return Mono.empty();
+                        } catch (Exception e) {
+                            log.error("检查到期提醒失败: recordId={}", record.getMemberCardRecordId(), e);
+                            return Mono.empty();
+                        }
+                    })
+                    .then()
+                    .subscribe();
+            })
+        ).subscribe();
+
+        log.info("到期提醒兜底检查任务完成");
+    }
+}

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

@@ -0,0 +1,91 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.enums.CardEvent;
+import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 会员卡状态机处理器
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Slf4j
+@Component
+public class MemberCardStateMachine {
+
+    private final Map<MemberCardRecordStatus, Map<CardEvent, MemberCardRecordStatus>> stateTransitionMap;
+
+    public MemberCardStateMachine() {
+        this.stateTransitionMap = buildStateTransitionMap();
+    }
+
+    private Map<MemberCardRecordStatus, Map<CardEvent, MemberCardRecordStatus>> buildStateTransitionMap() {
+        Map<MemberCardRecordStatus, Map<CardEvent, MemberCardRecordStatus>> map = new HashMap<>();
+
+        // ACTIVE 状态可以转换的事件
+        Map<CardEvent, MemberCardRecordStatus> activeTransitions = new HashMap<>();
+        activeTransitions.put(CardEvent.USE, MemberCardRecordStatus.ACTIVE);
+        activeTransitions.put(CardEvent.RENEW, MemberCardRecordStatus.ACTIVE);
+        activeTransitions.put(CardEvent.EXPIRE, MemberCardRecordStatus.EXPIRED);
+        activeTransitions.put(CardEvent.REFUND, MemberCardRecordStatus.REFUNDED);
+        map.put(MemberCardRecordStatus.ACTIVE, activeTransitions);
+
+        // USED_UP 状态可以转换的事件
+        Map<CardEvent, MemberCardRecordStatus> usedUpTransitions = new HashMap<>();
+        usedUpTransitions.put(CardEvent.RENEW, MemberCardRecordStatus.ACTIVE);
+        usedUpTransitions.put(CardEvent.REFUND, MemberCardRecordStatus.REFUNDED);
+        map.put(MemberCardRecordStatus.USED_UP, usedUpTransitions);
+
+        // EXPIRED 状态可以转换的事件
+        Map<CardEvent, MemberCardRecordStatus> expiredTransitions = new HashMap<>();
+        expiredTransitions.put(CardEvent.RENEW, MemberCardRecordStatus.ACTIVE);
+        map.put(MemberCardRecordStatus.EXPIRED, expiredTransitions);
+
+        // REFUNDED 状态是终态，不允许任何转换
+
+        return map;
+    }
+
+    public Mono<Boolean> canTransition(MemberCardRecordStatus currentState, CardEvent event) {
+        return Mono.fromSupplier(() -> {
+            Map<CardEvent, MemberCardRecordStatus> transitions = stateTransitionMap.get(currentState);
+            if (transitions == null) {
+                return false;
+            }
+            return transitions.containsKey(event);
+        });
+    }
+
+    public Mono<MemberCardRecordStatus> transition(MemberCardRecordStatus currentState, CardEvent event) {
+        return Mono.fromSupplier(() -> {
+            Map<CardEvent, MemberCardRecordStatus> transitions = stateTransitionMap.get(currentState);
+            if (transitions == null || !transitions.containsKey(event)) {
+                log.error("Invalid state transition: currentState={}, event={}", currentState, event);
+                throw new IllegalStateException(
+                        String.format("不允许的状态转换: 当前状态=%s, 事件=%s", currentState, event));
+            }
+            MemberCardRecordStatus newState = transitions.get(event);
+            log.info("State transition: {} --({})--> {}", currentState, event, newState);
+            return newState;
+        });
+    }
+
+    public Mono<Void> validateTransition(MemberCardRecord card, CardEvent event) {
+        return canTransition(card.getStatus(), event)
+                .flatMap(canTransition -> {
+                    if (!canTransition) {
+                        return Mono.error(new IllegalStateException(
+                                String.format("会员卡记录ID=%d 不允许的状态转换: 当前状态=%s, 事件=%s",
+                                        card.getMemberCardRecordId(), card.getStatus(), event)));
+                    }
+                    return Mono.empty();
+                });
+    }
+}

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

@@ -0,0 +1,152 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.hutool.db.PageResult;
+import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
+import cn.novalon.gym.manage.member.enums.TransactionType;
+import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Validator;
+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 付嘉
+ * @date 2026-05-27
+ */
+@Component
+@Tag(name = "会员卡流水管理", description = "会员卡流水相关操作")
+public class MemberCardTransactionHandler {
+
+    private final IMemberCardTransactionService memberCardTransactionService;
+    private final Validator validator;
+
+    public MemberCardTransactionHandler(IMemberCardTransactionService memberCardTransactionService,
+                                        Validator validator) {
+        this.memberCardTransactionService = memberCardTransactionService;
+        this.validator = validator;
+    }
+
+    /**
+     * 记录每一次变动
+     */
+    @Operation(summary = "插入流水记录", description = "购卡、扣次、续费、退款、过期时插入流水")
+    public Mono<ServerResponse> insertTransaction(ServerRequest request) {
+        return request.bodyToMono(MemberCardTransaction.class)
+                .flatMap(memberCardTransactionService::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(memberCardTransactionService.findByMemberIdAndTimeRange(
+                        memberId, startTime, endTime, pageable), MemberCardTransaction.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);
+        TransactionType operationType = request.queryParam("operationType")
+                .map(s -> TransactionType.valueOf(s.toUpperCase())).orElse(null);
+        LocalDateTime startTime = request.queryParam("startTime").map(LocalDateTime::parse).orElse(null);
+        LocalDateTime endTime = request.queryParam("endTime").map(LocalDateTime::parse).orElse(null);
+        int page = request.queryParam("page").map(Integer::parseInt).orElse(0);
+        int size = request.queryParam("size").map(Integer::parseInt).orElse(10);
+        Pageable pageable = PageRequest.of(page, size, Sort.by("created_at").descending());
+
+        Mono<Long> countMono = memberCardTransactionService.countWithConditions(
+                memberId, memberCardId, operationType, startTime, endTime);
+        Flux<MemberCardTransaction> flux = memberCardTransactionService.findWithConditions(
+                memberId, memberCardId, operationType, startTime, endTime, pageable);
+
+        return Mono.zip(countMono, flux.collectList())
+                .flatMap(tuple -> {
+                    Long total = tuple.getT1();
+                    List<MemberCardTransaction> list = tuple.getT2();
+                    // 构造 PageResult，内部自动计算总页数
+                    PageResult<MemberCardTransaction> 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(memberCardTransactionService.findByMemberCardId(memberCardId),
+                        MemberCardTransaction.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 memberCardTransactionService.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 memberCardTransactionService.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 memberCardTransactionService.sumPurchaseAmountByMemberId(memberId, startTime, endTime)
+                .flatMap(amount -> ServerResponse.ok().bodyValue(amount));
+    }
+}

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

@@ -8,6 +8,7 @@ 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.WechatPhoneUtil;
 import cn.novalon.gym.manage.sys.util.AuthUtil;
 import cn.novalon.gym.manage.sys.security.JwtTokenProvider;
 import lombok.RequiredArgsConstructor;
@@ -34,8 +35,6 @@ 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;
 
     /**
@@ -179,11 +178,21 @@ public class MemberHandler {
 
         log.info("前台查看会员信息, adminId: {}, memberId: {}", adminId, memberId);
 
-        // TODO 多表查询：会员信息、团课信息、会员卡信息
+        return memberService.getMemberDetail(memberId)
-
+                .flatMap(detail -> {
+                    if (detail.getPhone() != null && !detail.getPhone().isEmpty()) {
+                        try {
+                            String decryptedPhone = AesUtil.decrypt(detail.getPhone());
+                            detail.setPhone(WechatPhoneUtil.maskPhone(decryptedPhone));
+                        } catch (Exception e) {
+                            log.error("手机号解密失败, memberId: {}", detail.getId(), e);
+                            detail.setPhone(null);
+                        }
+                    }
                     return ServerResponse.ok()
                         .contentType(MediaType.APPLICATION_JSON)
-                .bodyValue("成功");
+                        .bodyValue(detail);
+                });
     }
 
     /**
@@ -201,13 +210,14 @@ public class MemberHandler {
         long memberId = NumberUtils.toLong(memberIdStr, 0L);
         if(memberId <= 0L) throw new IllegalArgumentException("会员ID格式错误");
 
+        // TODO: 补充签到记录
         log.info("前台编辑会员信息, adminId: {}, memberId: {}", adminId, memberId);
 
-        // TODO 多表查询：会员信息、团课信息、会员卡信息
+        return request.bodyToMono(UpdateMemberInfoDto.class)
-
+                .flatMap(updateDto -> memberService.adminUpdateMemberInfo(memberId, updateDto))
-        return ServerResponse.ok()
+                .flatMap(detail -> ServerResponse.ok()
                         .contentType(MediaType.APPLICATION_JSON)
-                .bodyValue("成功");
+                        .bodyValue(detail));
     }
 
     /**
@@ -221,9 +231,9 @@ public class MemberHandler {
         Long adminId = authUtil.getMemberIdOrThrow(request);
 
         String keyword = request.queryParam("searchValue").orElse(null);
-        String filter = request.queryParam("filter").orElse(null);
+        Integer filter = NumberUtils.toInt(request.queryParam("filter").orElse("-1"), -1);
-        int pageNum = NumberUtils.toInt(request.queryParam("pageNum").orElse("1"), 1);
+        Integer pageNum = NumberUtils.toInt(request.queryParam("pageNum").orElse("1"), 1);
-        int pageSize = NumberUtils.toInt(request.queryParam("pageSize").orElse("10"), 10);
+        Integer pageSize = NumberUtils.toInt(request.queryParam("pageSize").orElse("10"), 10);
 
         log.info("前台搜索会员列表, adminId: {}, keyword: {}, filter: {}, pageNum: {}, pageSize: {}",
                 adminId, keyword, filter, pageNum, pageSize);
@@ -233,10 +243,8 @@ public class MemberHandler {
                     // 解密手机号
                     if (member.getPhone() != null && !member.getPhone().isEmpty()) {
                         try {
-                            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
+                            String decryptedPhone = AesUtil.decrypt(member.getPhone());
-                            String iv = wechatProperties.getPhoneEncryption().getIv();
+                            member.setPhone(WechatPhoneUtil.maskPhone(decryptedPhone));
-                            String decryptedPhone = AesUtil.decrypt(member.getPhone(), secretKey, iv);
-                            member.setPhone(decryptedPhone);
                         } catch (Exception e) {
                             log.error("手机号解密失败, memberId: {}", member.getId(), e);
                             member.setPhone(null);
@@ -263,16 +271,15 @@ public class MemberHandler {
         int pageSize = NumberUtils.toInt(request.queryParam("pageSize").orElse("10"), 10);
 
         log.info("前台查看会员列表, adminId: {}, pageNum: {}, pageSize: {}", adminId, pageNum, pageSize);
+        // TODO: 补充签到记录
 
         return memberService.findAll(pageNum, pageSize)
                 .map(member -> {
                     // 解密手机号
                     if (member.getPhone() != null && !member.getPhone().isEmpty()) {
                         try {
-                            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
+                            String decryptedPhone = AesUtil.decrypt(member.getPhone());
-                            String iv = wechatProperties.getPhoneEncryption().getIv();
+                            member.setPhone(WechatPhoneUtil.maskPhone(decryptedPhone));
-                            String decryptedPhone = AesUtil.decrypt(member.getPhone(), secretKey, iv);
-                            member.setPhone(decryptedPhone);
                         } catch (Exception e) {
                             log.error("手机号解密失败, memberId: {}", member.getId(), e);
                             member.setPhone(null);

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

@@ -0,0 +1,134 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
+import cn.novalon.gym.manage.member.enums.CardEvent;
+import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
+import cn.novalon.gym.manage.member.enums.TransactionType;
+import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
+import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 退款 Saga 处理器
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class RefundSagaHandler {
+
+    private final MemberCardRecordRepository recordRepository;
+    private final IMemberCardTransactionService transactionService;
+    private final MemberCardStateMachine stateMachine;
+
+    public Mono<Void> executeRefund(Long recordId) {
+        return recordRepository.findById(recordId)
+                .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
+                .flatMap(record -> stateMachine.validateTransition(record, CardEvent.REFUND)
+                        .then(Mono.defer(() -> doExecuteRefund(recordId, record))));
+    }
+
+    private Mono<Void> doExecuteRefund(Long recordId, MemberCardRecord record) {
+        List<SagaStep> steps = new ArrayList<>();
+        List<SagaStep> rollbackSteps = new ArrayList<>();
+
+        SagaStep step1 = new SagaStep(
+                "更新会员卡状态为已退款",
+                updateCardStatus(recordId, MemberCardRecordStatus.REFUNDED),
+                Mono.defer(() -> updateCardStatus(recordId, record.getStatus()))
+        );
+        steps.add(step1);
+        rollbackSteps.add(0, step1);
+
+        SagaStep step2 = new SagaStep(
+                "记录退款流水",
+                createRefundTransaction(record),
+                createReversalTransaction(record)
+        );
+        steps.add(step2);
+        rollbackSteps.add(0, step2);
+
+        return executeSaga(steps, rollbackSteps);
+    }
+
+    private Mono<Void> updateCardStatus(Long recordId, MemberCardRecordStatus status) {
+        return recordRepository.updateStatus(recordId, status.name())
+                .flatMap(rows -> {
+                    if (rows == 0) {
+                        return Mono.error(new RuntimeException("更新会员卡状态失败"));
+                    }
+                    return Mono.empty();
+                });
+    }
+
+    private Mono<Void> createRefundTransaction(MemberCardRecord record) {
+        MemberCardTransaction transaction = MemberCardTransaction.builder()
+                .memberId(record.getMemberId())
+                .memberCardId(record.getMemberCardId())
+                .operationType(TransactionType.REFUND.name())
+                .changeAmount(-record.getRemainingTimes())
+                .changeBalance(-record.getRemainingAmount())
+                .afterRemainingCount(0)
+                .afterRemainingBalance(0.0)
+                .remark("会员卡退款")
+                .build();
+
+        return transactionService.createTransaction(transaction);
+    }
+
+    private Mono<Void> createReversalTransaction(MemberCardRecord record) {
+        MemberCardTransaction reversal = MemberCardTransaction.builder()
+                .memberId(record.getMemberId())
+                .memberCardId(record.getMemberCardId())
+                .operationType(TransactionType.REFUND.name())
+                .changeAmount(record.getRemainingTimes())
+                .changeBalance(record.getRemainingAmount())
+                .remark("退款冲正")
+                .build();
+
+        return transactionService.createTransaction(reversal);
+    }
+
+    private Mono<Void> executeSaga(List<SagaStep> steps, List<SagaStep> rollbackSteps) {
+        return executeStep(steps, 0, rollbackSteps);
+    }
+
+    private Mono<Void> executeStep(List<SagaStep> steps, int index, List<SagaStep> rollbackSteps) {
+        if (index >= steps.size()) {
+            return Mono.empty();
+        }
+
+        SagaStep currentStep = steps.get(index);
+
+        return currentStep.operation()
+                .then(Mono.defer(() -> executeStep(steps, index + 1, rollbackSteps)))
+                .onErrorResume(error -> {
+                    log.error("Saga步骤执行失败: step={}, error={}", currentStep.description(), error.getMessage());
+                    return rollback(rollbackSteps, 0).then(Mono.error(error));
+                });
+    }
+
+    private Mono<Void> rollback(List<SagaStep> rollbackSteps, int index) {
+        if (index >= rollbackSteps.size()) {
+            return Mono.empty();
+        }
+
+        SagaStep currentStep = rollbackSteps.get(index);
+
+        return currentStep.rollbackOperation()
+                .then(Mono.defer(() -> rollback(rollbackSteps, index + 1)))
+                .doOnError(error -> log.error("Saga回滚失败: step={}, error={}", currentStep.description(), error.getMessage()))
+                .onErrorResume(e -> Mono.empty());
+    }
+
+    private record SagaStep(String description, Mono<Void> operation, Mono<Void> rollbackOperation) {}
+}

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

@@ -1,7 +1,9 @@
 package cn.novalon.gym.manage.member.repository;
 
 import cn.novalon.gym.manage.member.entity.Member;
+import cn.novalon.gym.manage.member.vo.MemberCardInfoVO;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.r2dbc.repository.Query;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
@@ -30,7 +32,44 @@ public interface IMemberRepository extends R2dbcRepository<Member, Long> {
 
     /**
      * 分页查询所有会员
-     * 方法名 findAllBy 是 Spring Data 的约定，表示按条件查询所有
      */
     Flux<Member> findAllBy(Pageable pageable);
+
+    /**
+     * 查询会员的所有卡片
+     */
+    @Query("SELECT " +
+            "   r.id, " +
+            "   r.member_card_record_id, " +
+            "   r.member_id, " +
+            "   r.member_card_id, " +
+            "   r.status, " +
+            "   r.remaining_times, " +
+            "   r.remaining_amount, " +
+            "   r.expire_time, " +
+            "   r.purchase_time, " +
+            "   r.source_order_id, " +
+            "   r.created_at, " +
+            "   r.updated_at, " +
+            "   r.version, " +
+            "   r.card_composition, " +
+            "   c.id AS card_id, " +
+            "   c.member_card_id, " +
+            "   c.member_card_name, " +
+            "   c.member_card_type, " +
+            "   c.member_card_price, " +
+            "   c.member_card_validity_days, " +
+            "   c.member_card_total_times, " +
+            "   c.member_card_amount, " +
+            "   c.member_card_status, " +
+            "   c.extra_config, " +
+            "   c.created_at AS card_created_at, " +
+            "   c.updated_at AS card_updated_at " +
+            "FROM member_card_record r " +
+            "LEFT JOIN member_card c ON r.member_card_id = c.id " +
+            "WHERE r.member_id = :memberId " +
+            "AND r.deleted_at IS NULL " +
+            "AND c.deleted_at IS NULL " +
+            "ORDER BY r.created_at DESC")
+    Flux<MemberCardInfoVO> findCardRecordsWithCardInfoByMemberId(Long memberId);
 }

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

@@ -0,0 +1,109 @@
+package cn.novalon.gym.manage.member.repository;
+
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.r2dbc.repository.Modifying;
+import org.springframework.data.r2dbc.repository.Query;
+import org.springframework.data.r2dbc.repository.R2dbcRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡记录 Repository（会员持有的卡）
+ *
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Repository
+public interface MemberCardRecordRepository extends R2dbcRepository<MemberCardRecord, Long> {
+
+    /**
+     * 插入新的激活卡记录
+     */
+    @Modifying
+    @Query("INSERT INTO member_card_record (member_id, member_card_id, status, expire_time, remaining_times, remaining_amount, source_order_id, purchase_time, created_at, updated_at) " +
+            "VALUES (:memberId, :memberCardId, 'ACTIVE', :expireTime, :remainingTimes, :remainingAmount, :sourceOrderId, NOW(), NOW(), NOW()) " +
+            "RETURNING *")
+    Mono<MemberCardRecord> insertActiveRecord(Long memberId, Long memberCardId,
+                                              LocalDateTime expireTime, Integer remainingTimes,
+                                              Double remainingAmount, Long sourceOrderId);
+
+    /**
+     * 扣减使用次数/金额
+     */
+    @Modifying
+    @Query("UPDATE member_card_record SET " +
+            "remaining_times = remaining_times - :deductTimes, " +
+            "remaining_amount = remaining_amount - :deductAmount, " +
+            "updated_at = NOW() " +
+            "WHERE member_card_record_id = :recordId " +
+            "AND deleted_at IS NULL " +
+            "AND remaining_times >= :deductTimes " +
+            "AND remaining_amount >= :deductAmount")
+    Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
+
+    /**
+     * 续费卡片
+     */
+    @Modifying
+    @Query("UPDATE member_card_record SET remaining_times = remaining_times + :addTimes, " +
+            "remaining_amount = remaining_amount + :addAmount, expire_time = :newExpireTime, updated_at = NOW() " +
+            "WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
+    Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime);
+
+    /**
+     * 更新卡片状态
+     */
+    @Modifying
+    @Query("UPDATE member_card_record SET status = :status, updated_at = NOW() " +
+            "WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
+    Mono<Integer> updateStatus(Long recordId, String status);
+
+    /**
+     * 查询会员的有效卡片
+     */
+    @Query("SELECT * FROM member_card_record WHERE member_id = :memberId AND status = 'ACTIVE' AND deleted_at IS NULL ORDER BY expire_time ASC")
+    Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
+
+    /**
+     * 查询会员的所有卡片（分页）
+     */
+    @Query("SELECT mcr.* FROM member_card_record mcr " +
+            "INNER JOIN member_user m ON mcr.member_id = m.id " +
+            "WHERE mcr.member_id = :memberId AND mcr.deleted_at IS NULL " +
+            "ORDER BY mcr.purchase_time DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
+    Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
+
+    /**
+     * 验证次卡是否有足够次数
+     */
+    @Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
+            "AND status = 'ACTIVE' AND deleted_at IS NULL " +
+            "AND expire_time > NOW() " +
+            "AND remaining_times >= :requiredTimes")
+    Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
+
+    /**
+     * 验证储值卡是否有足够余额
+     */
+    @Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
+            "AND status = 'ACTIVE' AND deleted_at IS NULL " +
+            "AND expire_time > NOW() " +
+            "AND remaining_amount >= :requiredAmount")
+    Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
+
+    /**
+     * 查询已过期的卡片
+     */
+    @Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND expire_time < NOW() AND deleted_at IS NULL LIMIT 500")
+    Flux<MemberCardRecord> findExpiredCards();
+
+    /**
+     * 查询所有有效记录
+     */
+    @Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND deleted_at IS NULL")
+    Flux<MemberCardRecord> findActiveRecords();
+}

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

@@ -0,0 +1,91 @@
+package cn.novalon.gym.manage.member.repository;
+
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.r2dbc.repository.Modifying;
+import org.springframework.data.r2dbc.repository.Query;
+import org.springframework.data.r2dbc.repository.R2dbcRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * 会员卡类型 Repository
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Repository
+public interface MemberCardRepository extends R2dbcRepository<MemberCard, Long> {
+
+    /**
+     * 根据会员卡ID查询（未删除的）
+     */
+    Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
+
+    /**
+     * 条件查询会员卡列表
+     */
+    @Query("SELECT * FROM member_card WHERE deleted_at IS NULL " +
+            "AND (:status IS NULL OR member_card_status = :status) " +
+            "AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
+            "AND (:type IS NULL OR member_card_type = :type) " +
+            "AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
+            "AND (:maxPrice IS NULL OR member_card_price <= :maxPrice) " +
+            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
+    Flux<MemberCard> findWithConditions(Integer status, String name, String type,
+                                        Double minPrice, Double maxPrice, Pageable pageable);
+
+    /**
+     * 统计符合条件的会员卡总数
+     */
+    @Query("SELECT COUNT(*) FROM member_card WHERE deleted_at IS NULL " +
+            "AND (:status IS NULL OR member_card_status = :status) " +
+            "AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
+            "AND (:type IS NULL OR member_card_type = :type) " +
+            "AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
+            "AND (:maxPrice IS NULL OR member_card_price <= :maxPrice)")
+    Mono<Long> countWithConditions(Integer status, String name, String type,
+                                   Double minPrice, Double maxPrice);
+
+    /**
+     * 按状态查询会员卡列表
+     */
+    Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
+
+    /**
+     * 检查会员卡是否已被购买
+     */
+    @Query("SELECT EXISTS(SELECT 1 FROM member_card_record WHERE member_card_id = :memberCardId AND deleted_at IS NULL LIMIT 1)")
+    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
+
+    /**
+     * 逻辑删除会员卡
+     */
+    @Modifying
+    @Query("UPDATE member_card SET deleted_at = NOW() WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
+    Mono<Integer> logicalDelete(Long memberCardId);
+
+    /**
+     * 安全更新会员卡信息
+     */
+    @Modifying
+    @Query("UPDATE member_card SET " +
+            "member_card_name = COALESCE(:name, member_card_name), " +
+            "member_card_price = COALESCE(:price, member_card_price), " +
+            "member_card_validity_days = COALESCE(:durationDays, member_card_validity_days), " +
+            "member_card_total_times = COALESCE(:totalCount, member_card_total_times), " +
+            "member_card_amount = COALESCE(:denomination, member_card_amount), " +
+            "member_card_status = COALESCE(:status, member_card_status), " +
+            "updated_at = NOW() " +
+            "WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
+    Mono<Integer> updateSafe(Long memberCardId, String name, Double price,
+                             Integer durationDays, Integer totalCount,
+                             Double denomination, Integer status);
+
+    /**
+     * 批量查询上架的会员卡
+     */
+    @Query("SELECT * FROM member_card WHERE deleted_at IS NULL AND member_card_status = :status ORDER BY member_card_price ASC")
+    Flux<MemberCard> findActiveCards(Integer status);
+}

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

@@ -0,0 +1,121 @@
+package cn.novalon.gym.manage.member.repository;
+
+import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.r2dbc.repository.Modifying;
+import org.springframework.data.r2dbc.repository.Query;
+import org.springframework.data.r2dbc.repository.R2dbcRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡交易流水 Repository
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Repository
+public interface MemberCardTransactionRepository extends R2dbcRepository<MemberCardTransaction, Long> {
+
+    /**
+     * 插入交易流水记录
+     */
+    @Modifying
+    @Query("INSERT INTO member_card_transactions (member_card_record_id, member_card_id, member_id, operation_type, change_amount, " +
+            "change_balance, after_remaining_count, after_remaining_balance, related_biz_type, source_order_id, remark, created_at) " +
+            "VALUES (:memberCardRecordId, :memberCardId, :memberId, :operationType, :changeAmount, :changeBalance, " +
+            ":afterRemainingCount, :afterRemainingBalance, :relatedBizType, :sourceOrderId, :remark, NOW()) " +
+            "RETURNING *")
+    Mono<MemberCardTransaction> insertTransaction(Long memberCardRecordId, Long memberCardId, Long memberId,
+                                                   String operationType, Integer changeAmount,
+                                                   Double changeBalance, Integer afterRemainingCount,
+                                                   Double afterRemainingBalance, String relatedBizType,
+                                                   Long sourceOrderId, String remark);
+
+    /**
+     * 查询会员的使用记录（按时间范围）
+     */
+    @Query("SELECT * FROM member_card_transactions WHERE member_id = :memberId " +
+            "AND created_at BETWEEN :startTime AND :endTime " +
+            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
+    Flux<MemberCardTransaction> findByMemberIdAndTimeRange(Long memberId,
+                                                           LocalDateTime startTime,
+                                                           LocalDateTime endTime,
+                                                           Pageable pageable);
+
+    /**
+     * 条件查询流水记录
+     */
+    @Query("SELECT * FROM member_card_transactions " +
+            "AND (:memberId IS NULL OR member_id = :memberId) " +
+            "AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
+            "AND (:operationType IS NULL OR operation_type = :operationType) " +
+            "AND (:startTime IS NULL OR created_at >= :startTime) " +
+            "AND (:endTime IS NULL OR created_at <= :endTime) " +
+            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
+    Flux<MemberCardTransaction> findWithConditions(Long memberId, Long memberCardId,
+                                                   String operationType,
+                                                   LocalDateTime startTime,
+                                                   LocalDateTime endTime,
+                                                   Pageable pageable);
+
+    /**
+     * 统计符合条件的流水总数
+     */
+    @Query("SELECT COUNT(*) FROM member_card_transactions " +
+            "AND (:memberId IS NULL OR member_id = :memberId) " +
+            "AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
+            "AND (:operationType IS NULL OR operation_type = :operationType) " +
+            "AND (:startTime IS NULL OR created_at >= :startTime) " +
+            "AND (:endTime IS NULL OR created_at <= :endTime)")
+    Mono<Long> countWithConditions(Long memberId, Long memberCardId,
+                                   String operationType,
+                                   LocalDateTime startTime,
+                                   LocalDateTime endTime);
+
+    /**
+     * 按会员卡ID查询所有流水
+     */
+    @Query("SELECT * FROM member_card_transactions WHERE member_card_id = :memberCardId ORDER BY created_at DESC")
+    Flux<MemberCardTransaction> findByMemberCardId(Long memberCardId);
+
+    /**
+     * 按会员ID查询所有流水
+     */
+    @Query("SELECT * FROM member_card_transactions WHERE member_id = :memberId ORDER BY created_at DESC")
+    Flux<MemberCardTransaction> findByMemberId(Long memberId);
+
+    /**
+     * 按会员卡记录ID查询所有流水
+     */
+    @Query("SELECT * FROM member_card_transactions WHERE member_card_record_id = :recordId ORDER BY created_at DESC")
+    Flux<MemberCardTransaction> findByRecordId(Long recordId);
+
+    /**
+     * 统计某卡种的总扣次数
+     */
+    @Query("SELECT COALESCE(SUM(change_amount), 0) FROM member_card_transactions " +
+            "WHERE member_card_id = :memberCardId AND operation_type = 'DEDUCT' " +
+            "AND created_at BETWEEN :startTime AND :endTime")
+    Mono<Long> sumDeductCountByCardId(Long memberCardId,
+                                      LocalDateTime startTime,
+                                      LocalDateTime endTime);
+
+    /**
+     * 统计某时间段的续费总金额
+     */
+    @Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
+            "WHERE operation_type = 'RENEW' AND created_at BETWEEN :startTime AND :endTime")
+    Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 统计某会员的购卡总金额
+     */
+    @Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
+            "WHERE member_id = :memberId AND operation_type = 'PURCHASE' " +
+            "AND created_at BETWEEN :startTime AND :endTime")
+    Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
+}

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

@@ -0,0 +1,48 @@
+package cn.novalon.gym.manage.member.repository;
+
+import cn.novalon.gym.manage.member.entity.RefundApplication;
+import org.springframework.data.r2dbc.repository.Query;
+import org.springframework.data.r2dbc.repository.R2dbcRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * 退款申请 Repository
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Repository
+public interface RefundApplicationRepository extends R2dbcRepository<RefundApplication, Long> {
+
+    /**
+     * 根据会员卡记录ID查询退款申请
+     */
+    @Query("SELECT * FROM refund_application WHERE record_id = :recordId AND deleted_at IS NULL LIMIT 1")
+    Mono<RefundApplication> findByRecordId(Long recordId);
+
+    /**
+     * 根据会员ID查询退款申请列表
+     */
+    @Query("SELECT * FROM refund_application WHERE member_id = :memberId AND deleted_at IS NULL ORDER BY created_at DESC")
+    Flux<RefundApplication> findByMemberId(Long memberId);
+
+    /**
+     * 根据状态查询退款申请列表
+     */
+    @Query("SELECT * FROM refund_application WHERE status = :status AND deleted_at IS NULL ORDER BY created_at DESC")
+    Flux<RefundApplication> findByStatus(String status);
+
+    /**
+     * 审核退款申请
+     */
+    @Query("UPDATE refund_application SET status = :status, auditor_id = :auditorId, audit_time = NOW(), audit_remark = :auditRemark, updated_at = NOW() WHERE id = :id")
+    Mono<Integer> approve(Long id, String status, Long auditorId, String auditRemark);
+
+    /**
+     * 逻辑删除退款申请
+     */
+    @Query("UPDATE refund_application SET deleted_at = NOW() WHERE id = :id")
+    Mono<Integer> logicalDelete(Long id);
+}

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

@@ -0,0 +1,35 @@
+package cn.novalon.gym.manage.member.service;
+
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import org.springframework.data.domain.Pageable;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * 会员卡记录服务接口
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public interface IMemberCardRecordService {
+    
+    Mono<MemberCardRecord> findById(Long id);
+    
+    Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
+    
+    Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
+    
+    Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
+    
+    Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
+    
+    Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, java.time.LocalDateTime newExpireTime);
+    
+    Mono<Integer> updateStatus(Long recordId, String status);
+    
+    Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
+    
+    Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
+    
+    Flux<MemberCardRecord> findExpiredCards();
+}

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

@@ -0,0 +1,44 @@
+package cn.novalon.gym.manage.member.service;
+
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import org.springframework.data.domain.Pageable;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * 会员卡服务接口
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public interface IMemberCardService {
+    
+    Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
+    
+    Flux<MemberCard> findWithConditions(Integer status, String name, String type,
+                                        Double minPrice, Double maxPrice, Pageable pageable);
+    
+    Mono<Long> countWithConditions(Integer status, String name, String type,
+                                   Double minPrice, Double maxPrice);
+    
+    Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
+    
+    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
+    
+    Mono<Integer> logicalDelete(Long memberCardId);
+    
+    Flux<MemberCard> findActiveCards(Integer status);
+    
+    Mono<MemberCard> save(MemberCard entity);
+    
+    Mono<MemberCardRecord> purchaseCard(Long memberId, Long memberCardId, Long sourceOrderId);
+    
+    Mono<MemberCardRecord> renewCard(Long recordId, Integer addTimes, Double addAmount, Integer addDays, Long sourceOrderId);
+    
+    Mono<MemberCardRecord> useCard(Long recordId, Integer deductTimes, Double deductAmount);
+    
+    Mono<Void> refundCard(Long recordId);
+    
+    Mono<Integer> processExpiredCards();
+}

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

@@ -0,0 +1,93 @@
+package cn.novalon.gym.manage.member.service;
+
+import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
+import cn.novalon.gym.manage.member.enums.TransactionType;
+import org.springframework.data.domain.Pageable;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡交易流水服务接口
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public interface IMemberCardTransactionService {
+
+    /**
+     * 记录每一次变动
+     * @param transaction 流水记录
+     * @return 插入的流水记录
+     */
+    Mono<MemberCardTransaction> insertTransaction(MemberCardTransaction transaction);
+
+    /**
+     * 会员端"使用记录"
+     * @param memberId 会员ID
+     * @param startTime 开始时间
+     * @param endTime 结束时间
+     * @param pageable 分页参数
+     * @return 流水记录列表
+     */
+    Flux<MemberCardTransaction> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
+                                                           LocalDateTime endTime, Pageable pageable);
+
+    /**
+     * 后台"使用记录查询"
+     * @param memberId 会员ID
+     * @param memberCardId 会员卡ID
+     * @param operationType 操作类型
+     * @param startTime 开始时间
+     * @param endTime 结束时间
+     * @param pageable 分页参数
+     * @return 流水记录列表
+     */
+    Flux<MemberCardTransaction> findWithConditions(Long memberId, Long memberCardId,
+                                                   TransactionType operationType,
+                                                   LocalDateTime startTime, LocalDateTime endTime,
+                                                   Pageable pageable);
+
+    /**
+     * 统计符合条件的流水总数
+     */
+    Mono<Long> countWithConditions(Long memberId, Long memberCardId,
+                                   TransactionType operationType,
+                                   LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 按会员卡ID查询所有流水记录
+     */
+    Flux<MemberCardTransaction> findByMemberCardId(Long memberCardId);
+
+    /**
+     * 数据统计 - 统计某卡种的总扣次数
+     */
+    Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 数据统计 - 统计某时间段的续费总金额
+     */
+    Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 数据统计 - 统计某会员的购卡总金额
+     */
+    Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 创建交易记录
+     */
+    Mono<Void> createTransaction(MemberCardTransaction transaction);
+
+    /**
+     * 查询会员的交易记录
+     */
+    Flux<MemberCardTransaction> findByMemberId(Long memberId);
+
+    /**
+     * 查询会员卡记录的交易历史
+     */
+    Flux<MemberCardTransaction> findByRecordId(Long recordId);
+}

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

@@ -0,0 +1,33 @@
+package cn.novalon.gym.manage.member.service;
+
+import cn.novalon.gym.manage.member.entity.RefundApplication;
+import reactor.core.publisher.Mono;
+
+/**
+ * 退款申请服务接口
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+public interface IRefundApplicationService {
+
+    /**
+     * 创建退款申请
+     */
+    Mono<RefundApplication> create(Long recordId, String reason);
+
+    /**
+     * 审核退款申请
+     */
+    Mono<RefundApplication> approve(Long applicationId, Long auditorId, String remark);
+
+    /**
+     * 拒绝退款申请
+     */
+    Mono<RefundApplication> reject(Long applicationId, Long auditorId, String remark);
+
+    /**
+     * 根据记录ID查询申请
+     */
+    Mono<RefundApplication> findByRecordId(Long recordId);
+}

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

@@ -4,6 +4,7 @@ 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.MemberDetailVO;
 import cn.novalon.gym.manage.member.vo.MemberInfoVO;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -58,4 +59,21 @@ public interface MemberService {
      * @return 所有会员信息
      */
     Flux<Member> findAll(Integer pageNum, Integer pageSize);
+
+    /**
+     * 前台管理端获取会员详情（含会员卡信息）
+     *
+     * @param memberId 会员ID
+     * @return 会员详情
+     */
+    Mono<MemberDetailVO> getMemberDetail(Long memberId);
+
+    /**
+     * 前台管理端编辑会员信息
+     *
+     * @param memberId 会员ID
+     * @param updateDto 更新信息DTO
+     * @return 更新后的会员详情
+     */
+    Mono<Boolean> adminUpdateMemberInfo(Long memberId, UpdateMemberInfoDto updateDto);
 }

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

@@ -0,0 +1,83 @@
+package cn.novalon.gym.manage.member.service.impl;
+
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
+import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡记录服务实现
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Service
+public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
+    private final MemberCardRecordRepository memberCardRecordRepository;
+
+    public MemberCardRecordServiceImpl(MemberCardRecordRepository memberCardRecordRepository) {
+        this.memberCardRecordRepository = memberCardRecordRepository;
+    }
+
+    @Override
+    public Mono<MemberCardRecord> findById(Long recordId) {
+        return memberCardRecordRepository.findById(recordId);
+    }
+
+    @Override
+    public Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable) {
+        return memberCardRecordRepository.findByMemberId(memberId, pageable);
+    }
+
+    @Override
+    public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
+        return memberCardRecordRepository.findActiveCardsByMemberId(memberId);
+    }
+
+    @Override
+    public Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record) {
+        return memberCardRecordRepository.insertActiveRecord(
+                record.getMemberId(),
+                record.getMemberCardId(),
+                record.getExpireTime(),
+                record.getRemainingTimes(),
+                record.getRemainingAmount(),
+                record.getSourceOrderId()
+        );
+    }
+
+    @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, String status) {
+        return memberCardRecordRepository.updateStatus(recordId, status);
+    }
+
+    @Override
+    public Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes) {
+        return memberCardRecordRepository.validateCountCard(recordId, requiredTimes);
+    }
+
+    @Override
+    public Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount) {
+        return memberCardRecordRepository.validateStoredCard(recordId, requiredAmount);
+    }
+
+    @Override
+    public Flux<MemberCardRecord> findExpiredCards() {
+        return memberCardRecordRepository.findExpiredCards();
+    }
+}

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

@@ -0,0 +1,332 @@
+package cn.novalon.gym.manage.member.service.impl;
+
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
+import cn.novalon.gym.manage.member.enums.CardEvent;
+import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
+import cn.novalon.gym.manage.member.enums.MemberCardType;
+import cn.novalon.gym.manage.member.enums.TransactionType;
+import cn.novalon.gym.manage.member.handler.DistributedLockService;
+import cn.novalon.gym.manage.member.handler.ExpirationReminderService;
+import cn.novalon.gym.manage.member.handler.MemberCardStateMachine;
+import cn.novalon.gym.manage.member.handler.RefundSagaHandler;
+import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
+import cn.novalon.gym.manage.member.repository.MemberCardRepository;
+import cn.novalon.gym.manage.member.service.IMemberCardService;
+import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡服务实现
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Slf4j
+@Service
+public class MemberCardServiceImpl implements IMemberCardService {
+    private final MemberCardRepository memberCardRepository;
+    private final MemberCardRecordRepository recordRepository;
+    private final IMemberCardTransactionService transactionService;
+    private final MemberCardStateMachine stateMachine;
+    private final DistributedLockService distributedLockService;
+    private final ExpirationReminderService expirationReminderService;
+    private final RefundSagaHandler refundSagaHandler;
+
+    public MemberCardServiceImpl(MemberCardRepository memberCardRepository,
+                                 MemberCardRecordRepository recordRepository,
+                                 IMemberCardTransactionService transactionService,
+                                 MemberCardStateMachine stateMachine,
+                                 DistributedLockService distributedLockService,
+                                 ExpirationReminderService expirationReminderService,
+                                 RefundSagaHandler refundSagaHandler) {
+        this.memberCardRepository = memberCardRepository;
+        this.recordRepository = recordRepository;
+        this.transactionService = transactionService;
+        this.stateMachine = stateMachine;
+        this.distributedLockService = distributedLockService;
+        this.expirationReminderService = expirationReminderService;
+        this.refundSagaHandler = refundSagaHandler;
+    }
+
+    @Override
+    public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
+        return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId);
+    }
+
+    @Override
+    public Flux<MemberCard> findWithConditions(Integer status, String name, String type,
+                                               Double minPrice, Double maxPrice, Pageable pageable) {
+        return memberCardRepository.findWithConditions(status, name, type, minPrice, maxPrice, pageable);
+    }
+
+    @Override
+    public Mono<Long> countWithConditions(Integer status, String name, String type,
+                                          Double minPrice, Double maxPrice) {
+        return memberCardRepository.countWithConditions(status, name, type, minPrice, maxPrice);
+    }
+
+    @Override
+    public Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable) {
+        return memberCardRepository.findByMemberCardStatusAndDeletedAtIsNull(status, pageable);
+    }
+
+    @Override
+    public Mono<Boolean> existsPurchasedRecord(Long memberCardId) {
+        return memberCardRepository.existsPurchasedRecord(memberCardId);
+    }
+
+    @Override
+    public Mono<Integer> logicalDelete(Long memberCardId) {
+        return memberCardRepository.logicalDelete(memberCardId);
+    }
+
+    @Override
+    public Flux<MemberCard> findActiveCards(Integer status) {
+        return memberCardRepository.findActiveCards(status);
+    }
+
+    @Override
+    public Mono<MemberCard> save(MemberCard entity) {
+        return memberCardRepository.save(entity);
+    }
+
+    @Override
+    public Mono<MemberCardRecord> purchaseCard(Long memberId, Long memberCardId, Long sourceOrderId) {
+        return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
+                .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
+                .flatMap(card -> {
+                    if (card.getMemberCardStatus() != null && card.getMemberCardStatus() == 1) {
+                        return Mono.error(new RuntimeException("该会员卡已禁用"));
+                    }
+
+                    MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+
+                    return distributedLockService.executeWithLock(
+                            memberId.toString(),
+                            cardType.name(),
+                            Mono.defer(() -> createCardRecord(memberId, memberCardId, sourceOrderId, card))
+                    );
+                })
+                .flatMap(record -> createTransaction(record, TransactionType.PURCHASE, "购买会员卡")
+                        .thenReturn(record))
+                .flatMap(record -> expirationReminderService.scheduleExpirationReminder(record)
+                        .then(Mono.just(record)));
+    }
+
+    private Mono<MemberCardRecord> createCardRecord(Long memberId, Long memberCardId, 
+                                                      Long sourceOrderId, MemberCard card) {
+        return Mono.defer(() -> {
+            MemberCardRecord record = MemberCardRecord.builder()
+                    .memberId(memberId)
+                    .memberCardId(memberCardId)
+                    .sourceOrderId(sourceOrderId)
+                    .purchaseTime(LocalDateTime.now())
+                    .status(MemberCardRecordStatus.ACTIVE)
+                    .build();
+
+            MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+            LocalDateTime now = LocalDateTime.now();
+
+            switch (cardType) {
+                case TIME_CARD:
+                    record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
+                    record.setRemainingTimes(0);
+                    record.setRemainingAmount(0.0);
+                    break;
+                case COUNT_CARD:
+                    record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
+                    record.setRemainingTimes(card.getMemberCardTotalTimes());
+                    record.setRemainingAmount(0.0);
+                    break;
+                case STORED_VALUE_CARD:
+                    record.setExpireTime(now.plusYears(1));
+                    record.setRemainingTimes(0);
+                    record.setRemainingAmount(card.getMemberCardAmount());
+                    break;
+                default:
+                    return Mono.error(new RuntimeException("不支持的会员卡类型"));
+            }
+
+            return recordRepository.insertActiveRecord(
+                    record.getMemberId(),
+                    record.getMemberCardId(),
+                    record.getExpireTime(),
+                    record.getRemainingTimes(),
+                    record.getRemainingAmount(),
+                    record.getSourceOrderId()
+            );
+        });
+    }
+
+    @Override
+    public Mono<MemberCardRecord> renewCard(Long recordId, Integer addTimes, Double addAmount, 
+                                             Integer addDays, Long sourceOrderId) {
+        return recordRepository.findById(recordId)
+                .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
+                .flatMap(originalRecord -> stateMachine.validateTransition(originalRecord, CardEvent.RENEW)
+                        .then(Mono.just(originalRecord)))
+                .flatMap(originalRecord -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(originalRecord.getMemberCardId())
+                        .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
+                        .flatMap(card -> {
+                            MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+
+                            return distributedLockService.executeWithLock(
+                                    originalRecord.getMemberId().toString(),
+                                    cardType.name(),
+                                    Mono.defer(() -> doRenewCard(originalRecord, card, addTimes, addAmount, addDays))
+                            );
+                        }));
+    }
+
+     private Mono<MemberCardRecord> doRenewCard(MemberCardRecord record, MemberCard card, 
+                                                Integer addTimes, Double addAmount, Integer addDays) {
+        LocalDateTime now = LocalDateTime.now();
+        MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+
+        switch (cardType) {
+            case TIME_CARD:
+                LocalDateTime currentExpire = record.getExpireTime();
+                LocalDateTime baseTime = (currentExpire != null && currentExpire.isAfter(now)) ? currentExpire : now;
+                int daysToAdd = addDays != null ? addDays : card.getMemberCardValidityDays();
+                record.setExpireTime(baseTime.plusDays(daysToAdd));
+                break;
+            case COUNT_CARD:
+                int currentTimes = record.getRemainingTimes() != null ? record.getRemainingTimes() : 0;
+                int timesToAdd = addTimes != null ? addTimes : card.getMemberCardTotalTimes();
+                record.setRemainingTimes(currentTimes + timesToAdd);
+                if (MemberCardRecordStatus.USED_UP.equals(record.getStatus())) {
+                    record.setStatus(MemberCardRecordStatus.ACTIVE);
+                }
+                break;
+            case STORED_VALUE_CARD:
+                double currentAmount = record.getRemainingAmount() != null ? record.getRemainingAmount() : 0.0;
+                double amountToAdd = addAmount != null ? addAmount : card.getMemberCardAmount();
+                record.setRemainingAmount(currentAmount + amountToAdd);
+                if (MemberCardRecordStatus.USED_UP.equals(record.getStatus())) {
+                    record.setStatus(MemberCardRecordStatus.ACTIVE);
+                }
+                break;
+            default:
+                return Mono.error(new RuntimeException("不支持的会员卡类型"));
+        }
+
+        return recordRepository.save(record)
+                .flatMap(updatedRecord -> createTransaction(updatedRecord, TransactionType.RENEW, "续费会员卡")
+                        .then(expirationReminderService.scheduleExpirationReminder(updatedRecord))
+                        .thenReturn(updatedRecord));
+    }
+
+    @Override
+    public Mono<MemberCardRecord> useCard(Long recordId, Integer deductTimes, Double deductAmount) {
+        return recordRepository.findById(recordId)
+                .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
+                .flatMap(record -> stateMachine.validateTransition(record, CardEvent.USE)
+                        .then(Mono.just(record)))
+                .flatMap(record -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
+                        .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
+                        .flatMap(card -> {
+                            MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+
+                            return distributedLockService.executeWithLock(
+                                record.getMemberId().toString(),
+                                cardType.name(),
+                                Mono.defer(() -> doUseCard(record, card, deductTimes, deductAmount))
+                            );
+                        }));
+    }
+
+    private Mono<MemberCardRecord> doUseCard(MemberCardRecord record, MemberCard card, 
+                                              Integer deductTimes, Double deductAmount) {
+        if (!MemberCardRecordStatus.ACTIVE.name().equals(record.getStatus())) {
+            return Mono.error(new RuntimeException("会员卡状态不正确"));
+        }
+
+        MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+        LocalDateTime now = LocalDateTime.now();
+
+        switch (cardType) {
+            case TIME_CARD:
+                if (record.getExpireTime() != null && record.getExpireTime().isBefore(now)) {
+                    return Mono.error(new RuntimeException("会员卡已过期"));
+                }
+                break;
+            case COUNT_CARD:
+                int currentTimes = record.getRemainingTimes() != null ? record.getRemainingTimes() : 0;
+                int timesToDeduct = deductTimes != null ? deductTimes : 1;
+                if (currentTimes < timesToDeduct) {
+                    return Mono.error(new RuntimeException("剩余次数不足"));
+                }
+                record.setRemainingTimes(currentTimes - timesToDeduct);
+                if (record.getRemainingTimes() == 0) {
+                    record.setStatus(MemberCardRecordStatus.USED_UP);
+                }
+                break;
+            case STORED_VALUE_CARD:
+                double currentAmount = record.getRemainingAmount() != null ? record.getRemainingAmount() : 0.0;
+                double amountToDeduct = deductAmount != null ? deductAmount : 0.0;
+                if (currentAmount < amountToDeduct) {
+                    return Mono.error(new RuntimeException("余额不足"));
+                }
+                record.setRemainingAmount(currentAmount - amountToDeduct);
+                if (record.getRemainingAmount() == 0) {
+                    record.setStatus(MemberCardRecordStatus.USED_UP);
+                }
+                break;
+            default:
+                return Mono.error(new RuntimeException("不支持的会员卡类型"));
+        }
+
+        return recordRepository.save(record)
+                .flatMap(updatedRecord -> createTransaction(updatedRecord, TransactionType.DEDUCT, "使用会员卡")
+                        .thenReturn(updatedRecord));
+    }
+
+    @Override
+    public Mono<Void> refundCard(Long recordId) {
+        return recordRepository.findById(recordId)
+                .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
+                .flatMap(record -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
+                        .switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
+                        .flatMap(card -> {
+                            MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+                            return distributedLockService.executeWithLock(
+                                record.getMemberId().toString(),
+                                cardType.name(),
+                                refundSagaHandler.executeRefund(recordId)
+                            );
+                        }));
+    }
+
+    @Override
+    public Mono<Integer> processExpiredCards() {
+        return recordRepository.findExpiredCards()
+            .flatMap(record -> stateMachine.transition(record.getStatus(), CardEvent.EXPIRE)
+                .flatMap(newState -> recordRepository.updateStatus(
+                    record.getMemberCardRecordId(), newState.name())))
+            .reduce(0, (count, result) -> count + 1)
+            .doOnSuccess(count -> log.info("处理过期会员卡完成，共处理{}条", count));
+    }
+
+    private Mono<Void> createTransaction(MemberCardRecord record, TransactionType action, String remark) {
+        MemberCardTransaction transaction = MemberCardTransaction.builder()
+                .memberId(record.getMemberId())
+                .memberCardId(record.getMemberCardId())
+                .operationType(action.name())
+                .changeAmount(record.getRemainingTimes())
+                .changeBalance(record.getRemainingAmount())
+                .afterRemainingCount(record.getRemainingTimes())
+                .afterRemainingBalance(record.getRemainingAmount())
+                .remark(remark)
+                .build();
+
+        return transactionService.createTransaction(transaction);
+    }
+}

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

@@ -0,0 +1,109 @@
+package cn.novalon.gym.manage.member.service.impl;
+
+import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
+import cn.novalon.gym.manage.member.enums.TransactionType;
+import cn.novalon.gym.manage.member.repository.MemberCardTransactionRepository;
+import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡交易流水服务实现
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Slf4j
+@Service
+public class MemberCardTransactionServiceImpl implements IMemberCardTransactionService {
+    private final MemberCardTransactionRepository transactionRepository;
+
+    public MemberCardTransactionServiceImpl(MemberCardTransactionRepository transactionRepository) {
+        this.transactionRepository = transactionRepository;
+    }
+
+    @Override
+    public Mono<MemberCardTransaction> insertTransaction(MemberCardTransaction transaction) {
+        return transactionRepository.insertTransaction(
+                transaction.getMemberCardRecordId(),
+                transaction.getMemberCardId(),
+                transaction.getMemberId(),
+                transaction.getOperationType(),
+                transaction.getChangeAmount(),
+                transaction.getChangeBalance(),
+                transaction.getAfterRemainingCount(),
+                transaction.getAfterRemainingBalance(),
+                transaction.getRelatedBizType(),
+                transaction.getSourceOrderId(),
+                transaction.getRemark()
+        );
+    }
+
+    @Override
+    public Flux<MemberCardTransaction> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
+                                                                   LocalDateTime endTime, Pageable pageable) {
+        return transactionRepository.findByMemberIdAndTimeRange(memberId, startTime, endTime, pageable);
+    }
+
+    @Override
+    public Flux<MemberCardTransaction> findWithConditions(Long memberId, Long memberCardId,
+                                                          TransactionType operationType,
+                                                          LocalDateTime startTime, LocalDateTime endTime,
+                                                          Pageable pageable) {
+        return transactionRepository.findWithConditions(memberId, memberCardId, 
+                operationType != null ? operationType.name() : null,
+                startTime, endTime, pageable);
+    }
+
+    @Override
+    public Mono<Long> countWithConditions(Long memberId, Long memberCardId,
+                                          TransactionType operationType,
+                                          LocalDateTime startTime, LocalDateTime endTime) {
+        return transactionRepository.countWithConditions(memberId, memberCardId,
+                operationType != null ? operationType.name() : null,
+                startTime, endTime);
+    }
+
+    @Override
+    public Flux<MemberCardTransaction> findByMemberCardId(Long memberCardId) {
+        return transactionRepository.findByMemberCardId(memberCardId);
+    }
+
+    @Override
+    public Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime) {
+        return transactionRepository.sumDeductCountByCardId(memberCardId, startTime, endTime);
+    }
+
+    @Override
+    public Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
+        return transactionRepository.sumRenewAmountByTimeRange(startTime, endTime);
+    }
+
+    @Override
+    public Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime) {
+        return transactionRepository.sumPurchaseAmountByMemberId(memberId, startTime, endTime);
+    }
+
+    @Override
+    public Mono<Void> createTransaction(MemberCardTransaction transaction) {
+        return transactionRepository.save(transaction)
+                .then()
+                .doOnSuccess(v -> log.info("创建会员卡交易记录: memberId={}, cardId={}, type={}",
+                        transaction.getMemberId(), transaction.getMemberCardId(), transaction.getOperationType()));
+    }
+
+    @Override
+    public Flux<MemberCardTransaction> findByMemberId(Long memberId) {
+        return transactionRepository.findByMemberId(memberId);
+    }
+
+    @Override
+    public Flux<MemberCardTransaction> findByRecordId(Long recordId) {
+        return transactionRepository.findByRecordId(recordId);
+    }
+}

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

@@ -4,20 +4,31 @@ import cn.novalon.gym.manage.common.exception.ConflictException;
 import cn.novalon.gym.manage.common.exception.ErrorCode;
 import cn.novalon.gym.manage.common.exception.NotFoundException;
 import cn.novalon.gym.manage.common.exception.SystemException;
-import cn.novalon.gym.manage.member.config.WechatProperties;
+import cn.novalon.gym.manage.common.util.HtmlEscapeUtil;
 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.enums.GenderEnum;
+import cn.novalon.gym.manage.member.enums.MemberCardType;
 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.BeanConvertUtil;
 import cn.novalon.gym.manage.member.util.EsSyncUtils;
+import cn.novalon.gym.manage.member.vo.MemberCardInfoVO;
+import cn.novalon.gym.manage.member.vo.MemberDetailVO;
 import cn.novalon.gym.manage.member.vo.MemberInfoVO;
+import co.elastic.clients.elasticsearch.ElasticsearchClient;
+import co.elastic.clients.elasticsearch.core.IndexResponse;
+import co.elastic.clients.json.jackson.JacksonJsonpMapper;
+import co.elastic.clients.transport.rest_client.RestClientTransport;
 import jakarta.annotation.PostConstruct;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.http.HttpHost;
+import org.elasticsearch.client.RestClient;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
@@ -26,6 +37,10 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * 会员服务实现
@@ -41,7 +56,6 @@ 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;
 
@@ -67,10 +81,10 @@ public class MemberServiceImpl implements MemberService {
         return memberRepository.findById(memberId)
                 .flatMap(member -> {
                     if (updateDto.getNickname() != null) {
-                        member.setNickname(updateDto.getNickname());
+                        member.setNickname(HtmlEscapeUtil.escape(updateDto.getNickname()));
                     }
                     if (updateDto.getGender() != null) {
-                        member.setGender(updateDto.getGender());
+                        member.setGender(updateDto.getGender().getCode());
                     }
                     if (updateDto.getBirthday() != null) {
                         member.setBirthday(updateDto.getBirthday());
@@ -79,7 +93,7 @@ public class MemberServiceImpl implements MemberService {
                         member.setAvatar(updateDto.getAvatar());
                     }
                     if (updateDto.getAddress() != null) {
-                        member.setAddress(updateDto.getAddress());
+                        member.setAddress(HtmlEscapeUtil.escape(updateDto.getAddress()));
                     }
 
                     return memberRepository.save(member);
@@ -99,11 +113,14 @@ public class MemberServiceImpl implements MemberService {
         String phone = member.getPhone();
         String maskedPhone = phone != null ? phone.replace(phone.substring(3, 7), "****") : null;
 
+        GenderEnum genderEnum = GenderEnum.fromCode(member.getGender());
+
         return MemberInfoVO.builder()
                 .id(member.getId())
                 .nickname(member.getNickname())
                 .phone(maskedPhone)
-                .gender(member.getGender())
+                .gender(genderEnum)
+                .genderDesc(genderEnum.getDesc())
                 .birthday(member.getBirthday())
                 .avatar(member.getAvatar())
                 .hasPhone(phone != null)
@@ -117,9 +134,7 @@ public class MemberServiceImpl implements MemberService {
 
         String encryptedPhone;
         try {
-            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
+            encryptedPhone = AesUtil.encrypt(phone);
-            String iv = wechatProperties.getPhoneEncryption().getIv();
-            encryptedPhone = AesUtil.encrypt(phone, secretKey, iv);
             log.info("手机号加密成功");
         } catch (Exception e) {
             log.error("手机号加密失败", e);
@@ -147,7 +162,7 @@ public class MemberServiceImpl implements MemberService {
     public Flux<MemberES> searchMember(SearchMemberDto searchMemberDto) {
         log.info("搜索会员, searchValue: {}, filter: {}, pageNum: {}, pageSize: {}",
                 searchMemberDto.getSearchValue(),
-                searchMemberDto.getFilter(),
+                searchMemberDto.getGender(),
                 searchMemberDto.getPageNum(),
                 searchMemberDto.getPageSize());
 
@@ -155,22 +170,23 @@ public class MemberServiceImpl implements MemberService {
 
         if(searchValue != null && searchValue.matches("^1[3-9]\\d{9}$")){
             log.debug("搜索值为手机号格式，进行加密处理");
-            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
+            searchValue = AesUtil.encrypt(searchValue);
-            String iv = wechatProperties.getPhoneEncryption().getIv();
-            searchValue = AesUtil.encrypt(searchValue,secretKey,iv);
         }
 
         Pageable pageable = PageRequest.of(
                 searchMemberDto.getPageNum() - 1,
-                searchMemberDto.getPageSize(),
+                searchMemberDto.getPageSize()
-                Sort.by(Sort.Direction.DESC, "update_at")
         );
 
-        return memberESRepository.findByMemberNoOrPhoneOrNicknameContainingAndGender(
+        if (searchValue == null) {
+            log.warn("搜索值为空，返回空结果");
+            return Flux.empty();
+        }
+
+        return memberESRepository.findByMemberNoOrPhoneOrNicknameContaining(
                 searchValue,
                 searchValue,
                 searchValue,
-                searchMemberDto.getFilter() ,
                 pageable
         );
     }
@@ -187,6 +203,86 @@ public class MemberServiceImpl implements MemberService {
         return memberRepository.findAllBy(pageable);
     }
 
+    @Override
+    public Mono<MemberDetailVO> getMemberDetail(Long memberId) {
+        log.info("查询会员详情, memberId: {}", memberId);
+
+        return memberRepository.findById(memberId)
+                .zipWith(
+                        memberRepository.findCardRecordsWithCardInfoByMemberId(memberId)
+                                .collectList(),
+                        (baseInfo, cardList) -> {
+                            MemberDetailVO memberDetailVO = BeanConvertUtil.toBean(baseInfo, MemberDetailVO.class);
+
+                            GenderEnum genderEnum = GenderEnum.fromCode(baseInfo.getGender());
+                            memberDetailVO.setGenderDesc(genderEnum.getDesc());
+
+                            List<MemberCardInfoVO> enrichedCards = cardList.stream()
+                                    .peek(vo -> {
+                                        if (vo.getMemberCardType() != null) {
+                                            try {
+                                                MemberCardType cardType = MemberCardType.valueOf(vo.getMemberCardType());
+                                                vo.setMemberCardTypeDesc(cardType.getDesc());
+                                            } catch (IllegalArgumentException e) {
+                                                vo.setMemberCardTypeDesc(vo.getMemberCardType());
+                                            }
+                                        }
+                                        if (vo.getMemberCardStatus() != null) {
+                                            vo.setMemberCardStatusDesc(vo.getMemberCardStatus() == 1 ? "上架" : "下架");
+                                        }
+                                    })
+                                    .collect(Collectors.toList());
+                            memberDetailVO.setMemberCards(enrichedCards);
+
+                            long activeCount = enrichedCards.stream()
+                                    .filter(card -> card.getMemberCardStatus() != null && card.getMemberCardStatus() == 1)
+                                    .count();
+                            memberDetailVO.setActiveCardCount((int) activeCount);
+                            memberDetailVO.setInactiveCardCount(enrichedCards.size() - (int) activeCount);
+
+                            return memberDetailVO;
+                        }
+                );
+    }
+
+
+    @Override
+    public Mono<Boolean> adminUpdateMemberInfo(Long memberId, UpdateMemberInfoDto updateDto) {
+        log.info("前台管理端编辑会员信息, memberId: {}", memberId);
+
+        return memberRepository.findById(memberId)
+                .switchIfEmpty(Mono.error(() -> {
+                    log.error("会员不存在: memberId={}", memberId);
+                    throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
+                }))
+                .flatMap(member -> {
+                    log.error("有用户");
+                    if (updateDto.getNickname() != null) {
+                        member.setNickname(HtmlEscapeUtil.escape(updateDto.getNickname()));
+                    }
+                    if (updateDto.getGender() != null) {
+                        member.setGender(updateDto.getGender().getCode());
+                    }
+                    if (updateDto.getBirthday() != null) {
+                        member.setBirthday(updateDto.getBirthday());
+                    }
+                    if (updateDto.getAvatar() != null) {
+                        member.setAvatar(updateDto.getAvatar());
+                    }
+                    if (updateDto.getAddress() != null) {
+                        member.setAddress(HtmlEscapeUtil.escape(updateDto.getAddress()));
+                    }
+
+                    return memberRepository.save(member);
+                })
+                .doOnSuccess(memberSyncer::sync)
+                .map(savedMember -> true)
+                .onErrorResume(e -> {
+                    log.error("编辑会员信息失败, memberId: {}, error: {}", memberId, e.getMessage(), e);
+                    return Mono.just(false);
+                });
+    }
+
     private Mono<Boolean> updateMemberPhone(Long memberId, String encryptedPhone) {
         return memberRepository.findById(memberId)
                 .flatMap(member -> {

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

@@ -0,0 +1,89 @@
+package cn.novalon.gym.manage.member.service.impl;
+
+import cn.novalon.gym.manage.common.util.HtmlEscapeUtil;
+import cn.novalon.gym.manage.member.entity.RefundApplication;
+import cn.novalon.gym.manage.member.enums.RefundStatus;
+import cn.novalon.gym.manage.member.repository.RefundApplicationRepository;
+import cn.novalon.gym.manage.member.service.IRefundApplicationService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+/**
+ * 退款申请服务实现
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Slf4j
+@Service
+public class RefundApplicationServiceImpl implements IRefundApplicationService {
+
+    private final RefundApplicationRepository refundApplicationRepository;
+
+    public RefundApplicationServiceImpl(RefundApplicationRepository refundApplicationRepository) {
+        this.refundApplicationRepository = refundApplicationRepository;
+    }
+
+    @Override
+    public Mono<RefundApplication> create(Long recordId, String reason) {
+        return refundApplicationRepository.findByRecordId(recordId)
+                .flatMap(existing -> {
+                    if (existing != null) {
+                        return Mono.error(new RuntimeException("该会员卡记录已有退款申请"));
+                    }
+                    return Mono.empty();
+                })
+                .then(Mono.defer(() -> {
+                    RefundApplication application = RefundApplication.builder()
+                            .recordId(recordId)
+                            .reason(HtmlEscapeUtil.escape(reason))
+                            .status(RefundStatus.PENDING)
+                            .applyTime(LocalDateTime.now())
+                            .build();
+
+                    return refundApplicationRepository.save(application)
+                            .doOnSuccess(app -> log.info("创建退款申请成功: applicationId={}, recordId={}",
+                                app.getId(), recordId));
+                }));
+    }
+
+    @Override
+    public Mono<RefundApplication> approve(Long applicationId, Long auditorId, String remark) {
+        return refundApplicationRepository.findById(applicationId)
+                .switchIfEmpty(Mono.error(new RuntimeException("退款申请不存在")))
+                .flatMap(application -> {
+                    if (!"PENDING".equals(application.getStatus())) {
+                        return Mono.error(new RuntimeException("退款申请状态不正确，当前状态: " + application.getStatus()));
+                    }
+
+                    return refundApplicationRepository.approve(applicationId, "APPROVED", auditorId, HtmlEscapeUtil.escape(remark))
+                            .thenReturn(application)
+                            .doOnSuccess(app -> log.info("批准退款申请成功: applicationId={}, auditorId={}",
+                                applicationId, auditorId));
+                });
+    }
+
+    @Override
+    public Mono<RefundApplication> reject(Long applicationId, Long auditorId, String remark) {
+        return refundApplicationRepository.findById(applicationId)
+                .switchIfEmpty(Mono.error(new RuntimeException("退款申请不存在")))
+                .flatMap(application -> {
+                    if (!"PENDING".equals(application.getStatus())) {
+                        return Mono.error(new RuntimeException("退款申请状态不正确，当前状态: " + application.getStatus()));
+                    }
+
+                    return refundApplicationRepository.approve(applicationId, "REJECTED", auditorId, HtmlEscapeUtil.escape(remark))
+                            .thenReturn(application)
+                            .doOnSuccess(app -> log.info("拒绝退款申请成功: applicationId={}, auditorId={}",
+                                applicationId, auditorId));
+                });
+    }
+
+    @Override
+    public Mono<RefundApplication> findByRecordId(Long recordId) {
+        return refundApplicationRepository.findByRecordId(recordId);
+    }
+}

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

@@ -4,6 +4,7 @@ import cn.novalon.gym.manage.common.exception.ConflictException;
 import cn.novalon.gym.manage.common.exception.ErrorCode;
 import cn.novalon.gym.manage.common.exception.NotFoundException;
 import cn.novalon.gym.manage.common.exception.SystemException;
+import cn.novalon.gym.manage.common.util.HtmlEscapeUtil;
 import cn.novalon.gym.manage.member.config.WechatProperties;
 import cn.novalon.gym.manage.member.dto.WechatLoginDto;
 import cn.novalon.gym.manage.member.entity.Member;
@@ -42,7 +43,6 @@ 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;
@@ -199,10 +199,7 @@ public class WechatAuthServiceImpl implements WechatAuthService {
 
     private String encryptPhone(String phoneNumber) {
         try {
-            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
+            String encryptedPhone = AesUtil.encrypt(phoneNumber);
-            String iv = wechatProperties.getPhoneEncryption().getIv();
-
-            String encryptedPhone = AesUtil.encrypt(phoneNumber, secretKey, iv);
 
             log.debug("手机号加密成功");
             return encryptedPhone;
@@ -214,10 +211,8 @@ public class WechatAuthServiceImpl implements WechatAuthService {
 
     public String decryptPhone(String encryptedPhone) {
         try {
-            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
-            String iv = wechatProperties.getPhoneEncryption().getIv();
 
-            String phoneNumber = AesUtil.decrypt(encryptedPhone, secretKey, iv);
+            String phoneNumber = AesUtil.decrypt(encryptedPhone);
 
             log.debug("手机号解密成功");
             return phoneNumber;

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

@@ -1,5 +1,6 @@
 package cn.novalon.gym.manage.member.service.impl;
 
+import cn.novalon.gym.manage.common.util.HtmlEscapeUtil;
 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;
@@ -74,11 +75,11 @@ public class WechatOfficialServiceImpl implements WechatOfficialService {
                                         existingMember.setOfficialOpenId(openId);
                                         
                                         if (existingMember.getNickname() == null || existingMember.getNickname().isEmpty()) {
-                                            existingMember.setNickname(userInfo.getNickname());
+                                            existingMember.setNickname(HtmlEscapeUtil.escape(userInfo.getNickname()));
                                         }
                                         
                                         if (existingMember.getAvatar() == null || existingMember.getAvatar().isEmpty()) {
-                                            existingMember.setAvatar(userInfo.getHeadimgurl());
+                                            existingMember.setAvatar(HtmlEscapeUtil.escape(userInfo.getHeadimgurl()));
                                         }
                                         
                                         return memberRepository.save(existingMember)

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

@@ -1,12 +1,24 @@
 package cn.novalon.gym.manage.member.util;
 
+import cn.novalon.gym.manage.member.config.WechatProperties;
+import co.elastic.clients.elasticsearch.ElasticsearchClient;
+import co.elastic.clients.elasticsearch.core.IndexResponse;
+import co.elastic.clients.json.jackson.JacksonJsonpMapper;
+import co.elastic.clients.transport.rest_client.RestClientTransport;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.http.HttpHost;
+import org.checkerframework.checker.units.qual.K;
+import org.elasticsearch.client.RestClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
 
 import javax.crypto.Cipher;
 import javax.crypto.spec.IvParameterSpec;
 import javax.crypto.spec.SecretKeySpec;
 import java.nio.charset.StandardCharsets;
 import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
 
 /**
  * AES加密工具类
@@ -16,24 +28,35 @@ import java.util.Base64;
  */
 
 @Slf4j
+@Component
 public class AesUtil {
 
     private static final String ALGORITHM = "AES";
     private static final String TRANSFORMATION = "AES/CBC/PKCS5Padding";
 
+    private static String KEY;
+    private static String IV;
+
+    @Autowired
+    public void setWechatProperties(WechatProperties props) {
+        KEY = props.getPhoneEncryption().getSecretKey();  // 从配置类读取
+        IV = props.getPhoneEncryption().getIv();
+        if(KEY == null || IV == null) throw new RuntimeException("请配置AES密钥和偏移量");
+    }
+
+
     /**
      * 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) {
+    public static String decrypt(String encryptedData) {
+
         try {
             byte[] dataByte = Base64.getDecoder().decode(encryptedData);
-            byte[] keyByte = Base64.getDecoder().decode(key);
+            byte[] keyByte = Base64.getDecoder().decode(KEY);
-            byte[] ivByte = Base64.getDecoder().decode(iv);
+            byte[] ivByte = Base64.getDecoder().decode(IV);
 
             Cipher cipher = Cipher.getInstance(TRANSFORMATION);
             SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte, ALGORITHM);
@@ -52,15 +75,13 @@ public class AesUtil {
      * AES 加密
      *
      * @param data 原始数据
-     * @param key  AES密钥，Base64编码（32字节）
-     * @param iv   初始化向量IV，Base64编码（16字节）
      * @return Base64编码的加密数据
      */
-    public static String encrypt(String data, String key, String iv) {
+    public static String encrypt(String data) {
         try {
             byte[] dataByte = data.getBytes(StandardCharsets.UTF_8);
-            byte[] keyByte = Base64.getDecoder().decode(key);
+            byte[] keyByte = Base64.getDecoder().decode(KEY);
-            byte[] ivByte = Base64.getDecoder().decode(iv);
+            byte[] ivByte = Base64.getDecoder().decode(IV);
 
             Cipher cipher = Cipher.getInstance(TRANSFORMATION);
             SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte, ALGORITHM);

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

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

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

@@ -56,7 +56,7 @@ public class WechatPhoneUtil {
      * @param phone 手机号
      * @return 脱敏后的手机号，如：138****8000
      */
-    private String maskPhone(String phone) {
+    public static String maskPhone(String phone) {
         if (phone == null || phone.length() < 7) {
             return "***";
         }

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

@@ -0,0 +1,92 @@
+package cn.novalon.gym.manage.member.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡类型响应 VO
+ *
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class MemberCardInfoVO {
+
+    /**
+     * 主键ID
+     */
+    private Long id;
+
+    /**
+     * 会员卡ID
+     */
+    private Long memberCardId;
+
+    /**
+     * 会员卡名称
+     */
+    private String memberCardName;
+
+    /**
+     * 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
+     */
+    private String memberCardType;
+
+    /**
+     * 卡类型描述
+     */
+    private String memberCardTypeDesc;
+
+    /**
+     * 会员卡价格
+     */
+    private BigDecimal memberCardPrice;
+
+    /**
+     * 有效天数（时长卡用）
+     */
+    private Integer memberCardValidityDays;
+
+    /**
+     * 总次数（次卡用）
+     */
+    private Integer memberCardTotalTimes;
+
+    /**
+     * 面额（储值卡用）
+     */
+    private BigDecimal memberCardAmount;
+
+    /**
+     * 状态：0-下架, 1-上架
+     */
+    private Integer memberCardStatus;
+
+    /**
+     * 状态描述
+     */
+    private String memberCardStatusDesc;
+
+    /**
+     * 扩展配置（JSON格式）
+     */
+    private String extraConfig;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createdAt;
+
+    /**
+     * 更新时间
+     */
+    private LocalDateTime updatedAt;
+}

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

@@ -0,0 +1,71 @@
+package cn.novalon.gym.manage.member.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡记录响应 VO
+ *
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class MemberCardRecordVO {
+
+    /**
+     * 会员卡记录ID
+     */
+    private Long memberCardRecordId;
+
+    /**
+     * 会员ID
+     */
+    private Long memberId;
+
+    /**
+     * 会员卡类型ID
+     */
+    private Long memberCardId;
+
+    /**
+     * 会员卡名称
+     */
+    private String memberCardName;
+
+    /**
+     * 状态：ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款
+     */
+    private String status;
+
+    /**
+     * 剩余次数
+     */
+    private Integer remainingTimes;
+
+    /**
+     * 剩余金额
+     */
+    private Double remainingAmount;
+
+    /**
+     * 到期时间
+     */
+    private LocalDateTime expireTime;
+
+    /**
+     * 购买时间
+     */
+    private LocalDateTime purchaseTime;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createdAt;
+}

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

@@ -0,0 +1,81 @@
+package cn.novalon.gym.manage.member.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡交易流水响应 VO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class MemberCardTransactionVO {
+
+    /**
+     * 交易ID
+     */
+    private Long id;
+
+    /**
+     * 会员卡记录ID
+     */
+    private Long memberCardRecordId;
+
+    /**
+     * 会员ID
+     */
+    private Long memberId;
+
+    /**
+     * 会员卡类型ID
+     */
+    private Long memberCardId;
+
+    /**
+     * 操作类型：PURCHASE-购买, DEDUCT-扣次/扣费, RENEW-续费, REFUND-退款, EXPIRE-过期
+     */
+    private String operationType;
+
+    /**
+     * 变动次数
+     */
+    private Integer changeAmount;
+
+    /**
+     * 变动金额
+     */
+    private Double changeBalance;
+
+    /**
+     * 变动后剩余次数
+     */
+    private Integer afterRemainingCount;
+
+    /**
+     * 变动后剩余金额
+     */
+    private Double afterRemainingBalance;
+
+    /**
+     * 关联业务类型
+     */
+    private String relatedBizType;
+
+    /**
+     * 备注
+     */
+    private String remark;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createdAt;
+}

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

@@ -0,0 +1,77 @@
+package cn.novalon.gym.manage.member.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡类型响应 VO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class MemberCardVO {
+
+    /**
+     * 会员卡ID
+     */
+    private Long memberCardId;
+
+    /**
+     * 会员卡名称
+     */
+    private String memberCardName;
+
+    /**
+     * 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
+     */
+    private String memberCardType;
+
+    /**
+     * 会员卡价格
+     */
+    private BigDecimal memberCardPrice;
+
+    /**
+     * 有效天数（时长卡用）
+     */
+    private Integer memberCardValidityDays;
+
+    /**
+     * 总次数（次卡用）
+     */
+    private Integer memberCardTotalTimes;
+
+    /**
+     * 面额（储值卡用）
+     */
+    private BigDecimal memberCardAmount;
+
+    /**
+     * 状态：0-下架, 1-上架
+     */
+    private Integer memberCardStatus;
+
+    /**
+     * 扩展配置（JSON格式）
+     */
+    private String extraConfig;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createdAt;
+
+    /**
+     * 更新时间
+     */
+    private LocalDateTime updatedAt;
+}

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

@@ -0,0 +1,96 @@
+package cn.novalon.gym.manage.member.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import java.time.LocalDateTime;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * 会员详情 VO（管理端使用）
+ *
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class MemberDetailVO {
+
+    // ==================== 会员基础信息 ====================
+
+    /**
+     * 会员ID
+     */
+    private Long id;
+
+    /**
+     * 会员编号
+     */
+    private String memberNo;
+
+    /**
+     * 昵称
+     */
+    private String nickname;
+
+    /**
+     * 手机号（脱敏显示）
+     */
+    private String phone;
+
+    /**
+     * 性别描述
+     */
+    private String genderDesc;
+
+    /**
+     * 生日
+     */
+    private Date birthday;
+
+    /**
+     * 地址
+     */
+    private String address;
+
+    /**
+     * 头像URL
+     */
+    private String avatar;
+
+    /**
+     * 是否关注服务号
+     */
+    private Boolean subscribed;
+
+    /**
+     * 最后登录时间
+     */
+    private LocalDateTime lastLoginAt;
+
+    /**
+     * 注册时间
+     */
+    private LocalDateTime createdAt;
+
+    // ==================== 会员卡信息 ====================
+
+    /**
+     * 会员持有的卡列表
+     */
+    private List<MemberCardInfoVO> memberCards;
+
+    /**
+     * 有效会员卡数量
+     */
+    private Integer activeCardCount;
+
+    /**
+     * 过期/用完会员卡数量
+     */
+    private Integer inactiveCardCount;
+}

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

@@ -1,10 +1,12 @@
 package cn.novalon.gym.manage.member.vo;
 
+import cn.novalon.gym.manage.member.enums.GenderEnum;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.time.LocalDate;
 import java.util.Date;
 
 /**
@@ -30,10 +32,13 @@ public class MemberInfoVO {
     private String phone;
 
     // 性别
-    private Integer gender;
+    private GenderEnum gender;
+
+    // 性别描述
+    private String genderDesc;
 
     // 生日
-    private Date birthday;
+    private LocalDate birthday;
 
     // 头像
     private String avatar;

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

@@ -0,0 +1,77 @@
+package cn.novalon.gym.manage.member.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+/**
+ * 退款申请响应 VO
+ * 
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class RefundApplicationVO {
+
+    /**
+     * 申请ID
+     */
+    private Long id;
+
+    /**
+     * 会员卡记录ID
+     */
+    private Long recordId;
+
+    /**
+     * 会员ID
+     */
+    private Long memberId;
+
+    /**
+     * 状态：PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败
+     */
+    private String status;
+
+    /**
+     * 退款原因
+     */
+    private String reason;
+
+    /**
+     * 申请时间
+     */
+    private LocalDateTime applyTime;
+
+    /**
+     * 审核时间
+     */
+    private LocalDateTime auditTime;
+
+    /**
+     * 审核人ID
+     */
+    private Long auditorId;
+
+    /**
+     * 审核备注
+     */
+    private String auditRemark;
+
+    /**
+     * 退款金额
+     */
+    private BigDecimal refundAmount;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createdAt;
+}

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

@@ -17,7 +17,7 @@ CREATE TABLE IF NOT EXISTS member_user (
     nickname VARCHAR(100),                                         -- 昵称
     phone VARCHAR(255),                                            -- 手机号（AES加密存储）
     gender INTEGER DEFAULT 0,                                      -- 性别：0-未知，1-男，2-女
-    birthday TIMESTAMP,                                            -- 生日
+    birthday DATE,                                            -- 生日
     address VARCHAR(500),                                          -- 地址
     avatar VARCHAR(500),                                           -- 头像URL
     subscribed BOOLEAN DEFAULT FALSE,                              -- 是否关注服务号
@@ -136,3 +136,146 @@ 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 '最后一次取消关注时间';
+
+
+-- ============================================
+-- 3. member_card 表（会员卡类型表）
+-- ============================================
+CREATE TABLE IF NOT EXISTS member_card (
+    id BIGSERIAL PRIMARY KEY,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP,
+    
+    member_card_id BIGSERIAL,
+    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 TEXT DEFAULT '{}'
+);
+
+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格式）';
+
+
+-- ============================================
+-- 4. member_card_record 表（会员卡记录表）
+-- ============================================
+CREATE TABLE IF NOT EXISTS member_card_record (
+    id BIGSERIAL PRIMARY KEY,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP,
+    
+    member_card_record_id BIGSERIAL,
+    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 TIMESTAMP,
+    source_order_id BIGINT,
+    purchase_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    version INTEGER DEFAULT 0 NOT NULL,
+    card_composition TEXT
+);
+
+-- 索引优化
+CREATE INDEX IF NOT EXISTS idx_member_card_record_member_id ON member_card_record(member_id);
+CREATE INDEX IF NOT EXISTS idx_member_card_record_status ON member_card_record(status);
+CREATE INDEX IF NOT EXISTS idx_member_card_record_expire_time ON member_card_record(expire_time);
+CREATE INDEX IF NOT EXISTS idx_member_card_record_member_status ON member_card_record(member_id, status);
+CREATE INDEX IF NOT EXISTS 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格式，用于组合卡）';
+
+
+-- ============================================
+-- 5. member_card_transactions 表（会员卡交易流水表）
+-- ============================================
+CREATE TABLE IF NOT EXISTS member_card_transactions (
+    id BIGSERIAL PRIMARY KEY,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    
+    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,
+    archived_at TIMESTAMP
+);
+
+-- 索引优化
+CREATE INDEX IF NOT EXISTS idx_member_card_transactions_member_id ON member_card_transactions(member_id);
+CREATE INDEX IF NOT EXISTS idx_member_card_transactions_record_id ON member_card_transactions(member_card_record_id);
+CREATE INDEX IF NOT EXISTS idx_member_card_transactions_created_at ON member_card_transactions(created_at);
+CREATE INDEX IF NOT EXISTS 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 '归档时间';
+
+
+-- ============================================
+-- 6. refund_application 表（退款申请表）
+-- ============================================
+CREATE TABLE IF NOT EXISTS refund_application (
+    id BIGSERIAL PRIMARY KEY,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP,
+    
+    record_id BIGINT NOT NULL,
+    member_id BIGINT NOT NULL,
+    status VARCHAR(20) NOT NULL DEFAULT 'PENDING',
+    reason VARCHAR(500),
+    apply_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    audit_time TIMESTAMP,
+    auditor_id BIGINT,
+    audit_remark VARCHAR(500),
+    refund_amount DECIMAL(10, 2)
+);
+
+CREATE INDEX IF NOT EXISTS idx_refund_application_record_id ON refund_application(record_id);
+CREATE INDEX IF NOT EXISTS 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-失败';

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

@@ -7,7 +7,10 @@ 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.EnableElasticsearchRepositories;
 import org.springframework.data.elasticsearch.repository.config.EnableReactiveElasticsearchRepositories;
 import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
 import org.springframework.web.server.WebFilter;
@@ -18,10 +21,11 @@ import java.util.List;
         ReactiveUserDetailsServiceAutoConfiguration.class })
 @EnableR2dbcRepositories(basePackages = {
         "cn.novalon.gym.manage.db.dao",
-        "cn.novalon.gym.manage.sys.audit.repository",
+        "cn.novalon.gym.manage.sys.audit.repository" ,
+        "cn.novalon.gym.manage.gymmembercard.dao",
         "cn.novalon.gym.manage.member.repository"
 })
-@EnableReactiveElasticsearchRepositories("cn.novalon.gym.manage.member.es.repository")
+@EnableReactiveElasticsearchRepositories(basePackages = "cn.novalon.gym.manage.member.es.repository")
 public class ManageApplication {
 
     private static final Logger logger = LoggerFactory.getLogger(ManageApplication.class);

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

@@ -2,6 +2,9 @@ package cn.novalon.gym.manage.app.config;
 
 
 import cn.novalon.gym.manage.file.handler.SysFileHandler;
+import cn.novalon.gym.manage.member.handler.MemberCardHandler;
+import cn.novalon.gym.manage.member.handler.MemberCardRecordHandler;
+import cn.novalon.gym.manage.member.handler.MemberCardTransactionHandler;
 import cn.novalon.gym.manage.member.handler.MemberHandler;
 import cn.novalon.gym.manage.member.handler.WechatAuthHandler;
 import cn.novalon.gym.manage.notify.handler.SysNoticeHandler;
@@ -56,7 +59,10 @@ public class SystemRouter {
             SysPermissionHandler permissionHandler,
             MemberHandler memberHandler,
             WechatAuthHandler wechatAuthHandler,
-            PasswordDiagnosticHandler passwordDiagnosticHandler) {
+            PasswordDiagnosticHandler passwordDiagnosticHandler,
+            MemberCardHandler memberCardHandler,
+            MemberCardRecordHandler memberCardRecordHandler,
+            MemberCardTransactionHandler memberCardTransactionHandler) {
 
         return route()
                 // ========== 诊断路由 ==========
@@ -216,6 +222,34 @@ public class SystemRouter {
                 .GET("/api/admin/members", memberHandler::searchMembers)
                 .GET("/api/admin/members/all", memberHandler::getAllMembers)
 
+
+                // ========================================
+                // ========== 会员卡管理路由 ==============
+                // ========================================
+
+                // ===== 会员卡类型管理 =====
+                .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)
+                
                 .build();
     }
 }

gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/util/HtmlEscapeUtil.java

@@ -0,0 +1,117 @@
+package cn.novalon.gym.manage.common.util;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * HTML 转义工具类
+ * 防止 XSS 注入攻击
+ *
+ * @author 付嘉
+ * @date 2026-05-29
+ */
+public class HtmlEscapeUtil {
+
+    private static final Map<Character, String> ESCAPE_MAP = new HashMap<>();
+    private static final Map<String, Character> UNESCAPE_MAP = new HashMap<>();
+    private static final Pattern HTML_PATTERN = Pattern.compile("<[^>]*>");
+
+    static {
+        // HTML 特殊字符转义映射
+        ESCAPE_MAP.put('&', "&amp;");
+        ESCAPE_MAP.put('<', "&lt;");
+        ESCAPE_MAP.put('>', "&gt;");
+        ESCAPE_MAP.put('"', "&quot;");
+        ESCAPE_MAP.put('\'', "&#39;");
+
+        // 反向映射
+        UNESCAPE_MAP.put("&amp;", '&');
+        UNESCAPE_MAP.put("&lt;", '<');
+        UNESCAPE_MAP.put("&gt;", '>');
+        UNESCAPE_MAP.put("&quot;", '"');
+        UNESCAPE_MAP.put("&#39;", '\'');
+    }
+
+    /**
+     * 转义 HTML 特殊字符
+     *
+     * @param input 原始字符串
+     * @return 转义后的字符串
+     */
+    public static String escape(String input) {
+        if (input == null || input.isEmpty()) {
+            return input;
+        }
+
+        StringBuilder result = new StringBuilder();
+        for (char c : input.toCharArray()) {
+            String escaped = ESCAPE_MAP.get(c);
+            if (escaped != null) {
+                result.append(escaped);
+            } else {
+                result.append(c);
+            }
+        }
+        return result.toString();
+    }
+
+    /**
+     * 反转义 HTML 特殊字符
+     *
+     * @param input 转义后的字符串
+     * @return 原始字符串
+     */
+    public static String unescape(String input) {
+        if (input == null || input.isEmpty()) {
+            return input;
+        }
+
+        String result = input;
+        for (Map.Entry<String, Character> entry : UNESCAPE_MAP.entrySet()) {
+            result = result.replace(entry.getKey(), String.valueOf(entry.getValue()));
+        }
+        return result;
+    }
+
+    /**
+     * 移除所有 HTML 标签
+     *
+     * @param input 原始字符串
+     * @return 移除标签后的字符串
+     */
+    public static String stripHtmlTags(String input) {
+        if (input == null || input.isEmpty()) {
+            return input;
+        }
+        return HTML_PATTERN.matcher(input).replaceAll("");
+    }
+
+    /**
+     * 安全转义（转义 + 移除标签）
+     *
+     * @param input 原始字符串
+     * @return 安全字符串
+     */
+    public static String sanitize(String input) {
+        if (input == null || input.isEmpty()) {
+            return input;
+        }
+        // 先移除 HTML 标签，再转义特殊字符
+        String noTags = stripHtmlTags(input);
+        return escape(noTags);
+    }
+
+    /**
+     * 判断是否包含 HTML 标签
+     *
+     * @param input 原始字符串
+     * @return true-包含, false-不包含
+     */
+    public static boolean containsHtmlTags(String input) {
+        if (input == null || input.isEmpty()) {
+            return false;
+        }
+        return HTML_PATTERN.matcher(input).find();
+    }
+}

gym-manage-api/pom.xml

@@ -43,7 +43,6 @@
         <module>manage-notify</module>
         <module>manage-file</module>
         <module>gym-member</module>
-	    <module>gym-checkIn</module>
 	</modules>
 
     <dependencyManagement>

gym-manage-web/pnpm-lock.yaml

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