novalon/gym-manage
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: novalon/gym-manage:feature/groupCourseSearch
Branches Tags
novalon/gym-manage:main novalon/gym-manage:feature/member-card-management novalon/gym-manage:feature/member-register novalon/gym-manage:feature/groupCourseSearch novalon/gym-manage:feature/userInfoManage novalon/gym-manage:dev
..
compare: novalon/gym-manage:2325c66c37ea74bde4c0499eb7b69946cac1baec
Branches Tags
novalon/gym-manage:feature/member-card-management novalon/gym-manage:feature/member-register novalon/gym-manage:feature/groupCourseSearch novalon/gym-manage:feature/userInfoManage novalon/gym-manage:dev novalon/gym-manage:main

3 Commits
feature/groupCourseSearch .. 2325c66c37

Author SHA1 Message Date
时舟年 2325c66c37 新增会员卡模块基础 2026-05-21 14:53:53 +08:00
时舟年 0afd1cc865 新增会员卡模块基础 2026-05-21 14:51:29 +08:00
时舟年 8b8920a53d 新增会员卡模块基础 2026-05-21 12:34:11 +08:00
59 changed files with 2786 additions and 1180 deletions
Expand all files Collapse all files
gym-manage-api/gym-groupCourse/.mvn/wrapper/maven-wrapper.properties
Vendored
-3
View File
@@ -1,3 +0,0 @@
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
-88
View File
@@ -1,88 +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>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
-53
View File
@@ -1,53 +0,0 @@
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
-23
View File
@@ -1,23 +0,0 @@
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
-142
View File
@@ -1,142 +0,0 @@
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
-144
View File
@@ -1,144 +0,0 @@
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
-128
View File
@@ -1,128 +0,0 @@
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
-20
View File
@@ -1,20 +0,0 @@
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
-131
View File
@@ -1,131 +0,0 @@
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
-16
View File
@@ -1,16 +0,0 @@
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
-76
View File
@@ -1,76 +0,0 @@
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
-138
View File
@@ -1,138 +0,0 @@
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
-3
View File
@@ -1,3 +0,0 @@
spring:
application:
name: gym-groupCourse
gym-manage-api/gym-member-card/pom.xml
+84
View File
@@ -0,0 +1,84 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.5.13</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-member-card</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>gym-member-card</name>
<description>gym-member-card</description>
<properties>
<java.version>21</java.version>
</properties>
<dependencies>
<!-- WebFlux 启动器（响应式） -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<!-- PostgreSQL 驱动（JDBC，如果工具类需要） -->
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
</dependency>
<!-- 你的内部模块 -->
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-db</artifactId>
<version>1.0.0</version>
<scope>compile</scope>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.36</version>
<scope>provided</scope>
</dependency>
<!-- Hutool 工具箱 -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.22</version>
</dependency>
<!-- Spring 上下文（其实 WebFlux 已经包含，保留也可以） -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<!-- ⭐ 必须添加：测试依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<!-- 保留标准 JAR，供其他模块引用 -->
<classifier>exec</classifier>
</configuration>
</plugin>
</plugins>
</build>
</project>
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/GymMemberCardApplication.java
+15
View File
@@ -0,0 +1,15 @@
package cn.novalon.gym.manage.gymmembercard;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
@SpringBootApplication
@EnableR2dbcRepositories(basePackages = "cn.novalon.gym.manage.db.dao")
public class GymMemberCardApplication {
public static void main(String[] args) {
SpringApplication.run(GymMemberCardApplication.class, args);
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/dao/MemberCardDao.java
+130
View File
@@ -0,0 +1,130 @@
package cn.novalon.gym.manage.gymmembercard.dao;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardEntity;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.repository.Modifying;
import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@Repository
public interface MemberCardDao extends R2dbcRepository<MemberCardEntity, Long> {
/**
* 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
* @param memberCardId 会员卡ID
* @return 会员卡完整信息，如果不存在或已删除则返回空
*/
Mono<MemberCardEntity> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
/**
* 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
* 注意：模糊查询使用前后缀通配符，若数据量较大可能影响索引效率，建议后期引入全文索引或改用后缀模糊
* @param status 会员卡状态（上架/下架）
* @param name 会员卡名称（模糊查询）
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
@Query("SELECT * FROM member_card WHERE deleted_at IS NULL " +
"AND (:status IS NULL OR member_card_status = :status) " +
"AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
"AND (:type IS NULL OR member_card_type = :type) " +
"AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
"AND (:maxPrice IS NULL OR member_card_price <= :maxPrice) " +
"ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
Flux<MemberCardEntity> findWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice, Pageable pageable);
/**
* 统计符合条件的会员卡总数（配合列表查询使用）
* @param status 会员卡状态
* @param name 会员卡名称（模糊查询）
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @return 符合条件的会员卡数量
*/
@Query("SELECT COUNT(*) FROM member_card WHERE deleted_at IS NULL " +
"AND (:status IS NULL OR member_card_status = :status) " +
"AND (:name IS NULL OR member_card_name LIKE CONCAT('%', :name, '%')) " +
"AND (:type IS NULL OR member_card_type = :type) " +
"AND (:minPrice IS NULL OR member_card_price >= :minPrice) " +
"AND (:maxPrice IS NULL OR member_card_price <= :maxPrice)")
Mono<Long> countWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice);
/**
* 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
* @param status 会员卡状态（通常传上架状态）
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
Flux<MemberCardEntity> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
/**
* 检查会员卡是否已被购买（用于删除前的校验）
* 注意：此查询关联到 member_card_record 表，建议后续独立至 MemberCardRecordDao
* @param memberCardId 会员卡ID
* @return 如果存在关联的会员记录则返回true，否则返回false
*/
@Query("SELECT EXISTS(SELECT 1 FROM member_card_record WHERE member_card_id = :memberCardId AND deleted_at IS NULL LIMIT 1)")
Mono<Boolean> existsPurchasedRecord(Long memberCardId);
/**
* 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
* @param memberCardId 会员卡ID
* @return 受影响的行数
*/
@Modifying
@Query("UPDATE member_card SET deleted_at = NOW() WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
Mono<Integer> logicalDelete(Long memberCardId);
/**
* 【新增】安全更新会员卡信息（仅允许修改业务相关字段，防止覆盖敏感字段）
* @param memberCardId 会员卡ID
* @param name 卡种名称
* @param price 价格
* @param durationDays 有效天数
* @param totalCount 总次数
* @param denomination 面额
* @param status 状态
* @return 受影响的行数
*/
@Modifying
@Query("UPDATE member_card SET " +
"member_card_name = COALESCE(:name, member_card_name), " +
"member_card_price = COALESCE(:price, member_card_price), " +
"duration_days = COALESCE(:durationDays, duration_days), " +
"total_count = COALESCE(:totalCount, total_count), " +
"denomination = COALESCE(:denomination, denomination), " +
"member_card_status = COALESCE(:status, member_card_status), " +
"updated_at = NOW() " +
"WHERE member_card_id = :memberCardId AND deleted_at IS NULL")
Mono<Integer> updateSafe(Long memberCardId, String name, Double price,
Integer durationDays, Integer totalCount,
Double denomination, Integer status);
/**
* 保存卡种信息（新增或更新）
* - 新增：entity.memberCardId 为 null 时，插入新记录
* - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
* 注意：直接 save 会更新所有字段，如需安全更新请调用 updateSafe 方法
* @param entity 卡种信息
* @return 保存后的实体对象
*/
@Override
<S extends MemberCardEntity> Mono<S> save(S entity);
/**
* 批量查询上架的会员卡（用于小程序端展示）
* @param status 上架状态值
* @return 上架的会员卡列表
*/
@Query("SELECT * FROM member_card WHERE deleted_at IS NULL AND member_card_status = :status ORDER BY member_card_price ASC")
Flux<MemberCardEntity> findActiveCards(Integer status);
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/dao/MemberCardRecordDao.java
+148
View File
@@ -0,0 +1,148 @@
package cn.novalon.gym.manage.gymmembercard.dao;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardRecordEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.repository.Modifying;
import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Repository
public interface MemberCardRecordDao extends R2dbcRepository<MemberCardRecordEntity, Long> {
/**
* 会员购卡/后台发卡
* 支付成功后插入一条记录，状态为ACTIVE，设置有效期和初始剩余次数/余额
* @param memberId 会员ID
* @param memberCardId 会员卡类型ID
* @param expireTime 到期时间
* @param remainingTimes 剩余次数
* @param remainingAmount 剩余余额
* @param sourceOrderId 来源订单ID
* @return 插入的记录
*/
@Modifying
@Query("INSERT INTO member_card_record (member_id, member_card_id, status, expire_time, remaining_times, remaining_amount, source_order_id, purchase_time, created_at, updated_at) " +
"VALUES (:memberId, :memberCardId, 'ACTIVE', :expireTime, :remainingTimes, :remainingAmount, :sourceOrderId, NOW(), NOW(), NOW()) " +
"RETURNING *")
Mono<MemberCardRecordEntity> insertActiveRecord(@Param("memberId") Long memberId,
@Param("memberCardId") Long memberCardId,
@Param("expireTime") LocalDateTime expireTime,
@Param("remainingTimes") Integer remainingTimes,
@Param("remainingAmount") Double remainingAmount,
@Param("sourceOrderId") Long sourceOrderId);
/**
* 扣次/扣费（含防超扣校验）
* 预约团课或私教成功后，更新 remaining_times 减1 或 remaining_amount 减课程价格
* @param recordId 会员卡记录ID
* @param deductTimes 扣除次数
* @param deductAmount 扣除金额
* @return 受影响的行数（0表示余额不足，扣费失败）
*/
@Modifying
@Query("UPDATE member_card_record SET " +
"remaining_times = remaining_times - :deductTimes, " +
"remaining_amount = remaining_amount - :deductAmount, " +
"updated_at = NOW() " +
"WHERE member_card_record_id = :recordId " +
"AND deleted_at IS NULL " +
"AND remaining_times >= :deductTimes " +
"AND remaining_amount >= :deductAmount")
Mono<Integer> deductUsage(@Param("recordId") Long recordId,
@Param("deductTimes") Integer deductTimes,
@Param("deductAmount") Double deductAmount);
/**
* 续费
* 累加剩余次数/余额，顺延到期日期
* @param recordId 会员卡记录ID
* @param addTimes 增加次数
* @param addAmount 增加金额
* @param newExpireTime 新的到期时间
* @return 受影响的行数
*/
@Modifying
@Query("UPDATE member_card_record SET remaining_times = remaining_times + :addTimes, " +
"remaining_amount = remaining_amount + :addAmount, expire_time = :newExpireTime, updated_at = NOW() " +
"WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
Mono<Integer> renewCard(@Param("recordId") Long recordId,
@Param("addTimes") Integer addTimes,
@Param("addAmount") Double addAmount,
@Param("newExpireTime") LocalDateTime newExpireTime);
/**
* 状态变更
* 过期定时任务将状态改为EXPIRED；退款后改为REFUNDED
* @param recordId 会员卡记录ID
* @param status 新状态
* @return 受影响的行数
*/
@Modifying
@Query("UPDATE member_card_record SET status = :status, updated_at = NOW() " +
"WHERE member_card_record_id = :recordId AND deleted_at IS NULL")
Mono<Integer> updateStatus(@Param("recordId") Long recordId,
@Param("status") MemberCardRecordStatus status);
/**
* 会员端"我的卡包"
* 根据会员ID查询所有卡，过滤状态为ACTIVE的，展示剩余次数/天数/余额
* @param memberId 会员ID
* @return 有效会员卡列表
*/
@Query("SELECT * FROM member_card_record WHERE member_id = :memberId AND status = 'ACTIVE' AND deleted_at IS NULL ORDER BY expire_time ASC")
Flux<MemberCardRecordEntity> findActiveCardsByMemberId(@Param("memberId") Long memberId);
/**
* 前台/店长查会员卡
* 输入会员手机号或姓名，查出该会员持有的所有卡的信息
* @param memberId 会员ID
* @param pageable 分页参数
* @return 会员卡列表
*/
@Query("SELECT mcr.* FROM member_card_record mcr " +
"INNER JOIN member m ON mcr.member_id = m.member_id " +
"WHERE mcr.member_id = :memberId AND mcr.deleted_at IS NULL " +
"ORDER BY mcr.purchase_time DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
Flux<MemberCardRecordEntity> findByMemberId(@Param("memberId") Long memberId, Pageable pageable);
/**
* 验证次卡是否可用（仅检验次数和过期时间）
* @param recordId 会员卡记录ID
* @param requiredTimes 需要的次数
* @return 符合条件的记录，空表示不可用
*/
@Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
"AND status = 'ACTIVE' AND deleted_at IS NULL " +
"AND expire_time > NOW() " +
"AND remaining_times >= :requiredTimes")
Mono<MemberCardRecordEntity> validateCountCard(@Param("recordId") Long recordId,
@Param("requiredTimes") Integer requiredTimes);
/**
* 验证储值卡是否可用（仅检验余额和过期时间）
* @param recordId 会员卡记录ID
* @param requiredAmount 需要的金额
* @return 符合条件的记录，空表示不可用
*/
@Query("SELECT * FROM member_card_record WHERE member_card_record_id = :recordId " +
"AND status = 'ACTIVE' AND deleted_at IS NULL " +
"AND expire_time > NOW() " +
"AND remaining_amount >= :requiredAmount")
Mono<MemberCardRecordEntity> validateStoredCard(@Param("recordId") Long recordId,
@Param("requiredAmount") Double requiredAmount);
/**
* 到期扫描（分批处理，避免内存压力）
* 定时任务：查询 status=ACTIVE 且 expire_time < 当前时间 的记录，用于批量过期处理
* @return 已过期的会员卡记录列表（最多500条）
*/
@Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND expire_time < NOW() AND deleted_at IS NULL LIMIT 500")
Flux<MemberCardRecordEntity> findExpiredCards();
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/dao/MemberCardTransactionsDao.java
+159
View File
@@ -0,0 +1,159 @@
package cn.novalon.gym.manage.gymmembercard.dao;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardTransactionsEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.repository.Modifying;
import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Repository
public interface MemberCardTransactionsDao extends R2dbcRepository<MemberCardTransactionsEntity, Long> {
/**
* 记录每一次变动
* 购卡、扣次、续费、退款、过期，均插入一条流水，记录变动前后快照
* 注意：返回值依赖 PostgreSQL 的 RETURNING 语法，若使用 MySQL 请删除 RETURNING * 并改用 save()
* @param memberCardId 会员卡ID
* @param memberId 会员ID
* @param operationType 操作类型
* @param changeAmount 变动次数（次卡）
* @param changeBalance 变动金额（储值卡）
* @param afterRemainingCount 变动后剩余次数
* @param afterRemainingBalance 变动后剩余余额
* @param relatedBizType 关联业务类型
* @param remark 备注
* @return 插入的流水记录
*/
@Modifying
@Query("INSERT INTO member_card_transactions (member_card_id, member_id, operation_type, change_amount, " +
"change_balance, after_remaining_count, after_remaining_balance, related_biz_type, remark, created_at, updated_at) " +
"VALUES (:memberCardId, :memberId, :operationType, :changeAmount, :changeBalance, " +
":afterRemainingCount, :afterRemainingBalance, :relatedBizType, :remark, NOW(), NOW()) " +
"RETURNING *")
Mono<MemberCardTransactionsEntity> insertTransaction(@Param("memberCardId") Long memberCardId,
@Param("memberId") Long memberId,
@Param("operationType") MemberCardTransactionsAction operationType,
@Param("changeAmount") Integer changeAmount,
@Param("changeBalance") Double changeBalance,
@Param("afterRemainingCount") Integer afterRemainingCount,
@Param("afterRemainingBalance") Double afterRemainingBalance,
@Param("relatedBizType") MemberCardTransactionsType relatedBizType,
@Param("remark") String remark);
/**
* 会员端"使用记录"
* 按会员ID和时间范围查询，按时间倒序，显示每次变动明细
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
@Query("SELECT * FROM member_card_transactions WHERE member_id = :memberId " +
"AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL " +
"ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
Flux<MemberCardTransactionsEntity> findByMemberIdAndTimeRange(@Param("memberId") Long memberId,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime,
Pageable pageable);
/**
* 后台"使用记录查询"
* 按会员、卡号、操作类型、时间范围等条件组合查询
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
@Query("SELECT * FROM member_card_transactions WHERE deleted_at IS NULL " +
"AND (:memberId IS NULL OR member_id = :memberId) " +
"AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
"AND (:operationType IS NULL OR operation_type = :operationType) " +
"AND (:startTime IS NULL OR created_at >= :startTime) " +
"AND (:endTime IS NULL OR created_at <= :endTime) " +
"ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
Flux<MemberCardTransactionsEntity> findWithConditions(@Param("memberId") Long memberId,
@Param("memberCardId") Long memberCardId,
@Param("operationType") MemberCardTransactionsAction operationType,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime,
Pageable pageable);
/**
* 统计符合条件的流水总数
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @return 流水记录数量
*/
@Query("SELECT COUNT(*) FROM member_card_transactions WHERE deleted_at IS NULL " +
"AND (:memberId IS NULL OR member_id = :memberId) " +
"AND (:memberCardId IS NULL OR member_card_id = :memberCardId) " +
"AND (:operationType IS NULL OR operation_type = :operationType) " +
"AND (:startTime IS NULL OR created_at >= :startTime) " +
"AND (:endTime IS NULL OR created_at <= :endTime)")
Mono<Long> countWithConditions(@Param("memberId") Long memberId,
@Param("memberCardId") Long memberCardId,
@Param("operationType") MemberCardTransactionsAction operationType,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
/**
* 按会员卡ID查询所有流水记录（补充常用方法）
* @param memberCardId 会员卡ID
* @return 该卡的所有流水记录，按时间倒序
*/
@Query("SELECT * FROM member_card_transactions WHERE member_card_id = :memberCardId AND deleted_at IS NULL ORDER BY created_at DESC")
Flux<MemberCardTransactionsEntity> findByMemberCardId(@Param("memberCardId") Long memberCardId);
/**
* 数据统计 - 统计某卡种的总扣次数
* @param memberCardId 会员卡ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 总扣次数
*/
@Query("SELECT COALESCE(SUM(change_amount), 0) FROM member_card_transactions " +
"WHERE member_card_id = :memberCardId AND operation_type = 'DEDUCT' " +
"AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
Mono<Long> sumDeductCountByCardId(@Param("memberCardId") Long memberCardId,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
/**
* 数据统计 - 统计某时间段的续费总金额
* @param startTime 开始时间
* @param endTime 结束时间
* @return 续费总金额
*/
@Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
"WHERE operation_type = 'RENEW' AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
Mono<Double> sumRenewAmountByTimeRange(@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
/**
* 数据统计 - 统计某会员的购卡总金额
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 购卡总金额
*/
@Query("SELECT COALESCE(SUM(change_balance), 0) FROM member_card_transactions " +
"WHERE member_id = :memberId AND operation_type = 'PURCHASE' " +
"AND created_at BETWEEN :startTime AND :endTime AND deleted_at IS NULL")
Mono<Double> sumPurchaseAmountByMemberId(@Param("memberId") Long memberId,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/domain/MemberCard.java
+49
View File
@@ -0,0 +1,49 @@
package cn.novalon.gym.manage.gymmembercard.domain;
import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 22:47:31
*/
@Schema(description = "会员卡类型表")
public class MemberCard extends BaseDomain {
//会员卡id
@Schema(description = "会员卡Id",example = "1")
private Long memberCardId;
//会员卡名称
@Schema(description = "会员卡名称",example = "月卡")
private String memberCardName;
//会员卡类型
@Schema(description = "会员卡类型",example = "TIME_CARD")
private String memberCardType;
//会员卡价格
@Schema(description = "会员卡价格",example = "199.0")
private Double memberCardPrice;
//会员卡有效天数（时长卡用）
@Schema(description = "会员卡有效天数",example = "30")
private Integer memberCardValidityDays;
//会员卡总次数（次卡用）
@Schema(description = "会员卡总次数",example = "10")
private Integer memberCardTotalTimes;
//会员卡面额（储值卡用）
@Schema(description = "会员卡面额",example = "500.0")
private Double memberCardAmount;
//会员卡状态：0-正常，1-禁用
@Schema(description = "会员卡状态",example = "0")
private Integer memberCardStatus;
//会员卡创建时间
@Schema(description = "会员卡创建时间",example = "2026-05-10 05:22:47")
private LocalDateTime memberCardCreateTime;
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/domain/MemberCardRecord.java
+50
View File
@@ -0,0 +1,50 @@
package cn.novalon.gym.manage.gymmembercard.domain;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 22:47:31
*/
@Schema(description = "会员卡记录",example = "member_card_record")
public class MemberCardRecord extends BaseDomain {
//会员持有卡id
@Schema(description = "会员持有卡Id",example = "1")
private Long memberCardRecordId;
//会员Id
@Schema(description = "会员Id",example = "1")
private Long memberId;
//关联会员卡Id
@Schema(description = "关联会员卡Id",example = "1")
private Long memberCardId;
//状态：ACTIVE(有效) / USED_UP(用完) / EXPIRED(过期) / REFUNDED(已退款)
@Schema(description = "状态",example = "ACTIVE")
private MemberCardRecordStatus status;
//剩余次数
@Schema(description = "剩余次数",example = "1")
private Integer remainingTimes;
//剩余余额
@Schema(description = "剩余余额",example = "1")
private Double remainingAmount;
//到期时间
@Schema(description = "到期时间",example = "2026-05-10 05:22:47")
private LocalDateTime expireTime;
//购买订单Id
@Schema(description = "购买订单Id",example = "1")
private Long sourceOrderId;
//购买时间
@Schema(description = "购买时间",example = "2026-05-10 05:22:47")
private LocalDateTime purchaseTime;
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/domain/MemberCardTransactions.java
+59
View File
@@ -0,0 +1,59 @@
package cn.novalon.gym.manage.gymmembercard.domain;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 22:47:31
*/
@Schema(description = "会员卡流水")
public class MemberCardTransactions extends BaseDomain {
//会员卡流水Id
@Schema(description = "会员卡流水Id",example = "1")
private Long memberCardTransactionsId;
//会员卡Id
@Schema(description = "会员卡Id",example = "1")
private Long memberCardId;
//会员Id
@Schema(description = "会员Id",example = "1")
private Long memberId;
//操作类型：PURCHASE(购买) / DEDUCT(扣次/扣费) / RENEW(续费) / REFUND(退款) / EXPIRE(过期)
@Schema(description = "操作类型",example = "PURCHASE")
private MemberCardTransactionsAction operationType;
//变动次数（次卡用）
@Schema(description = "变动次数（次卡用）",example = "1")
private Integer changeAmount;
//变动金额（储值卡用）
@Schema(description = "变动金额（储值卡用）",example = "1")
private Double changeBalance;
//变动后剩余次数
@Schema(description = "变动后剩余次数",example = "1")
private Integer afterRemainingCount;
//变动后剩余金额
@Schema(description = "变动后剩余金额",example = "500.0")
private Double afterRemainingBalance;
//关联业务类型
@Schema(description = "关联业务类型",example = "GROUP_CLASS")
private MemberCardTransactionsType relatedBizType;
//备注
@Schema(description = "备注",example = "预约团课：瑜伽课扣1次")
private String remark;
//创建时间
@Schema(description = "创建时间",example = "2026-05-10 05:22:47")
private LocalDateTime createdAt;
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/entity/MemberCardEntity.java
+52
View File
@@ -0,0 +1,52 @@
package cn.novalon.gym.manage.gymmembercard.entity;
import cn.novalon.gym.manage.db.entity.BaseEntity;
import lombok.Data;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;
import java.time.LocalDateTime;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 22:47:31
*/
@Data
@Table("member_card")
public class MemberCardEntity extends BaseEntity {
//会员卡id
@Column("member_card_id")
private Long memberCardId;
//会员卡名称
@Column("member_card_name")
private String memberCardName;
//会员卡类型
@Column("member_card_type")
private String memberCardType;
//会员卡价格
@Column("member_card_price")
private Double memberCardPrice;
//会员卡有效天数（时长卡用）
@Column("member_card_validity_days")
private Integer memberCardValidityDays;
//会员卡总次数（次卡用）
@Column("member_card_total_times")
private Integer memberCardTotalTimes;
//会员卡面额（储值卡用）
@Column("member_card_amount")
private Double memberCardAmount;
//会员卡状态：0-正常，1-禁用
@Column("member_card_status")
private Integer memberCardStatus;
//会员卡创建时间
@Column("member_card_create_time")
private LocalDateTime memberCardCreateTime;
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/entity/MemberCardRecordEntity.java
+53
View File
@@ -0,0 +1,53 @@
package cn.novalon.gym.manage.gymmembercard.entity;
import cn.novalon.gym.manage.db.entity.BaseEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import lombok.Data;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;
import java.time.LocalDateTime;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 22:47:31
*/
@Data
@Table("member_card_record")
public class MemberCardRecordEntity extends BaseEntity {
//会员持有卡id
@Column("member_card_record_id")
private Long memberCardRecordId;
//会员Id
@Column("member_id")
private Long memberId;
//关联会员卡Id
@Column("member_card_id")
private Long memberCardId;
//状态：ACTIVE(有效) / USED_UP(用完) / EXPIRED(过期) / REFUNDED(已退款)
@Column("status")
private MemberCardRecordStatus status;
//剩余次数
@Column("remaining_times")
private Integer remainingTimes;
//剩余余额
@Column("remaining_amount")
private Double remainingAmount;
//到期时间
@Column("expire_time")
private LocalDateTime expireTime;
//购买订单Id
@Column("source_order_id")
private Long sourceOrderId;
//购买时间
@Column("purchase_time")
private LocalDateTime purchaseTime;
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/entity/MemberCardTransactionsEntity.java
+62
View File
@@ -0,0 +1,62 @@
package cn.novalon.gym.manage.gymmembercard.entity;
import cn.novalon.gym.manage.db.entity.BaseEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsType;
import lombok.Data;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;
import java.time.LocalDateTime;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 22:47:31
*/
@Data
@Table("member_card_transactions")
public class MemberCardTransactionsEntity extends BaseEntity {
//会员卡流水Id
@Column("member_card_transactions_id")
private Long memberCardTransactionsId;
//会员卡Id
@Column("member_card_id")
private Long memberCardId;
//会员Id
@Column("member_id")
private Long memberId;
//操作类型：PURCHASE(购买) / DEDUCT(扣次/扣费) / RENEW(续费) / REFUND(退款) / EXPIRE(过期)
@Column("operation_type")
private MemberCardTransactionsAction operationType;
//变动次数（次卡用）
@Column("change_amount")
private Integer changeAmount;
//变动金额（储值卡用）
@Column("change_balance")
private Double changeBalance;
//变动后剩余次数
@Column("after_remaining_count")
private Integer afterRemainingCount;
//变动后剩余金额
@Column("after_remaining_balance")
private Double afterRemainingBalance;
//关联业务类型
@Column("related_biz_type")
private MemberCardTransactionsType relatedBizType;
//备注
@Column("remark")
private String remark;
//创建时间
@Column("created_at")
private LocalDateTime createdAt;
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/enums/MemberCardRecordStatus.java
+36
View File
@@ -0,0 +1,36 @@
package cn.novalon.gym.manage.gymmembercard.enums;
import io.swagger.v3.oas.annotations.media.Schema;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 23:59:29
*/
@Schema(description = "会员卡状态枚举")
public enum MemberCardRecordStatus {
//有效
@Schema(description = "有效")
ACTIVE("有效"),
//用完
@Schema(description = "用完")
USED_UP("用完"),
//过期
@Schema(description = "过期")
EXPIRED("过期"),
//已退款
@Schema(description = "已退款")
REFUNDED("已退款");
private final String desc;
MemberCardRecordStatus(String desc) {
this.desc = desc;
}
public String getDesc() {
return desc;
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/enums/MemberCardTransactionsAction.java
+40
View File
@@ -0,0 +1,40 @@
package cn.novalon.gym.manage.gymmembercard.enums;
import io.swagger.v3.oas.annotations.media.Schema;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 23:59:29
*/
@Schema(description = "会员卡流水操作枚举")
public enum MemberCardTransactionsAction {
//购买
@Schema(description = "购买")
PURCHASE("购买"),
//扣次/扣费
@Schema(description = "扣次/扣费")
DEDUCT("扣次/扣费"),
//续费
@Schema(description = "续费")
RENEW("续费"),
//退款
@Schema(description = "退款")
REFUND("退款"),
//过期
@Schema(description = "过期")
EXPIRE("过期");
private final String desc;
MemberCardTransactionsAction(String desc) {
this.desc = desc;
}
public String getDesc() {
return desc;
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/enums/MemberCardTransactionsType.java
+32
View File
@@ -0,0 +1,32 @@
package cn.novalon.gym.manage.gymmembercard.enums;
import io.swagger.v3.oas.annotations.media.Schema;
/*
*@Author:shizhounian
*@Date:2026/5/10-05 23:59:29
*/
@Schema(description = "会员卡流水关联业务类型枚举")
public enum MemberCardTransactionsType {
//团课
@Schema(description = "团课")
GROUP_CLASS("团课"),
//私教
@Schema(description = "私教")
PT_CLASS("私教"),
//签到
@Schema(description = "签到")
CHECK_IN("签到");
private final String desc;
MemberCardTransactionsType(String desc) {
this.desc = desc;
}
public String getDesc() {
return desc;
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/handler/MemberCardHandler.java
+114
View File
@@ -0,0 +1,114 @@
package cn.novalon.gym.manage.gymmembercard.handler;
import cn.hutool.db.PageResult;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Validator;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.List;
/*
*@Author:shizhounian
*@Date:2026/5/17-05 20:10:22
*/
@Component
@Tag(name = "会员卡类型管理", description = "会员卡类型相关操作")
public class MemberCardHandler {
private final IMemberCardService memberCardService;
private final Validator validator;
public MemberCardHandler(IMemberCardService memberCardService, Validator validator) {
this.memberCardService = memberCardService;
this.validator = validator;
}
/**
* 根据会员卡ID查询会员卡详情
*/
@Operation(summary = "根据会员卡ID查询会员卡详情", description = "用于编辑前回显或小程序端展示")
public Mono<ServerResponse> getMemberCardById(ServerRequest request) {
Long memberCardId = Long.parseLong(request.pathVariable("memberCardId"));
return memberCardService.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
.flatMap(card -> ServerResponse.ok().bodyValue(card))
.switchIfEmpty(ServerResponse.notFound().build());
}
/**
* 条件查询会员卡列表（分页）
*/
@Operation(summary = "条件查询会员卡列表", description = "后台卡种列表展示，支持多条件组合+分页+排序")
public Mono<ServerResponse> getMemberCardList(ServerRequest request) {
Integer status = request.queryParam("status").map(Integer::parseInt).orElse(null);
String name = request.queryParam("name").orElse(null);
String type = request.queryParam("type").orElse(null);
Double minPrice = request.queryParam("minPrice").map(Double::parseDouble).orElse(null);
Double maxPrice = request.queryParam("maxPrice").map(Double::parseDouble).orElse(null);
int page = request.queryParam("page").map(Integer::parseInt).orElse(0);
int size = request.queryParam("size").map(Integer::parseInt).orElse(10);
String sortField = request.queryParam("sortField").orElse("created_at");
String sortOrder = request.queryParam("sortOrder").orElse("DESC");
Pageable pageable = PageRequest.of(page, size, Sort.by(Sort.Direction.fromString(sortOrder), sortField));
Mono<Long> countMono = memberCardService.countWithConditions(status, name, type, minPrice, maxPrice);
Flux<MemberCard> cardsFlux = memberCardService.findWithConditions(status, name, type, minPrice, maxPrice, pageable);
return Mono.zip(countMono, cardsFlux.collectList())
.flatMap(tuple -> {
long total = tuple.getT1();
List<MemberCard> list = tuple.getT2();
// 使用 PageResult(int page, int pageSize, int total) 构造，
// 它会自动计算 totalPage
PageResult<MemberCard> result = new PageResult<>(page, size, (int) total);
result.addAll(list); // 将查询结果填充进去
return ServerResponse.ok().bodyValue(result);
});
}
/**
* 保存卡种信息（新增或更新）
*/
@Operation(summary = "保存卡种信息", description = "新增或更新会员卡类型")
public Mono<ServerResponse> saveMemberCard(ServerRequest request) {
return request.bodyToMono(MemberCard.class)
.flatMap(memberCardService::save)
.flatMap(card -> ServerResponse.ok().bodyValue(card));
}
/**
* 逻辑删除会员卡（下架）
*/
@Operation(summary = "逻辑删除会员卡", description = "下架卡种，防止已购会员数据异常")
public Mono<ServerResponse> deleteMemberCard(ServerRequest request) {
Long memberCardId = Long.parseLong(request.pathVariable("memberCardId"));
return memberCardService.logicalDelete(memberCardId)
.flatMap(rows -> {
if (rows > 0) {
return ServerResponse.noContent().build();
} else {
return ServerResponse.notFound().build();
}
});
}
/**
* 批量查询上架的会员卡
*/
@Operation(summary = "批量查询上架的会员卡", description = "用于小程序端展示")
public Mono<ServerResponse> getActiveCards(ServerRequest request) {
Integer status = request.queryParam("status").map(Integer::parseInt).orElse(0);
return ServerResponse.ok().body(memberCardService.findActiveCards(status), MemberCard.class);
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/handler/MemberCardRecordHandler.java
+179
View File
@@ -0,0 +1,179 @@
package cn.novalon.gym.manage.gymmembercard.handler;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardRecordService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Validator;
import lombok.Data;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
/*
*@Author:shizhounian
*@Date:2026/5/17-05 20:10:22
*/
@Component
@Tag(name = "会员卡记录管理", description = "会员卡记录相关操作")
public class MemberCardRecordHandler {
private final IMemberCardRecordService memberCardRecordService;
private final Validator validator;
public MemberCardRecordHandler(IMemberCardRecordService memberCardRecordService, Validator validator) {
this.memberCardRecordService = memberCardRecordService;
this.validator = validator;
}
/**
* 会员购卡/后台发卡
*/
@Operation(summary = "会员购卡/后台发卡", description = "支付成功后插入一条记录，状态为ACTIVE")
public Mono<ServerResponse> insertActiveRecord(ServerRequest request) {
return request.bodyToMono(MemberCardRecord.class)
.flatMap(memberCardRecordService::insertActiveRecord)
.flatMap(record -> ServerResponse.ok().bodyValue(record));
}
/**
* 扣次/扣费
*/
@Operation(summary = "扣次/扣费", description = "预约团课或私教成功后扣减次数或余额")
public Mono<ServerResponse> deductUsage(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("id"));
return request.bodyToMono(DeductRequest.class)
.flatMap(body -> memberCardRecordService.deductUsage(recordId,
body.getDeductTimes(),
body.getDeductAmount()))
.flatMap(rows -> {
if (rows > 0) {
return ServerResponse.ok().build();
} else {
return ServerResponse.badRequest().bodyValue("余额不足或卡无效");
}
});
}
/**
* 续费
*/
@Operation(summary = "续费", description = "累加剩余次数/余额，顺延到期日期")
public Mono<ServerResponse> renewCard(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("id"));
return request.bodyToMono(RenewRequest.class)
.flatMap(body -> memberCardRecordService.renewCard(recordId,
body.getAddTimes(),
body.getAddAmount(),
body.getNewExpireTime()))
.flatMap(rows -> {
if (rows > 0) {
return ServerResponse.ok().build();
} else {
return ServerResponse.notFound().build();
}
});
}
/**
* 状态变更（过期、退款）
*/
@Operation(summary = "状态变更", description = "将卡状态改为EXPIRED或REFUNDED")
public Mono<ServerResponse> updateStatus(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("id"));
return request.queryParam("status")
.map(s -> {
try {
return MemberCardRecordStatus.valueOf(s.toUpperCase());
} catch (IllegalArgumentException e) {
return null;
}
})
.map(status -> memberCardRecordService.updateStatus(recordId, status)
.flatMap(rows -> {
if (rows > 0) {
return ServerResponse.ok().build();
} else {
return ServerResponse.notFound().build();
}
}))
.orElse(ServerResponse.badRequest().bodyValue("status 参数缺失或无效"));
}
/**
* 会员端“我的卡包”
*/
@Operation(summary = "会员我的卡包", description = "查询当前登录会员的所有有效卡")
public Mono<ServerResponse> getMyCards(ServerRequest request) {
Long memberId = Long.parseLong(request.pathVariable("memberId"));
return ServerResponse.ok().body(memberCardRecordService.findActiveCardsByMemberId(memberId),
MemberCardRecord.class);
}
/**
* 前台/店长查会员卡（分页）
*/
@Operation(summary = "管理端查询会员卡", description = "按会员ID分页查询所有会员卡记录")
public Mono<ServerResponse> getMemberCardRecords(ServerRequest request) {
Long memberId = Long.parseLong(request.pathVariable("memberId"));
int page = request.queryParam("page").map(Integer::parseInt).orElse(0);
int size = request.queryParam("size").map(Integer::parseInt).orElse(10);
Pageable pageable = PageRequest.of(page, size, Sort.by("purchase_time").descending());
return ServerResponse.ok().body(memberCardRecordService.findByMemberId(memberId, pageable),
MemberCardRecord.class);
}
/**
* 验证次卡是否可用
*/
@Operation(summary = "验证次卡", description = "校验次卡剩余次数是否足够")
public Mono<ServerResponse> validateCountCard(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("id"));
Integer requiredTimes = request.queryParam("times").map(Integer::parseInt).orElse(1);
return memberCardRecordService.validateCountCard(recordId, requiredTimes)
.flatMap(card -> ServerResponse.ok().bodyValue(card))
.switchIfEmpty(ServerResponse.badRequest().bodyValue("次卡不可用"));
}
/**
* 验证储值卡是否可用
*/
@Operation(summary = "验证储值卡", description = "校验储值卡余额是否足够")
public Mono<ServerResponse> validateStoredCard(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("id"));
Double requiredAmount = request.queryParam("amount").map(Double::parseDouble).orElse(0.0);
return memberCardRecordService.validateStoredCard(recordId, requiredAmount)
.flatMap(card -> ServerResponse.ok().bodyValue(card))
.switchIfEmpty(ServerResponse.badRequest().bodyValue("储值卡不可用"));
}
/**
* 到期扫描（管理端触发）
*/
@Operation(summary = "到期扫描", description = "扫描并返回已过期的会员卡（最多500条）")
public Mono<ServerResponse> getExpiredCards(ServerRequest request) {
return ServerResponse.ok().body(memberCardRecordService.findExpiredCards(), MemberCardRecord.class);
}
// ==================== 内部请求体 DTO ====================
@Data
public static class DeductRequest {
private Integer deductTimes;
private Double deductAmount;
}
@Data
public static class RenewRequest {
private Integer addTimes;
private Double addAmount;
private LocalDateTime newExpireTime;
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/handler/MemberCardTransactionHandler.java
+150
View File
@@ -0,0 +1,150 @@
package cn.novalon.gym.manage.gymmembercard.handler;
import cn.hutool.db.PageResult;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardTransactionsService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Validator;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
import java.util.List;
/*
*@Author:shizhounian
*@Date:2026/5/17-05 20:10:22
*/
@Component
@Tag(name = "会员卡流水管理", description = "会员卡流水相关操作")
public class MemberCardTransactionHandler {
private final IMemberCardTransactionsService memberCardTransactionsService;
private final Validator validator;
public MemberCardTransactionHandler(IMemberCardTransactionsService memberCardTransactionsService,
Validator validator) {
this.memberCardTransactionsService = memberCardTransactionsService;
this.validator = validator;
}
/**
* 记录每一次变动
*/
@Operation(summary = "插入流水记录", description = "购卡、扣次、续费、退款、过期时插入流水")
public Mono<ServerResponse> insertTransaction(ServerRequest request) {
return request.bodyToMono(MemberCardTransactions.class)
.flatMap(memberCardTransactionsService::insertTransaction)
.flatMap(record -> ServerResponse.ok().bodyValue(record));
}
/**
* 会员端"使用记录"
*/
@Operation(summary = "会员查询使用记录", description = "按会员ID和时间范围查询流水，支持分页")
public Mono<ServerResponse> getMemberTransactions(ServerRequest request) {
Long memberId = Long.parseLong(request.pathVariable("memberId"));
LocalDateTime startTime = request.queryParam("startTime")
.map(LocalDateTime::parse).orElse(LocalDateTime.now().minusMonths(1));
LocalDateTime endTime = request.queryParam("endTime")
.map(LocalDateTime::parse).orElse(LocalDateTime.now());
int page = request.queryParam("page").map(Integer::parseInt).orElse(0);
int size = request.queryParam("size").map(Integer::parseInt).orElse(10);
Pageable pageable = PageRequest.of(page, size, Sort.by("created_at").descending());
return ServerResponse.ok()
.body(memberCardTransactionsService.findByMemberIdAndTimeRange(
memberId, startTime, endTime, pageable), MemberCardTransactions.class);
}
/**
* 后台"使用记录查询"（条件分页）
*/
@Operation(summary = "管理端流水查询", description = "按会员、卡号、操作类型、时间等条件分页查询流水")
public Mono<ServerResponse> getTransactionsWithConditions(ServerRequest request) {
Long memberId = request.queryParam("memberId").map(Long::parseLong).orElse(null);
Long memberCardId = request.queryParam("memberCardId").map(Long::parseLong).orElse(null);
MemberCardTransactionsAction operationType = request.queryParam("operationType")
.map(s -> MemberCardTransactionsAction.valueOf(s.toUpperCase())).orElse(null);
LocalDateTime startTime = request.queryParam("startTime").map(LocalDateTime::parse).orElse(null);
LocalDateTime endTime = request.queryParam("endTime").map(LocalDateTime::parse).orElse(null);
int page = request.queryParam("page").map(Integer::parseInt).orElse(0);
int size = request.queryParam("size").map(Integer::parseInt).orElse(10);
Pageable pageable = PageRequest.of(page, size, Sort.by("created_at").descending());
Mono<Long> countMono = memberCardTransactionsService.countWithConditions(
memberId, memberCardId, operationType, startTime, endTime);
Flux<MemberCardTransactions> flux = memberCardTransactionsService.findWithConditions(
memberId, memberCardId, operationType, startTime, endTime, pageable);
return Mono.zip(countMono, flux.collectList())
.flatMap(tuple -> {
Long total = tuple.getT1();
List<MemberCardTransactions> list = tuple.getT2();
// 构造 PageResult，内部自动计算总页数
PageResult<MemberCardTransactions> result = new PageResult<>(page, size, total.intValue());
result.addAll(list);
return ServerResponse.ok().bodyValue(result);
});
}
/**
* 按卡ID查询流水
*/
@Operation(summary = "按卡ID查询流水", description = "查看某张卡的所有流水记录")
public Mono<ServerResponse> getTransactionsByCardId(ServerRequest request) {
Long memberCardId = Long.parseLong(request.pathVariable("cardId"));
return ServerResponse.ok()
.body(memberCardTransactionsService.findByMemberCardId(memberCardId),
MemberCardTransactions.class);
}
/**
* 统计某卡种的总扣次数
*/
@Operation(summary = "统计卡种总扣次数", description = "按卡种ID和时间范围统计扣次总数")
public Mono<ServerResponse> getDeductCountByCardId(ServerRequest request) {
Long memberCardId = Long.parseLong(request.pathVariable("cardId"));
LocalDateTime startTime = request.queryParam("startTime")
.map(LocalDateTime::parse).orElse(LocalDateTime.now().minusMonths(1));
LocalDateTime endTime = request.queryParam("endTime")
.map(LocalDateTime::parse).orElse(LocalDateTime.now());
return memberCardTransactionsService.sumDeductCountByCardId(memberCardId, startTime, endTime)
.flatMap(count -> ServerResponse.ok().bodyValue(count));
}
/**
* 统计某时间段的续费总金额
*/
@Operation(summary = "统计续费总金额", description = "按时间段统计续费总金额")
public Mono<ServerResponse> getRenewAmountByTimeRange(ServerRequest request) {
LocalDateTime startTime = request.queryParam("startTime")
.map(LocalDateTime::parse).orElse(LocalDateTime.now().minusMonths(1));
LocalDateTime endTime = request.queryParam("endTime")
.map(LocalDateTime::parse).orElse(LocalDateTime.now());
return memberCardTransactionsService.sumRenewAmountByTimeRange(startTime, endTime)
.flatMap(amount -> ServerResponse.ok().bodyValue(amount));
}
/**
* 统计某会员的购卡总金额
*/
@Operation(summary = "统计会员购卡总金额", description = "按会员ID和时间段统计购卡总金额")
public Mono<ServerResponse> getPurchaseAmountByMember(ServerRequest request) {
Long memberId = Long.parseLong(request.pathVariable("memberId"));
LocalDateTime startTime = request.queryParam("startTime")
.map(LocalDateTime::parse).orElse(LocalDateTime.now().minusMonths(1));
LocalDateTime endTime = request.queryParam("endTime")
.map(LocalDateTime::parse).orElse(LocalDateTime.now());
return memberCardTransactionsService.sumPurchaseAmountByMemberId(memberId, startTime, endTime)
.flatMap(amount -> ServerResponse.ok().bodyValue(amount));
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/IMemberCardRecordRepository.java
+83
View File
@@ -0,0 +1,83 @@
package cn.novalon.gym.manage.gymmembercard.repository;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
public interface IMemberCardRecordRepository {
/**
* 会员购卡/后台发卡
* @param record 会员卡记录
* @return 插入的记录
*/
Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
/**
* 扣次/扣费（含防超扣校验）
* @param recordId 会员卡记录ID
* @param deductTimes 扣除次数
* @param deductAmount 扣除金额
* @return 受影响的行数（0表示余额不足，扣费失败）
*/
Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
/**
* 续费
* @param recordId 会员卡记录ID
* @param addTimes 增加次数
* @param addAmount 增加金额
* @param newExpireTime 新的到期时间
* @return 受影响的行数
*/
Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime);
/**
* 状态变更
* @param recordId 会员卡记录ID
* @param status 新状态
* @return 受影响的行数
*/
Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status);
/**
* 会员端"我的卡包"
* @param memberId 会员ID
* @return 有效会员卡列表
*/
Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
/**
* 前台/店长查会员卡
* @param memberId 会员ID
* @param pageable 分页参数
* @return 会员卡列表
*/
Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
/**
* 验证次卡是否可用（仅检验次数和过期时间）
* @param recordId 会员卡记录ID
* @param requiredTimes 需要的次数
* @return 符合条件的记录，空表示不可用
*/
Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
/**
* 验证储值卡是否可用（仅检验余额和过期时间）
* @param recordId 会员卡记录ID
* @param requiredAmount 需要的金额
* @return 符合条件的记录，空表示不可用
*/
Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
/**
* 到期扫描（分批处理，避免内存压力）
* @return 已过期的会员卡记录列表（最多500条）
*/
Flux<MemberCardRecord> findExpiredCards();
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/IMemberCardRepository.java
+78
View File
@@ -0,0 +1,78 @@
package cn.novalon.gym.manage.gymmembercard.repository;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public interface IMemberCardRepository {
/**
* 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
* @param memberCardId 会员卡ID
* @return 会员卡完整信息，如果不存在或已删除则返回空
*/
Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
/**
* 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
* @param status 会员卡状态（上架/下架）
* @param name 会员卡名称（模糊查询）
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
Flux<MemberCard> findWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice, Pageable pageable);
/**
* 统计符合条件的会员卡总数（配合列表查询使用）
* @param status 会员卡状态
* @param name 会员卡名称（模糊查询）
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @return 符合条件的会员卡数量
*/
Mono<Long> countWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice);
/**
* 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
* @param status 会员卡状态（通常传上架状态）
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
/**
* 检查会员卡是否已被购买（用于删除前的校验）
* @param memberCardId 会员卡ID
* @return 如果存在关联的会员记录则返回true，否则返回false
*/
Mono<Boolean> existsPurchasedRecord(Long memberCardId);
/**
* 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
* @param memberCardId 会员卡ID
* @return 受影响的行数
*/
Mono<Integer> logicalDelete(Long memberCardId);
/**
* 保存卡种信息（新增或更新）
* - 新增：entity.memberCardId 为 null 时，插入新记录
* - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
* @param entity 卡种信息
* @return 保存后的实体对象
*/
Mono<MemberCard> save(MemberCard entity);
/**
* 批量查询上架的会员卡（用于小程序端展示）
* @param status 上架状态值
* @return 上架的会员卡列表
*/
Flux<MemberCard> findActiveCards(Integer status);
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/IMemberCardTransactionsRepository.java
+91
View File
@@ -0,0 +1,91 @@
package cn.novalon.gym.manage.gymmembercard.repository;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
public interface IMemberCardTransactionsRepository {
/**
* 记录每一次变动
* @param transactions 流水记录
* @return 插入的流水记录
*/
Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions);
/**
* 会员端"使用记录"
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
LocalDateTime endTime, Pageable pageable);
/**
* 后台"使用记录查询"
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime,
Pageable pageable);
/**
* 统计符合条件的流水总数
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @return 流水记录数量
*/
Mono<Long> countWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime);
/**
* 按会员卡ID查询所有流水记录
* @param memberCardId 会员卡ID
* @return 该卡的所有流水记录，按时间倒序
*/
Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId);
/**
* 数据统计 - 统计某卡种的总扣次数
* @param memberCardId 会员卡ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 总扣次数
*/
Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime);
/**
* 数据统计 - 统计某时间段的续费总金额
* @param startTime 开始时间
* @param endTime 结束时间
* @return 续费总金额
*/
Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
/**
* 数据统计 - 统计某会员的购卡总金额
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 购卡总金额
*/
Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/impl/MemberCardRecordRepositoryImpl.java
+141
View File
@@ -0,0 +1,141 @@
package cn.novalon.gym.manage.gymmembercard.repository.impl;
import cn.novalon.gym.manage.gymmembercard.dao.MemberCardRecordDao;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardRecordEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Repository
public class MemberCardRecordRepositoryImpl implements IMemberCardRecordRepository {
private final MemberCardRecordDao memberCardRecordDao;
private final BeanConvertUtil beanConvertUtil;
private final R2dbcEntityTemplate r2dbcEntityTemplate;
public MemberCardRecordRepositoryImpl(MemberCardRecordDao memberCardRecordDao,
BeanConvertUtil beanConvertUtil,
R2dbcEntityTemplate r2dbcEntityTemplate) {
this.memberCardRecordDao = memberCardRecordDao;
this.beanConvertUtil = beanConvertUtil;
this.r2dbcEntityTemplate = r2dbcEntityTemplate;
}
/**
* 会员购卡/后台发卡
* @param record 会员卡记录
* @return 插入的记录
*/
@Override
public Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record) {
MemberCardRecordEntity entity = BeanConvertUtil.toBean(record, MemberCardRecordEntity.class);
return memberCardRecordDao.insertActiveRecord(
entity.getMemberId(),
entity.getMemberCardId(),
entity.getExpireTime(),
entity.getRemainingTimes(),
entity.getRemainingAmount(),
entity.getSourceOrderId())
.map(e -> beanConvertUtil.toBean(e, MemberCardRecord.class));
}
/**
* 扣次/扣费（含防超扣校验）
* @param recordId 会员卡记录ID
* @param deductTimes 扣除次数
* @param deductAmount 扣除金额
* @return 受影响的行数（0表示余额不足，扣费失败）
*/
@Override
public Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount) {
return memberCardRecordDao.deductUsage(recordId, deductTimes, deductAmount);
}
/**
* 续费
* @param recordId 会员卡记录ID
* @param addTimes 增加次数
* @param addAmount 增加金额
* @param newExpireTime 新的到期时间
* @return 受影响的行数
*/
@Override
public Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime) {
return memberCardRecordDao.renewCard(recordId, addTimes, addAmount, newExpireTime);
}
/**
* 状态变更
* @param recordId 会员卡记录ID
* @param status 新状态
* @return 受影响的行数
*/
@Override
public Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status) {
return memberCardRecordDao.updateStatus(recordId, status);
}
/**
* 会员端"我的卡包"
* @param memberId 会员ID
* @return 有效会员卡列表
*/
@Override
public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
return memberCardRecordDao.findActiveCardsByMemberId(memberId)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
}
/**
* 前台/店长查会员卡
* @param memberId 会员ID
* @param pageable 分页参数
* @return 会员卡列表
*/
@Override
public Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable) {
return memberCardRecordDao.findByMemberId(memberId, pageable)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
}
/**
* 验证次卡是否可用（仅检验次数和过期时间）
* @param recordId 会员卡记录ID
* @param requiredTimes 需要的次数
* @return 符合条件的记录，空表示不可用
*/
@Override
public Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes) {
return memberCardRecordDao.validateCountCard(recordId, requiredTimes)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
}
/**
* 验证储值卡是否可用（仅检验余额和过期时间）
* @param recordId 会员卡记录ID
* @param requiredAmount 需要的金额
* @return 符合条件的记录，空表示不可用
*/
@Override
public Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount) {
return memberCardRecordDao.validateStoredCard(recordId, requiredAmount)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
}
/**
* 到期扫描（分批处理，避免内存压力）
* @return 已过期的会员卡记录列表（最多500条）
*/
@Override
public Flux<MemberCardRecord> findExpiredCards() {
return memberCardRecordDao.findExpiredCards()
.map(entity -> beanConvertUtil.toBean(entity, MemberCardRecord.class));
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/impl/MemberCardRepositoryImpl.java
+146
View File
@@ -0,0 +1,146 @@
package cn.novalon.gym.manage.gymmembercard.repository.impl;
import cn.novalon.gym.manage.gymmembercard.dao.MemberCardDao;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardEntity;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRepository;
import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@Repository
public class MemberCardRepositoryImpl implements IMemberCardRepository {
private final MemberCardDao memberCardDao;
private final BeanConvertUtil beanConvertUtil;
private final R2dbcEntityTemplate r2dbcEntityTemplate;
//构造函数,初始化
public MemberCardRepositoryImpl(MemberCardDao memberCardDao, BeanConvertUtil beanConvertUtil, R2dbcEntityTemplate r2dbcEntityTemplate) {
this.memberCardDao = memberCardDao;
this.beanConvertUtil = beanConvertUtil;
this.r2dbcEntityTemplate = r2dbcEntityTemplate;
}
/**
* 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
* @param memberCardId 会员卡ID
* @return 会员卡完整信息，如果不存在或已删除则返回空
*/
@Override
public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
return memberCardDao.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
.map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
}
/**
* 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
* @param status 会员卡状态（上架/下架）
* @param name 会员卡名称（模糊查询）
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
@Override
public Flux<MemberCard> findWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice, Pageable pageable) {
return memberCardDao.findWithConditions(status, name, type, minPrice, maxPrice, pageable)
.map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
}
/**
* 统计符合条件的会员卡总数（配合列表查询使用）
* @param status 会员卡状态
* @param name 会员卡名称（模糊查询）
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @return 符合条件的会员卡数量
*/
@Override
public Mono<Long> countWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice) {
return memberCardDao.countWithConditions(status, name, type, minPrice, maxPrice);
}
/**
* 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
* @param status 会员卡状态（通常传上架状态）
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
@Override
public Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable) {
return memberCardDao.findByMemberCardStatusAndDeletedAtIsNull(status, pageable)
.map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
}
/**
* 检查会员卡是否已被购买（用于删除前的校验）
* @param memberCardId 会员卡ID
* @return 如果存在关联的会员记录则返回true，否则返回false
*/
@Override
public Mono<Boolean> existsPurchasedRecord(Long memberCardId) {
return memberCardDao.existsPurchasedRecord(memberCardId);
}
/**
* 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
* @param memberCardId 会员卡ID
* @return 受影响的行数
*/
@Override
public Mono<Integer> logicalDelete(Long memberCardId) {
return memberCardDao.logicalDelete(memberCardId);
}
/**
* 安全更新会员卡信息（不覆盖不允许修改的字段）
* @param memberCardId 会员卡ID
* @param updateData 需要更新的卡种信息
* @return 受影响的行数
*/
public Mono<Integer> updateSafe(Long memberCardId, MemberCard updateData) {
MemberCardEntity memberCardEntity = beanConvertUtil.toBean(updateData, MemberCardEntity.class);
return memberCardDao.updateSafe(
memberCardId,
memberCardEntity.getMemberCardName(),
memberCardEntity.getMemberCardPrice(),
memberCardEntity.getMemberCardValidityDays(),
memberCardEntity.getMemberCardTotalTimes(),
memberCardEntity.getMemberCardAmount(),
memberCardEntity.getMemberCardStatus()
);
}
/**
* 保存卡种信息（新增或更新）
* - 新增：entity.memberCardId 为 null 时，插入新记录
* - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
* 建议：更新时优先使用 updateSafe 方法避免全字段覆盖
* @param entity 卡种信息
* @return 保存后的实体对象
*/
@Override
public Mono<MemberCard> save(MemberCard entity) {
MemberCardEntity cardEntity = beanConvertUtil.toBean(entity, MemberCardEntity.class);
return memberCardDao.save(cardEntity)
.map(savedEntity -> beanConvertUtil.toBean(savedEntity, MemberCard.class));
}
/**
* 批量查询上架的会员卡（用于小程序端展示）
* @param status 上架状态值
* @return 上架的会员卡列表
*/
@Override
public Flux<MemberCard> findActiveCards(Integer status) {
return memberCardDao.findActiveCards(status)
.map(entity -> beanConvertUtil.toBean(entity, MemberCard.class));
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/repository/impl/MemberCardTransactionsRepositoryImpl.java
+147
View File
@@ -0,0 +1,147 @@
package cn.novalon.gym.manage.gymmembercard.repository.impl;
import cn.novalon.gym.manage.gymmembercard.dao.MemberCardTransactionsDao;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
import cn.novalon.gym.manage.gymmembercard.entity.MemberCardTransactionsEntity;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardTransactionsRepository;
import cn.novalon.gym.manage.gymmembercard.util.BeanConvertUtil;
import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Repository
public class MemberCardTransactionsRepositoryImpl implements IMemberCardTransactionsRepository {
private final MemberCardTransactionsDao memberCardTransactionsDao;
private final BeanConvertUtil beanConvertUtil;
private final R2dbcEntityTemplate r2dbcEntityTemplate;
public MemberCardTransactionsRepositoryImpl(MemberCardTransactionsDao memberCardTransactionsDao, BeanConvertUtil beanConvertUtil, R2dbcEntityTemplate r2dbcEntityTemplate) {
this.memberCardTransactionsDao = memberCardTransactionsDao;
this.beanConvertUtil = beanConvertUtil;
this.r2dbcEntityTemplate = r2dbcEntityTemplate;
}
/**
* 记录每一次变动
* @param transactions 流水记录
* @return 插入的流水记录
*/
@Override
public Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions) {
MemberCardTransactionsEntity entity = beanConvertUtil.toBean(transactions, MemberCardTransactionsEntity.class);
return memberCardTransactionsDao.insertTransaction(
entity.getMemberCardId(),
entity.getMemberId(),
entity.getOperationType(),
entity.getChangeAmount(),
entity.getChangeBalance(),
entity.getAfterRemainingCount(),
entity.getAfterRemainingBalance(),
entity.getRelatedBizType(),
entity.getRemark())
.map(e -> beanConvertUtil.toBean(e, MemberCardTransactions.class));
}
/**
* 会员端"使用记录"
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
@Override
public Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
LocalDateTime endTime, Pageable pageable) {
return memberCardTransactionsDao.findByMemberIdAndTimeRange(memberId, startTime, endTime, pageable)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
}
/**
* 后台"使用记录查询"
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
@Override
public Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime,
Pageable pageable) {
return memberCardTransactionsDao.findWithConditions(memberId, memberCardId, operationType,
startTime, endTime, pageable)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
}
/**
* 统计符合条件的流水总数
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @return 流水记录数量
*/
@Override
public Mono<Long> countWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsDao.countWithConditions(memberId, memberCardId,
operationType, startTime, endTime);
}
/**
* 按会员卡ID查询所有流水记录
* @param memberCardId 会员卡ID
* @return 该卡的所有流水记录，按时间倒序
*/
@Override
public Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId) {
return memberCardTransactionsDao.findByMemberCardId(memberCardId)
.map(entity -> beanConvertUtil.toBean(entity, MemberCardTransactions.class));
}
/**
* 数据统计 - 统计某卡种的总扣次数
* @param memberCardId 会员卡ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 总扣次数
*/
@Override
public Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsDao.sumDeductCountByCardId(memberCardId, startTime, endTime);
}
/**
* 数据统计 - 统计某时间段的续费总金额
* @param startTime 开始时间
* @param endTime 结束时间
* @return 续费总金额
*/
@Override
public Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsDao.sumRenewAmountByTimeRange(startTime, endTime);
}
/**
* 数据统计 - 统计某会员的购卡总金额
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 购卡总金额
*/
@Override
public Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsDao.sumPurchaseAmountByMemberId(memberId, startTime, endTime);
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/IMemberCardRecordService.java
+83
View File
@@ -0,0 +1,83 @@
package cn.novalon.gym.manage.gymmembercard.sevice;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
public interface IMemberCardRecordService {
/**
* 会员购卡/后台发卡
* @param record 会员卡记录
* @return 插入的记录
*/
Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record);
/**
* 扣次/扣费（含防超扣校验）
* @param recordId 会员卡记录ID
* @param deductTimes 扣除次数
* @param deductAmount 扣除金额
* @return 受影响的行数（0表示余额不足，扣费失败）
*/
Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount);
/**
* 续费
* @param recordId 会员卡记录ID
* @param addTimes 增加次数
* @param addAmount 增加金额
* @param newExpireTime 新的到期时间
* @return 受影响的行数
*/
Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime);
/**
* 状态变更
* @param recordId 会员卡记录ID
* @param status 新状态
* @return 受影响的行数
*/
Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status);
/**
* 会员端"我的卡包"
* @param memberId 会员ID
* @return 有效会员卡列表
*/
Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
/**
* 前台/店长查会员卡
* @param memberId 会员ID
* @param pageable 分页参数
* @return 会员卡列表
*/
Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable);
/**
* 验证次卡是否可用（仅检验次数和过期时间）
* @param recordId 会员卡记录ID
* @param requiredTimes 需要的次数
* @return 符合条件的记录，空表示不可用
*/
Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes);
/**
* 验证储值卡是否可用（仅检验余额和过期时间）
* @param recordId 会员卡记录ID
* @param requiredAmount 需要的金额
* @return 符合条件的记录，空表示不可用
*/
Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
/**
* 到期扫描（分批处理，避免内存压力）
* @return 已过期的会员卡记录列表（最多500条）
*/
Flux<MemberCardRecord> findExpiredCards();
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/IMemberCardService.java
+78
View File
@@ -0,0 +1,78 @@
package cn.novalon.gym.manage.gymmembercard.sevice;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public interface IMemberCardService {
/**
* 根据会员卡ID查询会员卡详情（用于编辑前回显或小程序端展示）
* @param memberCardId 会员卡ID
* @return 会员卡完整信息，如果不存在或已删除则返回空
*/
Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
/**
* 条件查询会员卡列表（后台卡种列表展示，支持多条件组合+分页+排序）
* @param status 会员卡状态（上架/下架）
* @param name 会员卡名称（模糊查询）
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
Flux<MemberCard> findWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice, Pageable pageable);
/**
* 统计符合条件的会员卡总数（配合列表查询使用）
* @param status 会员卡状态
* @param name 会员卡名称（模糊查询）
* @param type 会员卡类型
* @param minPrice 最低价格
* @param maxPrice 最高价格
* @return 符合条件的会员卡数量
*/
Mono<Long> countWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice);
/**
* 按状态查询会员卡列表（用于小程序端展示可购买卡列表，只展示上架的卡）
* @param status 会员卡状态（通常传上架状态）
* @param pageable 分页和排序参数
* @return 符合条件的会员卡列表
*/
Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable);
/**
* 检查会员卡是否已被购买（用于删除前的校验）
* @param memberCardId 会员卡ID
* @return 如果存在关联的会员记录则返回true，否则返回false
*/
Mono<Boolean> existsPurchasedRecord(Long memberCardId);
/**
* 逻辑删除会员卡（下架卡种，防止已购会员数据异常）
* @param memberCardId 会员卡ID
* @return 受影响的行数
*/
Mono<Integer> logicalDelete(Long memberCardId);
/**
* 保存卡种信息（新增或更新）
* - 新增：entity.memberCardId 为 null 时，插入新记录
* - 更新：entity.memberCardId 不为 null 时，根据ID更新现有记录
* @param entity 卡种信息
* @return 保存后的实体对象
*/
Mono<MemberCard> save(MemberCard entity);
/**
* 批量查询上架的会员卡（用于小程序端展示）
* @param status 上架状态值
* @return 上架的会员卡列表
*/
Flux<MemberCard> findActiveCards(Integer status);
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/IMemberCardTransactionsService.java
+91
View File
@@ -0,0 +1,91 @@
package cn.novalon.gym.manage.gymmembercard.sevice;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
public interface IMemberCardTransactionsService {
/**
* 记录每一次变动
* @param transactions 流水记录
* @return 插入的流水记录
*/
Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions);
/**
* 会员端"使用记录"
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
LocalDateTime endTime, Pageable pageable);
/**
* 后台"使用记录查询"
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageable 分页参数
* @return 流水记录列表
*/
Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime,
Pageable pageable);
/**
* 统计符合条件的流水总数
* @param memberId 会员ID
* @param memberCardId 会员卡ID
* @param operationType 操作类型
* @param startTime 开始时间
* @param endTime 结束时间
* @return 流水记录数量
*/
Mono<Long> countWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime);
/**
* 按会员卡ID查询所有流水记录
* @param memberCardId 会员卡ID
* @return 该卡的所有流水记录，按时间倒序
*/
Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId);
/**
* 数据统计 - 统计某卡种的总扣次数
* @param memberCardId 会员卡ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 总扣次数
*/
Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime);
/**
* 数据统计 - 统计某时间段的续费总金额
* @param startTime 开始时间
* @param endTime 结束时间
* @return 续费总金额
*/
Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
/**
* 数据统计 - 统计某会员的购卡总金额
* @param memberId 会员ID
* @param startTime 开始时间
* @param endTime 结束时间
* @return 购卡总金额
*/
Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/MemberCardRecordServiceImpl.java
+67
View File
@@ -0,0 +1,67 @@
package cn.novalon.gym.manage.gymmembercard.sevice.impl;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardRecord;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardRecordStatus;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRecordRepository;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardRecordService;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Service
public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
private final IMemberCardRecordRepository memberCardRecordRepository;
public MemberCardRecordServiceImpl(IMemberCardRecordRepository memberCardRecordRepository) {
this.memberCardRecordRepository = memberCardRecordRepository;
}
@Override
public Mono<MemberCardRecord> insertActiveRecord(MemberCardRecord record) {
return memberCardRecordRepository.insertActiveRecord(record);
}
@Override
public Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount) {
return memberCardRecordRepository.deductUsage(recordId, deductTimes, deductAmount);
}
@Override
public Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime) {
return memberCardRecordRepository.renewCard(recordId, addTimes, addAmount, newExpireTime);
}
@Override
public Mono<Integer> updateStatus(Long recordId, MemberCardRecordStatus status) {
return memberCardRecordRepository.updateStatus(recordId, status);
}
@Override
public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
return memberCardRecordRepository.findActiveCardsByMemberId(memberId);
}
@Override
public Flux<MemberCardRecord> findByMemberId(Long memberId, Pageable pageable) {
return memberCardRecordRepository.findByMemberId(memberId, pageable);
}
@Override
public Mono<MemberCardRecord> validateCountCard(Long recordId, Integer requiredTimes) {
return memberCardRecordRepository.validateCountCard(recordId, requiredTimes);
}
@Override
public Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount) {
return memberCardRecordRepository.validateStoredCard(recordId, requiredAmount);
}
@Override
public Flux<MemberCardRecord> findExpiredCards() {
return memberCardRecordRepository.findExpiredCards();
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/MemberCardServiceImpl.java
+65
View File
@@ -0,0 +1,65 @@
package cn.novalon.gym.manage.gymmembercard.sevice.impl;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCard;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardRepository;
import cn.novalon.gym.manage.gymmembercard.repository.impl.MemberCardRepositoryImpl;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardService;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@Service
public class MemberCardServiceImpl implements IMemberCardService {
private final IMemberCardRepository memberCardRepository;
public MemberCardServiceImpl(IMemberCardRepository memberCardRepository) {
this.memberCardRepository = memberCardRepository;
}
@Override
public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId);
}
@Override
public Flux<MemberCard> findWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice, Pageable pageable) {
return memberCardRepository.findWithConditions(status, name, type, minPrice, maxPrice, pageable);
}
@Override
public Mono<Long> countWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice) {
return memberCardRepository.countWithConditions(status, name, type, minPrice, maxPrice);
}
@Override
public Flux<MemberCard> findByMemberCardStatusAndDeletedAtIsNull(Integer status, Pageable pageable) {
return memberCardRepository.findByMemberCardStatusAndDeletedAtIsNull(status, pageable);
}
@Override
public Mono<Boolean> existsPurchasedRecord(Long memberCardId) {
return memberCardRepository.existsPurchasedRecord(memberCardId);
}
@Override
public Mono<Integer> logicalDelete(Long memberCardId) {
return memberCardRepository.logicalDelete(memberCardId);
}
public Mono<Integer> updateSafe(Long memberCardId, MemberCard updateData) {
return ((MemberCardRepositoryImpl) memberCardRepository).updateSafe(memberCardId, updateData);
}
@Override
public Mono<MemberCard> save(MemberCard entity) {
return memberCardRepository.save(entity);
}
@Override
public Flux<MemberCard> findActiveCards(Integer status) {
return memberCardRepository.findActiveCards(status);
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/sevice/impl/MemberCardTransactionsServiceImpl.java
+69
View File
@@ -0,0 +1,69 @@
package cn.novalon.gym.manage.gymmembercard.sevice.impl;
import cn.novalon.gym.manage.gymmembercard.domain.MemberCardTransactions;
import cn.novalon.gym.manage.gymmembercard.enums.MemberCardTransactionsAction;
import cn.novalon.gym.manage.gymmembercard.repository.IMemberCardTransactionsRepository;
import cn.novalon.gym.manage.gymmembercard.sevice.IMemberCardTransactionsService;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
@Service
public class MemberCardTransactionsServiceImpl implements IMemberCardTransactionsService {
private final IMemberCardTransactionsRepository memberCardTransactionsRepository;
public MemberCardTransactionsServiceImpl(IMemberCardTransactionsRepository memberCardTransactionsRepository) {
this.memberCardTransactionsRepository = memberCardTransactionsRepository;
}
@Override
public Mono<MemberCardTransactions> insertTransaction(MemberCardTransactions transactions) {
return memberCardTransactionsRepository.insertTransaction(transactions);
}
@Override
public Flux<MemberCardTransactions> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime,
LocalDateTime endTime, Pageable pageable) {
return memberCardTransactionsRepository.findByMemberIdAndTimeRange(memberId, startTime, endTime, pageable);
}
@Override
public Flux<MemberCardTransactions> findWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime,
Pageable pageable) {
return memberCardTransactionsRepository.findWithConditions(memberId, memberCardId, operationType,
startTime, endTime, pageable);
}
@Override
public Mono<Long> countWithConditions(Long memberId, Long memberCardId,
MemberCardTransactionsAction operationType,
LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsRepository.countWithConditions(memberId, memberCardId,
operationType, startTime, endTime);
}
@Override
public Flux<MemberCardTransactions> findByMemberCardId(Long memberCardId) {
return memberCardTransactionsRepository.findByMemberCardId(memberCardId);
}
@Override
public Mono<Long> sumDeductCountByCardId(Long memberCardId, LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsRepository.sumDeductCountByCardId(memberCardId, startTime, endTime);
}
@Override
public Mono<Double> sumRenewAmountByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsRepository.sumRenewAmountByTimeRange(startTime, endTime);
}
@Override
public Mono<Double> sumPurchaseAmountByMemberId(Long memberId, LocalDateTime startTime, LocalDateTime endTime) {
return memberCardTransactionsRepository.sumPurchaseAmountByMemberId(memberId, startTime, endTime);
}
}
gym-manage-api/gym-member-card/src/main/java/cn/novalon/gym/manage/gymmembercard/util/BeanConvertUtil.java
+49
View File
@@ -0,0 +1,49 @@
package cn.novalon.gym.manage.gymmembercard.util;
/*
*@Author:shizhounian
*@Date:2026/5/11-05 21:19:04
*/
import cn.hutool.core.bean.BeanUtil;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
/**
* Entity、Domain、VO、DTO转换工具类
*/
@Component
public class BeanConvertUtil {
/**
* 单个对象泛型转换
* @param source 源对象
* @param targetClass 目标类Class
* @return 转换后的目标对象
*/
public static <S, T> T toBean(S source, Class<T> targetClass) {
if (source == null) {
return null;
}
return BeanUtil.copyProperties(source, targetClass);
}
/**
* 集合批量泛型转换
* @param sourceList 源对象集合
* @param targetClass 目标类Class
* @return 转换后的目标对象集合
*/
public static <S, T> List<T> toBeanList(List<S> sourceList, Class<T> targetClass) {
if (sourceList == null || sourceList.isEmpty()) {
return List.of();
}
List<T> targetList = new ArrayList<>();
for (S source : sourceList) {
targetList.add(toBean(source, targetClass));
}
return targetList;
}
}
gym-manage-api/gym-member-card/src/main/resources/application.properties
+1
View File
@@ -0,0 +1 @@
spring.application.name=gym-member-card
gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/GymGroupCourseApplicationTests.java → gym-manage-api/gym-member-card/src/test/java/cn/novalon/gym/manage/gymmembercard/GymMemberCardApplicationTests.java
+2 -2
View File
@@ -1,10 +1,10 @@
package cn.novalon.gym.manage.groupcourse; package cn.novalon.gym.manage.gymmembercard;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest @SpringBootTest
class GymGroupCourseApplicationTests { class GymMemberCardApplicationTests {
@Test @Test
void contextLoads() { void contextLoads() {
gym-manage-api/manage-app/pom.xml
+2 -7
View File
@@ -18,11 +18,6 @@
<description>Application module for Novalon Manage API</description> <description>Application module for Novalon Manage API</description>
<dependencies> <dependencies>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-groupCourse</artifactId>
<version>${project.version}</version>
</dependency>
<dependency> <dependency>
<groupId>cn.novalon.gym.manage</groupId> <groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-sys</artifactId> <artifactId>manage-sys</artifactId>
@@ -140,8 +135,8 @@
</dependency> </dependency>
<dependency> <dependency>
<groupId>cn.novalon.gym.manage</groupId> <groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-groupCourse</artifactId> <artifactId>gym-member-card</artifactId>
<version>1.0.0</version> <version>0.0.1-SNAPSHOT</version>
<scope>compile</scope> <scope>compile</scope>
</dependency> </dependency>
</dependencies> </dependencies>
gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/ManageApplication.java
+3 -2
View File
@@ -15,10 +15,11 @@ import org.springframework.web.server.WebFilter;
import java.util.List; import java.util.List;
@SpringBootApplication(scanBasePackages = {"cn.novalon.gym.manage", "cn.novalon.gym.manage.groupcourse"}, exclude = { @SpringBootApplication(scanBasePackages = "cn.novalon.gym.manage", exclude = {
ReactiveUserDetailsServiceAutoConfiguration.class }) ReactiveUserDetailsServiceAutoConfiguration.class })
@EnableR2dbcRepositories(basePackages = { "cn.novalon.gym.manage.db.dao", @EnableR2dbcRepositories(basePackages = { "cn.novalon.gym.manage.db.dao",
"cn.novalon.gym.manage.sys.audit.repository", "cn.novalon.gym.manage.groupcourse.dao" }) "cn.novalon.gym.manage.sys.audit.repository" ,
"cn.novalon.gym.manage.gymmembercard.dao"})
public class ManageApplication { public class ManageApplication {
private static final Logger logger = LoggerFactory.getLogger(ManageApplication.class); 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
-43
View File
@@ -1,43 +0,0 @@
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
+92 -23
View File
@@ -1,12 +1,13 @@
package cn.novalon.gym.manage.app.config; package cn.novalon.gym.manage.app.config;
import cn.novalon.gym.manage.groupcourse.handler.GroupCourseHandler; import cn.novalon.gym.manage.gymmembercard.handler.MemberCardHandler;
import cn.novalon.gym.manage.gymmembercard.handler.MemberCardRecordHandler;
import cn.novalon.gym.manage.gymmembercard.handler.MemberCardTransactionHandler;
import cn.novalon.gym.manage.sys.handler.auth.SysAuthHandler; import cn.novalon.gym.manage.sys.handler.auth.SysAuthHandler;
import cn.novalon.gym.manage.sys.handler.auth.PasswordDiagnosticHandler; 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.config.SysConfigHandler;
import cn.novalon.gym.manage.sys.handler.dictionary.DictionaryHandler; 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.dict.SysDictHandler;
import cn.novalon.gym.manage.sys.handler.log.SysLogHandler; 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.log.OperationLogHandler;
import cn.novalon.gym.manage.sys.handler.menu.MenuHandler; import cn.novalon.gym.manage.sys.handler.menu.MenuHandler;
@@ -24,11 +25,21 @@ import org.springframework.web.reactive.function.server.ServerResponse;
import static org.springframework.web.reactive.function.server.RouterFunctions.route; import static org.springframework.web.reactive.function.server.RouterFunctions.route;
/**
* 系统路由配置类
*
* 文件定义：配置WebFlux函数式路由，将HTTP请求映射到对应的Handler方法
* 涉及业务：用户、角色、字典、菜单、公告、文件等所有RESTful API路由
* 算法：使用RouterFunctions.route()构建函数式路由规则
*
* @author 张翔
* @date 2026-03-13
*/
@Configuration @Configuration
public class SystemRouter { public class SystemRouter {
@Bean @Bean
public RouterFunction<ServerResponse> systemRoutes( public RouterFunction<ServerResponse> systemRoutes(
GroupCourseHandler groupCourseHandler,
DictionaryHandler dictionaryHandler, DictionaryHandler dictionaryHandler,
SysUserHandler userHandler, SysUserHandler userHandler,
MenuHandler menuHandler, MenuHandler menuHandler,
@@ -43,11 +54,16 @@ public class SystemRouter {
SysUserMessageHandler messageHandler, SysUserMessageHandler messageHandler,
SysFileHandler fileHandler, SysFileHandler fileHandler,
SysPermissionHandler permissionHandler, SysPermissionHandler permissionHandler,
PasswordDiagnosticHandler passwordDiagnosticHandler) { PasswordDiagnosticHandler passwordDiagnosticHandler,
MemberCardHandler memberCardHandler,
MemberCardRecordHandler memberCardRecordHandler,
MemberCardTransactionHandler memberCardTransactionHandler) {
return route() return route()
// ========== 诊断路由 ==========
.GET("/api/diagnostic/password", passwordDiagnosticHandler::diagnose) .GET("/api/diagnostic/password", passwordDiagnosticHandler::diagnose)
// ========== 字典路由 ==========
.GET("/api/dictionaries", dictionaryHandler::getAllDictionaries) .GET("/api/dictionaries", dictionaryHandler::getAllDictionaries)
.GET("/api/dictionaries/{id}", dictionaryHandler::getDictionaryById) .GET("/api/dictionaries/{id}", dictionaryHandler::getDictionaryById)
.GET("/api/dictionaries/type/{type}", dictionaryHandler::getDictionariesByType) .GET("/api/dictionaries/type/{type}", dictionaryHandler::getDictionariesByType)
@@ -55,7 +71,8 @@ public class SystemRouter {
.POST("/api/dictionaries", dictionaryHandler::createDictionary) .POST("/api/dictionaries", dictionaryHandler::createDictionary)
.PUT("/api/dictionaries/{id}", dictionaryHandler::updateDictionary) .PUT("/api/dictionaries/{id}", dictionaryHandler::updateDictionary)
.DELETE("/api/dictionaries/{id}", dictionaryHandler::deleteDictionary) .DELETE("/api/dictionaries/{id}", dictionaryHandler::deleteDictionary)
// ========== 用户路由 ==========
.GET("/api/users", userHandler::getAllUsers) .GET("/api/users", userHandler::getAllUsers)
.GET("/api/users/page", userHandler::getUsersByPage) .GET("/api/users/page", userHandler::getUsersByPage)
.GET("/api/users/count", userHandler::getUserCount) .GET("/api/users/count", userHandler::getUserCount)
@@ -73,14 +90,16 @@ public class SystemRouter {
.POST("/api/users/{id}/action/restore", userHandler::restoreUser) .POST("/api/users/{id}/action/restore", userHandler::restoreUser)
.GET("/api/users/{id}/roles", userHandler::getUserRoles) .GET("/api/users/{id}/roles", userHandler::getUserRoles)
.POST("/api/users/{id}/roles", userHandler::assignRoles) .POST("/api/users/{id}/roles", userHandler::assignRoles)
// ========== 菜单路由 ==========
.GET("/api/menus", menuHandler::getAllMenus) .GET("/api/menus", menuHandler::getAllMenus)
.GET("/api/menus/tree", menuHandler::getMenuTree) .GET("/api/menus/tree", menuHandler::getMenuTree)
.GET("/api/menus/{id}", menuHandler::getMenuById) .GET("/api/menus/{id}", menuHandler::getMenuById)
.POST("/api/menus", menuHandler::createMenu) .POST("/api/menus", menuHandler::createMenu)
.PUT("/api/menus/{id}", menuHandler::updateMenu) .PUT("/api/menus/{id}", menuHandler::updateMenu)
.DELETE("/api/menus/{id}", menuHandler::deleteMenu) .DELETE("/api/menus/{id}", menuHandler::deleteMenu)
// ========== 角色路由 ==========
.GET("/api/roles", roleHandler::getAllRoles) .GET("/api/roles", roleHandler::getAllRoles)
.GET("/api/roles/page", roleHandler::getRolesByPage) .GET("/api/roles/page", roleHandler::getRolesByPage)
.GET("/api/roles/count", roleHandler::getRoleCount) .GET("/api/roles/count", roleHandler::getRoleCount)
@@ -93,14 +112,16 @@ public class SystemRouter {
.POST("/api/roles/{id}/restore", roleHandler::restoreRole) .POST("/api/roles/{id}/restore", roleHandler::restoreRole)
.GET("/api/roles/{id}/permissions", permissionHandler::getPermissionsByRoleId) .GET("/api/roles/{id}/permissions", permissionHandler::getPermissionsByRoleId)
.POST("/api/roles/{id}/permissions", permissionHandler::assignPermissionsToRole) .POST("/api/roles/{id}/permissions", permissionHandler::assignPermissionsToRole)
// ========== 配置路由 ==========
.GET("/api/config", configHandler::getAllConfigs) .GET("/api/config", configHandler::getAllConfigs)
.GET("/api/config/{id}", configHandler::getConfigById) .GET("/api/config/{id}", configHandler::getConfigById)
.GET("/api/config/key/{configKey}", configHandler::getConfigByKey) .GET("/api/config/key/{configKey}", configHandler::getConfigByKey)
.POST("/api/config", configHandler::createConfig) .POST("/api/config", configHandler::createConfig)
.PUT("/api/config/{id}", configHandler::updateConfig) .PUT("/api/config/{id}", configHandler::updateConfig)
.DELETE("/api/config/{id}", configHandler::deleteConfig) .DELETE("/api/config/{id}", configHandler::deleteConfig)
// ========== 日志路由 ==========
.GET("/api/logs/login", logHandler::getAllLoginLogs) .GET("/api/logs/login", logHandler::getAllLoginLogs)
.GET("/api/logs/login/page", logHandler::getLoginLogsByPage) .GET("/api/logs/login/page", logHandler::getLoginLogsByPage)
.GET("/api/logs/login/count", logHandler::getLoginLogCount) .GET("/api/logs/login/count", logHandler::getLoginLogCount)
@@ -119,13 +140,16 @@ public class SystemRouter {
.GET("/api/logs/operation/count", operationLogHandler::getOperationLogCount) .GET("/api/logs/operation/count", operationLogHandler::getOperationLogCount)
.GET("/api/logs/operation/{id}", operationLogHandler::getOperationLogById) .GET("/api/logs/operation/{id}", operationLogHandler::getOperationLogById)
.POST("/api/logs/operation", operationLogHandler::createOperationLog) .POST("/api/logs/operation", operationLogHandler::createOperationLog)
// ========== 认证路由 ==========
.POST("/api/auth/login", authHandler::login) .POST("/api/auth/login", authHandler::login)
.POST("/api/auth/register", authHandler::register) .POST("/api/auth/register", authHandler::register)
.POST("/api/auth/logout", authHandler::logout) .POST("/api/auth/logout", authHandler::logout)
// ========== 统计路由 ==========
.GET("/api/stats/overview", statsHandler::getOverview) .GET("/api/stats/overview", statsHandler::getOverview)
// ========== 数据字典路由 ==========
.GET("/api/dict/types", dictHandler::getAllDictTypes) .GET("/api/dict/types", dictHandler::getAllDictTypes)
.GET("/api/dict/types/{id}", dictHandler::getDictTypeById) .GET("/api/dict/types/{id}", dictHandler::getDictTypeById)
.GET("/api/dict/types/type/{dictType}", dictHandler::getDictTypeByType) .GET("/api/dict/types/type/{dictType}", dictHandler::getDictTypeByType)
@@ -138,21 +162,24 @@ public class SystemRouter {
.POST("/api/dict/data", dictHandler::createDictData) .POST("/api/dict/data", dictHandler::createDictData)
.PUT("/api/dict/data/{id}", dictHandler::updateDictData) .PUT("/api/dict/data/{id}", dictHandler::updateDictData)
.DELETE("/api/dict/data/{id}", dictHandler::deleteDictData) .DELETE("/api/dict/data/{id}", dictHandler::deleteDictData)
// ========== 公告路由 ==========
.GET("/api/notices", noticeHandler::getAllNotices) .GET("/api/notices", noticeHandler::getAllNotices)
.GET("/api/notices/{id}", noticeHandler::getNoticeById) .GET("/api/notices/{id}", noticeHandler::getNoticeById)
.GET("/api/notices/status/{status}", noticeHandler::getNoticesByStatus) .GET("/api/notices/status/{status}", noticeHandler::getNoticesByStatus)
.POST("/api/notices", noticeHandler::createNotice) .POST("/api/notices", noticeHandler::createNotice)
.PUT("/api/notices/{id}", noticeHandler::updateNotice) .PUT("/api/notices/{id}", noticeHandler::updateNotice)
.DELETE("/api/notices/{id}", noticeHandler::deleteNotice) .DELETE("/api/notices/{id}", noticeHandler::deleteNotice)
// ========== 消息路由 ==========
.GET("/api/messages/user/{userId}", messageHandler::getMessagesByUser) .GET("/api/messages/user/{userId}", messageHandler::getMessagesByUser)
.GET("/api/messages/user/{userId}/unread", messageHandler::getUnreadCount) .GET("/api/messages/user/{userId}/unread", messageHandler::getUnreadCount)
.GET("/api/messages/user/{userId}/unread/list", messageHandler::getUnreadList) .GET("/api/messages/user/{userId}/unread/list", messageHandler::getUnreadList)
.POST("/api/messages", messageHandler::createMessage) .POST("/api/messages", messageHandler::createMessage)
.PUT("/api/messages/{id}/read", messageHandler::markAsRead) .PUT("/api/messages/{id}/read", messageHandler::markAsRead)
.DELETE("/api/messages/{id}", messageHandler::deleteMessage) .DELETE("/api/messages/{id}", messageHandler::deleteMessage)
// ========== 文件路由 ==========
.GET("/api/files", fileHandler::getAllFiles) .GET("/api/files", fileHandler::getAllFiles)
.GET("/api/files/{id}", fileHandler::getFileById) .GET("/api/files/{id}", fileHandler::getFileById)
.POST("/api/files/upload", fileHandler::uploadFile) .POST("/api/files/upload", fileHandler::uploadFile)
@@ -161,7 +188,8 @@ public class SystemRouter {
.GET("/api/files/{id}/preview", fileHandler::previewFile) .GET("/api/files/{id}/preview", fileHandler::previewFile)
.GET("/api/files/preview/{fileName}", fileHandler::previewFileByName) .GET("/api/files/preview/{fileName}", fileHandler::previewFileByName)
.DELETE("/api/files/{id}", fileHandler::deleteFile) .DELETE("/api/files/{id}", fileHandler::deleteFile)
// ========== 权限路由 ==========
.GET("/api/permissions", permissionHandler::getAllPermissions) .GET("/api/permissions", permissionHandler::getAllPermissions)
.GET("/api/permissions/{id}", permissionHandler::getPermissionById) .GET("/api/permissions/{id}", permissionHandler::getPermissionById)
.GET("/api/permissions/code/{code}", permissionHandler::getPermissionByCode) .GET("/api/permissions/code/{code}", permissionHandler::getPermissionByCode)
@@ -171,11 +199,52 @@ public class SystemRouter {
.PUT("/api/permissions/{id}", permissionHandler::updatePermission) .PUT("/api/permissions/{id}", permissionHandler::updatePermission)
.DELETE("/api/permissions/{id}", permissionHandler::deletePermission) .DELETE("/api/permissions/{id}", permissionHandler::deletePermission)
.GET("/api/groupCourse", groupCourseHandler::getAllGroupCourse) // ========== 会员卡管理路由 ==========
.POST("/api/groupCourse/page", groupCourseHandler::getGroupCoursesByPage) // 会员卡类型
.POST("/api/groupCourse/cache/get", groupCourseHandler::getCacheByKey) // 1. 获取所有会员卡类型
.GET("/api/groupCourse/{id}", groupCourseHandler::getGroupCourseById) .GET("/api/memberCard/active", memberCardHandler::getActiveCards)
// 2. 获取会员卡详情
.GET("/api/memberCard/{memberCardId}", memberCardHandler::getMemberCardById)
// 3. 条件查询会员卡列表
.GET("/api/memberCard", memberCardHandler::getMemberCardList)
// 4. 新增/更新会员卡
.POST("/api/memberCard", memberCardHandler::saveMemberCard)
// 5. 逻辑删除会员卡
.DELETE("/api/memberCard/{memberCardId}", memberCardHandler::deleteMemberCard)
// 会员卡持卡
// 1. 会员购卡/发卡
.POST("/api/memberCardRecord", memberCardRecordHandler::insertActiveRecord)
// 2. 会员端“我的卡包” - 按会员ID获取有效卡
.GET("/api/memberCardRecord/member/{memberId}/active", memberCardRecordHandler::getMyCards)
// 3. 管理端按会员ID分页查所有卡记录
.GET("/api/memberCardRecord/member/{memberId}", memberCardRecordHandler::getMemberCardRecords)
// 4. 到期扫描
.GET("/api/memberCardRecord/expired", memberCardRecordHandler::getExpiredCards)
// 5. 扣次/扣费
.POST("/api/memberCardRecord/{id}/deduct", memberCardRecordHandler::deductUsage)
// 6. 续费
.POST("/api/memberCardRecord/{id}/renew", memberCardRecordHandler::renewCard)
// 7. 状态变更（过期/退款）
.PUT("/api/memberCardRecord/{id}/status", memberCardRecordHandler::updateStatus)
// 8. 验证次卡
.GET("/api/memberCardRecord/{id}/validate/count", memberCardRecordHandler::validateCountCard)
// 9. 验证储值卡
.GET("/api/memberCardRecord/{id}/validate/stored", memberCardRecordHandler::validateStoredCard)
// 会员卡交易
// 1. 插入流水记录
.POST("/api/transactions", memberCardTransactionHandler::insertTransaction)
// 2. 后台条件分页查询流水（带多个查询参数）
.GET("/api/transactions", memberCardTransactionHandler::getTransactionsWithConditions)
// 3. 按会员ID查询使用记录（分页 + 时间范围）
.GET("/api/transactions/member/{memberId}", memberCardTransactionHandler::getMemberTransactions)
// 4. 按卡ID查询所有流水记录
.GET("/api/transactions/card/{cardId}", memberCardTransactionHandler::getTransactionsByCardId)
// 5. 统计某卡种总扣次数
.GET("/api/transactions/statistics/deduct/card/{cardId}", memberCardTransactionHandler::getDeductCountByCardId)
// 6. 统计某时间段续费总金额
.GET("/api/transactions/statistics/renew", memberCardTransactionHandler::getRenewAmountByTimeRange)
// 7. 统计某会员购卡总金额
.GET("/api/transactions/statistics/purchase/member/{memberId}", memberCardTransactionHandler::getPurchaseAmountByMember)
.build(); .build();
} }
} }
gym-manage-api/manage-app/src/main/resources/application-dev.yml
-3
View File
@@ -12,9 +12,6 @@ spring:
max-life-time: 30m max-life-time: 30m
acquire-timeout: 3s acquire-timeout: 3s
flyway: flyway:
url: jdbc:postgresql://localhost:55432/manage_system
user: novalon
password: novalon123
enabled: true enabled: true
locations: classpath:db/migration locations: classpath:db/migration
baseline-on-migrate: true baseline-on-migrate: true
gym-manage-api/manage-app/src/main/resources/application.yml
+2 -17
View File
@@ -25,8 +25,8 @@ spring:
acquire-timeout: 5s acquire-timeout: 5s
datasource: datasource:
url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:55432}/${DB_NAME:manage_system} url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:55432}/${DB_NAME:manage_system}
username: ${DB_USERNAME:novalon} username: ${DB_USERNAME:postgres}
password: ${DB_PASSWORD:novalon123} password: ${DB_PASSWORD:postgres}
driver-class-name: org.postgresql.Driver driver-class-name: org.postgresql.Driver
flyway: flyway:
enabled: true enabled: true
@@ -38,21 +38,6 @@ spring:
user: user:
name: disabled name: disabled
password: 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: management:
endpoints: endpoints:
gym-manage-api/manage-db/pom.xml
-2
View File
@@ -99,8 +99,6 @@
<artifactId>spring-boot-starter-test</artifactId> <artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
</dependencies> </dependencies>
<build> <build>
gym-manage-api/manage-db/src/main/java/cn/novalon/gym/manage/db/repository/SysUserRepository.java
-1
View File
@@ -10,7 +10,6 @@ import cn.novalon.gym.manage.sys.core.query.SysUserQuery;
import cn.novalon.gym.manage.sys.core.repository.ISysUserRepository; import cn.novalon.gym.manage.sys.core.repository.ISysUserRepository;
import cn.novalon.gym.manage.common.dto.PageRequest; import cn.novalon.gym.manage.common.dto.PageRequest;
import cn.novalon.gym.manage.common.dto.PageResponse; 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.domain.Sort;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate; import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.data.relational.core.query.Query; import org.springframework.data.relational.core.query.Query;
gym-manage-api/manage-db/src/main/resources/db/migration/V6__Create_GroupCourse_table.sql
-71
View File
@@ -1,71 +0,0 @@
-- ============================================
-- 团课相关表
-- ============================================
-- 团课课程表
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
-19
View File
@@ -1,19 +0,0 @@
-- 测试数据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
+1 -3
View File
@@ -50,9 +50,7 @@ public class SecurityConfig {
spec.pathMatchers("/api/auth/**").permitAll() spec.pathMatchers("/api/auth/**").permitAll()
.pathMatchers("/api/public/**").permitAll() .pathMatchers("/api/public/**").permitAll()
.pathMatchers("/ws/**").permitAll() .pathMatchers("/ws/**").permitAll()
.pathMatchers("/actuator/**").permitAll() .pathMatchers("/actuator/**").permitAll();
.pathMatchers("/api/groupCourse/**").permitAll();
if (isDevOrTest) { if (isDevOrTest) {
spec.pathMatchers("/swagger-ui.html").permitAll() spec.pathMatchers("/swagger-ui.html").permitAll()
gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/core/service/impl/SysUserService.java
-1
View File
@@ -15,7 +15,6 @@ 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.service.ISysUserService;
import cn.novalon.gym.manage.sys.core.command.CreateUserCommand; import cn.novalon.gym.manage.sys.core.command.CreateUserCommand;
import cn.novalon.gym.manage.sys.core.command.UpdateUserCommand; 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.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.beans.factory.annotation.Qualifier;
gym-manage-api/pom.xml
+1 -8
View File
@@ -36,13 +36,13 @@
<modules> <modules>
<module>manage-sys</module> <module>manage-sys</module>
<module>manage-gateway</module> <module>manage-gateway</module>
<module>gym-member-card</module>
<module>manage-app</module> <module>manage-app</module>
<module>manage-common</module> <module>manage-common</module>
<module>manage-db</module> <module>manage-db</module>
<module>manage-audit</module> <module>manage-audit</module>
<module>manage-notify</module> <module>manage-notify</module>
<module>manage-file</module> <module>manage-file</module>
<module>gym-groupCourse</module>
</modules> </modules>
<dependencyManagement> <dependencyManagement>
@@ -222,13 +222,6 @@
<artifactId>lombok</artifactId> <artifactId>lombok</artifactId>
<optional>true</optional> <optional>true</optional>
</dependency> </dependency>
<!-- HuTool工具箱-->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.38</version>
</dependency>
</dependencies> </dependencies>
<build> <build>
gym-manage-web/pnpm-lock.yaml
Generated
+82 -13
View File
@@ -59,7 +59,7 @@ importers:
version: 6.21.0(eslint@8.57.1)(typescript@5.9.3) version: 6.21.0(eslint@8.57.1)(typescript@5.9.3)
'@vitejs/plugin-vue': '@vitejs/plugin-vue':
specifier: ^6.0.3 specifier: ^6.0.3
version: 6.0.5(vite@7.3.1(@types/node@20.19.37))(vue@3.5.30(typescript@5.9.3)) version: 6.0.5(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))(vue@3.5.30(typescript@5.9.3))
'@vitest/coverage-v8': '@vitest/coverage-v8':
specifier: ^4.1.1 specifier: ^4.1.1
version: 4.1.2(vitest@4.1.0) version: 4.1.2(vitest@4.1.0)
@@ -81,15 +81,18 @@ importers:
prettier: prettier:
specifier: ^3.1.1 specifier: ^3.1.1
version: 3.8.1 version: 3.8.1
terser:
specifier: ^5.46.1
version: 5.46.2
typescript: typescript:
specifier: ^5.9.3 specifier: ^5.9.3
version: 5.9.3 version: 5.9.3
vite: vite:
specifier: ^7.3.1 specifier: ^7.3.1
version: 7.3.1(@types/node@20.19.37) version: 7.3.1(@types/node@20.19.37)(terser@5.46.2)
vitest: vitest:
specifier: ^4.0.16 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)) version: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
vue-tsc: vue-tsc:
specifier: ^3.2.2 specifier: ^3.2.2
version: 3.2.5(typescript@5.9.3) version: 3.2.5(typescript@5.9.3)
@@ -390,10 +393,16 @@ packages:
resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==} resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
engines: {node: '>=12'} engines: {node: '>=12'}
'@jridgewell/gen-mapping@0.3.13':
resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
'@jridgewell/resolve-uri@3.1.2': '@jridgewell/resolve-uri@3.1.2':
resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
engines: {node: '>=6.0.0'} engines: {node: '>=6.0.0'}
'@jridgewell/source-map@0.3.11':
resolution: {integrity: sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==}
'@jridgewell/sourcemap-codec@1.5.5': '@jridgewell/sourcemap-codec@1.5.5':
resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==} resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
@@ -464,66 +473,79 @@ packages:
resolution: {integrity: sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==} resolution: {integrity: sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==}
cpu: [arm] cpu: [arm]
os: [linux] os: [linux]
libc: [glibc]
'@rollup/rollup-linux-arm-musleabihf@4.59.0': '@rollup/rollup-linux-arm-musleabihf@4.59.0':
resolution: {integrity: sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==} resolution: {integrity: sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==}
cpu: [arm] cpu: [arm]
os: [linux] os: [linux]
libc: [musl]
'@rollup/rollup-linux-arm64-gnu@4.59.0': '@rollup/rollup-linux-arm64-gnu@4.59.0':
resolution: {integrity: sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==} resolution: {integrity: sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==}
cpu: [arm64] cpu: [arm64]
os: [linux] os: [linux]
libc: [glibc]
'@rollup/rollup-linux-arm64-musl@4.59.0': '@rollup/rollup-linux-arm64-musl@4.59.0':
resolution: {integrity: sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==} resolution: {integrity: sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==}
cpu: [arm64] cpu: [arm64]
os: [linux] os: [linux]
libc: [musl]
'@rollup/rollup-linux-loong64-gnu@4.59.0': '@rollup/rollup-linux-loong64-gnu@4.59.0':
resolution: {integrity: sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==} resolution: {integrity: sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==}
cpu: [loong64] cpu: [loong64]
os: [linux] os: [linux]
libc: [glibc]
'@rollup/rollup-linux-loong64-musl@4.59.0': '@rollup/rollup-linux-loong64-musl@4.59.0':
resolution: {integrity: sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==} resolution: {integrity: sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==}
cpu: [loong64] cpu: [loong64]
os: [linux] os: [linux]
libc: [musl]
'@rollup/rollup-linux-ppc64-gnu@4.59.0': '@rollup/rollup-linux-ppc64-gnu@4.59.0':
resolution: {integrity: sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==} resolution: {integrity: sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==}
cpu: [ppc64] cpu: [ppc64]
os: [linux] os: [linux]
libc: [glibc]
'@rollup/rollup-linux-ppc64-musl@4.59.0': '@rollup/rollup-linux-ppc64-musl@4.59.0':
resolution: {integrity: sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==} resolution: {integrity: sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==}
cpu: [ppc64] cpu: [ppc64]
os: [linux] os: [linux]
libc: [musl]
'@rollup/rollup-linux-riscv64-gnu@4.59.0': '@rollup/rollup-linux-riscv64-gnu@4.59.0':
resolution: {integrity: sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==} resolution: {integrity: sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==}
cpu: [riscv64] cpu: [riscv64]
os: [linux] os: [linux]
libc: [glibc]
'@rollup/rollup-linux-riscv64-musl@4.59.0': '@rollup/rollup-linux-riscv64-musl@4.59.0':
resolution: {integrity: sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==} resolution: {integrity: sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==}
cpu: [riscv64] cpu: [riscv64]
os: [linux] os: [linux]
libc: [musl]
'@rollup/rollup-linux-s390x-gnu@4.59.0': '@rollup/rollup-linux-s390x-gnu@4.59.0':
resolution: {integrity: sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==} resolution: {integrity: sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==}
cpu: [s390x] cpu: [s390x]
os: [linux] os: [linux]
libc: [glibc]
'@rollup/rollup-linux-x64-gnu@4.59.0': '@rollup/rollup-linux-x64-gnu@4.59.0':
resolution: {integrity: sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==} resolution: {integrity: sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==}
cpu: [x64] cpu: [x64]
os: [linux] os: [linux]
libc: [glibc]
'@rollup/rollup-linux-x64-musl@4.59.0': '@rollup/rollup-linux-x64-musl@4.59.0':
resolution: {integrity: sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==} resolution: {integrity: sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==}
cpu: [x64] cpu: [x64]
os: [linux] os: [linux]
libc: [musl]
'@rollup/rollup-openbsd-x64@4.59.0': '@rollup/rollup-openbsd-x64@4.59.0':
resolution: {integrity: sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==} resolution: {integrity: sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==}
@@ -858,6 +880,9 @@ packages:
resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
engines: {node: '>=8'} engines: {node: '>=8'}
buffer-from@1.1.2:
resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
call-bind-apply-helpers@1.0.2: call-bind-apply-helpers@1.0.2:
resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==} resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
engines: {node: '>= 0.4'} engines: {node: '>= 0.4'}
@@ -889,6 +914,9 @@ packages:
resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==} resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==}
engines: {node: '>=14'} engines: {node: '>=14'}
commander@2.20.3:
resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
concat-map@0.0.1: concat-map@0.0.1:
resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
@@ -1631,6 +1659,13 @@ packages:
resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
engines: {node: '>=0.10.0'} 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: speakingurl@14.0.1:
resolution: {integrity: sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==} resolution: {integrity: sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==}
engines: {node: '>=0.10.0'} engines: {node: '>=0.10.0'}
@@ -1672,6 +1707,11 @@ packages:
symbol-tree@3.2.4: symbol-tree@3.2.4:
resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==} 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: text-table@0.2.0:
resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==} resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==}
@@ -2138,8 +2178,18 @@ snapshots:
wrap-ansi: 8.1.0 wrap-ansi: 8.1.0
wrap-ansi-cjs: wrap-ansi@7.0.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/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/sourcemap-codec@1.5.5': {}
'@jridgewell/trace-mapping@0.3.31': '@jridgewell/trace-mapping@0.3.31':
@@ -2366,10 +2416,10 @@ snapshots:
'@ungap/structured-clone@1.3.0': {} '@ungap/structured-clone@1.3.0': {}
'@vitejs/plugin-vue@6.0.5(vite@7.3.1(@types/node@20.19.37))(vue@3.5.30(typescript@5.9.3))': '@vitejs/plugin-vue@6.0.5(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))(vue@3.5.30(typescript@5.9.3))':
dependencies: dependencies:
'@rolldown/pluginutils': 1.0.0-rc.2 '@rolldown/pluginutils': 1.0.0-rc.2
vite: 7.3.1(@types/node@20.19.37) vite: 7.3.1(@types/node@20.19.37)(terser@5.46.2)
vue: 3.5.30(typescript@5.9.3) vue: 3.5.30(typescript@5.9.3)
'@vitest/coverage-v8@4.1.2(vitest@4.1.0)': '@vitest/coverage-v8@4.1.2(vitest@4.1.0)':
@@ -2384,7 +2434,7 @@ snapshots:
obug: 2.1.1 obug: 2.1.1
std-env: 4.0.0 std-env: 4.0.0
tinyrainbow: 3.1.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)) vitest: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
'@vitest/expect@4.1.0': '@vitest/expect@4.1.0':
dependencies: dependencies:
@@ -2395,13 +2445,13 @@ snapshots:
chai: 6.2.2 chai: 6.2.2
tinyrainbow: 3.1.0 tinyrainbow: 3.1.0
'@vitest/mocker@4.1.0(vite@7.3.1(@types/node@20.19.37))': '@vitest/mocker@4.1.0(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))':
dependencies: dependencies:
'@vitest/spy': 4.1.0 '@vitest/spy': 4.1.0
estree-walker: 3.0.3 estree-walker: 3.0.3
magic-string: 0.30.21 magic-string: 0.30.21
optionalDependencies: optionalDependencies:
vite: 7.3.1(@types/node@20.19.37) vite: 7.3.1(@types/node@20.19.37)(terser@5.46.2)
'@vitest/pretty-format@4.1.0': '@vitest/pretty-format@4.1.0':
dependencies: dependencies:
@@ -2434,7 +2484,7 @@ snapshots:
sirv: 3.0.2 sirv: 3.0.2
tinyglobby: 0.2.15 tinyglobby: 0.2.15
tinyrainbow: 3.1.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)) vitest: 4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
'@vitest/utils@4.1.0': '@vitest/utils@4.1.0':
dependencies: dependencies:
@@ -2642,6 +2692,8 @@ snapshots:
dependencies: dependencies:
fill-range: 7.1.1 fill-range: 7.1.1
buffer-from@1.1.2: {}
call-bind-apply-helpers@1.0.2: call-bind-apply-helpers@1.0.2:
dependencies: dependencies:
es-errors: 1.3.0 es-errors: 1.3.0
@@ -2668,6 +2720,8 @@ snapshots:
commander@10.0.1: {} commander@10.0.1: {}
commander@2.20.3: {}
concat-map@0.0.1: {} concat-map@0.0.1: {}
config-chain@1.1.13: config-chain@1.1.13:
@@ -3456,6 +3510,13 @@ snapshots:
source-map-js@1.2.1: {} 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: {} speakingurl@14.0.1: {}
stackback@0.0.2: {} stackback@0.0.2: {}
@@ -3494,6 +3555,13 @@ snapshots:
symbol-tree@3.2.4: {} 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: {} text-table@0.2.0: {}
tinybench@2.9.0: {} tinybench@2.9.0: {}
@@ -3547,7 +3615,7 @@ snapshots:
util-deprecate@1.0.2: {} util-deprecate@1.0.2: {}
vite@7.3.1(@types/node@20.19.37): vite@7.3.1(@types/node@20.19.37)(terser@5.46.2):
dependencies: dependencies:
esbuild: 0.27.4 esbuild: 0.27.4
fdir: 6.5.0(picomatch@4.0.3) fdir: 6.5.0(picomatch@4.0.3)
@@ -3558,11 +3626,12 @@ snapshots:
optionalDependencies: optionalDependencies:
'@types/node': 20.19.37 '@types/node': 20.19.37
fsevents: 2.3.3 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)): vitest@4.1.0(@types/node@20.19.37)(@vitest/ui@4.1.0)(jsdom@27.4.0)(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2)):
dependencies: dependencies:
'@vitest/expect': 4.1.0 '@vitest/expect': 4.1.0
'@vitest/mocker': 4.1.0(vite@7.3.1(@types/node@20.19.37)) '@vitest/mocker': 4.1.0(vite@7.3.1(@types/node@20.19.37)(terser@5.46.2))
'@vitest/pretty-format': 4.1.0 '@vitest/pretty-format': 4.1.0
'@vitest/runner': 4.1.0 '@vitest/runner': 4.1.0
'@vitest/snapshot': 4.1.0 '@vitest/snapshot': 4.1.0
@@ -3579,7 +3648,7 @@ snapshots:
tinyexec: 1.0.2 tinyexec: 1.0.2
tinyglobby: 0.2.15 tinyglobby: 0.2.15
tinyrainbow: 3.1.0 tinyrainbow: 3.1.0
vite: 7.3.1(@types/node@20.19.37) vite: 7.3.1(@types/node@20.19.37)(terser@5.46.2)
why-is-node-running: 2.3.0 why-is-node-running: 2.3.0
optionalDependencies: optionalDependencies:
'@types/node': 20.19.37 '@types/node': 20.19.37