增加Redis缓存功能

注：/api/groupCourse/cache/get接口为测试接口

gym-manage-api/gym-groupCourse/.mvn/wrapper/maven-wrapper.properties

@@ -0,0 +1,3 @@
+wrapperVersion=3.3.4
+distributionType=only-script
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.15/apache-maven-3.9.15-bin.zip

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

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>cn.novalon.gym.manage</groupId>
+        <artifactId>gym-manage-api</artifactId>
+        <version>1.0.0</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <groupId>cn.novalon.gym.manage</groupId>
+    <artifactId>gym-groupCourse</artifactId>
+    <version>1.0.0</version>
+    <name>gym-groupCourse</name>
+    <description>Group Course Management Module</description>
+    <url/>
+    <licenses>
+        <license/>
+    </licenses>
+    <developers>
+        <developer/>
+    </developers>
+    <scm>
+        <connection/>
+        <developerConnection/>
+        <tag/>
+        <url/>
+    </scm>
+    <properties>
+        <java.version>21</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-db</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webflux</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-r2dbc</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springdoc</groupId>
+            <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.swagger.core.v3</groupId>
+            <artifactId>swagger-annotations-jakarta</artifactId>
+            <version>2.2.43</version>
+            <scope>compile</scope>
+        </dependency>
+
+
+<!--        Redis依赖-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/converter/GroupCourseConverter.java

@@ -0,0 +1,53 @@
+
+package cn.novalon.gym.manage.groupcourse.converter;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Component
+@Slf4j
+public class GroupCourseConverter {
+    public GroupCourse toDomain(GroupCourseEntity entity){
+        if(entity == null){
+            return null;
+        }
+        GroupCourse groupCourse = new GroupCourse();
+        BeanUtil.copyProperties(entity,groupCourse);
+        log.info("转换bean，entity-domain：",groupCourse);
+        return groupCourse;
+    }
+
+    public GroupCourseEntity toEntity(GroupCourse domain){
+        if(domain == null){
+            return null;
+        }
+        GroupCourseEntity entity = new GroupCourseEntity();
+        BeanUtil.copyProperties(domain,entity);
+        log.info("转换bean，domain-entity：",entity);
+        return entity;
+    }
+
+    public List<GroupCourse> toDomainList(List<GroupCourseEntity> entities){
+        if (entities == null) {
+            return null;
+        }
+        return entities.stream()
+                .map(this::toDomain)
+                .collect(Collectors.toList());
+    }
+
+    public List<GroupCourseEntity> toEntityList(List<GroupCourse> domains){
+        if (domains == null) {
+            return null;
+        }
+        return domains.stream()
+                .map(this::toEntity)
+                .collect(Collectors.toList());
+    }
+}

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

@@ -0,0 +1,23 @@
+
+package cn.novalon.gym.manage.groupcourse.dao;
+
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.repository.R2dbcRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+@Repository
+public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long> {
+
+    Mono<GroupCourseEntity> findByIdIsAndDeletedAtIsNull(Long id);
+
+    Flux<GroupCourseEntity> findAll();
+
+    Flux<GroupCourseEntity> findAll(Sort sort);
+
+    Flux<GroupCourseEntity> findAllByDeletedAtIsNull();
+
+    Flux<GroupCourseEntity> findAllByDeletedAtIsNull(Sort sort);
+}

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

@@ -0,0 +1,142 @@
+
+package cn.novalon.gym.manage.groupcourse.domain;
+
+import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.time.LocalDateTime;
+
+public class GroupCourse extends BaseDomain{
+
+    //课程名称
+    @Schema(description = "团课名", example = "Push-up")
+    private String courseName;
+
+    //教练id
+    @Schema(description = "教练id", example = "1")
+    private Long coachId;
+
+    //课程类型
+    @Schema(description = "课程类型", example = "1")
+    private Long courseType;
+
+    //开始时间
+    @Schema(description = "开始时间", example = "2026-01-01")
+    private LocalDateTime startTime;
+
+    //结束时间
+    @Schema(description = "结束时间", example = "2026-01-02")
+    private LocalDateTime endTime;
+
+    //最大参与人数
+    @Schema(description = "最大参与人数", example = "20")
+    private Integer maxMembers;
+
+    //当前参与人数
+    @Schema(description = "当前参与人数", example = "2")
+    private Integer currentMembers;
+
+    //课程状态：0-正常，1-已取消，2-已结束
+    @Schema(description = "课程状态", example = "0")
+    private Long status;
+
+    //上课地点
+    @Schema(description = "上课地点", example = "龙泉驿区幸福路")
+    private String location;
+
+    //封面图URL
+    @Schema(description = "封面图URL", example = "https://12345.com")
+    private String coverImage;
+
+    //课程描述
+    @Schema(description = "课程描述", example = "从入门到入土")
+    private String description;
+
+    public String getCourseName() {
+        return courseName;
+    }
+
+    public void setCourseName(String courseName) {
+        this.courseName = courseName;
+    }
+
+    public Long getCoachId() {
+        return coachId;
+    }
+
+    public void setCoachId(Long coachId) {
+        this.coachId = coachId;
+    }
+
+    public Long getCourseType() {
+        return courseType;
+    }
+
+    public void setCourseType(Long courseType) {
+        this.courseType = courseType;
+    }
+
+    public LocalDateTime getStartTime() {
+        return startTime;
+    }
+
+    public void setStartTime(LocalDateTime startTime) {
+        this.startTime = startTime;
+    }
+
+    public LocalDateTime getEndTime() {
+        return endTime;
+    }
+
+    public void setEndTime(LocalDateTime endTime) {
+        this.endTime = endTime;
+    }
+
+    public Integer getMaxMembers() {
+        return maxMembers;
+    }
+
+    public void setMaxMembers(Integer maxMembers) {
+        this.maxMembers = maxMembers;
+    }
+
+    public Integer getCurrentMembers() {
+        return currentMembers;
+    }
+
+    public void setCurrentMembers(Integer currentMembers) {
+        this.currentMembers = currentMembers;
+    }
+
+    public Long getStatus() {
+        return status;
+    }
+
+    public void setStatus(Long status) {
+        this.status = status;
+    }
+
+    public String getLocation() {
+        return location;
+    }
+
+    public void setLocation(String location) {
+        this.location = location;
+    }
+
+    public String getCoverImage() {
+        return coverImage;
+    }
+
+    public void setCoverImage(String coverImage) {
+        this.coverImage = coverImage;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+}

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

@@ -0,0 +1,144 @@
+
+package cn.novalon.gym.manage.groupcourse.entity;
+
+import cn.novalon.gym.manage.db.entity.BaseEntity;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.LocalDateTime;
+
+@Table("group_course")
+public class GroupCourseEntity extends BaseEntity {
+
+    //课程名称
+    @Column("course_name")
+    private String courseName;
+
+    //教练id
+    @Column("coach_id")
+    private Long coachId;
+
+    //课程类型
+    @Column("course_type")
+    private Long courseType;
+
+    //开始时间
+    @Column("start_time")
+    private LocalDateTime startTime;
+
+    //结束时间
+    @Column("end_time")
+    private LocalDateTime endTime;
+
+    //最大参与人数
+    @Column("max_members")
+    private Integer maxMembers;
+
+    //当前参与人数
+    @Column("current_members")
+    private Integer currentMembers;
+
+    //课程状态：0-正常，1-已取消，2-已结束
+    @Column("status")
+    private Long status;
+
+    //上课地点
+    @Column("location")
+    private String location;
+
+    //封面图URL
+    @Column("cover_image")
+    private String coverImage;
+
+    //课程描述
+    @Column("description")
+    private String description;
+
+    public String getCourseName() {
+        return courseName;
+    }
+
+    public void setCourseName(String courseName) {
+        this.courseName = courseName;
+    }
+
+    public Long getCoachId() {
+        return coachId;
+    }
+
+    public void setCoachId(Long coachId) {
+        this.coachId = coachId;
+    }
+
+    public Long getCourseType() {
+        return courseType;
+    }
+
+    public void setCourseType(Long courseType) {
+        this.courseType = courseType;
+    }
+
+    public LocalDateTime getStartTime() {
+        return startTime;
+    }
+
+    public void setStartTime(LocalDateTime startTime) {
+        this.startTime = startTime;
+    }
+
+    public LocalDateTime getEndTime() {
+        return endTime;
+    }
+
+    public void setEndTime(LocalDateTime endTime) {
+        this.endTime = endTime;
+    }
+
+    public Integer getMaxMembers() {
+        return maxMembers;
+    }
+
+    public void setMaxMembers(Integer maxMembers) {
+        this.maxMembers = maxMembers;
+    }
+
+    public Integer getCurrentMembers() {
+        return currentMembers;
+    }
+
+    public void setCurrentMembers(Integer currentMembers) {
+        this.currentMembers = currentMembers;
+    }
+
+    public Long getStatus() {
+        return status;
+    }
+
+    public void setStatus(Long status) {
+        this.status = status;
+    }
+
+    public String getLocation() {
+        return location;
+    }
+
+    public void setLocation(String location) {
+        this.location = location;
+    }
+
+    public String getCoverImage() {
+        return coverImage;
+    }
+
+    public void setCoverImage(String coverImage) {
+        this.coverImage = coverImage;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+}

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

@@ -0,0 +1,128 @@
+
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseService;
+import cn.novalon.gym.manage.groupcourse.service.RedisService;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Validator;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import reactor.core.publisher.Mono;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Component
+@Tag(name="团课管理",description = "团课相关操作")
+public class GroupCourseHandler {
+    private final IGroupCourseService groupCourseService;
+    private final Validator validator;
+    private final RedisService redisService;
+    private final ObjectMapper objectMapper;
+    
+    public GroupCourseHandler(IGroupCourseService groupCourseService, 
+                              Validator validator,
+                              RedisService redisService,
+                              ObjectMapper objectMapper){
+        this.groupCourseService = groupCourseService;
+        this.validator = validator;
+        this.redisService = redisService;
+        this.objectMapper = objectMapper;
+    }
+
+    @Operation(summary = "获取所有团课", description = "获取系统中所有团课列表")
+    public Mono<ServerResponse> getAllGroupCourse(ServerRequest request){
+        boolean includeDeleted = Boolean.valueOf(request.queryParam("includeDeleted").orElse("false"));
+        return ServerResponse.ok()
+                .body(groupCourseService.findAll(includeDeleted), GroupCourse.class);
+    }
+
+    @Operation(summary = "分页获取团课", description = "根据分页参数获取团课列表")
+    public Mono<ServerResponse> getGroupCoursesByPage(ServerRequest request) {
+        return request.bodyToMono(PageRequest.class)
+                .flatMap(pageRequest -> {
+                    boolean includeDeleted = request.queryParam("includeDeleted")
+                            .map(Boolean::parseBoolean)
+                            .orElse(false);
+                    
+                    if (pageRequest.getPage() < 0) {
+                        pageRequest.setPage(0);
+                    }
+                    if (pageRequest.getSize() <= 0 || pageRequest.getSize() > 100) {
+                        pageRequest.setSize(10);
+                    }
+                    if (pageRequest.getSort() == null || pageRequest.getSort().isEmpty()) {
+                        pageRequest.setSort("id");
+                    }
+                    if (pageRequest.getOrder() == null || pageRequest.getOrder().isEmpty()) {
+                        pageRequest.setOrder("asc");
+                    }
+
+                    return groupCourseService.findByPage(pageRequest, includeDeleted)
+                            .flatMap(response -> ServerResponse.ok().bodyValue(response));
+                });
+    }
+
+    @Operation(summary = "根据ID获取团课", description = "根据ID获取团课详情")
+    public Mono<ServerResponse> getGroupCourseById(ServerRequest request){
+        Long id = Long.valueOf(request.pathVariable("id"));
+        return ServerResponse.ok()
+                .body(groupCourseService.findById(id), GroupCourse.class);
+    }
+
+    @Operation(summary = "测试-根据Key获取Redis缓存", description = "测试接口：根据传入的key值获取Redis中缓存的数据")
+    public Mono<ServerResponse> getCacheByKey(ServerRequest request) {
+        return request.bodyToMono(Map.class)
+                .flatMap(body -> {
+                    String key = (String) body.get("key");
+                    
+                    if (key == null || key.isEmpty()) {
+                        Map<String, Object> error = new HashMap<>();
+                        error.put("success", false);
+                        error.put("message", "key参数不能为空");
+                        return ServerResponse.badRequest().bodyValue(error);
+                    }
+                    
+                    Object cachedValue = redisService.get(key);
+                    
+                    Map<String, Object> result = new HashMap<>();
+                    if (cachedValue != null) {
+                        result.put("success", true);
+                        result.put("key", key);
+                        result.put("value", cachedValue);
+                        result.put("message", "缓存命中");
+                        
+                        try {
+                            if (cachedValue instanceof String) {
+                                Object jsonObject = objectMapper.readValue((String) cachedValue, Object.class);
+                                result.put("parsedValue", jsonObject);
+                                result.put("valueType", "JSON字符串");
+                            } else {
+                                result.put("valueType", cachedValue.getClass().getSimpleName());
+                            }
+                        } catch (Exception e) {
+                            result.put("parsedValue", null);
+                            result.put("valueType", "无法解析");
+                        }
+                    } else {
+                        result.put("success", false);
+                        result.put("key", key);
+                        result.put("value", null);
+                        result.put("message", "缓存未命中");
+                    }
+                    
+                    return ServerResponse.ok().bodyValue(result);
+                })
+                .onErrorResume(error -> {
+                    Map<String, Object> errorResponse = new HashMap<>();
+                    errorResponse.put("success", false);
+                    errorResponse.put("message", "请求处理失败: " + error.getMessage());
+                    return ServerResponse.status(500).bodyValue(errorResponse);
+                });
+    }
+}

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

@@ -0,0 +1,20 @@
+
+package cn.novalon.gym.manage.groupcourse.repository;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import org.springframework.data.domain.Sort;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+public interface IGroupCourseRepository {
+    Mono<GroupCourse> findByIdAndDeletedAtIsNull(Long id);
+    Flux<GroupCourse> findAll();
+    Flux<GroupCourse> findAll(Sort sort);
+    Flux<GroupCourse> findByDeletedAtIsNull();
+    Flux<GroupCourse> findByDeletedAtIsNull(Sort sort);
+    
+    Mono<PageResponse<GroupCourse>> findByPage(PageRequest pageRequest);
+    Mono<PageResponse<GroupCourse>> findByPageAndNotDeleted(PageRequest pageRequest);
+}

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

@@ -0,0 +1,131 @@
+
+package cn.novalon.gym.manage.groupcourse.repository.impl;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.groupcourse.converter.GroupCourseConverter;
+import cn.novalon.gym.manage.groupcourse.dao.GroupCourseDao;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+
+@Repository
+public class GroupCourseRepository implements IGroupCourseRepository {
+    private final GroupCourseDao groupCourseDao;
+    private final GroupCourseConverter groupCourseConverter;
+    private final R2dbcEntityTemplate r2dbcEntityTemplate;
+
+    public GroupCourseRepository(GroupCourseDao groupCourseDao, GroupCourseConverter groupCourseConverter,
+                                  R2dbcEntityTemplate r2dbcEntityTemplate){
+        this.groupCourseDao = groupCourseDao;
+        this.groupCourseConverter = groupCourseConverter;
+        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
+    }
+
+    @Override
+    public Mono<GroupCourse> findByIdAndDeletedAtIsNull(Long id) {
+        return groupCourseDao.findByIdIsAndDeletedAtIsNull(id)
+                .map(groupCourseConverter::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourse> findAll() {
+        return groupCourseDao.findAll()
+                .map(groupCourseConverter::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourse> findAll(Sort sort) {
+        return groupCourseDao.findAll(sort)
+                .map(groupCourseConverter::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourse> findByDeletedAtIsNull() {
+        return groupCourseDao.findAllByDeletedAtIsNull()
+                .map(groupCourseConverter::toDomain);
+    }
+
+    @Override
+    public Flux<GroupCourse> findByDeletedAtIsNull(Sort sort) {
+        return groupCourseDao.findAllByDeletedAtIsNull(sort)
+                .map(groupCourseConverter::toDomain);
+    }
+
+    @Override
+    public Mono<PageResponse<GroupCourse>> findByPage(PageRequest pageRequest) {
+        int page = pageRequest.getPage();
+        int size = pageRequest.getSize();
+        String sort = pageRequest.getSort();
+        String order = pageRequest.getOrder();
+
+        Sort sortObj = Sort.unsorted();
+        if (sort != null && !sort.isEmpty()) {
+            sortObj = Sort.by(Sort.Direction.fromString(order), sort);
+        }
+
+        org.springframework.data.domain.PageRequest pageable = org.springframework.data.domain.PageRequest.of(page, size, sortObj);
+
+        Query query = Query.empty();
+
+        return r2dbcEntityTemplate.select(GroupCourseEntity.class)
+                .matching(query.with(pageable))
+                .all()
+                .collectList()
+                .zipWith(r2dbcEntityTemplate.count(query, GroupCourseEntity.class))
+                .map(tuple -> {
+                    long total = tuple.getT2();
+                    int totalPages = (int) Math.ceil((double) total / size);
+                    List<GroupCourse> courseList = tuple.getT1().stream()
+                            .map(groupCourseConverter::toDomain)
+                            .toList();
+                    return new PageResponse<>(courseList, totalPages, total, page, size);
+                });
+    }
+
+    @Override
+    public Mono<PageResponse<GroupCourse>> findByPageAndNotDeleted(PageRequest pageRequest) {
+        int page = pageRequest.getPage();
+        int size = pageRequest.getSize();
+        String sort = pageRequest.getSort();
+        String order = pageRequest.getOrder();
+
+        Sort sortObj = Sort.unsorted();
+        if (sort != null && !sort.isEmpty()) {
+            sortObj = Sort.by(Sort.Direction.fromString(order), sort);
+        }
+
+        org.springframework.data.domain.PageRequest pageable = org.springframework.data.domain.PageRequest.of(page, size, sortObj);
+
+        return groupCourseDao.findAllByDeletedAtIsNull(sortObj)
+                .collectList()
+                .zipWith(groupCourseDao.findAllByDeletedAtIsNull().count())
+                .map(tuple -> {
+                    List<GroupCourseEntity> allEntities = tuple.getT1();
+                    long total = tuple.getT2();
+                    
+                    int fromIndex = page * size;
+                    int toIndex = Math.min(fromIndex + size, allEntities.size());
+                    
+                    List<GroupCourse> courseList;
+                    if (fromIndex < allEntities.size()) {
+                        courseList = allEntities.subList(fromIndex, toIndex).stream()
+                                .map(groupCourseConverter::toDomain)
+                                .toList();
+                    } else {
+                        courseList = List.of();
+                    }
+                    
+                    int totalPages = (int) Math.ceil((double) total / size);
+                    return new PageResponse<>(courseList, totalPages, total, page, size);
+                });
+    }
+}

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

@@ -0,0 +1,16 @@
+
+package cn.novalon.gym.manage.groupcourse.service;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+public interface IGroupCourseService {
+    Mono<GroupCourse> findById(Long id);
+    Flux<GroupCourse> findAll();
+    Flux<GroupCourse> findAll(boolean includeDeleted);
+    
+    Mono<PageResponse<GroupCourse>> findByPage(PageRequest pageRequest, boolean includeDeleted);
+}

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

@@ -0,0 +1,76 @@
+package cn.novalon.gym.manage.groupcourse.service;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author:liwentao
+ * @date:2026/5/15-05-15-16:05
+ */
+@Service
+public class RedisService {
+
+    @Autowired
+    private RedisTemplate<String, Object> redisTemplate;
+
+    // 设置值
+    public void set(String key, Object value) {
+        redisTemplate.opsForValue().set(key, value);
+    }
+
+    // 设置值并指定过期时间（秒）
+    public void setWithExpire(String key, Object value, long timeout) {
+        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
+    }
+
+    // 获取值
+    public Object get(String key) {
+        return redisTemplate.opsForValue().get(key);
+    }
+
+    // 删除key
+    public Boolean delete(String key) {
+        return redisTemplate.delete(key);
+    }
+
+    // 判断key是否存在
+    public Boolean hasKey(String key) {
+        return redisTemplate.hasKey(key);
+    }
+
+    // 设置过期时间
+    public Boolean expire(String key, long timeout) {
+        return redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
+    }
+
+    // Hash操作
+    public void putHash(String key, String hashKey, Object value) {
+        redisTemplate.opsForHash().put(key, hashKey, value);
+    }
+
+    public Object getHash(String key, String hashKey) {
+        return redisTemplate.opsForHash().get(key, hashKey);
+    }
+
+    // List操作
+    public void leftPush(String key, Object value) {
+        redisTemplate.opsForList().leftPush(key, value);
+    }
+
+    public Object rightPop(String key) {
+        return redisTemplate.opsForList().rightPop(key);
+    }
+
+    // Set操作
+    public void addToSet(String key, Object... values) {
+        redisTemplate.opsForSet().add(key, values);
+    }
+
+    public Set<Object> getSet(String key) {
+        return redisTemplate.opsForSet().members(key);
+    }
+}

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

@@ -0,0 +1,138 @@
+
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseService;
+import cn.novalon.gym.manage.groupcourse.service.RedisService;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.Duration;
+import java.util.List;
+
+@Service
+public class GroupCourseService implements IGroupCourseService {
+    private static final Logger logger = LoggerFactory.getLogger(GroupCourseService.class);
+    
+    private final IGroupCourseRepository groupCourseRepository;
+    private final RedisService redisService;
+    private final ObjectMapper objectMapper;
+    
+    private static final String CACHE_KEY_PREFIX = "group_course:page:";
+    private static final String CACHE_KEY_ID_PREFIX = "group_course:id:";
+    private static final long CACHE_EXPIRE_SECONDS = 300;
+    
+    public GroupCourseService(IGroupCourseRepository groupCourseRepository, 
+                              RedisService redisService,
+                              ObjectMapper objectMapper){
+        this.groupCourseRepository = groupCourseRepository;
+        this.redisService = redisService;
+        this.objectMapper = objectMapper;
+    }
+
+    @Override
+    public Mono<GroupCourse> findById(Long id) {
+        String cacheKey = CACHE_KEY_ID_PREFIX + id;
+        
+        Object cachedData = redisService.get(cacheKey);
+        if (cachedData != null) {
+            try {
+                String json;
+                if (cachedData instanceof String) {
+                    json = (String) cachedData;
+                } else {
+                    json = objectMapper.writeValueAsString(cachedData);
+                }
+                
+                GroupCourse groupCourse = objectMapper.readValue(json, GroupCourse.class);
+                logger.info("缓存命中 - findById: id={}", id);
+                return Mono.just(groupCourse);
+            } catch (JsonProcessingException e) {
+                logger.warn("缓存解析失败，删除缓存 - id: {}, error: {}", id, e.getMessage());
+                redisService.delete(cacheKey);
+            }
+        }
+        
+        logger.debug("缓存未命中，查询数据库 - findById: id={}", id);
+        return groupCourseRepository.findByIdAndDeletedAtIsNull(id)
+                .doOnSuccess(groupCourse -> {
+                    if (groupCourse != null) {
+                        try {
+                            String jsonData = objectMapper.writeValueAsString(groupCourse);
+                            redisService.setWithExpire(cacheKey, jsonData, CACHE_EXPIRE_SECONDS);
+                            logger.debug("缓存已设置 - findById: id={}", id);
+                        } catch (JsonProcessingException e) {
+                            logger.error("缓存设置失败 - id: {}, error: {}", id, e.getMessage());
+                        }
+                    }
+                });
+    }
+
+    @Override
+    public Flux<GroupCourse> findAll() {
+        return groupCourseRepository.findAll();
+    }
+
+    @Override
+    public Flux<GroupCourse> findAll(boolean includeDeleted) {
+        if(includeDeleted){
+            return groupCourseRepository.findAll();
+        }else{
+            return groupCourseRepository.findByDeletedAtIsNull();
+        }
+    }
+
+    @Override
+    public Mono<PageResponse<GroupCourse>> findByPage(PageRequest pageRequest, boolean includeDeleted) {
+        int page = pageRequest.getPage();
+        int size = pageRequest.getSize();
+        
+        String cacheKey = CACHE_KEY_PREFIX + page + ":" + size + ":" + includeDeleted;
+
+        Object cachedData = redisService.get(cacheKey);
+        if (cachedData != null) {
+            try {
+                String json;
+                if (cachedData instanceof String) {
+                    json = (String) cachedData;
+                } else {
+                    json = objectMapper.writeValueAsString(cachedData);
+                }
+                
+                PageResponse<GroupCourse> pageResponse = objectMapper.readValue(json, 
+                    objectMapper.getTypeFactory().constructParametricType(PageResponse.class, GroupCourse.class));
+                logger.info("缓存命中 - findByPage: key={}", cacheKey);
+                return Mono.just(pageResponse);
+            } catch (JsonProcessingException e) {
+                logger.warn("缓存解析失败，删除缓存 - key: {}, error: {}", cacheKey, e.getMessage());
+                redisService.delete(cacheKey);
+            }
+        }
+        
+        logger.debug("缓存未命中，查询数据库 - findByPage: key={}", cacheKey);
+        Mono<PageResponse<GroupCourse>> resultMono;
+        if (includeDeleted) {
+            resultMono = groupCourseRepository.findByPage(pageRequest);
+        } else {
+            resultMono = groupCourseRepository.findByPageAndNotDeleted(pageRequest);
+        }
+        
+        return resultMono.doOnSuccess(pageResponse -> {
+            try {
+                String jsonData = objectMapper.writeValueAsString(pageResponse);
+                redisService.setWithExpire(cacheKey, jsonData, CACHE_EXPIRE_SECONDS);
+                logger.debug("缓存已设置 - findByPage: key={}", cacheKey);
+            } catch (JsonProcessingException e) {
+                logger.error("缓存设置失败 - key: {}, error: {}", cacheKey, e.getMessage());
+            }
+        });
+    }
+}

gym-manage-api/gym-groupCourse/src/main/resources/application.yaml

@@ -0,0 +1,3 @@
+spring:
+  application:
+    name: gym-groupCourse

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

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

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

@@ -1,112 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <parent>
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.5.13</version>
-        <relativePath/> <!-- lookup parent from repository -->
-    </parent>
-    <groupId>cn.novalon.gym.manage</groupId>
-    <artifactId>gym-member-card</artifactId>
-    <version>0.0.1-SNAPSHOT</version>
-    <name>gym-member-card</name>
-    <description>gym-member-card</description>
-
-    <properties>
-        <java.version>21</java.version>
-    </properties>
-
-    <dependencies>
-        <!-- WebFlux 启动器（响应式） -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-webflux</artifactId>
-        </dependency>
-
-        <!-- PostgreSQL 驱动（JDBC，如果工具类需要） -->
-        <dependency>
-            <groupId>org.postgresql</groupId>
-            <artifactId>postgresql</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-
-        <!-- 你的内部模块 -->
-        <dependency>
-            <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>manage-db</artifactId>
-            <version>1.0.0</version>
-            <scope>compile</scope>
-        </dependency>
-
-        <!-- Lombok -->
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>1.18.36</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <!-- Hutool 工具箱 -->
-        <dependency>
-            <groupId>cn.hutool</groupId>
-            <artifactId>hutool-all</artifactId>
-            <version>5.8.22</version>
-        </dependency>
-
-        <!-- Spring 上下文（其实 WebFlux 已经包含，保留也可以） -->
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-context</artifactId>
-        </dependency>
-
-            <!-- Redis响应式支持 -->
-    <dependency>
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
-    </dependency>
-
-<!--    &lt;!&ndash; ⭐ Redisson 响应式客户端 &ndash;&gt;-->
-<!--    <dependency>-->
-<!--        <groupId>org.redisson</groupId>-->
-<!--        <artifactId>redisson-spring-boot-starter</artifactId>-->
-<!--        <version>3.27.0</version>-->
-<!--    </dependency>-->
-
-<!--    &lt;!&ndash; ⭐ RabbitMQ 支持 &ndash;&gt;-->
-<!--    <dependency>-->
-<!--        <groupId>org.springframework.boot</groupId>-->
-<!--        <artifactId>spring-boot-starter-amqp</artifactId>-->
-<!--    </dependency>-->
-
-    <!-- Jackson for JSON处理 -->
-    <dependency>
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-starter-json</artifactId>
-    </dependency>
-
-
-        <!-- ⭐ 必须添加：测试依赖 -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-
-
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-maven-plugin</artifactId>
-                <configuration>
-                    <!-- 保留标准 JAR，供其他模块引用 -->
-                    <classifier>exec</classifier>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-</project>

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

@@ -1,17 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard;
-
-import org.springframework.boot.SpringApplication;
-import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
-import org.springframework.scheduling.annotation.EnableScheduling;
-
-@SpringBootApplication
-@EnableR2dbcRepositories(basePackages = "cn.novalon.gym.manage.gymmembercard.dao")
-@EnableScheduling
-public class GymMemberCardApplication {
-
-    public static void main(String[] args) {
-        SpringApplication.run(GymMemberCardApplication.class, args);
-    }
-
-}

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

@@ -1,130 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.dao;
-
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardEntity;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.r2dbc.repository.Modifying;
-import org.springframework.data.r2dbc.repository.Query;
-import org.springframework.data.r2dbc.repository.R2dbcRepository;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-@Repository
-public interface MemberCardDao extends R2dbcRepository<MemberCardEntity, Long> {
-
-    /**
-     * 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
-     * @param memberCardId 会员卡ID
-     * @return 会员卡完整信息，如果不存在或已删除则返回空
-     */
-    Mono<MemberCardEntity> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
-
-    /**
-     * 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
-     * 注意：模糊查询使用前后缀通配符，若数据量较大可能影响索引效率，建议后期引入全文索引或改用后缀模糊
-     * @param status 会员卡状态（上架/下架）
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    @Query("SELECT * FROM member_card WHERE deleted_at IS NULL " +
-            "AND (:status IS NULL OR member_card_status = :status) " +
-            "AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
-            "AND (:type IS NULL OR member_card_type = :type) " +
-            "AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
-            "AND (:maxPrice IS NULL OR member_card_price <= :maxPrice) " +
-            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
-    Flux<MemberCardEntity> findWithConditions(Integer status, String name, String type,
-                                              Double minPrice, Double maxPrice, Pageable pageable);
-
-    /**
-     * 统计符合条件的会员卡总数（配合列表查询使用）
-     * @param status 会员卡状态
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @return 符合条件的会员卡数量
-     */
-    @Query("SELECT COUNT(*) FROM member_card WHERE deleted_at IS NULL " +
-            "AND (:status IS NULL OR member_card_status = :status) " +
-            "AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
-            "AND (:type IS NULL OR member_card_type = :type) " +
-            "AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
-            "AND (:maxPrice IS NULL OR member_card_price <= :maxPrice)")
-    Mono<Long> countWithConditions(Integer status, String name, String type,
-                                   Double minPrice, Double maxPrice);
-
-    /**
-     * 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
-     * @param status 会员卡状态（通常传上架状态）
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    Flux<MemberCardEntity> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
-
-    /**
-     * 检查会员卡是否已被购买（用于删除前的校验）
-     * 注意：此查询关联到 member_card_record 表，建议后续独立至 MemberCardRecordDao
-     * @param memberCardId 会员卡ID
-     * @return 如果存在关联的会员记录则返回true，否则返回false
-     */
-    @Query("SELECT EXISTS(SELECT 1 FROM member_card_record WHERE member_card_id = :memberCardId AND deleted_at IS NULL LIMIT 1)")
-    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
-
-    /**
-     * 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
-     * @param memberCardId 会员卡ID
-     * @return 受影响的行数
-     */
-    @Modifying
-    @Query("UPDATE member_card SET deleted_at = NOW() WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
-    Mono<Integer> logicalDelete(Long memberCardId);
-
-    /**
-     * 【新增】安全更新会员卡信息（仅允许修改业务相关字段，防止覆盖敏感字段）
-     * @param memberCardId 会员卡ID
-     * @param name 卡种名称
-     * @param price 价格
-     * @param durationDays 有效天数
-     * @param totalCount 总次数
-     * @param denomination 面额
-     * @param status 状态
-     * @return 受影响的行数
-     */
-    @Modifying
-    @Query("UPDATE member_card SET " +
-            "member_card_name = COALESCE(:name, member_card_name), " +
-            "member_card_price = COALESCE(:price, member_card_price), " +
-            "duration_days = COALESCE(:durationDays, duration_days), " +
-            "total_count = COALESCE(:totalCount, total_count), " +
-            "denomination = COALESCE(:denomination, denomination), " +
-            "member_card_status = COALESCE(:status, member_card_status), " +
-            "updated_at = NOW() " +
-            "WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
-    Mono<Integer> updateSafe(Long memberCardId, String name, Double price,
-                             Integer durationDays, Integer totalCount,
-                             Double denomination, Integer status);
-
-    /**
-     * 保存卡种信息（新增或更新）
-     * - 新增：entity.memberCardId 为 null 时，插入新记录
-     * - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
-     * 注意：直接 save 会更新所有字段，如需安全更新请调用 updateSafe 方法
-     * @param entity 卡种信息
-     * @return 保存后的实体对象
-     */
-    @Override
-    <S extends MemberCardEntity> Mono<S> save(S entity);
-
-    /**
-     * 批量查询上架的会员卡（用于小程序端展示）
-     * @param status 上架状态值
-     * @return 上架的会员卡列表
-     */
-    @Query("SELECT * FROM member_card WHERE deleted_at IS NULL AND member_card_status = :status ORDER BY member_card_price ASC")
-    Flux<MemberCardEntity> findActiveCards(Integer status);
-}

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

@@ -1,87 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.dao;
-
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardRecordEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.r2dbc.repository.Modifying;
-import org.springframework.data.r2dbc.repository.Query;
-import org.springframework.data.r2dbc.repository.R2dbcRepository;
-import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Repository
-public interface MemberCardRecordDao extends R2dbcRepository<MemberCardRecordEntity, Long> {
-
-    @Modifying
-    @Query("INSERT INTO member_card_record (member_id, member_card_id, status, expire_time, remaining_times, remaining_amount, source_order_id, purchase_time, created_at, updated_at) " +
-            "VALUES (:memberId, :memberCardId, 'ACTIVE', :expireTime, :remainingTimes, :remainingAmount, :sourceOrderId, NOW(), NOW(), NOW()) " +
-            "RETURNING *")
-    Mono<MemberCardRecordEntity> insertActiveRecord(@Param("memberId") Long memberId,
-                                                    @Param("memberCardId") Long memberCardId,
-                                                    @Param("expireTime") LocalDateTime expireTime,
-                                                    @Param("remainingTimes") Integer remainingTimes,
-                                                    @Param("remainingAmount") Double remainingAmount,
-                                                    @Param("sourceOrderId") Long sourceOrderId);
-
-    @Modifying
-    @Query("UPDATE member_card_record SET " +
-            "remaining_times = remaining_times - :deductTimes, " +
-            "remaining_amount = remaining_amount - :deductAmount, " +
-            "updated_at = NOW() " +
-            "WHERE member_card_record_id = :recordId " +
-            "AND deleted_at IS NULL " +
-            "AND remaining_times >= :deductTimes " +
-            "AND remaining_amount >= :deductAmount")
-    Mono<Integer> deductUsage(@Param("recordId") Long recordId,
-                              @Param("deductTimes") Integer deductTimes,
-                              @Param("deductAmount") Double deductAmount);
-
-    @Modifying
-    @Query("UPDATE member_card_record SET remaining_times = remaining_times + :addTimes, " +
-            "remaining_amount = remaining_amount + :addAmount, expire_time = :newExpireTime, updated_at = NOW() " +
-            "WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
-    Mono<Integer> renewCard(@Param("recordId") Long recordId,
-                            @Param("addTimes") Integer addTimes,
-                            @Param("addAmount") Double addAmount,
-                            @Param("newExpireTime") LocalDateTime newExpireTime);
-
-    @Modifying
-    @Query("UPDATE member_card_record SET status = :status, updated_at = NOW() " +
-            "WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
-    Mono<Integer> updateStatus(@Param("recordId") Long recordId,
-                               @Param("status") MemberCardRecordStatus status);
-
-    @Query("SELECT * FROM member_card_record WHERE member_id = :memberId AND status = 'ACTIVE' AND deleted_at IS NULL ORDER BY expire_time ASC")
-    Flux<MemberCardRecordEntity> findActiveCardsByMemberId(@Param("memberId") Long memberId);
-
-    @Query("SELECT mcr.* FROM member_card_record mcr " +
-            "INNER JOIN member m ON mcr.member_id = m.member_id " +
-            "WHERE mcr.member_id = :memberId AND mcr.deleted_at IS NULL " +
-            "ORDER BY mcr.purchase_time DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
-    Flux<MemberCardRecordEntity> findByMemberId(@Param("memberId") Long memberId, Pageable pageable);
-
-    @Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
-            "AND status = 'ACTIVE' AND deleted_at IS NULL " +
-            "AND expire_time > NOW() " +
-            "AND remaining_times >= :requiredTimes")
-    Mono<MemberCardRecordEntity> validateCountCard(@Param("recordId") Long recordId,
-                                                   @Param("requiredTimes") Integer requiredTimes);
-
-    @Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
-            "AND status = 'ACTIVE' AND deleted_at IS NULL " +
-            "AND expire_time > NOW() " +
-            "AND remaining_amount >= :requiredAmount")
-    Mono<MemberCardRecordEntity> validateStoredCard(@Param("recordId") Long recordId,
-                                                    @Param("requiredAmount") Double requiredAmount);
-
-    @Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND expire_time < NOW() AND deleted_at IS NULL LIMIT 500")
-    Flux<MemberCardRecordEntity> findExpiredCards();
-
-    @Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND deleted_at IS NULL")
-    Flux<MemberCardRecordEntity> findActiveRecords();
-
-}

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

@@ -1,173 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.dao;
-
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardTransactionsEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.r2dbc.repository.Modifying;
-import org.springframework.data.r2dbc.repository.Query;
-import org.springframework.data.r2dbc.repository.R2dbcRepository;
-import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Repository
-public interface MemberCardTransactionsDao extends R2dbcRepository<MemberCardTransactionsEntity, Long> {
-    /**
-     * 记录每一次变动
-     * 购卡、扣次、续费、退款、过期，均插入一条流水，记录变动前后快照
-     * 注意：返回值依赖 PostgreSQL 的 RETURNING 语法，若使用 MySQL 请删除 RETURNING * 并改用 save()
-     * @param memberCardId 会员卡ID
-     * @param memberId 会员ID
-     * @param operationType 操作类型
-     * @param changeAmount 变动次数（次卡）
-     * @param changeBalance 变动金额（储值卡）
-     * @param afterRemainingCount 变动后剩余次数
-     * @param afterRemainingBalance 变动后剩余余额
-     * @param relatedBizType 关联业务类型
-     * @param remark 备注
-     * @return 插入的流水记录
-     */
-    @Modifying
-    @Query("INSERT INTO member_card_transactions (member_card_id, member_id, operation_type, change_amount, " +
-            "change_balance, after_remaining_count, after_remaining_balance, related_biz_type, remark, created_at, updated_at) " +
-            "VALUES (:memberCardId, :memberId, :operationType, :changeAmount, :changeBalance, " +
-            ":afterRemainingCount, :afterRemainingBalance, :relatedBizType, :remark, NOW(), NOW()) " +
-            "RETURNING *")
-    Mono<MemberCardTransactionsEntity> insertTransaction(@Param("memberCardId") Long memberCardId,
-                                                         @Param("memberId") Long memberId,
-                                                         @Param("operationType") MemberCardTransactionsAction operationType,
-                                                         @Param("changeAmount") Integer changeAmount,
-                                                         @Param("changeBalance") Double changeBalance,
-                                                         @Param("afterRemainingCount") Integer afterRemainingCount,
-                                                         @Param("afterRemainingBalance") Double afterRemainingBalance,
-                                                         @Param("relatedBizType") MemberCardTransactionsType relatedBizType,
-                                                         @Param("remark") String remark);
-
-    /**
-     * 会员端"使用记录"
-     * 按会员ID和时间范围查询，按时间倒序，显示每次变动明细
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    @Query("SELECT * FROM member_card_transactions WHERE member_id = :memberId " +
-            "AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL " +
-            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
-    Flux<MemberCardTransactionsEntity> findByMemberIdAndTimeRange(@Param("memberId") Long memberId,
-                                                                  @Param("startTime") LocalDateTime startTime,
-                                                                  @Param("endTime") LocalDateTime endTime,
-                                                                  Pageable pageable);
-
-    /**
-     * 后台"使用记录查询"
-     * 按会员、卡号、操作类型、时间范围等条件组合查询
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    @Query("SELECT * FROM member_card_transactions WHERE deleted_at IS NULL " +
-            "AND (:memberId IS NULL OR member_id = :memberId) " +
-            "AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
-            "AND (:operationType IS NULL OR operation_type = :operationType) " +
-            "AND (:startTime IS NULL OR created_at >= :startTime) " +
-            "AND (:endTime IS NULL OR created_at <= :endTime) " +
-            "ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
-    Flux<MemberCardTransactionsEntity> findWithConditions(@Param("memberId") Long memberId,
-                                                          @Param("memberCardId") Long memberCardId,
-                                                          @Param("operationType") MemberCardTransactionsAction operationType,
-                                                          @Param("startTime") LocalDateTime startTime,
-                                                          @Param("endTime") LocalDateTime endTime,
-                                                          Pageable pageable);
-
-    /**
-     * 统计符合条件的流水总数
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 流水记录数量
-     */
-    @Query("SELECT COUNT(*) FROM member_card_transactions WHERE deleted_at IS NULL " +
-            "AND (:memberId IS NULL OR member_id = :memberId) " +
-            "AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
-            "AND (:operationType IS NULL OR operation_type = :operationType) " +
-            "AND (:startTime IS NULL OR created_at >= :startTime) " +
-            "AND (:endTime IS NULL OR created_at <= :endTime)")
-    Mono<Long> countWithConditions(@Param("memberId") Long memberId,
-                                   @Param("memberCardId") Long memberCardId,
-                                   @Param("operationType") MemberCardTransactionsAction operationType,
-                                   @Param("startTime") LocalDateTime startTime,
-                                   @Param("endTime") LocalDateTime endTime);
-
-    /**
-     * 按会员卡ID查询所有流水记录（补充常用方法）
-     * @param memberCardId 会员卡ID
-     * @return 该卡的所有流水记录，按时间倒序
-     */
-    @Query("SELECT * FROM member_card_transactions WHERE member_card_id = :memberCardId AND deleted_at IS NULL ORDER BY created_at DESC")
-    Flux<MemberCardTransactionsEntity> findByMemberCardId(@Param("memberCardId") Long memberCardId);
-
-    /**
-     * 数据统计 - 统计某卡种的总扣次数
-     * @param memberCardId 会员卡ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 总扣次数
-     */
-    @Query("SELECT COALESCE(SUM(change_amount), 0) FROM member_card_transactions " +
-            "WHERE member_card_id = :memberCardId AND operation_type = 'DEDUCT' " +
-            "AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
-    Mono<Long> sumDeductCountByCardId(@Param("memberCardId") Long memberCardId,
-                                      @Param("startTime") LocalDateTime startTime,
-                                      @Param("endTime") LocalDateTime endTime);
-
-    /**
-     * 数据统计 - 统计某时间段的续费总金额
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 续费总金额
-     */
-    @Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
-            "WHERE operation_type = 'RENEW' AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
-    Mono<Double> sumRenewAmountByTimeRange(@Param("startTime") LocalDateTime startTime,
-                                           @Param("endTime") LocalDateTime endTime);
-
-    /**
-     * 数据统计 - 统计某会员的购卡总金额
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 购卡总金额
-     */
-    @Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
-            "WHERE member_id = :memberId AND operation_type = 'PURCHASE' " +
-            "AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
-    Mono<Double> sumPurchaseAmountByMemberId(@Param("memberId") Long memberId, @Param("startTime") LocalDateTime startTime,
-                                             @Param("endTime") LocalDateTime endTime);
-    /**
-     * 按会员ID查询所有流水记录
-     * @param memberId 会员ID
-     * @return 该会员的所有流水记录，按时间倒序
-     */
-    @Query("SELECT * FROM member_card_transactions WHERE member_id = :memberId ORDER BY created_at DESC")
-    Flux<MemberCardTransactionsEntity> findByMemberId(Long memberId);
-    /**
-     * 按会员卡记录ID查询所有流水记录
-     * @param recordId 会员卡记录ID
-     * @return 该会员卡的所有流水记录，按时间倒序
-     */
-    @Query("SELECT * FROM member_card_transactions WHERE member_card_record_id = :recordId ORDER BY created_at DESC")
-    Flux<MemberCardTransactionsEntity> findByRecordId(Long recordId);
-
-}

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

@@ -1,64 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.dao;
-
-import cn.novalon.gym.manage.gymmembercard.entity.RefundApplicationEntity;
-import org.springframework.data.r2dbc.repository.Query;
-import org.springframework.data.r2dbc.repository.R2dbcRepository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-/**
- * 退款申请数据访问对象
- *
- * @author shizhounian
- * @date 2026-05-23
- */
-public interface RefundApplicationDao extends R2dbcRepository<RefundApplicationEntity, Long> {
-
-    /**
-     * 根据会员卡记录ID查询退款申请
-     *
-     * @param recordId 会员卡记录ID
-     * @return 退款申请实体
-     */
-    @Query("SELECT * FROM refund_application WHERE record_id = :recordId AND deleted_at IS NULL LIMIT 1")
-    Mono<RefundApplicationEntity> findByRecordId(Long recordId);
-
-    /**
-     * 根据会员ID查询退款申请列表
-     *
-     * @param memberId 会员ID
-     * @return 退款申请列表
-     */
-    @Query("SELECT * FROM refund_application WHERE member_id = :memberId AND deleted_at IS NULL ORDER BY created_at DESC")
-    Flux<RefundApplicationEntity> findByMemberId(Long memberId);
-
-    /**
-     * 根据状态查询退款申请列表
-     *
-     * @param status 状态
-     * @return 退款申请列表
-     */
-    @Query("SELECT * FROM refund_application WHERE status = :status AND deleted_at IS NULL ORDER BY created_at DESC")
-    Flux<RefundApplicationEntity> findByStatus(String status);
-
-    /**
-     * 审核退款申请（更新状态、审核人、审核时间、备注）
-     *
-     * @param id 退款申请ID
-     * @param status 审核状态
-     * @param auditorId 审核人ID
-     * @param auditRemark 审核备注
-     * @return 受影响的行数
-     */
-    @Query("UPDATE refund_application SET status = :status, auditor_id = :auditorId, audit_time = NOW(), audit_remark = :auditRemark, updated_at = NOW() WHERE id = :id")
-    Mono<Integer> approve(Long id, String status, Long auditorId, String auditRemark);
-
-    /**
-     * 逻辑删除退款申请
-     *
-     * @param id 退款申请ID
-     * @return 受影响的行数
-     */
-    @Query("UPDATE refund_application SET deleted_at = NOW() WHERE id = :id")
-    Mono<Integer> logicalDelete(Long id);
-}

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

@@ -1,121 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.domain;
-
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-import java.time.LocalDateTime;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 22:47:31
- */
-@Schema(description = "会员卡类型表")
-public class MemberCard extends BaseDomain {
-    //会员卡id
-    @Schema(description = "会员卡Id",example = "1")
-    private Long memberCardId;
-
-    //会员卡名称
-    @Schema(description = "会员卡名称",example = "月卡")
-    private String memberCardName;
-
-    //会员卡类型
-    @Schema(description = "会员卡类型",example = "TIME_CARD")
-    private String memberCardType;
-
-    //会员卡价格
-    @Schema(description = "会员卡价格",example = "199.0")
-    private Double memberCardPrice;
-
-    //会员卡有效天数（时长卡用）
-    @Schema(description = "会员卡有效天数",example = "30")
-    private Integer memberCardValidityDays;
-
-    //会员卡总次数（次卡用）
-    @Schema(description = "会员卡总次数",example = "10")
-    private Integer memberCardTotalTimes;
-
-    //会员卡面额（储值卡用）
-    @Schema(description = "会员卡面额",example = "500.0")
-    private Double memberCardAmount;
-
-    //会员卡状态：0-正常，1-禁用
-    @Schema(description = "会员卡状态",example = "0")
-    private Integer memberCardStatus;
-
-    //会员卡创建时间
-    @Schema(description = "会员卡创建时间",example = "2026-05-10 05:22:47")
-    private LocalDateTime memberCardCreateTime;
-
-    public Long getMemberCardId() {
-        return memberCardId;
-    }
-
-    public void setMemberCardId(Long memberCardId) {
-        this.memberCardId = memberCardId;
-    }
-
-    public String getMemberCardName() {
-        return memberCardName;
-    }
-
-    public void setMemberCardName(String memberCardName) {
-        this.memberCardName = memberCardName;
-    }
-
-    public String getMemberCardType() {
-        return memberCardType;
-    }
-
-    public void setMemberCardType(String memberCardType) {
-        this.memberCardType = memberCardType;
-    }
-
-    public Double getMemberCardPrice() {
-        return memberCardPrice;
-    }
-
-    public void setMemberCardPrice(Double memberCardPrice) {
-        this.memberCardPrice = memberCardPrice;
-    }
-
-    public Integer getMemberCardValidityDays() {
-        return memberCardValidityDays;
-    }
-
-    public void setMemberCardValidityDays(Integer memberCardValidityDays) {
-        this.memberCardValidityDays = memberCardValidityDays;
-    }
-
-    public Integer getMemberCardTotalTimes() {
-        return memberCardTotalTimes;
-    }
-
-    public void setMemberCardTotalTimes(Integer memberCardTotalTimes) {
-        this.memberCardTotalTimes = memberCardTotalTimes;
-    }
-
-    public Double getMemberCardAmount() {
-        return memberCardAmount;
-    }
-
-    public void setMemberCardAmount(Double memberCardAmount) {
-        this.memberCardAmount = memberCardAmount;
-    }
-
-    public Integer getMemberCardStatus() {
-        return memberCardStatus;
-    }
-
-    public void setMemberCardStatus(Integer memberCardStatus) {
-        this.memberCardStatus = memberCardStatus;
-    }
-
-    public LocalDateTime getMemberCardCreateTime() {
-        return memberCardCreateTime;
-    }
-
-    public void setMemberCardCreateTime(LocalDateTime memberCardCreateTime) {
-        this.memberCardCreateTime = memberCardCreateTime;
-    }
-}

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

@@ -1,109 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.domain;
-
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-import java.time.LocalDateTime;
-
-@Schema(description = "会员卡记录")
-public class MemberCardRecord extends BaseDomain {
-    @Schema(description = "会员持有卡ID", example = "1")
-    private Long memberCardRecordId;
-
-    @Schema(description = "会员ID", example = "1001")
-    private Long memberId;
-
-    @Schema(description = "关联会员卡ID", example = "1")
-    private Long memberCardId;
-
-    @Schema(description = "状态：ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款", example = "ACTIVE")
-    private MemberCardRecordStatus status;
-
-    @Schema(description = "剩余次数", example = "10")
-    private Integer remainingTimes;
-
-    @Schema(description = "剩余余额", example = "500.0")
-    private Double remainingAmount;
-
-    @Schema(description = "到期时间", example = "2026-06-23 10:00:00")
-    private LocalDateTime expireTime;
-
-    @Schema(description = "购买订单ID", example = "10001")
-    private Long sourceOrderId;
-
-    @Schema(description = "购买时间", example = "2026-05-23 10:00:00")
-    private LocalDateTime purchaseTime;
-
-    public Long getMemberCardRecordId() {
-        return memberCardRecordId;
-    }
-
-    public void setMemberCardRecordId(Long memberCardRecordId) {
-        this.memberCardRecordId = memberCardRecordId;
-    }
-
-    public Long getMemberId() {
-        return memberId;
-    }
-
-    public void setMemberId(Long memberId) {
-        this.memberId = memberId;
-    }
-
-    public Long getMemberCardId() {
-        return memberCardId;
-    }
-
-    public void setMemberCardId(Long memberCardId) {
-        this.memberCardId = memberCardId;
-    }
-
-    public MemberCardRecordStatus getStatus() {
-        return status;
-    }
-
-    public void setStatus(MemberCardRecordStatus status) {
-        this.status = status;
-    }
-
-    public Integer getRemainingTimes() {
-        return remainingTimes;
-    }
-
-    public void setRemainingTimes(Integer remainingTimes) {
-        this.remainingTimes = remainingTimes;
-    }
-
-    public Double getRemainingAmount() {
-        return remainingAmount;
-    }
-
-    public void setRemainingAmount(Double remainingAmount) {
-        this.remainingAmount = remainingAmount;
-    }
-
-    public LocalDateTime getExpireTime() {
-        return expireTime;
-    }
-
-    public void setExpireTime(LocalDateTime expireTime) {
-        this.expireTime = expireTime;
-    }
-
-    public Long getSourceOrderId() {
-        return sourceOrderId;
-    }
-
-    public void setSourceOrderId(Long sourceOrderId) {
-        this.sourceOrderId = sourceOrderId;
-    }
-
-    public LocalDateTime getPurchaseTime() {
-        return purchaseTime;
-    }
-
-    public void setPurchaseTime(LocalDateTime purchaseTime) {
-        this.purchaseTime = purchaseTime;
-    }
-}

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

@@ -1,159 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.domain;
-
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-import java.time.LocalDateTime;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 22:47:31
- */
-@Schema(description = "会员卡流水")
-public class MemberCardTransactions extends BaseDomain {
-    //会员卡流水Id
-    @Schema(description = "会员卡流水Id",example = "1")
-    private Long memberCardTransactionsId;
-
-    //会员卡Id
-    @Schema(description = "会员卡Id",example = "1")
-    private Long memberCardId;
-
-    //会员Id
-    @Schema(description = "会员Id",example = "1")
-    private Long memberId;
-
-    //操作类型：PURCHASE(购买) / DEDUCT(扣次/扣费) / RENEW(续费) / REFUND(退款) / EXPIRE(过期)
-    @Schema(description = "操作类型",example = "PURCHASE")
-    private MemberCardTransactionsAction operationType;
-
-    //变动次数（次卡用）
-    @Schema(description = "变动次数（次卡用）",example = "1")
-    private Integer changeAmount;
-
-    //变动金额（储值卡用）
-    @Schema(description = "变动金额（储值卡用）",example = "1")
-    private Double changeBalance;
-
-    //变动后剩余次数
-    @Schema(description = "变动后剩余次数",example = "1")
-    private Integer afterRemainingCount;
-
-    //变动后剩余金额
-    @Schema(description = "变动后剩余金额",example = "500.0")
-    private Double afterRemainingBalance;
-
-    //关联业务类型
-    @Schema(description = "关联业务类型",example = "GROUP_CLASS")
-    private MemberCardTransactionsType relatedBizType;
-
-    //备注
-    @Schema(description = "备注",example = "预约团课：瑜伽课扣1次")
-    private String remark;
-
-    //关联订单ID
-    @Schema(description = "关联订单ID",example = "1")
-    private Long sourceOrderId;
-
-    //创建时间
-    @Schema(description = "创建时间",example = "2026-05-10 05:22:47")
-    private LocalDateTime createdAt;
-
-    public Long getMemberCardTransactionsId() {
-        return memberCardTransactionsId;
-    }
-
-    public void setMemberCardTransactionsId(Long memberCardTransactionsId) {
-        this.memberCardTransactionsId = memberCardTransactionsId;
-    }
-
-    public Long getMemberCardId() {
-        return memberCardId;
-    }
-
-    public void setMemberCardId(Long memberCardId) {
-        this.memberCardId = memberCardId;
-    }
-
-    public Long getMemberId() {
-        return memberId;
-    }
-
-    public void setMemberId(Long memberId) {
-        this.memberId = memberId;
-    }
-
-    public MemberCardTransactionsAction getOperationType() {
-        return operationType;
-    }
-
-    public void setOperationType(MemberCardTransactionsAction operationType) {
-        this.operationType = operationType;
-    }
-
-    public Integer getChangeAmount() {
-        return changeAmount;
-    }
-
-    public void setChangeAmount(Integer changeAmount) {
-        this.changeAmount = changeAmount;
-    }
-
-    public Double getChangeBalance() {
-        return changeBalance;
-    }
-
-    public void setChangeBalance(Double changeBalance) {
-        this.changeBalance = changeBalance;
-    }
-
-    public Integer getAfterRemainingCount() {
-        return afterRemainingCount;
-    }
-
-    public void setAfterRemainingCount(Integer afterRemainingCount) {
-        this.afterRemainingCount = afterRemainingCount;
-    }
-
-    public Double getAfterRemainingBalance() {
-        return afterRemainingBalance;
-    }
-
-    public void setAfterRemainingBalance(Double afterRemainingBalance) {
-        this.afterRemainingBalance = afterRemainingBalance;
-    }
-
-    public MemberCardTransactionsType getRelatedBizType() {
-        return relatedBizType;
-    }
-
-    public void setRelatedBizType(MemberCardTransactionsType relatedBizType) {
-        this.relatedBizType = relatedBizType;
-    }
-
-    public String getRemark() {
-        return remark;
-    }
-
-    public void setRemark(String remark) {
-        this.remark = remark;
-    }
-
-    public Long getSourceOrderId() {
-        return sourceOrderId;
-    }
-
-    public void setSourceOrderId(Long sourceOrderId) {
-        this.sourceOrderId = sourceOrderId;
-    }
-
-    public LocalDateTime getCreatedAt() {
-        return createdAt;
-    }
-
-    public void setCreatedAt(LocalDateTime createdAt) {
-        this.createdAt = createdAt;
-    }
-}

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

@@ -1,127 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.domain;
-
-import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-
-/**
- * 退款申请领域对象
- *
- * @author shizhounian
- * @date 2026-05-23 21:11:46
- */
-@Schema(description = "退款申请", example = "refund_application")
-public class RefundApplication extends BaseDomain {
-
-    @Schema(description = "退款申请ID", example = "1")
-    private Long id;
-
-    @Schema(description = "会员卡记录ID", example = "1")
-    private Long recordId;
-
-    @Schema(description = "会员ID", example = "1")
-    private Long memberId;
-
-    @Schema(description = "状态：PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败", example = "PENDING")
-    private String status;
-
-    @Schema(description = "退款原因", example = "个人原因申请退款")
-    private String reason;
-
-    @Schema(description = "申请时间", example = "2026-05-23 21:09:14")
-    private LocalDateTime applyTime;
-
-    @Schema(description = "审核时间", example = "2026-05-24 10:00:00")
-    private LocalDateTime auditTime;
-
-    @Schema(description = "审核人ID", example = "1")
-    private Long auditorId;
-
-    @Schema(description = "审核备注", example = "同意退款")
-    private String auditRemark;
-
-    @Schema(description = "退款金额", example = "500.00")
-    private BigDecimal refundAmount;
-
-    public Long getId() {
-        return id;
-    }
-
-    public void setId(Long id) {
-        this.id = id;
-    }
-
-    public Long getRecordId() {
-        return recordId;
-    }
-
-    public void setRecordId(Long recordId) {
-        this.recordId = recordId;
-    }
-
-    public Long getMemberId() {
-        return memberId;
-    }
-
-    public void setMemberId(Long memberId) {
-        this.memberId = memberId;
-    }
-
-    public String getStatus() {
-        return status;
-    }
-
-    public void setStatus(String status) {
-        this.status = status;
-    }
-
-    public String getReason() {
-        return reason;
-    }
-
-    public void setReason(String reason) {
-        this.reason = reason;
-    }
-
-    public LocalDateTime getApplyTime() {
-        return applyTime;
-    }
-
-    public void setApplyTime(LocalDateTime applyTime) {
-        this.applyTime = applyTime;
-    }
-
-    public LocalDateTime getAuditTime() {
-        return auditTime;
-    }
-
-    public void setAuditTime(LocalDateTime auditTime) {
-        this.auditTime = auditTime;
-    }
-
-    public Long getAuditorId() {
-        return auditorId;
-    }
-
-    public void setAuditorId(Long auditorId) {
-        this.auditorId = auditorId;
-    }
-
-    public String getAuditRemark() {
-        return auditRemark;
-    }
-
-    public void setAuditRemark(String auditRemark) {
-        this.auditRemark = auditRemark;
-    }
-
-    public BigDecimal getRefundAmount() {
-        return refundAmount;
-    }
-
-    public void setRefundAmount(BigDecimal refundAmount) {
-        this.refundAmount = refundAmount;
-    }
-}

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

@@ -1,123 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.entity;
-
-import cn.novalon.gym.manage.db.entity.BaseEntity;
-import lombok.Data;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.time.LocalDateTime;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 22:47:31
- */
-@Table("member_card")
-public class MemberCardEntity extends BaseEntity {
-    //会员卡id
-    @Column("member_card_id")
-    private Long memberCardId;
-
-    //会员卡名称
-    @Column("member_card_name")
-    private String memberCardName;
-
-    //会员卡类型
-    @Column("member_card_type")
-    private String memberCardType;
-
-    //会员卡价格
-    @Column("member_card_price")
-    private Double memberCardPrice;
-
-    //会员卡有效天数（时长卡用）
-    @Column("member_card_validity_days")
-    private Integer memberCardValidityDays;
-
-    //会员卡总次数（次卡用）
-    @Column("member_card_total_times")
-    private Integer memberCardTotalTimes;
-
-    //会员卡面额（储值卡用）
-    @Column("member_card_amount")
-    private Double memberCardAmount;
-
-    //会员卡状态：0-正常，1-禁用
-    @Column("member_card_status")
-    private Integer memberCardStatus;
-
-    //会员卡创建时间
-    @Column("member_card_create_time")
-    private LocalDateTime memberCardCreateTime;
-
-    public Long getMemberCardId() {
-        return memberCardId;
-    }
-
-    public void setMemberCardId(Long memberCardId) {
-        this.memberCardId = memberCardId;
-    }
-
-    public String getMemberCardName() {
-        return memberCardName;
-    }
-
-    public void setMemberCardName(String memberCardName) {
-        this.memberCardName = memberCardName;
-    }
-
-    public String getMemberCardType() {
-        return memberCardType;
-    }
-
-    public void setMemberCardType(String memberCardType) {
-        this.memberCardType = memberCardType;
-    }
-
-    public Double getMemberCardPrice() {
-        return memberCardPrice;
-    }
-
-    public void setMemberCardPrice(Double memberCardPrice) {
-        this.memberCardPrice = memberCardPrice;
-    }
-
-    public Integer getMemberCardValidityDays() {
-        return memberCardValidityDays;
-    }
-
-    public void setMemberCardValidityDays(Integer memberCardValidityDays) {
-        this.memberCardValidityDays = memberCardValidityDays;
-    }
-
-    public Integer getMemberCardTotalTimes() {
-        return memberCardTotalTimes;
-    }
-
-    public void setMemberCardTotalTimes(Integer memberCardTotalTimes) {
-        this.memberCardTotalTimes = memberCardTotalTimes;
-    }
-
-    public Double getMemberCardAmount() {
-        return memberCardAmount;
-    }
-
-    public void setMemberCardAmount(Double memberCardAmount) {
-        this.memberCardAmount = memberCardAmount;
-    }
-
-    public Integer getMemberCardStatus() {
-        return memberCardStatus;
-    }
-
-    public void setMemberCardStatus(Integer memberCardStatus) {
-        this.memberCardStatus = memberCardStatus;
-    }
-
-    public LocalDateTime getMemberCardCreateTime() {
-        return memberCardCreateTime;
-    }
-
-    public void setMemberCardCreateTime(LocalDateTime memberCardCreateTime) {
-        this.memberCardCreateTime = memberCardCreateTime;
-    }
-}

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

@@ -1,124 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.entity;
-
-import cn.novalon.gym.manage.db.entity.BaseEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import lombok.Data;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.time.LocalDateTime;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 22:47:31
- */
-@Table("member_card_record")
-public class MemberCardRecordEntity extends BaseEntity {
-    //会员持有卡id
-    @Column("member_card_record_id")
-    private Long memberCardRecordId;
-
-    //会员Id
-    @Column("member_id")
-    private Long memberId;
-
-    //关联会员卡Id
-    @Column("member_card_id")
-    private Long memberCardId;
-
-    //状态：ACTIVE(有效) / USED_UP(用完) / EXPIRED(过期) / REFUNDED(已退款)
-    @Column("status")
-    private MemberCardRecordStatus status;
-
-    //剩余次数
-    @Column("remaining_times")
-    private Integer remainingTimes;
-
-    //剩余余额
-    @Column("remaining_amount")
-    private Double remainingAmount;
-
-    //到期时间
-    @Column("expire_time")
-    private LocalDateTime expireTime;
-
-    //购买订单Id
-    @Column("source_order_id")
-    private Long sourceOrderId;
-
-    //购买时间
-    @Column("purchase_time")
-    private LocalDateTime purchaseTime;
-
-    public Long getMemberCardRecordId() {
-        return memberCardRecordId;
-    }
-
-    public void setMemberCardRecordId(Long memberCardRecordId) {
-        this.memberCardRecordId = memberCardRecordId;
-    }
-
-    public Long getMemberId() {
-        return memberId;
-    }
-
-    public void setMemberId(Long memberId) {
-        this.memberId = memberId;
-    }
-
-    public Long getMemberCardId() {
-        return memberCardId;
-    }
-
-    public void setMemberCardId(Long memberCardId) {
-        this.memberCardId = memberCardId;
-    }
-
-    public MemberCardRecordStatus getStatus() {
-        return status;
-    }
-
-    public void setStatus(MemberCardRecordStatus status) {
-        this.status = status;
-    }
-
-    public Integer getRemainingTimes() {
-        return remainingTimes;
-    }
-
-    public void setRemainingTimes(Integer remainingTimes) {
-        this.remainingTimes = remainingTimes;
-    }
-
-    public Double getRemainingAmount() {
-        return remainingAmount;
-    }
-
-    public void setRemainingAmount(Double remainingAmount) {
-        this.remainingAmount = remainingAmount;
-    }
-
-    public LocalDateTime getExpireTime() {
-        return expireTime;
-    }
-
-    public void setExpireTime(LocalDateTime expireTime) {
-        this.expireTime = expireTime;
-    }
-
-    public Long getSourceOrderId() {
-        return sourceOrderId;
-    }
-
-    public void setSourceOrderId(Long sourceOrderId) {
-        this.sourceOrderId = sourceOrderId;
-    }
-
-    public LocalDateTime getPurchaseTime() {
-        return purchaseTime;
-    }
-
-    public void setPurchaseTime(LocalDateTime purchaseTime) {
-        this.purchaseTime = purchaseTime;
-    }
-}

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

@@ -1,160 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.entity;
-
-import cn.novalon.gym.manage.db.entity.BaseEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.time.LocalDateTime;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 22:47:31
- */
-@Table("member_card_transactions")
-public class MemberCardTransactionsEntity extends BaseEntity{
-
-    @Column("id")
-    private Long id;
-
-    @Column("member_card_record_id")
-    private Long memberCardRecordId;
-
-    @Column("member_id")
-    private Long memberId;
-
-    @Column("member_card_id")
-    private Long memberCardId;
-
-    @Column("operation_type")
-    private MemberCardTransactionsAction operationType;
-
-    @Column("change_amount")
-    private Integer changeAmount;
-
-    @Column("change_balance")
-    private Double changeBalance;
-
-    @Column("after_remaining_count")
-    private Integer afterRemainingCount;
-
-    @Column("after_remaining_balance")
-    private Double afterRemainingBalance;
-
-    @Column("related_biz_type")
-    private MemberCardTransactionsType relatedBizType;
-
-    @Column("source_order_id")
-    private Long sourceOrderId;
-
-    @Column("remark")
-    private String remark;
-
-    @Column("created_at")
-    private LocalDateTime createdAt;
-
-    public Long getId() {
-        return id;
-    }
-
-    public void setId(Long id) {
-        this.id = id;
-    }
-
-    public Long getMemberCardRecordId() {
-        return memberCardRecordId;
-    }
-
-    public void setMemberCardRecordId(Long memberCardRecordId) {
-        this.memberCardRecordId = memberCardRecordId;
-    }
-
-    public Long getMemberId() {
-        return memberId;
-    }
-
-    public void setMemberId(Long memberId) {
-        this.memberId = memberId;
-    }
-
-    public Long getMemberCardId() {
-        return memberCardId;
-    }
-
-    public void setMemberCardId(Long memberCardId) {
-        this.memberCardId = memberCardId;
-    }
-
-    public MemberCardTransactionsAction getOperationType() {
-        return operationType;
-    }
-
-    public void setOperationType(MemberCardTransactionsAction operationType) {
-        this.operationType = operationType;
-    }
-
-    public Integer getChangeAmount() {
-        return changeAmount;
-    }
-
-    public void setChangeAmount(Integer changeAmount) {
-        this.changeAmount = changeAmount;
-    }
-
-    public Double getChangeBalance() {
-        return changeBalance;
-    }
-
-    public void setChangeBalance(Double changeBalance) {
-        this.changeBalance = changeBalance;
-    }
-
-    public Integer getAfterRemainingCount() {
-        return afterRemainingCount;
-    }
-
-    public void setAfterRemainingCount(Integer afterRemainingCount) {
-        this.afterRemainingCount = afterRemainingCount;
-    }
-
-    public Double getAfterRemainingBalance() {
-        return afterRemainingBalance;
-    }
-
-    public void setAfterRemainingBalance(Double afterRemainingBalance) {
-        this.afterRemainingBalance = afterRemainingBalance;
-    }
-
-    public MemberCardTransactionsType getRelatedBizType() {
-        return relatedBizType;
-    }
-
-    public void setRelatedBizType(MemberCardTransactionsType relatedBizType) {
-        this.relatedBizType = relatedBizType;
-    }
-
-    public Long getSourceOrderId() {
-        return sourceOrderId;
-    }
-
-    public void setSourceOrderId(Long sourceOrderId) {
-        this.sourceOrderId = sourceOrderId;
-    }
-
-    public String getRemark() {
-        return remark;
-    }
-
-    public void setRemark(String remark) {
-        this.remark = remark;
-    }
-
-    public LocalDateTime getCreatedAt() {
-        return createdAt;
-    }
-
-    public void setCreatedAt(LocalDateTime createdAt) {
-        this.createdAt = createdAt;
-    }
-}

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

@@ -1,127 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.entity;
-
-import cn.novalon.gym.manage.db.entity.BaseEntity;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-
-/**
- * 退款申请实体类
- *
- * @author shizhounian
- * @date 2026-05-23 21:09:14
- */
-@Schema(description = "退款申请实体", example = "refund_application")
-public class RefundApplicationEntity extends BaseEntity {
-
-    @Schema(description = "退款申请ID", example = "1")
-    private Long id;
-
-    @Schema(description = "会员卡记录ID", example = "1")
-    private Long recordId;
-
-    @Schema(description = "会员ID", example = "1")
-    private Long memberId;
-
-    @Schema(description = "状态：PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败", example = "PENDING")
-    private String status;
-
-    @Schema(description = "退款原因", example = "个人原因申请退款")
-    private String reason;
-
-    @Schema(description = "申请时间", example = "2026-05-23 21:09:14")
-    private LocalDateTime applyTime;
-
-    @Schema(description = "审核时间", example = "2026-05-24 10:00:00")
-    private LocalDateTime auditTime;
-
-    @Schema(description = "审核人ID", example = "1")
-    private Long auditorId;
-
-    @Schema(description = "审核备注", example = "同意退款")
-    private String auditRemark;
-
-    @Schema(description = "退款金额", example = "500.00")
-    private BigDecimal refundAmount;
-
-    public Long getId() {
-        return id;
-    }
-
-    public void setId(Long id) {
-        this.id = id;
-    }
-
-    public Long getRecordId() {
-        return recordId;
-    }
-
-    public void setRecordId(Long recordId) {
-        this.recordId = recordId;
-    }
-
-    public Long getMemberId() {
-        return memberId;
-    }
-
-    public void setMemberId(Long memberId) {
-        this.memberId = memberId;
-    }
-
-    public String getStatus() {
-        return status;
-    }
-
-    public void setStatus(String status) {
-        this.status = status;
-    }
-
-    public String getReason() {
-        return reason;
-    }
-
-    public void setReason(String reason) {
-        this.reason = reason;
-    }
-
-    public LocalDateTime getApplyTime() {
-        return applyTime;
-    }
-
-    public void setApplyTime(LocalDateTime applyTime) {
-        this.applyTime = applyTime;
-    }
-
-    public LocalDateTime getAuditTime() {
-        return auditTime;
-    }
-
-    public void setAuditTime(LocalDateTime auditTime) {
-        this.auditTime = auditTime;
-    }
-
-    public Long getAuditorId() {
-        return auditorId;
-    }
-
-    public void setAuditorId(Long auditorId) {
-        this.auditorId = auditorId;
-    }
-
-    public String getAuditRemark() {
-        return auditRemark;
-    }
-
-    public void setAuditRemark(String auditRemark) {
-        this.auditRemark = auditRemark;
-    }
-
-    public BigDecimal getRefundAmount() {
-        return refundAmount;
-    }
-
-    public void setRefundAmount(BigDecimal refundAmount) {
-        this.refundAmount = refundAmount;
-    }
-}

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

@@ -1,34 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.enums;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
-@Schema(description = "会员卡状态机事件")
-public enum MemberCardEvent {
-    @Schema(description = "激活卡片")
-    ACTIVATE("激活卡片"),
-
-    @Schema(description = "使用卡片")
-    USE("使用卡片"),
-
-    @Schema(description = "续费")
-    RENEW("续费"),
-
-    @Schema(description = "过期")
-    EXPIRE("过期"),
-
-    @Schema(description = "退款")
-    REFUND("退款"),
-
-    @Schema(description = "禁用")
-    DISABLE("禁用");
-
-    private final String desc;
-
-    MemberCardEvent(String desc) {
-        this.desc = desc;
-    }
-
-    public String getDesc() {
-        return desc;
-    }
-}

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

@@ -1,36 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.enums;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 23:59:29
- */
-@Schema(description = "会员卡状态枚举")
-public enum MemberCardRecordStatus {
-    //有效
-    @Schema(description = "有效")
-    ACTIVE("有效"),
-
-    //用完
-    @Schema(description = "用完")
-    USED_UP("用完"),
-
-    //过期
-    @Schema(description = "过期")
-    EXPIRED("过期"),
-
-    //已退款
-    @Schema(description = "已退款")
-    REFUNDED("已退款");
-
-    private final String desc;
-
-    MemberCardRecordStatus(String desc) {
-        this.desc = desc;
-    }
-
-    public String getDesc() {
-        return desc;
-    }
-}

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

@@ -1,40 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.enums;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 23:59:29
- */
-@Schema(description = "会员卡流水操作枚举")
-public enum MemberCardTransactionsAction {
-    //购买
-    @Schema(description = "购买")
-    PURCHASE("购买"),
-
-    //扣次/扣费
-    @Schema(description = "扣次/扣费")
-    DEDUCT("扣次/扣费"),
-
-    //续费
-    @Schema(description = "续费")
-    RENEW("续费"),
-
-    //退款
-    @Schema(description = "退款")
-    REFUND("退款"),
-
-    //过期
-    @Schema(description = "过期")
-    EXPIRE("过期");
-
-    private final String desc;
-
-    MemberCardTransactionsAction(String desc) {
-        this.desc = desc;
-    }
-
-    public String getDesc() {
-        return desc;
-    }
-}

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

@@ -1,32 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.enums;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
-/*
- *@Author:shizhounian
- *@Date:2026/5/10-05 23:59:29
- */
-@Schema(description = "会员卡流水关联业务类型枚举")
-public enum MemberCardTransactionsType {
-    //团课
-    @Schema(description = "团课")
-    GROUP_CLASS("团课"),
-
-    //私教
-    @Schema(description = "私教")
-    PT_CLASS("私教"),
-
-    //签到
-    @Schema(description = "签到")
-    CHECK_IN("签到");
-
-    private final String desc;
-
-    MemberCardTransactionsType(String desc) {
-        this.desc = desc;
-    }
-
-    public String getDesc() {
-        return desc;
-    }
-}

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

@@ -1,25 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.enums;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
-@Schema(description = "会员卡类型枚举")
-public enum MemberCardType {
-    @Schema(description = "时长卡")
-    TIME_CARD("时长卡"),
-
-    @Schema(description = "次卡")
-    COUNT_CARD("次卡"),
-
-    @Schema(description = "储值卡")
-    STORED_VALUE_CARD("储值卡");
-
-    private final String desc;
-
-    MemberCardType(String desc) {
-        this.desc = desc;
-    }
-
-    public String getDesc() {
-        return desc;
-    }
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,126 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.handler;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardEvent;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
-import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardTransactionsService;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Component;
-import reactor.core.publisher.Mono;
-
-import java.util.ArrayList;
-import java.util.List;
-
-@Slf4j
-@Component
-@RequiredArgsConstructor
-public class RefundSagaHandler {
-
-    private final IMemberCardRecordRepository recordRepository;
-    private final IMemberCardTransactionsService transactionsService;
-    private final MemberCardStateMachine stateMachine;
-
-    public Mono<Void> executeRefund(Long recordId) {
-        return recordRepository.findById(recordId)
-                .switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
-                .flatMap(record -> stateMachine.validateTransition(record, MemberCardEvent.REFUND)
-                        .then(Mono.defer(() -> doExecuteRefund(recordId, record))));
-    }
-
-    private Mono<Void> doExecuteRefund(Long recordId, MemberCardRecord record) {
-        List<SagaStep> steps = new ArrayList<>();
-        List<SagaStep> rollbackSteps = new ArrayList<>();
-
-        SagaStep step1 = new SagaStep(
-                "更新会员卡状态为已退款",
-                updateCardStatus(recordId, MemberCardRecordStatus.REFUNDED),
-                Mono.defer(() -> updateCardStatus(recordId, record.getStatus()))
-        );
-        steps.add(step1);
-        rollbackSteps.add(0, step1);
-
-        SagaStep step2 = new SagaStep(
-                "记录退款流水",
-                createRefundTransaction(record),
-                createReversalTransaction(record)
-        );
-        steps.add(step2);
-        rollbackSteps.add(0, step2);
-
-        return executeSaga(steps, rollbackSteps);
-    }
-
-    private Mono<Void> updateCardStatus(Long recordId, MemberCardRecordStatus status) {
-        return recordRepository.updateStatus(recordId, status)
-                .flatMap(rows -> {
-                    if (rows == 0) {
-                        return Mono.error(new RuntimeException("更新会员卡状态失败"));
-                    }
-                    return Mono.empty();
-                });
-    }
-
-    private Mono<Void> createRefundTransaction(MemberCardRecord record) {
-        MemberCardTransactions transaction = new MemberCardTransactions();
-        transaction.setMemberId(record.getMemberId());
-        transaction.setMemberCardId(record.getMemberCardId());
-        transaction.setOperationType(MemberCardTransactionsAction.REFUND);
-        transaction.setChangeAmount(-record.getRemainingTimes());
-        transaction.setChangeBalance(-record.getRemainingAmount());
-        transaction.setAfterRemainingCount(0);
-        transaction.setAfterRemainingBalance(0.0);
-        transaction.setRemark("会员卡退款");
-
-        return transactionsService.createTransaction(transaction);
-    }
-
-    private Mono<Void> createReversalTransaction(MemberCardRecord record) {
-        MemberCardTransactions reversal = new MemberCardTransactions();
-        reversal.setMemberId(record.getMemberId());
-        reversal.setMemberCardId(record.getMemberCardId());
-        reversal.setOperationType(MemberCardTransactionsAction.REFUND);
-        reversal.setChangeAmount(record.getRemainingTimes());
-        reversal.setChangeBalance(record.getRemainingAmount());
-        reversal.setRemark("退款冲正");
-
-        return transactionsService.createTransaction(reversal);
-    }
-
-    private Mono<Void> executeSaga(List<SagaStep> steps, List<SagaStep> rollbackSteps) {
-        return executeStep(steps, 0, rollbackSteps);
-    }
-
-    private Mono<Void> executeStep(List<SagaStep> steps, int index, List<SagaStep> rollbackSteps) {
-        if (index >= steps.size()) {
-            return Mono.empty();
-        }
-
-        SagaStep currentStep = steps.get(index);
-
-        return currentStep.operation()
-                .then(Mono.defer(() -> executeStep(steps, index + 1, rollbackSteps)))
-                .onErrorResume(error -> {
-                    log.error("Saga步骤执行失败: step={}, error={}", currentStep.description(), error.getMessage());
-                    return rollback(rollbackSteps, 0).then(Mono.error(error));
-                });
-    }
-
-    private Mono<Void> rollback(List<SagaStep> rollbackSteps, int index) {
-        if (index >= rollbackSteps.size()) {
-            return Mono.empty();
-        }
-
-        SagaStep currentStep = rollbackSteps.get(index);
-
-        return currentStep.rollbackOperation()
-                .then(Mono.defer(() -> rollback(rollbackSteps, index + 1)))
-                .doOnError(error -> log.error("Saga回滚失败: step={}, error={}", currentStep.description(), error.getMessage()))
-                .onErrorResume(e -> Mono.empty());
-    }
-
-    private record SagaStep(String description, Mono<Void> operation, Mono<Void> rollbackOperation) {}
-}

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

@@ -1,34 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import org.springframework.data.domain.Pageable;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-public interface IMemberCardRecordRepository {
-    
-    Mono<MemberCardRecord> findById(Long id);
-    
-    Mono<MemberCardRecord> save(MemberCardRecord record);
-    
-    Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
-    
-    Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
-    
-    Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
-    
-    Flux<MemberCardRecord> findActiveRecords();
-    
-    Mono<Integer> updateStatus(Long id, MemberCardRecordStatus status);
-    
-    Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
-    
-    Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, java.time.LocalDateTime newExpireTime);
-    
-    Flux<MemberCardRecord> findExpiredCards();
-    
-    Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
-    
-    Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
-}

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

@@ -1,78 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
-import org.springframework.data.domain.Pageable;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-public interface IMemberCardRepository {
-    /**
-     * 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
-     * @param memberCardId 会员卡ID
-     * @return 会员卡完整信息，如果不存在或已删除则返回空
-     */
-    Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
-
-    /**
-     * 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
-     * @param status 会员卡状态（上架/下架）
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    Flux<MemberCard> findWithConditions(Integer status, String name, String type,
-                                              Double minPrice, Double maxPrice, Pageable pageable);
-
-    /**
-     * 统计符合条件的会员卡总数（配合列表查询使用）
-     * @param status 会员卡状态
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @return 符合条件的会员卡数量
-     */
-    Mono<Long> countWithConditions(Integer status, String name, String type,
-                                   Double minPrice, Double maxPrice);
-
-    /**
-     * 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
-     * @param status 会员卡状态（通常传上架状态）
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
-
-    /**
-     * 检查会员卡是否已被购买（用于删除前的校验）
-     * @param memberCardId 会员卡ID
-     * @return 如果存在关联的会员记录则返回true，否则返回false
-     */
-    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
-
-    /**
-     * 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
-     * @param memberCardId 会员卡ID
-     * @return 受影响的行数
-     */
-    Mono<Integer> logicalDelete(Long memberCardId);
-
-    /**
-     * 保存卡种信息（新增或更新）
-     * - 新增：entity.memberCardId 为 null 时，插入新记录
-     * - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
-     * @param entity 卡种信息
-     * @return 保存后的实体对象
-     */
-    Mono<MemberCard> save(MemberCard entity);
-
-    /**
-     * 批量查询上架的会员卡（用于小程序端展示）
-     * @param status 上架状态值
-     * @return 上架的会员卡列表
-     */
-    Flux<MemberCard> findActiveCards(Integer status);
-}

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

@@ -1,112 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import org.springframework.data.domain.Pageable;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-public interface IMemberCardTransactionsRepository {
-
-    /**
-     * 记录每一次变动
-     * @param transactions 流水记录
-     * @return 插入的流水记录
-     */
-    Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions);
-
-    /**
-     * 会员端"使用记录"
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
-                                                             LocalDateTime endTime, Pageable pageable);
-
-    /**
-     * 后台"使用记录查询"
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
-                                                     MemberCardTransactionsAction operationType,
-                                                     LocalDateTime startTime, LocalDateTime endTime,
-                                                     Pageable pageable);
-
-    /**
-     * 统计符合条件的流水总数
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 流水记录数量
-     */
-    Mono<Long> countWithConditions(Long memberId, Long memberCardId,
-                                   MemberCardTransactionsAction operationType,
-                                   LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 按会员卡ID查询所有流水记录
-     * @param memberCardId 会员卡ID
-     * @return 该卡的所有流水记录，按时间倒序
-     */
-    Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId);
-
-    /**
-     * 数据统计 - 统计某卡种的总扣次数
-     * @param memberCardId 会员卡ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 总扣次数
-     */
-    Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 数据统计 - 统计某时间段的续费总金额
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 续费总金额
-     */
-    Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 数据统计 - 统计某会员的购卡总金额
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 购卡总金额
-     */
-    Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
-
-    /**
-     * 保存流水记录
-     * @param transaction 流水记录
-     * @return 保存后的流水记录
-     */
-    Mono<MemberCardTransactions> save(MemberCardTransactions transaction);
-
-    /**
-     * 按会员ID查询所有流水记录
-     * @param memberId 会员ID
-     * @return 该会员的所有流水记录，按时间倒序
-     */
-    Flux<MemberCardTransactions> findByMemberId(Long memberId);
-
-    /**
-     * 按流水ID查询流水记录
-     * @param recordId 流水ID
-     * @return 该流水记录
-     */
-    Flux<MemberCardTransactions> findByRecordId(Long recordId);
-}

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

@@ -1,81 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository;
-
-import cn.novalon.gym.manage.gymmembercard.domain.RefundApplication;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-/**
- * 退款申请仓储接口
- *
- * @author shizhounian
- * @date 2026-05-23
- */
-public interface IRefundApplicationRepository {
-
-    /**
-     * 创建退款申请
-     *
-     * @param application 退款申请对象
-     * @return 创建后的退款申请
-     */
-    Mono<RefundApplication> create(RefundApplication application);
-
-    /**
-     * 根据ID查询退款申请
-     *
-     * @param id 退款申请ID
-     * @return 退款申请对象
-     */
-    Mono<RefundApplication> findById(Long id);
-
-    /**
-     * 根据会员卡记录ID查询退款申请
-     *
-     * @param recordId 会员卡记录ID
-     * @return 退款申请对象
-     */
-    Mono<RefundApplication> findByRecordId(Long recordId);
-
-    /**
-     * 根据会员ID查询退款申请列表
-     *
-     * @param memberId 会员ID
-     * @return 退款申请列表
-     */
-    Flux<RefundApplication> findByMemberId(Long memberId);
-
-    /**
-     * 根据状态查询退款申请列表
-     *
-     * @param status 状态
-     * @return 退款申请列表
-     */
-    Flux<RefundApplication> findByStatus(String status);
-
-    /**
-     * 更新退款申请
-     *
-     * @param application 退款申请对象
-     * @return 更新后的退款申请
-     */
-    Mono<RefundApplication> update(RefundApplication application);
-
-    /**
-     * 审核退款申请
-     *
-     * @param id 退款申请ID
-     * @param status 审核状态（APPROVED/REJECTED）
-     * @param auditorId 审核人ID
-     * @param auditRemark 审核备注
-     * @return 更新后的退款申请
-     */
-    Mono<RefundApplication> approve(Long id, String status, Long auditorId, String auditRemark);
-
-    /**
-     * 删除退款申请（逻辑删除）
-     *
-     * @param id 退款申请ID
-     * @return 受影响的行数
-     */
-    Mono<Integer> delete(Long id);
-}

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

@@ -1,105 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository.impl;
-
-import cn.novalon.gym.manage.gymmembercard.dao.MemberCardRecordDao;
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardRecordEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
-import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-@Repository
-public class MemberCardRecordRepositoryImpl implements IMemberCardRecordRepository {
-    private final MemberCardRecordDao memberCardRecordDao;
-    private final BeanConvertUtil beanConvertUtil;
-    private final R2dbcEntityTemplate r2dbcEntityTemplate;
-
-    public MemberCardRecordRepositoryImpl(MemberCardRecordDao memberCardRecordDao,
-                                          BeanConvertUtil beanConvertUtil,
-                                          R2dbcEntityTemplate r2dbcEntityTemplate) {
-        this.memberCardRecordDao = memberCardRecordDao;
-        this.beanConvertUtil = beanConvertUtil;
-        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
-    }
-
-    @Override
-    public Mono<MemberCardRecord> findById(Long id) {
-        return memberCardRecordDao.findById(id)
-                .map(e -> beanConvertUtil.toBean(e, MemberCardRecord.class));
-    }
-
-    @Override
-    public Mono<MemberCardRecord> save(MemberCardRecord record) {
-        MemberCardRecordEntity entity = beanConvertUtil.toBean(record, MemberCardRecordEntity.class);
-        return memberCardRecordDao.save(entity)
-                .map(e -> beanConvertUtil.toBean(e, MemberCardRecord.class));
-    }
-
-    @Override
-    public Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record) {
-        MemberCardRecordEntity entity = beanConvertUtil.toBean(record, MemberCardRecordEntity.class);
-        return memberCardRecordDao.insertActiveRecord(
-                        entity.getMemberId(),
-                        entity.getMemberCardId(),
-                        entity.getExpireTime(),
-                        entity.getRemainingTimes(),
-                        entity.getRemainingAmount(),
-                        entity.getSourceOrderId())
-                .map(e -> beanConvertUtil.toBean(e, MemberCardRecord.class));
-    }
-
-    @Override
-    public Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable) {
-        return memberCardRecordDao.findByMemberId(memberId, pageable)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
-    }
-
-    @Override
-    public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
-        return memberCardRecordDao.findActiveCardsByMemberId(memberId)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
-    }
-
-    @Override
-    public Flux<MemberCardRecord> findActiveRecords() {
-        return memberCardRecordDao.findActiveRecords()
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
-    }
-
-    @Override
-    public Mono<Integer> updateStatus(Long id, MemberCardRecordStatus status) {
-        return memberCardRecordDao.updateStatus(id, status);
-    }
-
-    @Override
-    public Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount) {
-        return memberCardRecordDao.deductUsage(recordId, deductTimes, deductAmount);
-    }
-
-    @Override
-    public Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, java.time.LocalDateTime newExpireTime) {
-        return memberCardRecordDao.renewCard(recordId, addTimes, addAmount, newExpireTime);
-    }
-
-    @Override
-    public Flux<MemberCardRecord> findExpiredCards() {
-        return memberCardRecordDao.findExpiredCards()
-                .map(e -> beanConvertUtil.toBean(e, MemberCardRecord.class));
-    }
-
-    @Override
-    public Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes) {
-        return memberCardRecordDao.validateCountCard(recordId, requiredTimes)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
-    }
-
-    @Override
-    public Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount) {
-        return memberCardRecordDao.validateStoredCard(recordId, requiredAmount)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
-    }
-}

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

@@ -1,146 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository.impl;
-
-import cn.novalon.gym.manage.gymmembercard.dao.MemberCardDao;
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardEntity;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRepository;
-import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-@Repository
-public class MemberCardRepositoryImpl implements IMemberCardRepository {
-    private final MemberCardDao memberCardDao;
-    private final BeanConvertUtil beanConvertUtil;
-    private final R2dbcEntityTemplate r2dbcEntityTemplate;
-    //构造函数,初始化
-    public MemberCardRepositoryImpl(MemberCardDao memberCardDao, BeanConvertUtil beanConvertUtil, R2dbcEntityTemplate r2dbcEntityTemplate) {
-        this.memberCardDao = memberCardDao;
-        this.beanConvertUtil = beanConvertUtil;
-        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
-    }
-
-    /**
-     * 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
-     * @param memberCardId 会员卡ID
-     * @return 会员卡完整信息，如果不存在或已删除则返回空
-     */
-    @Override
-    public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
-        return memberCardDao.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
-    }
-
-    /**
-     * 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
-     * @param status 会员卡状态（上架/下架）
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    @Override
-    public Flux<MemberCard> findWithConditions(Integer status, String name, String type,
-                                               Double minPrice, Double maxPrice, Pageable pageable) {
-        return memberCardDao.findWithConditions(status, name, type, minPrice, maxPrice, pageable)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
-    }
-
-    /**
-     * 统计符合条件的会员卡总数（配合列表查询使用）
-     * @param status 会员卡状态
-     * @param name 会员卡名称（模糊查询）
-     * @param type 会员卡类型
-     * @param minPrice 最低价格
-     * @param maxPrice 最高价格
-     * @return 符合条件的会员卡数量
-     */
-    @Override
-    public Mono<Long> countWithConditions(Integer status, String name, String type,
-                                          Double minPrice, Double maxPrice) {
-        return memberCardDao.countWithConditions(status, name, type, minPrice, maxPrice);
-    }
-
-    /**
-     * 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
-     * @param status 会员卡状态（通常传上架状态）
-     * @param pageable 分页和排序参数
-     * @return 符合条件的会员卡列表
-     */
-    @Override
-    public Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable) {
-        return memberCardDao.findByMemberCardStatusAndDeletedAtIsNull(status, pageable)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
-    }
-
-    /**
-     * 检查会员卡是否已被购买（用于删除前的校验）
-     * @param memberCardId 会员卡ID
-     * @return 如果存在关联的会员记录则返回true，否则返回false
-     */
-    @Override
-    public Mono<Boolean> existsPurchasedRecord(Long memberCardId) {
-        return memberCardDao.existsPurchasedRecord(memberCardId);
-    }
-
-    /**
-     * 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
-     * @param memberCardId 会员卡ID
-     * @return 受影响的行数
-     */
-    @Override
-    public Mono<Integer> logicalDelete(Long memberCardId) {
-        return memberCardDao.logicalDelete(memberCardId);
-    }
-
-    /**
-     * 安全更新会员卡信息（不覆盖不允许修改的字段）
-     * @param memberCardId 会员卡ID
-     * @param updateData 需要更新的卡种信息
-     * @return 受影响的行数
-     */
-    public Mono<Integer> updateSafe(Long memberCardId, MemberCard updateData) {
-        MemberCardEntity memberCardEntity = beanConvertUtil.toBean(updateData, MemberCardEntity.class);
-        return memberCardDao.updateSafe(
-                memberCardId,
-                memberCardEntity.getMemberCardName(),
-                memberCardEntity.getMemberCardPrice(),
-                memberCardEntity.getMemberCardValidityDays(),
-                memberCardEntity.getMemberCardTotalTimes(),
-                memberCardEntity.getMemberCardAmount(),
-                memberCardEntity.getMemberCardStatus()
-        );
-    }
-
-
-    /**
-     * 保存卡种信息（新增或更新）
-     * - 新增：entity.memberCardId 为 null 时，插入新记录
-     * - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
-     * 建议：更新时优先使用 updateSafe 方法避免全字段覆盖
-     * @param entity 卡种信息
-     * @return 保存后的实体对象
-     */
-    @Override
-    public Mono<MemberCard> save(MemberCard entity) {
-        MemberCardEntity cardEntity = beanConvertUtil.toBean(entity, MemberCardEntity.class);
-        return memberCardDao.save(cardEntity)
-                .map(savedEntity -> beanConvertUtil.toBean(savedEntity, MemberCard.class));
-    }
-
-    /**
-     * 批量查询上架的会员卡（用于小程序端展示）
-     * @param status 上架状态值
-     * @return 上架的会员卡列表
-     */
-    @Override
-    public Flux<MemberCard> findActiveCards(Integer status) {
-        return memberCardDao.findActiveCards(status)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
-    }
-}

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

@@ -1,170 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository.impl;
-
-import cn.novalon.gym.manage.gymmembercard.dao.MemberCardTransactionsDao;
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
-import cn.novalon.gym.manage.gymmembercard.entity.MemberCardTransactionsEntity;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardTransactionsRepository;
-import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Repository
-public class MemberCardTransactionsRepositoryImpl implements IMemberCardTransactionsRepository {
-    private final MemberCardTransactionsDao memberCardTransactionsDao;
-    private final BeanConvertUtil beanConvertUtil;
-    private final R2dbcEntityTemplate r2dbcEntityTemplate;
-
-    public MemberCardTransactionsRepositoryImpl(MemberCardTransactionsDao memberCardTransactionsDao, BeanConvertUtil beanConvertUtil, R2dbcEntityTemplate r2dbcEntityTemplate) {
-        this.memberCardTransactionsDao = memberCardTransactionsDao;
-        this.beanConvertUtil = beanConvertUtil;
-        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
-    }
-
-    /**
-     * 记录每一次变动
-     * @param transactions 流水记录
-     * @return 插入的流水记录
-     */
-    @Override
-    public Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions) {
-        MemberCardTransactionsEntity entity = beanConvertUtil.toBean(transactions, MemberCardTransactionsEntity.class);
-        return memberCardTransactionsDao.insertTransaction(
-                        entity.getMemberCardId(),
-                        entity.getMemberId(),
-                        entity.getOperationType(),
-                        entity.getChangeAmount(),
-                        entity.getChangeBalance(),
-                        entity.getAfterRemainingCount(),
-                        entity.getAfterRemainingBalance(),
-                        entity.getRelatedBizType(),
-                        entity.getRemark())
-                .map(e -> beanConvertUtil.toBean(e, MemberCardTransactions.class));
-    }
-
-    /**
-     * 会员端"使用记录"
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    @Override
-    public Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
-                                                                    LocalDateTime endTime, Pageable pageable) {
-        return memberCardTransactionsDao.findByMemberIdAndTimeRange(memberId, startTime, endTime, pageable)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
-    }
-
-    /**
-     * 后台"使用记录查询"
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @param pageable 分页参数
-     * @return 流水记录列表
-     */
-    @Override
-    public Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
-                                                            MemberCardTransactionsAction operationType,
-                                                            LocalDateTime startTime, LocalDateTime endTime,
-                                                            Pageable pageable) {
-        return memberCardTransactionsDao.findWithConditions(memberId, memberCardId, operationType,
-                                                             startTime, endTime, pageable)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
-    }
-
-    /**
-     * 统计符合条件的流水总数
-     * @param memberId 会员ID
-     * @param memberCardId 会员卡ID
-     * @param operationType 操作类型
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 流水记录数量
-     */
-    @Override
-    public Mono<Long> countWithConditions(Long memberId, Long memberCardId,
-                                          MemberCardTransactionsAction operationType,
-                                          LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsDao.countWithConditions(memberId, memberCardId,
-                                                              operationType, startTime, endTime);
-    }
-
-    /**
-     * 按会员卡ID查询所有流水记录
-     * @param memberCardId 会员卡ID
-     * @return 该卡的所有流水记录，按时间倒序
-     */
-    @Override
-    public Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId) {
-        return memberCardTransactionsDao.findByMemberCardId(memberCardId)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
-    }
-
-    /**
-     * 数据统计 - 统计某卡种的总扣次数
-     * @param memberCardId 会员卡ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 总扣次数
-     */
-    @Override
-    public Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsDao.sumDeductCountByCardId(memberCardId, startTime, endTime);
-    }
-
-    /**
-     * 数据统计 - 统计某时间段的续费总金额
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 续费总金额
-     */
-    @Override
-    public Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsDao.sumRenewAmountByTimeRange(startTime, endTime);
-    }
-
-    /**
-     * 数据统计 - 统计某会员的购卡总金额
-     * @param memberId 会员ID
-     * @param startTime 开始时间
-     * @param endTime 结束时间
-     * @return 购卡总金额
-     */
-    @Override
-    public Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsDao.sumPurchaseAmountByMemberId(memberId, startTime, endTime);
-    }
-    /**
-     * 保存流水记录
-     * @param transaction 流水记录
-     * @return 保存后的流水记录
-     */
-    @Override
-    public Mono<MemberCardTransactions> save(MemberCardTransactions transaction) {
-        MemberCardTransactionsEntity entity = beanConvertUtil.toBean(transaction, MemberCardTransactionsEntity.class);
-        return memberCardTransactionsDao.save(entity)
-                .map(savedEntity -> beanConvertUtil.toBean(savedEntity, MemberCardTransactions.class));
-    }
-
-    @Override
-    public Flux<MemberCardTransactions> findByMemberId(Long memberId) {
-        return memberCardTransactionsDao.findByMemberId(memberId)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
-    }
-
-    @Override
-    public Flux<MemberCardTransactions> findByRecordId(Long recordId) {
-        return memberCardTransactionsDao.findByRecordId(recordId)
-                .map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
-    }
-}

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

@@ -1,125 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.repository.impl;
-
-import cn.novalon.gym.manage.gymmembercard.dao.RefundApplicationDao;
-import cn.novalon.gym.manage.gymmembercard.domain.RefundApplication;
-import cn.novalon.gym.manage.gymmembercard.entity.RefundApplicationEntity;
-import cn.novalon.gym.manage.gymmembercard.repository.IRefundApplicationRepository;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Repository;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-/**
- * 退款申请仓储实现类
- *
- * @author shizhounian
- * @date 2026-05-23 21:16:36
- */
-@Repository
-@RequiredArgsConstructor
-public class RefundApplicationRepositoryImpl implements IRefundApplicationRepository {
-
-    private final RefundApplicationDao refundApplicationDao;
-
-    @Override
-    public Mono<RefundApplication> create(RefundApplication application) {
-        RefundApplicationEntity entity = new RefundApplicationEntity();
-        entity.setRecordId(application.getRecordId());
-        entity.setMemberId(application.getMemberId());
-        entity.setStatus(application.getStatus() != null ? application.getStatus() : "PENDING");
-        entity.setReason(application.getReason());
-        entity.setApplyTime(application.getApplyTime() != null ? application.getApplyTime() : LocalDateTime.now());
-        entity.setRefundAmount(application.getRefundAmount());
-
-        return refundApplicationDao.save(entity)
-                .map(this::convertToDomain);
-    }
-
-    @Override
-    public Mono<RefundApplication> findById(Long id) {
-        return refundApplicationDao.findById(id)
-                .map(this::convertToDomain);
-    }
-
-    @Override
-    public Mono<RefundApplication> findByRecordId(Long recordId) {
-        return refundApplicationDao.findByRecordId(recordId)
-                .map(this::convertToDomain);
-    }
-
-    @Override
-    public Flux<RefundApplication> findByMemberId(Long memberId) {
-        return refundApplicationDao.findByMemberId(memberId)
-                .map(this::convertToDomain);
-    }
-
-    @Override
-    public Flux<RefundApplication> findByStatus(String status) {
-        return refundApplicationDao.findByStatus(status)
-                .map(this::convertToDomain);
-    }
-
-    @Override
-    public Mono<RefundApplication> update(RefundApplication application) {
-        return refundApplicationDao.findById(application.getId())
-                .flatMap(entity -> {
-                    if (application.getStatus() != null) {
-                        entity.setStatus(application.getStatus());
-                    }
-                    if (application.getReason() != null) {
-                        entity.setReason(application.getReason());
-                    }
-                    if (application.getAuditTime() != null) {
-                        entity.setAuditTime(application.getAuditTime());
-                    }
-                    if (application.getAuditorId() != null) {
-                        entity.setAuditorId(application.getAuditorId());
-                    }
-                    if (application.getAuditRemark() != null) {
-                        entity.setAuditRemark(application.getAuditRemark());
-                    }
-                    if (application.getRefundAmount() != null) {
-                        entity.setRefundAmount(application.getRefundAmount());
-                    }
-                    return refundApplicationDao.save(entity);
-                })
-                .map(this::convertToDomain);
-    }
-
-    @Override
-    public Mono<RefundApplication> approve(Long id, String status, Long auditorId, String auditRemark) {
-        return refundApplicationDao.approve(id, status, auditorId, auditRemark)
-                .flatMap(rows -> {
-                    if (rows > 0) {
-                        return refundApplicationDao.findById(id)
-                                .map(this::convertToDomain);
-                    }
-                    return Mono.empty();
-                });
-    }
-
-    @Override
-    public Mono<Integer> delete(Long id) {
-        return refundApplicationDao.logicalDelete(id);
-    }
-
-    /**
-     * Entity转Domain
-     */
-    private RefundApplication convertToDomain(RefundApplicationEntity entity) {
-        RefundApplication domain = new RefundApplication();
-        domain.setId(entity.getId());
-        domain.setRecordId(entity.getRecordId());
-        domain.setMemberId(entity.getMemberId());
-        domain.setStatus(entity.getStatus());
-        domain.setReason(entity.getReason());
-        domain.setApplyTime(entity.getApplyTime());
-        domain.setAuditTime(entity.getAuditTime());
-        domain.setAuditorId(entity.getAuditorId());
-        domain.setAuditRemark(entity.getAuditRemark());
-        domain.setRefundAmount(entity.getRefundAmount());
-        return domain;
-    }
-}

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

@@ -1,29 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.sevice;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
-import org.springframework.data.domain.Pageable;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-public interface IMemberCardRecordService {
-    
-    Mono<MemberCardRecord> findById(Long id);
-    
-    Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
-    
-    Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
-    
-    Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
-    
-    Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
-    
-    Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, java.time.LocalDateTime newExpireTime);
-    
-    Mono<Integer> updateStatus(Long recordId, cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus status);
-    
-    Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
-    
-    Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
-    
-    Flux<MemberCardRecord> findExpiredCards();
-}

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

@@ -1,38 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.sevice;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
-import org.springframework.data.domain.Pageable;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-public interface IMemberCardService {
-    
-    Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
-    
-    Flux<MemberCard> findWithConditions(Integer status, String name, String type,
-                                        Double minPrice, Double maxPrice, Pageable pageable);
-    
-    Mono<Long> countWithConditions(Integer status, String name, String type,
-                                   Double minPrice, Double maxPrice);
-    
-    Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
-    
-    Mono<Boolean> existsPurchasedRecord(Long memberCardId);
-    
-    Mono<Integer> logicalDelete(Long memberCardId);
-    
-    Flux<MemberCard> findActiveCards(Integer status);
-    
-    Mono<MemberCard> save(MemberCard entity);
-    
-    Mono<MemberCardRecord> purchaseCard(Long memberId, Long memberCardId, Long sourceOrderId);
-    
-    Mono<MemberCardRecord> renewCard(Long recordId, Integer addTimes, Double addAmount, Integer addDays, Long sourceOrderId);
-    
-    Mono<MemberCardRecord> useCard(Long recordId, Integer deductTimes, Double deductAmount);
-    
-    Mono<Void> refundCard(Long recordId);
-    
-    Mono<Integer> processExpiredCards();
-}

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

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

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

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

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

@@ -1,72 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.sevice.impl;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
-import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardRecordService;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.data.domain.Pageable;
-import org.springframework.stereotype.Service;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Service
-public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
-    private final IMemberCardRecordRepository memberCardRecordRepository;
-
-    public MemberCardRecordServiceImpl(IMemberCardRecordRepository memberCardRecordRepository) {
-        this.memberCardRecordRepository = memberCardRecordRepository;
-    }
-
-    @Override
-    public Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record) {
-        return memberCardRecordRepository.insertActiveRecord(record);
-    }
-
-    @Override
-    public Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount) {
-        return memberCardRecordRepository.deductUsage(recordId, deductTimes, deductAmount);
-    }
-
-    @Override
-    public Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime) {
-        return memberCardRecordRepository.renewCard(recordId, addTimes, addAmount, newExpireTime);
-    }
-
-    @Override
-    public Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status) {
-        return memberCardRecordRepository.updateStatus(recordId, status);
-    }
-
-    @Override
-    public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
-        return memberCardRecordRepository.findActiveCardsByMemberId(memberId);
-    }
-
-    @Override
-    public Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable) {
-        return memberCardRecordRepository.findByMemberId(memberId, pageable);
-    }
-
-    @Override
-    public Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes) {
-        return memberCardRecordRepository.validateCountCard(recordId, requiredTimes);
-    }
-
-    @Override
-    public Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount) {
-        return memberCardRecordRepository.validateStoredCard(recordId, requiredAmount);
-    }
-
-    @Override
-    public Flux<MemberCardRecord> findExpiredCards() {
-        return memberCardRecordRepository.findExpiredCards();
-    }
-
-    @Override
-    public Mono<MemberCardRecord> findById(Long recordId) {
-        return memberCardRecordRepository.findById(recordId);
-    }
-}

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

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

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

@@ -1,89 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.sevice.impl;
-
-import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
-import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
-import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardTransactionsRepository;
-import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardTransactionsService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.data.domain.Pageable;
-import org.springframework.stereotype.Service;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-@Slf4j
-@Service
-public class MemberCardTransactionsServiceImpl implements IMemberCardTransactionsService {
-    private final IMemberCardTransactionsRepository memberCardTransactionsRepository;
-
-    public MemberCardTransactionsServiceImpl(IMemberCardTransactionsRepository memberCardTransactionsRepository) {
-        this.memberCardTransactionsRepository = memberCardTransactionsRepository;
-    }
-
-    @Override
-    public Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions) {
-        return memberCardTransactionsRepository.insertTransaction(transactions);
-    }
-
-    @Override
-    public Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
-                                                                    LocalDateTime endTime, Pageable pageable) {
-        return memberCardTransactionsRepository.findByMemberIdAndTimeRange(memberId, startTime, endTime, pageable);
-    }
-
-    @Override
-    public Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
-                                                            MemberCardTransactionsAction operationType,
-                                                            LocalDateTime startTime, LocalDateTime endTime,
-                                                            Pageable pageable) {
-        return memberCardTransactionsRepository.findWithConditions(memberId, memberCardId, operationType,
-                                                             startTime, endTime, pageable);
-    }
-
-    @Override
-    public Mono<Long> countWithConditions(Long memberId, Long memberCardId,
-                                          MemberCardTransactionsAction operationType,
-                                          LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsRepository.countWithConditions(memberId, memberCardId,
-                                                              operationType, startTime, endTime);
-    }
-
-    @Override
-    public Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId) {
-        return memberCardTransactionsRepository.findByMemberCardId(memberCardId);
-    }
-
-    @Override
-    public Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsRepository.sumDeductCountByCardId(memberCardId, startTime, endTime);
-    }
-
-    @Override
-    public Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsRepository.sumRenewAmountByTimeRange(startTime, endTime);
-    }
-
-    @Override
-    public Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime) {
-        return memberCardTransactionsRepository.sumPurchaseAmountByMemberId(memberId, startTime, endTime);
-    }
-
-    @Override
-    public Mono<Void> createTransaction(MemberCardTransactions transaction) {
-        return memberCardTransactionsRepository.save(transaction)
-                .then()
-                .doOnSuccess(v -> log.info("创建会员卡交易记录: memberId={}, cardId={}, type={}",
-                        transaction.getMemberId(), transaction.getMemberCardId(), transaction.getOperationType()));
-    }
-
-    @Override
-    public Flux<MemberCardTransactions> findByMemberId(Long memberId) {
-        return memberCardTransactionsRepository.findByMemberId(memberId);
-    }
-
-    @Override
-    public Flux<MemberCardTransactions> findByRecordId(Long recordId) {
-        return memberCardTransactionsRepository.findByRecordId(recordId);
-    }
-}

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

@@ -1,85 +0,0 @@
-package cn.novalon.gym.manage.gymmembercard.sevice.impl;
-
-import cn.novalon.gym.manage.gymmembercard.domain.RefundApplication;
-import cn.novalon.gym.manage.gymmembercard.repository.IRefundApplicationRepository;
-import cn.novalon.gym.manage.gymmembercard.sevice.IRefundApplicationService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.time.LocalDateTime;
-
-/**
- * 退款申请服务实现类
- *
- * @author shizhounian
- * @date 2026-05-23 21:18:33
- */
-@Slf4j
-@Service
-public class RefundApplicationServiceImpl implements IRefundApplicationService {
-
-    private final IRefundApplicationRepository refundApplicationRepository;
-
-    public RefundApplicationServiceImpl(IRefundApplicationRepository refundApplicationRepository) {
-        this.refundApplicationRepository = refundApplicationRepository;
-    }
-
-    @Override
-    public Mono<RefundApplication> create(Long recordId, String reason) {
-        return refundApplicationRepository.findByRecordId(recordId)
-                .flatMap(existing -> {
-                    if (existing != null) {
-                        return Mono.error(new RuntimeException("该会员卡记录已有退款申请"));
-                    }
-                    return Mono.empty();
-                })
-                .then(Mono.defer(() -> {
-                    RefundApplication application = new RefundApplication();
-                    application.setRecordId(recordId);
-                    application.setReason(reason);
-                    application.setStatus("PENDING");
-                    application.setApplyTime(LocalDateTime.now());
-
-                    return refundApplicationRepository.create(application)
-                            .doOnSuccess(app -> log.info("创建退款申请成功: applicationId={}, recordId={}",
-                                app.getId(), recordId));
-                }));
-    }
-
-    @Override
-    public Mono<RefundApplication> approve(Long applicationId, Long auditorId, String remark) {
-        return refundApplicationRepository.findById(applicationId)
-                .switchIfEmpty(Mono.error(new RuntimeException("退款申请不存在")))
-                .flatMap(application -> {
-                    if (!"PENDING".equals(application.getStatus())) {
-                        return Mono.error(new RuntimeException("退款申请状态不正确，当前状态: " + application.getStatus()));
-                    }
-
-                    return refundApplicationRepository.approve(applicationId, "APPROVED", auditorId, remark)
-                            .doOnSuccess(app -> log.info("批准退款申请成功: applicationId={}, auditorId={}",
-                                applicationId, auditorId));
-                });
-    }
-
-    @Override
-    public Mono<RefundApplication> reject(Long applicationId, Long auditorId, String remark) {
-        return refundApplicationRepository.findById(applicationId)
-                .switchIfEmpty(Mono.error(new RuntimeException("退款申请不存在")))
-                .flatMap(application -> {
-                    if (!"PENDING".equals(application.getStatus())) {
-                        return Mono.error(new RuntimeException("退款申请状态不正确，当前状态: " + application.getStatus()));
-                    }
-
-                    return refundApplicationRepository.approve(applicationId, "REJECTED", auditorId, remark)
-                            .doOnSuccess(app -> log.info("拒绝退款申请成功: applicationId={}, auditorId={}",
-                                applicationId, auditorId));
-                });
-    }
-
-    @Override
-    public Mono<RefundApplication> findByRecordId(Long recordId) {
-        return refundApplicationRepository.findByRecordId(recordId);
-    }
-}

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

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

gym-manage-api/gym-member-card/src/main/resources/sql

@@ -1,132 +0,0 @@
--- ============================================
--- 会员卡类型表
--- ============================================
-CREATE TABLE IF NOT EXISTS member_card (
-    member_card_id BIGSERIAL PRIMARY KEY,
-    member_card_name VARCHAR(100) NOT NULL,
-    member_card_type VARCHAR(20) NOT NULL,
-    member_card_price DECIMAL(10, 2) NOT NULL,
-    member_card_validity_days INTEGER,
-    member_card_total_times INTEGER,
-    member_card_amount DECIMAL(10, 2),
-    member_card_status INTEGER DEFAULT 1 NOT NULL,
-    extra_config JSONB DEFAULT '{}'::jsonb,
-    created_at TIMESTAMPTZ DEFAULT NOW(),
-    updated_at TIMESTAMPTZ DEFAULT NOW(),
-    deleted_at TIMESTAMPTZ
-);
-
-COMMENT ON TABLE member_card IS '会员卡类型表';
-COMMENT ON COLUMN member_card.member_card_id IS '会员卡ID';
-COMMENT ON COLUMN member_card.member_card_name IS '会员卡名称';
-COMMENT ON COLUMN member_card.member_card_type IS '会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡';
-COMMENT ON COLUMN member_card.member_card_price IS '会员卡价格';
-COMMENT ON COLUMN member_card.member_card_validity_days IS '有效天数（时长卡用）';
-COMMENT ON COLUMN member_card.member_card_total_times IS '总次数（次卡用）';
-COMMENT ON COLUMN member_card.member_card_amount IS '面额（储值卡用）';
-COMMENT ON COLUMN member_card.member_card_status IS '状态：0-下架, 1-上架';
-COMMENT ON COLUMN member_card.extra_config IS '扩展配置（JSON格式，用于未来组合卡等）';
-
--- ============================================
--- 会员卡记录表（会员持有的卡）
--- ============================================
-CREATE TABLE IF NOT EXISTS member_card_record (
-    member_card_record_id BIGSERIAL PRIMARY KEY,
-    member_id BIGINT NOT NULL,
-    member_card_id BIGINT NOT NULL,
-    status VARCHAR(20) NOT NULL DEFAULT 'ACTIVE',
-    remaining_times INTEGER DEFAULT 0,
-    remaining_amount DECIMAL(10, 2) DEFAULT 0.00,
-    expire_time TIMESTAMPTZ,
-    source_order_id BIGINT,
-    purchase_time TIMESTAMPTZ DEFAULT NOW(),
-    version INTEGER DEFAULT 0 NOT NULL,
-    card_composition JSONB DEFAULT NULL,
-    created_at TIMESTAMPTZ DEFAULT NOW(),
-    updated_at TIMESTAMPTZ DEFAULT NOW(),
-    deleted_at TIMESTAMPTZ
-    -- 移除外键约束，改用应用层验证
-);
-
--- 索引优化
-CREATE INDEX idx_member_card_record_member_id ON member_card_record(member_id);
-CREATE INDEX idx_member_card_record_status ON member_card_record(status);
-CREATE INDEX idx_member_card_record_expire_time ON member_card_record(expire_time);
-CREATE INDEX idx_member_card_record_member_status ON member_card_record(member_id, status);
-CREATE INDEX idx_member_card_record_status_expire ON member_card_record(status, expire_time)
-    WHERE status = 'ACTIVE';
-
-COMMENT ON TABLE member_card_record IS '会员卡记录表';
-COMMENT ON COLUMN member_card_record.member_card_record_id IS '会员卡记录ID';
-COMMENT ON COLUMN member_card_record.member_id IS '会员ID';
-COMMENT ON COLUMN member_card_record.member_card_id IS '会员卡类型ID';
-COMMENT ON COLUMN member_card_record.status IS '状态：ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款';
-COMMENT ON COLUMN member_card_record.remaining_times IS '剩余次数';
-COMMENT ON COLUMN member_card_record.remaining_amount IS '剩余金额';
-COMMENT ON COLUMN member_card_record.expire_time IS '到期时间';
-COMMENT ON COLUMN member_card_record.source_order_id IS '来源订单ID';
-COMMENT ON COLUMN member_card_record.purchase_time IS '购买时间';
-COMMENT ON COLUMN member_card_record.version IS '乐观锁版本号';
-COMMENT ON COLUMN member_card_record.card_composition IS '卡片组成（JSON格式，用于组合卡）';
-
--- ============================================
--- 会员卡交易流水表
--- ============================================
-CREATE TABLE IF NOT EXISTS member_card_transactions (
-    id BIGSERIAL PRIMARY KEY,
-    member_card_record_id BIGINT NOT NULL,
-    member_id BIGINT NOT NULL,
-    member_card_id BIGINT NOT NULL,
-    operation_type VARCHAR(20) NOT NULL,
-    change_amount INTEGER DEFAULT 0,
-    change_balance DECIMAL(10, 2) DEFAULT 0.00,
-    after_remaining_count INTEGER DEFAULT 0,
-    after_remaining_balance DECIMAL(10, 2) DEFAULT 0.00,
-    related_biz_type VARCHAR(20),
-    source_order_id BIGINT,
-    remark VARCHAR(500),
-    is_archived BOOLEAN DEFAULT FALSE NOT NULL,
-    archived_at TIMESTAMPTZ,
-    created_at TIMESTAMPTZ DEFAULT NOW()
-    -- 移除外键约束，改用应用层验证
-);
-
--- 退款申请表
-CREATE TABLE IF NOT EXISTS refund_application (
-    id BIGSERIAL PRIMARY KEY,
-    record_id BIGINT NOT NULL,
-    member_id BIGINT NOT NULL,
-    status VARCHAR(20) NOT NULL DEFAULT 'PENDING', -- PENDING/APPROVED/REJECTED/PROCESSING/SUCCESS/FAILED
-    reason VARCHAR(500),
-    apply_time TIMESTAMPTZ DEFAULT NOW(),
-    audit_time TIMESTAMPTZ,
-    auditor_id BIGINT,
-    audit_remark VARCHAR(500),
-    refund_amount DECIMAL(10, 2),
-    created_at TIMESTAMPTZ DEFAULT NOW(),
-    updated_at TIMESTAMPTZ DEFAULT NOW()
-);
-
-CREATE INDEX idx_refund_application_record_id ON refund_application(record_id);
-CREATE INDEX idx_refund_application_status ON refund_application(status);
-
-COMMENT ON TABLE refund_application IS '退款申请表';
-COMMENT ON COLUMN refund_application.status IS '状态：PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败';
-
-
--- 索引优化
-CREATE INDEX idx_member_card_transactions_member_id ON member_card_transactions(member_id);
-CREATE INDEX idx_member_card_transactions_record_id ON member_card_transactions(member_card_record_id);
-CREATE INDEX idx_member_card_transactions_created_at ON member_card_transactions(created_at);
-CREATE INDEX idx_member_card_transactions_member_type_time
-    ON member_card_transactions(member_id, operation_type, created_at);
-
-COMMENT ON TABLE member_card_transactions IS '会员卡交易流水表';
-COMMENT ON COLUMN member_card_transactions.operation_type IS '操作类型：PURCHASE-购买, DEDUCT-扣次/扣费, RENEW-续费, REFUND-退款, EXPIRE-过期';
-COMMENT ON COLUMN member_card_transactions.change_amount IS '变动次数';
-COMMENT ON COLUMN member_card_transactions.change_balance IS '变动金额';
-COMMENT ON COLUMN member_card_transactions.after_remaining_count IS '变动后剩余次数';
-COMMENT ON COLUMN member_card_transactions.after_remaining_balance IS '变动后剩余金额';
-COMMENT ON COLUMN member_card_transactions.related_biz_type IS '关联业务类型：GROUP_CLASS-团课, PT_CLASS-私教, CHECK_IN-签到';
-COMMENT ON COLUMN member_card_transactions.is_archived IS '是否已归档';
-COMMENT ON COLUMN member_card_transactions.archived_at IS '归档时间';

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

@@ -18,6 +18,11 @@
     <description>Application module for Novalon Manage API</description>
 
     <dependencies>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>gym-groupCourse</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>cn.novalon.gym.manage</groupId>
             <artifactId>manage-sys</artifactId>
@@ -135,8 +140,8 @@
         </dependency>
         <dependency>
             <groupId>cn.novalon.gym.manage</groupId>
-            <artifactId>gym-member-card</artifactId>
+            <artifactId>gym-groupCourse</artifactId>
-            <version>0.0.1-SNAPSHOT</version>
+            <version>1.0.0</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>

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

@@ -15,11 +15,10 @@ import org.springframework.web.server.WebFilter;
 
 import java.util.List;
 
-@SpringBootApplication(scanBasePackages = "cn.novalon.gym.manage", exclude = {
+@SpringBootApplication(scanBasePackages = {"cn.novalon.gym.manage", "cn.novalon.gym.manage.groupcourse"}, exclude = {
         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.groupcourse.dao" })
-        "cn.novalon.gym.manage.gymmembercard.dao"})
 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/RedisConfig.java

@@ -0,0 +1,43 @@
+package cn.novalon.gym.manage.app.config;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+/**
+ * @author:liwentao
+ * @date:2026/5/15-05-15-16:01
+ */
+@Configuration
+public class RedisConfig {
+
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
+        RedisTemplate<String, Object> template = new RedisTemplate<>();
+        template.setConnectionFactory(factory);
+
+        // 创建ObjectMapper并配置
+        ObjectMapper om = new ObjectMapper();
+        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        om.activateDefaultTyping(om.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
+
+        // 使用GenericJackson2JsonRedisSerializer替代已弃用的方式
+        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(om);
+
+        // 使用StringRedisSerializer来序列化和反序列化redis的key值
+        StringRedisSerializer stringSerializer = new StringRedisSerializer();
+        template.setKeySerializer(stringSerializer);
+        template.setValueSerializer(genericJackson2JsonRedisSerializer);
+        template.setHashKeySerializer(stringSerializer);
+        template.setHashValueSerializer(genericJackson2JsonRedisSerializer);
+
+        template.afterPropertiesSet();
+        return template;
+    }
+}

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

@@ -1,13 +1,12 @@
 package cn.novalon.gym.manage.app.config;
 
-import cn.novalon.gym.manage.gymmembercard.handler.MemberCardHandler;
+import cn.novalon.gym.manage.groupcourse.handler.GroupCourseHandler;
-import cn.novalon.gym.manage.gymmembercard.handler.MemberCardRecordHandler;
-import cn.novalon.gym.manage.gymmembercard.handler.MemberCardTransactionHandler;
 import cn.novalon.gym.manage.sys.handler.auth.SysAuthHandler;
 import cn.novalon.gym.manage.sys.handler.auth.PasswordDiagnosticHandler;
 import cn.novalon.gym.manage.sys.handler.config.SysConfigHandler;
 import cn.novalon.gym.manage.sys.handler.dictionary.DictionaryHandler;
 import cn.novalon.gym.manage.sys.handler.dict.SysDictHandler;
+
 import cn.novalon.gym.manage.sys.handler.log.SysLogHandler;
 import cn.novalon.gym.manage.sys.handler.log.OperationLogHandler;
 import cn.novalon.gym.manage.sys.handler.menu.MenuHandler;
@@ -25,21 +24,11 @@ import org.springframework.web.reactive.function.server.ServerResponse;
 
 import static org.springframework.web.reactive.function.server.RouterFunctions.route;
 
-/**
- * 系统路由配置类
- * 
- * 文件定义：配置WebFlux函数式路由，将HTTP请求映射到对应的Handler方法
- * 涉及业务：用户、角色、字典、菜单、公告、文件等所有RESTful API路由
- * 算法：使用RouterFunctions.route()构建函数式路由规则
- *
- * @author 张翔
- * @date 2026-03-13
- */
 @Configuration
 public class SystemRouter {
-
     @Bean
     public RouterFunction<ServerResponse> systemRoutes(
+            GroupCourseHandler groupCourseHandler,
             DictionaryHandler dictionaryHandler,
             SysUserHandler userHandler,
             MenuHandler menuHandler,
@@ -54,16 +43,11 @@ public class SystemRouter {
             SysUserMessageHandler messageHandler,
             SysFileHandler fileHandler,
             SysPermissionHandler permissionHandler,
-            PasswordDiagnosticHandler passwordDiagnosticHandler,
+            PasswordDiagnosticHandler passwordDiagnosticHandler) {
-            MemberCardHandler memberCardHandler,
-            MemberCardRecordHandler memberCardRecordHandler,
-            MemberCardTransactionHandler memberCardTransactionHandler) {
 
         return route()
-                // ========== 诊断路由 ==========
                 .GET("/api/diagnostic/password", passwordDiagnosticHandler::diagnose)
 
-                // ========== 字典路由 ==========
                 .GET("/api/dictionaries", dictionaryHandler::getAllDictionaries)
                 .GET("/api/dictionaries/{id}", dictionaryHandler::getDictionaryById)
                 .GET("/api/dictionaries/type/{type}", dictionaryHandler::getDictionariesByType)
@@ -72,7 +56,6 @@ public class SystemRouter {
                 .PUT("/api/dictionaries/{id}", dictionaryHandler::updateDictionary)
                 .DELETE("/api/dictionaries/{id}", dictionaryHandler::deleteDictionary)
 
-                // ========== 用户路由 ==========
                 .GET("/api/users", userHandler::getAllUsers)
                 .GET("/api/users/page", userHandler::getUsersByPage)
                 .GET("/api/users/count", userHandler::getUserCount)
@@ -91,7 +74,6 @@ public class SystemRouter {
                 .GET("/api/users/{id}/roles", userHandler::getUserRoles)
                 .POST("/api/users/{id}/roles", userHandler::assignRoles)
 
-                // ========== 菜单路由 ==========
                 .GET("/api/menus", menuHandler::getAllMenus)
                 .GET("/api/menus/tree", menuHandler::getMenuTree)
                 .GET("/api/menus/{id}", menuHandler::getMenuById)
@@ -99,7 +81,6 @@ public class SystemRouter {
                 .PUT("/api/menus/{id}", menuHandler::updateMenu)
                 .DELETE("/api/menus/{id}", menuHandler::deleteMenu)
 
-                // ========== 角色路由 ==========
                 .GET("/api/roles", roleHandler::getAllRoles)
                 .GET("/api/roles/page", roleHandler::getRolesByPage)
                 .GET("/api/roles/count", roleHandler::getRoleCount)
@@ -113,7 +94,6 @@ public class SystemRouter {
                 .GET("/api/roles/{id}/permissions", permissionHandler::getPermissionsByRoleId)
                 .POST("/api/roles/{id}/permissions", permissionHandler::assignPermissionsToRole)
 
-                // ========== 配置路由 ==========
                 .GET("/api/config", configHandler::getAllConfigs)
                 .GET("/api/config/{id}", configHandler::getConfigById)
                 .GET("/api/config/key/{configKey}", configHandler::getConfigByKey)
@@ -121,7 +101,6 @@ public class SystemRouter {
                 .PUT("/api/config/{id}", configHandler::updateConfig)
                 .DELETE("/api/config/{id}", configHandler::deleteConfig)
 
-                // ========== 日志路由 ==========
                 .GET("/api/logs/login", logHandler::getAllLoginLogs)
                 .GET("/api/logs/login/page", logHandler::getLoginLogsByPage)
                 .GET("/api/logs/login/count", logHandler::getLoginLogCount)
@@ -141,15 +120,12 @@ public class SystemRouter {
                 .GET("/api/logs/operation/{id}", operationLogHandler::getOperationLogById)
                 .POST("/api/logs/operation", operationLogHandler::createOperationLog)
 
-                // ========== 认证路由 ==========
                 .POST("/api/auth/login", authHandler::login)
                 .POST("/api/auth/register", authHandler::register)
                 .POST("/api/auth/logout", authHandler::logout)
 
-                // ========== 统计路由 ==========
                 .GET("/api/stats/overview", statsHandler::getOverview)
 
-                // ========== 数据字典路由 ==========
                 .GET("/api/dict/types", dictHandler::getAllDictTypes)
                 .GET("/api/dict/types/{id}", dictHandler::getDictTypeById)
                 .GET("/api/dict/types/type/{dictType}", dictHandler::getDictTypeByType)
@@ -163,7 +139,6 @@ public class SystemRouter {
                 .PUT("/api/dict/data/{id}", dictHandler::updateDictData)
                 .DELETE("/api/dict/data/{id}", dictHandler::deleteDictData)
 
-                // ========== 公告路由 ==========
                 .GET("/api/notices", noticeHandler::getAllNotices)
                 .GET("/api/notices/{id}", noticeHandler::getNoticeById)
                 .GET("/api/notices/status/{status}", noticeHandler::getNoticesByStatus)
@@ -171,7 +146,6 @@ public class SystemRouter {
                 .PUT("/api/notices/{id}", noticeHandler::updateNotice)
                 .DELETE("/api/notices/{id}", noticeHandler::deleteNotice)
 
-                // ========== 消息路由 ==========
                 .GET("/api/messages/user/{userId}", messageHandler::getMessagesByUser)
                 .GET("/api/messages/user/{userId}/unread", messageHandler::getUnreadCount)
                 .GET("/api/messages/user/{userId}/unread/list", messageHandler::getUnreadList)
@@ -179,7 +153,6 @@ public class SystemRouter {
                 .PUT("/api/messages/{id}/read", messageHandler::markAsRead)
                 .DELETE("/api/messages/{id}", messageHandler::deleteMessage)
 
-                // ========== 文件路由 ==========
                 .GET("/api/files", fileHandler::getAllFiles)
                 .GET("/api/files/{id}", fileHandler::getFileById)
                 .POST("/api/files/upload", fileHandler::uploadFile)
@@ -189,7 +162,6 @@ public class SystemRouter {
                 .GET("/api/files/preview/{fileName}", fileHandler::previewFileByName)
                 .DELETE("/api/files/{id}", fileHandler::deleteFile)
 
-                // ========== 权限路由 ==========
                 .GET("/api/permissions", permissionHandler::getAllPermissions)
                 .GET("/api/permissions/{id}", permissionHandler::getPermissionById)
                 .GET("/api/permissions/code/{code}", permissionHandler::getPermissionByCode)
@@ -199,33 +171,11 @@ public class SystemRouter {
                 .PUT("/api/permissions/{id}", permissionHandler::updatePermission)
                 .DELETE("/api/permissions/{id}", permissionHandler::deletePermission)
 
-                // ========================================
+                .GET("/api/groupCourse", groupCourseHandler::getAllGroupCourse)
-                // ========== 会员卡管理路由 ==============
+                .POST("/api/groupCourse/page", groupCourseHandler::getGroupCoursesByPage)
-                // ========================================
+                .POST("/api/groupCourse/cache/get", groupCourseHandler::getCacheByKey)
+                .GET("/api/groupCourse/{id}", groupCourseHandler::getGroupCourseById)
 
-                // ===== 会员卡类型管理 =====
-                .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-app/src/main/resources/application-dev.yml

@@ -12,6 +12,9 @@ spring:
       max-life-time: 30m
       acquire-timeout: 3s
   flyway:
+    url: jdbc:postgresql://localhost:55432/manage_system
+    user: novalon
+    password: novalon123
     enabled: true
     locations: classpath:db/migration
     baseline-on-migrate: true

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

@@ -25,8 +25,8 @@ spring:
       acquire-timeout: 5s
   datasource:
     url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:55432}/${DB_NAME:manage_system}
-    username: ${DB_USERNAME:postgres}
+    username: ${DB_USERNAME:novalon}
-    password: ${DB_PASSWORD:postgres}
+    password: ${DB_PASSWORD:novalon123}
     driver-class-name: org.postgresql.Driver
   flyway:
     enabled: true
@@ -38,6 +38,21 @@ spring:
     user:
       name: disabled
       password: disabled
+  data:
+    redis:
+      host: ${REDIS_HOST:localhost}
+      port: ${REDIS_PORT:6379}
+      password: ${REDIS_PASSWORD:novalon123}
+      timeout: 5000
+      lettuce:
+        pool:
+          max-active: 8  # 最大连接数
+          max-idle: 8    # 最大空闲连接
+          min-idle: 0    # 最小空闲连接
+          max-wait: -1ms # 连接等待时间
+  profiles:
+    active: dev
+
 
 management:
   endpoints:

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

@@ -99,6 +99,8 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+
+
     </dependencies>
 
     <build>

gym-manage-api/manage-db/src/main/java/cn/novalon/gym/manage/db/repository/SysUserRepository.java

@@ -10,6 +10,7 @@ import cn.novalon.gym.manage.sys.core.query.SysUserQuery;
 import cn.novalon.gym.manage.sys.core.repository.ISysUserRepository;
 import cn.novalon.gym.manage.common.dto.PageRequest;
 import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.sys.dto.response.UserResponse;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.data.relational.core.query.Query;

gym-manage-api/manage-db/src/main/resources/db/migration/V6__Create_GroupCourse_table.sql

@@ -0,0 +1,71 @@
+-- ============================================
+-- 团课相关表
+-- ============================================
+
+-- 团课课程表
+CREATE TABLE IF NOT EXISTS group_course (
+    id BIGSERIAL PRIMARY KEY,
+    course_name VARCHAR(100) NOT NULL,
+    coach_id BIGINT,
+    course_type BIGINT,
+    start_time TIMESTAMP NOT NULL,
+    end_time TIMESTAMP NOT NULL,
+    max_members INTEGER DEFAULT 20,
+    current_members INTEGER DEFAULT 0,
+    status VARCHAR(1) DEFAULT '0',
+    location VARCHAR(255),
+    cover_image VARCHAR(500),
+    description TEXT,
+    create_by VARCHAR(50),
+    update_by VARCHAR(50),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP
+);
+
+-- 团课预约记录表
+CREATE TABLE IF NOT EXISTS group_course_booking (
+    id BIGSERIAL PRIMARY KEY,
+    course_id BIGINT NOT NULL,
+    user_id BIGINT NOT NULL,
+    booking_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    status VARCHAR(1) DEFAULT '0',
+    cancel_time TIMESTAMP,
+    create_by VARCHAR(50),
+    update_by VARCHAR(50),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP
+);
+
+COMMENT ON TABLE group_course IS '团课课程表';
+COMMENT ON COLUMN group_course.id IS '主键ID';
+COMMENT ON COLUMN group_course.course_name IS '课程名称';
+COMMENT ON COLUMN group_course.coach_id IS '教练ID（关联sys_user）';
+COMMENT ON COLUMN group_course.course_type IS '课程类型（如瑜伽/普拉提/动感单车）';
+COMMENT ON COLUMN group_course.start_time IS '开始时间';
+COMMENT ON COLUMN group_course.end_time IS '结束时间';
+COMMENT ON COLUMN group_course.max_members IS '最大参与人数';
+COMMENT ON COLUMN group_course.current_members IS '当前参与人数';
+COMMENT ON COLUMN group_course.status IS '状态（0正常 1已取消 2已结束）';
+COMMENT ON COLUMN group_course.location IS '上课地点';
+COMMENT ON COLUMN group_course.cover_image IS '封面图URL';
+COMMENT ON COLUMN group_course.description IS '课程描述';
+COMMENT ON COLUMN group_course.create_by IS '创建人';
+COMMENT ON COLUMN group_course.update_by IS '更新人';
+COMMENT ON COLUMN group_course.created_at IS '创建时间';
+COMMENT ON COLUMN group_course.updated_at IS '更新时间';
+COMMENT ON COLUMN group_course.deleted_at IS '删除时间（软删除）';
+
+COMMENT ON TABLE group_course_booking IS '团课预约记录表';
+COMMENT ON COLUMN group_course_booking.id IS '主键ID';
+COMMENT ON COLUMN group_course_booking.course_id IS '团课ID';
+COMMENT ON COLUMN group_course_booking.user_id IS '用户ID';
+COMMENT ON COLUMN group_course_booking.booking_time IS '预约时间';
+COMMENT ON COLUMN group_course_booking.status IS '状态（0已预约 1已取消 2已出席 3缺席）';
+COMMENT ON COLUMN group_course_booking.cancel_time IS '取消时间';
+COMMENT ON COLUMN group_course_booking.create_by IS '创建人';
+COMMENT ON COLUMN group_course_booking.update_by IS '更新人';
+COMMENT ON COLUMN group_course_booking.created_at IS '创建时间';
+COMMENT ON COLUMN group_course_booking.updated_at IS '更新时间';
+COMMENT ON COLUMN group_course_booking.deleted_at IS '删除时间（软删除）';

gym-manage-api/manage-db/src/main/resources/db/migration/V7__Insert_GroupCourse_test_data.sql

@@ -0,0 +1,19 @@
+-- 测试数据1: 进行中的瑜伽课程 (已有部分学员)
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
+    ('清晨流瑜伽', 101, 1, '2026-05-10 09:00:00', '2026-05-10 10:30:00', 15, 8, '1', 'A座3楼瑜伽教室', '/images/yoga_flow.jpg', '适合有一定基础的学员，通过流畅的体式连接呼吸，唤醒身体能量。', 'admin', '2026-05-01 10:00:00', '2026-05-01 10:00:00');
+
+-- 测试数据2: 即将开始的搏击课 (几乎满员)
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
+    ('燃脂搏击', 102, 2, '2026-05-12 18:30:00', '2026-05-12 19:30:00', 20, 19, '1', '综合训练区', '/images/kickboxing.jpg', '高强度间歇训练，配合音乐快速燃脂，释放压力。', 'coach_zhang', '2026-05-02 14:30:00', '2026-05-02 14:30:00');
+
+-- 测试数据3: 已结束的私教小团课 (课程号已满)
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
+    ('蜜桃臀塑造', 103, 3, '2026-04-25 19:00:00', '2026-04-25 20:00:00', 10, 10, '2', '私教专区', '/images/glute.jpg', '针对性训练臀部肌肉群，打造完美臀线。小班教学，动作一对一纠正。', 'coach_li', '2026-04-20 09:15:00', '2026-04-20 09:15:00');
+
+-- 测试数据4: 即将开始的动感单车 (名额充足，尚未有人报名)
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at) VALUES
+    ('极速燃脂单车', 104, 2, '2026-05-15 19:30:00', '2026-05-15 20:20:00', 25, 0, '0', '单车房', '/images/spinning.jpg', '跟随音乐节奏变换阻力和速度，体验爬坡与冲刺的快感，一节课消耗800大卡。', 'admin', '2026-05-06 11:00:00', '2026-05-06 11:00:00');
+
+-- 测试数据5: 已删除/作废的课程 (deleted_at 不为空)
+INSERT INTO group_course (course_name, coach_id, course_type, start_time, end_time, max_members, current_members, status, location, cover_image, description, create_by, created_at, updated_at, deleted_at) VALUES
+    ('周末冥想修复', 101, 1, '2026-05-03 15:00:00', '2026-05-03 16:00:00', 12, 3, '3', '冥想室', '/images/meditation.jpg', '通过呼吸和正念冥想，深度放松身心，缓解一周疲劳。', 'coach_wang', '2026-04-28 08:00:00', '2026-04-28 08:00:00', '2026-04-29 16:20:00');

gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/config/SecurityConfig.java

@@ -50,7 +50,9 @@ public class SecurityConfig {
                     spec.pathMatchers("/api/auth/**").permitAll()
                             .pathMatchers("/api/public/**").permitAll()
                             .pathMatchers("/ws/**").permitAll()
-                            .pathMatchers("/actuator/**").permitAll();
+                            .pathMatchers("/actuator/**").permitAll()
+                            .pathMatchers("/api/groupCourse/**").permitAll();
+
 
                     if (isDevOrTest) {
                         spec.pathMatchers("/swagger-ui.html").permitAll()

gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/core/service/impl/SysUserService.java

@@ -15,6 +15,7 @@ import cn.novalon.gym.manage.sys.core.repository.IUserRoleRepository;
 import cn.novalon.gym.manage.sys.core.service.ISysUserService;
 import cn.novalon.gym.manage.sys.core.command.CreateUserCommand;
 import cn.novalon.gym.manage.sys.core.command.UpdateUserCommand;
+import cn.novalon.gym.manage.sys.dto.response.UserResponse;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Qualifier;

gym-manage-api/pom.xml

@@ -36,13 +36,13 @@
     <modules>
         <module>manage-sys</module>
         <module>manage-gateway</module>
-        <module>gym-member-card</module>
         <module>manage-app</module>
         <module>manage-common</module>
         <module>manage-db</module>
         <module>manage-audit</module>
         <module>manage-notify</module>
         <module>manage-file</module>
+        <module>gym-groupCourse</module>
     </modules>
 
     <dependencyManagement>
@@ -222,6 +222,13 @@
             <artifactId>lombok</artifactId>
             <optional>true</optional>
         </dependency>
+
+        <!--        HuTool工具箱-->
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.8.38</version>
+        </dependency>
     </dependencies>
 
     <build>

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.46.2))(vue@3.5.30(typescript@5.9.3))
+        version: 6.0.5(vite@7.3.1(@types/node@20.19.37))(vue@3.5.30(typescript@5.9.3))
       '@vitest/coverage-v8':
         specifier: ^4.1.1
         version: 4.1.2(vitest@4.1.0)
@@ -81,18 +81,15 @@ importers:
       prettier:
         specifier: ^3.1.1
         version: 3.8.1
-      terser:
-        specifier: ^5.46.1
-        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.46.2)
+        version: 7.3.1(@types/node@20.19.37)
       vitest:
         specifier: ^4.0.16
-        version: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
+        version: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37))
       vue-tsc:
         specifier: ^3.2.2
         version: 3.2.5(typescript@5.9.3)
@@ -393,16 +390,10 @@ packages:
     resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
     engines: {node: '>=12'}
 
-  '@jridgewell/gen-mapping@0.3.13':
-    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
-
   '@jridgewell/resolve-uri@3.1.2':
     resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
     engines: {node: '>=6.0.0'}
 
-  '@jridgewell/source-map@0.3.11':
-    resolution: {integrity: sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==}
-
   '@jridgewell/sourcemap-codec@1.5.5':
     resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
 
@@ -473,79 +464,66 @@ packages:
     resolution: {integrity: sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==}
     cpu: [arm]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-arm-musleabihf@4.59.0':
     resolution: {integrity: sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==}
     cpu: [arm]
     os: [linux]
-    libc: [musl]
 
   '@rollup/rollup-linux-arm64-gnu@4.59.0':
     resolution: {integrity: sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==}
     cpu: [arm64]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-arm64-musl@4.59.0':
     resolution: {integrity: sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==}
     cpu: [arm64]
     os: [linux]
-    libc: [musl]
 
   '@rollup/rollup-linux-loong64-gnu@4.59.0':
     resolution: {integrity: sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==}
     cpu: [loong64]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-loong64-musl@4.59.0':
     resolution: {integrity: sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==}
     cpu: [loong64]
     os: [linux]
-    libc: [musl]
 
   '@rollup/rollup-linux-ppc64-gnu@4.59.0':
     resolution: {integrity: sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==}
     cpu: [ppc64]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-ppc64-musl@4.59.0':
     resolution: {integrity: sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==}
     cpu: [ppc64]
     os: [linux]
-    libc: [musl]
 
   '@rollup/rollup-linux-riscv64-gnu@4.59.0':
     resolution: {integrity: sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==}
     cpu: [riscv64]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-riscv64-musl@4.59.0':
     resolution: {integrity: sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==}
     cpu: [riscv64]
     os: [linux]
-    libc: [musl]
 
   '@rollup/rollup-linux-s390x-gnu@4.59.0':
     resolution: {integrity: sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==}
     cpu: [s390x]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-x64-gnu@4.59.0':
     resolution: {integrity: sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==}
     cpu: [x64]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-x64-musl@4.59.0':
     resolution: {integrity: sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==}
     cpu: [x64]
     os: [linux]
-    libc: [musl]
 
   '@rollup/rollup-openbsd-x64@4.59.0':
     resolution: {integrity: sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==}
@@ -880,9 +858,6 @@ packages:
     resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
     engines: {node: '>=8'}
 
-  buffer-from@1.1.2:
-    resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
-
   call-bind-apply-helpers@1.0.2:
     resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
     engines: {node: '>= 0.4'}
@@ -914,9 +889,6 @@ packages:
     resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==}
     engines: {node: '>=14'}
 
-  commander@2.20.3:
-    resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
-
   concat-map@0.0.1:
     resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
 
@@ -1659,13 +1631,6 @@ packages:
     resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
     engines: {node: '>=0.10.0'}
 
-  source-map-support@0.5.21:
-    resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
-
-  source-map@0.6.1:
-    resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
-    engines: {node: '>=0.10.0'}
-
   speakingurl@14.0.1:
     resolution: {integrity: sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==}
     engines: {node: '>=0.10.0'}
@@ -1707,11 +1672,6 @@ packages:
   symbol-tree@3.2.4:
     resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
 
-  terser@5.46.2:
-    resolution: {integrity: sha512-uxfo9fPcSgLDYob/w1FuL0c99MWiJDnv+5qXSQc5+Ki5NjVNsYi66INnMFBjf6uFz6OnX12piJQPF4IpjJTNTw==}
-    engines: {node: '>=10'}
-    hasBin: true
-
   text-table@0.2.0:
     resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==}
 
@@ -2178,18 +2138,8 @@ snapshots:
       wrap-ansi: 8.1.0
       wrap-ansi-cjs: wrap-ansi@7.0.0
 
-  '@jridgewell/gen-mapping@0.3.13':
-    dependencies:
-      '@jridgewell/sourcemap-codec': 1.5.5
-      '@jridgewell/trace-mapping': 0.3.31
-
   '@jridgewell/resolve-uri@3.1.2': {}
 
-  '@jridgewell/source-map@0.3.11':
-    dependencies:
-      '@jridgewell/gen-mapping': 0.3.13
-      '@jridgewell/trace-mapping': 0.3.31
-
   '@jridgewell/sourcemap-codec@1.5.5': {}
 
   '@jridgewell/trace-mapping@0.3.31':
@@ -2416,10 +2366,10 @@ snapshots:
 
   '@ungap/structured-clone@1.3.0': {}
 
-  '@vitejs/plugin-vue@6.0.5(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))(vue@3.5.30(typescript@5.9.3))':
+  '@vitejs/plugin-vue@6.0.5(vite@7.3.1(@types/node@20.19.37))(vue@3.5.30(typescript@5.9.3))':
     dependencies:
       '@rolldown/pluginutils': 1.0.0-rc.2
-      vite: 7.3.1(@types/node@20.19.37)(terser@5.46.2)
+      vite: 7.3.1(@types/node@20.19.37)
       vue: 3.5.30(typescript@5.9.3)
 
   '@vitest/coverage-v8@4.1.2(vitest@4.1.0)':
@@ -2434,7 +2384,7 @@ snapshots:
       obug: 2.1.1
       std-env: 4.0.0
       tinyrainbow: 3.1.0
-      vitest: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
+      vitest: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37))
 
   '@vitest/expect@4.1.0':
     dependencies:
@@ -2445,13 +2395,13 @@ snapshots:
       chai: 6.2.2
       tinyrainbow: 3.1.0
 
-  '@vitest/mocker@4.1.0(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))':
+  '@vitest/mocker@4.1.0(vite@7.3.1(@types/node@20.19.37))':
     dependencies:
       '@vitest/spy': 4.1.0
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
-      vite: 7.3.1(@types/node@20.19.37)(terser@5.46.2)
+      vite: 7.3.1(@types/node@20.19.37)
 
   '@vitest/pretty-format@4.1.0':
     dependencies:
@@ -2484,7 +2434,7 @@ snapshots:
       sirv: 3.0.2
       tinyglobby: 0.2.15
       tinyrainbow: 3.1.0
-      vitest: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
+      vitest: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37))
 
   '@vitest/utils@4.1.0':
     dependencies:
@@ -2692,8 +2642,6 @@ snapshots:
     dependencies:
       fill-range: 7.1.1
 
-  buffer-from@1.1.2: {}
-
   call-bind-apply-helpers@1.0.2:
     dependencies:
       es-errors: 1.3.0
@@ -2720,8 +2668,6 @@ snapshots:
 
   commander@10.0.1: {}
 
-  commander@2.20.3: {}
-
   concat-map@0.0.1: {}
 
   config-chain@1.1.13:
@@ -3510,13 +3456,6 @@ snapshots:
 
   source-map-js@1.2.1: {}
 
-  source-map-support@0.5.21:
-    dependencies:
-      buffer-from: 1.1.2
-      source-map: 0.6.1
-
-  source-map@0.6.1: {}
-
   speakingurl@14.0.1: {}
 
   stackback@0.0.2: {}
@@ -3555,13 +3494,6 @@ snapshots:
 
   symbol-tree@3.2.4: {}
 
-  terser@5.46.2:
-    dependencies:
-      '@jridgewell/source-map': 0.3.11
-      acorn: 8.16.0
-      commander: 2.20.3
-      source-map-support: 0.5.21
-
   text-table@0.2.0: {}
 
   tinybench@2.9.0: {}
@@ -3615,7 +3547,7 @@ snapshots:
 
   util-deprecate@1.0.2: {}
 
-  vite@7.3.1(@types/node@20.19.37)(terser@5.46.2):
+  vite@7.3.1(@types/node@20.19.37):
     dependencies:
       esbuild: 0.27.4
       fdir: 6.5.0(picomatch@4.0.3)
@@ -3626,12 +3558,11 @@ snapshots:
     optionalDependencies:
       '@types/node': 20.19.37
       fsevents: 2.3.3
-      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.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)):
     dependencies:
       '@vitest/expect': 4.1.0
-      '@vitest/mocker': 4.1.0(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
+      '@vitest/mocker': 4.1.0(vite@7.3.1(@types/node@20.19.37))
       '@vitest/pretty-format': 4.1.0
       '@vitest/runner': 4.1.0
       '@vitest/snapshot': 4.1.0
@@ -3648,7 +3579,7 @@ snapshots:
       tinyexec: 1.0.2
       tinyglobby: 0.2.15
       tinyrainbow: 3.1.0
-      vite: 7.3.1(@types/node@20.19.37)(terser@5.46.2)
+      vite: 7.3.1(@types/node@20.19.37)
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 20.19.37