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

Compare commits

base: novalon/gym-manage:feature/new-uniapp
Branches Tags
novalon/gym-manage:main novalon/gym-manage:dev novalon/gym-manage:feature/small-uniapp novalon/gym-manage:feature/new-uniapp novalon/gym-manage:feature/uni-app novalon/gym-manage:feature/manage-for-cuit novalon/gym-manage:feature/member-register-integration novalon/gym-manage:feature/member-register novalon/gym-manage:feature/coupon novalon/gym-manage:feature/data-count novalon/gym-manage:feature/member-register-refactor novalon/gym-manage:feature/groupCourseSearch novalon/gym-manage:feature/member-card-management novalon/gym-manage:feature/userInfoManage
..
compare: novalon/gym-manage:f1b25aec0d967adfa996189fd6d8991551fd54d0
Branches Tags
novalon/gym-manage:dev novalon/gym-manage:feature/small-uniapp novalon/gym-manage:feature/new-uniapp novalon/gym-manage:feature/uni-app novalon/gym-manage:feature/manage-for-cuit novalon/gym-manage:feature/member-register-integration novalon/gym-manage:feature/member-register novalon/gym-manage:feature/coupon novalon/gym-manage:feature/data-count novalon/gym-manage:feature/member-register-refactor novalon/gym-manage:feature/groupCourseSearch novalon/gym-manage:feature/member-card-management novalon/gym-manage:feature/userInfoManage novalon/gym-manage:main
7 Commits
feature/new-uniapp .. f1b25aec0d
Author SHA1 Message Date
future f1b25aec0d Merge branch 'dev' into feature/member-register-integration 2026-06-24 23:02:49 +08:00
future 58feae78b7 合并dev分支 2026-06-24 22:32:38 +08:00
future c44478a9cb 完成登录功能 2026-06-24 22:28:03 +08:00
future 972cbf1e56 修复丢失文件 2026-06-24 22:28:02 +08:00
future 0f8fe00501 feat: 添加签到模块和数据库表结构 
- 新增gym-checkIn签到模块
- 创建sign_in_record签到记录表(V13迁移脚本)
- 添加签到相关路由配置
- 更新应用配置以支持签到模块
- 添加Redis密钥常量
 2026-06-24 22:28:02 +08:00
future ce6bc107cc 签到模块 2026-06-24 22:28:02 +08:00
future e0df10752c 修复项目构建 2026-06-24 22:28:02 +08:00
355 changed files with 2784 additions and 32619 deletions
Expand all files Collapse all files
gym-manage-api/KeyAnalyzer.java
-202
View File
@@ -1,202 +0,0 @@
import java.util.Base64;
import java.math.BigInteger;
import java.io.ByteArrayInputStream;
public class KeyAnalyzer {
public static void main(String[] args) {
String privateKeyBase64 = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCcxAwrhZF+izz1gxQKOr4jnC05obIBHbl0DzHOcd4CaaDV7Kv1NRJKi33JhdDsW4JGgu16e5Rtzq1VzU5VWz5EKgGL46maOFwCkngJUTP/LC3JVf/wtJmYCm8xNE8C7GNNIqKzYEvUOEfXqagpVvVrGsQ9FpzFp2rP9hBmHY3yizVyPX/uT9S+af5TRxiaItj3SSJGgloaEMrnKOpb/EH7JwPSS0liAyT/NxPfOyyZHc22AvaAIOE5y+0PMUIKPuIdfpOrej3LVpO1Arc2hSgmdB+YIPSiBVYPXa6AuAmil9mpbtSikQJ7Uu7lX4JyTW4QxQ06rPFKnFWVKkzivAElAgMBAAECggEAJd0AJ37iTlMpDQ90xqe7hvRQxAu256gbQ9nrqLY97g0/KIw6WEZSPakFX6gvdvb/NzKmUyAIEKGLoh6tXdZk6qfOqc/6BeK47nIcBfwT9/zerjNUVvn34w4aHyNINieMMHQ+Id8PUZmqWH+Euz9ilVTosuyEPwUZulLvUQqwXzU5VnwVghURbUhDd+ecBJACWgemRun6d5241PQXNYAdH1k7cETd8GfIi3qclhhJrxi7tu5tq4YGCXQIoz7HCLim7GIvT0M+FRgSw2EOrHnAQNFeQ/vQbP71ttLoTxehL6Se9dfWrV5OI+Y/T7vR2F84Qt0iNbaxyJGir7siKDFIwQKBgQDXDzinx3/TasplM78pR/0CtuuKr1Ch02LOPrTosJ1qf1OohxQThowhOTxMsBlgYSKu9s1QRffUUXEqYXxd2B6lzDKfggwO6U2XxIcxWeNow0xoFfqcXYSg7Ga2sCr9uhdwxIdFQNF7SNBpT8ht4fJrRX6mWY1nHybpyTDQ4xoQNQKBgQC6m+yiOoi5JD3zVSSJq/iq5DJPA5B4aoP+t5u9lp2Q7iVO0QI5ilBlEKGE4VOU0glnXlDTfuqEYooMY85ekl4WGb3AOT0PhLL2i+gO2nlWBzf4HPzB/hibjfyPyniRM03cHkG3HXucL7Sne6FwERcfjEqjUd2cdP1l89PNrq4rMQKBgQCMmjABSWYh8/y1I5rEQ4OAJdVjC3GdC1Xa35ZpVybjvLEWSpHunhW5lvD8dllw8LC7UTI0XDpGPqTM/4VO2YBYB2PFc0Gs8g0/v0ZgFpOeJ6kpl80MM/wFNemFYTIKRoMSv/psZY9PmfBgGcBBTuquBXZjDcNr+yr2yAm5V/DvTQKBgHqRi94KoF8q5N39IKCkqhJlDH5FkxDktYoKw2rFkPzuzuZz9gghRyj6wXxsG9/2DWMt2dzw0czehFoa/CO188KEadPmRKr6uCmkP2nyKhxNZX+8WnB5G2Sg4DD6BjMpBYz8+qDx5ozx8LDJTYI0V4HLPgMD9JGdbgsXGhlREOkhAoGALr6IQOXnviWNAhCdc7rrsaMLMPbLZ1wqzWtQUG1JxDobbpzEP4CW/mvW5pMn58mSBg5qbXhyDI4fFP0CPb98QIz2tGnIzYyFzdKmF5Z1N7X1OF9O+tsSqASoBZzTqB4fr/o4mz0s9JCeriBR2LWjsbsDU13DTLsfQpWbtOnIy70=";
System.out.println("========== 密钥分析开始 ==========");
System.out.println("密钥长度: " + privateKeyBase64.length());
byte[] keyBytes = Base64.getDecoder().decode(privateKeyBase64);
System.out.println("解码后长度: " + keyBytes.length + " bytes");
// 打印前30字节
System.out.print("前30字节(hex): ");
for (int i = 0; i < 30 && i < keyBytes.length; i++) {
System.out.printf("%02X ", keyBytes[i]);
}
System.out.println();
// 解析ASN.1结构
try {
parseASN1(keyBytes);
} catch (Exception e) {
System.out.println("解析失败: " + e.getMessage());
e.printStackTrace();
}
}
static void parseASN1(byte[] keyBytes) throws Exception {
ByteArrayInputStream bis = new ByteArrayInputStream(keyBytes);
// 读取SEQUENCE
int tag = bis.read();
System.out.println("第一个tag: 0x" + Integer.toHexString(tag));
if (tag == 0x30) {
System.out.println("这是SEQUENCE");
// 读取长度
int len = readASN1Length(bis);
System.out.println("SEQUENCE长度: " + len);
// 检查下一个tag
int nextTag = bis.read();
System.out.println("下一个tag: 0x" + Integer.toHexString(nextTag));
if (nextTag == 0x02) {
// INTEGER
int intLen = readASN1Length(bis);
byte[] versionBytes = new byte[intLen];
bis.read(versionBytes);
int version = new BigInteger(versionBytes).intValue();
System.out.println("版本INTEGER值: " + version);
// 检查这是PKCS#8还是PKCS#1
// PKCS#8: version=0后是SEQUENCE(算法标识符)
// PKCS#1: version=0后是INTEGER(modulus)
int afterVersionTag = bis.read();
System.out.println("版本后的tag: 0x" + Integer.toHexString(afterVersionTag));
if (afterVersionTag == 0x30) {
System.out.println(">>> 这是PKCS#8格式 (version后是SEQUENCE)");
// 解析PKCS#8
// AlgorithmIdentifier: SEQUENCE { OID, NULL }
int algLen = readASN1Length(bis);
System.out.println("AlgorithmIdentifier长度: " + algLen);
// 跳过AlgorithmIdentifier内容
byte[] algBytes = new byte[algLen];
bis.read(algBytes);
// 打印OID
System.out.print("OID bytes: ");
for (int i = 0; i < algBytes.length; i++) {
System.out.printf("%02X ", algBytes[i]);
}
System.out.println();
// 下一个应该是OCTET STRING (包含私钥)
int octetTag = bis.read();
System.out.println("下一个tag: 0x" + Integer.toHexString(octetTag));
if (octetTag == 0x04) {
System.out.println("这是OCTET STRING (包含私钥数据)");
int octetLen = readASN1Length(bis);
System.out.println("OCTET STRING长度: " + octetLen);
// OCTET STRING内容是PKCS#1私钥
byte[] pkcs1Bytes = new byte[octetLen];
bis.read(pkcs1Bytes);
System.out.print("PKCS#1私钥前20字节: ");
for (int i = 0; i < 20; i++) {
System.out.printf("%02X ", pkcs1Bytes[i]);
}
System.out.println();
// 解析PKCS#1私钥
ByteArrayInputStream pkcs1Stream = new ByteArrayInputStream(pkcs1Bytes);
int pkcs1Tag = pkcs1Stream.read();
System.out.println("PKCS#1第一个tag: 0x" + Integer.toHexString(pkcs1Tag));
if (pkcs1Tag == 0x30) {
int pkcs1Len = readASN1Length(pkcs1Stream);
System.out.println("PKCS#1 SEQUENCE长度: " + pkcs1Len);
// version
int vTag = pkcs1Stream.read();
int vLen = readASN1Length(pkcs1Stream);
byte[] vBytes = new byte[vLen];
pkcs1Stream.read(vBytes);
System.out.println("PKCS#1版本: " + new BigInteger(vBytes));
// 解析私钥参数
parsePKCS1(pkcs1Stream);
}
}
} else if (afterVersionTag == 0x02) {
System.out.println(">>> 这是PKCS#1格式 (version后是INTEGER)");
// 继续解析PKCS#1
parsePKCS1(bis);
} else {
System.out.println(">>> 未知格式 (tag: 0x" + Integer.toHexString(afterVersionTag) + ")");
}
}
}
}
static void parsePKCS1(ByteArrayInputStream bis) throws Exception {
System.out.println("\n========== 解析PKCS#1私钥参数 ==========");
// modulus
BigInteger modulus = readASN1Integer(bis);
System.out.println("modulus长度: " + modulus.bitLength() + " bits");
// publicExponent
BigInteger publicExponent = readASN1Integer(bis);
System.out.println("publicExponent: " + publicExponent);
// privateExponent
BigInteger privateExponent = readASN1Integer(bis);
System.out.println("privateExponent长度: " + privateExponent.bitLength() + " bits");
// prime1
BigInteger prime1 = readASN1Integer(bis);
System.out.println("prime1长度: " + prime1.bitLength() + " bits");
// prime2
BigInteger prime2 = readASN1Integer(bis);
System.out.println("prime2长度: " + prime2.bitLength() + " bits");
// 验证 prime1 * prime2 == modulus
BigInteger calculatedModulus = prime1.multiply(prime2);
boolean valid = calculatedModulus.equals(modulus);
System.out.println("\n验证 prime1 * prime2 == modulus: " + valid);
if (!valid) {
System.out.println(">>> 密钥数学关系不正确！这是无效的RSA私钥");
System.out.println("计算得到的modulus长度: " + calculatedModulus.bitLength() + " bits");
}
// exponent1
BigInteger exponent1 = readASN1Integer(bis);
System.out.println("exponent1长度: " + exponent1.bitLength() + " bits");
// exponent2
BigInteger exponent2 = readASN1Integer(bis);
System.out.println("exponent2长度: " + exponent2.bitLength() + " bits");
// coefficient
BigInteger coefficient = readASN1Integer(bis);
System.out.println("coefficient长度: " + coefficient.bitLength() + " bits");
System.out.println("\n========== 解析完成 ==========");
}
static int readASN1Length(ByteArrayInputStream bis) throws Exception {
int firstByte = bis.read();
if ((firstByte & 0x80) == 0) {
return firstByte;
}
int numBytes = firstByte & 0x7F;
int length = 0;
for (int i = 0; i < numBytes; i++) {
length = (length << 8) | (bis.read() & 0xFF);
}
return length;
}
static BigInteger readASN1Integer(ByteArrayInputStream bis) throws Exception {
int tag = bis.read();
if (tag != 0x02) throw new Exception("期望INTEGER tag: 0x02, 实际: 0x" + Integer.toHexString(tag));
int len = readASN1Length(bis);
byte[] data = new byte[len];
bis.read(data);
return new BigInteger(1, data);
}
}
gym-manage-api/gym-auth/pom.xml
+14 -66
View File
@@ -10,11 +10,12 @@
<version>1.0.0</version>
</parent>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-auth</artifactId>
<packaging>jar</packaging>
<name>Gym Auth</name>
<description>Phone Authentication Module - Phone Number Login Services</description>
<description>Authentication module for Gym Management System</description>
<dependencies>
<dependency>
@@ -29,99 +30,46 @@
</dependency>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-sys</artifactId>
<artifactId>gym-member</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-member</artifactId>
<artifactId>manage-sys</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<dependency>
<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-commons</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>io.projectreactor</groupId>
<artifactId>reactor-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.25</version>
</dependency>
<!-- 阿里云号码认证服务（新版SDK） -->
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>dypnsapi20170525</artifactId>
<version>1.0.6</version>
</dependency>
<!-- 阿里云一键登录服务（旧版SDK，保留兼容） -->
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>aliyun-java-sdk-dypnsapi</artifactId>
<version>1.2.12</version>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>aliyun-java-sdk-core</artifactId>
<version>4.6.0</version>
<version>4.6.3</version>
</dependency>
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>dysmsapi20170525</artifactId>
<version>2.0.0</version>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.4.2</version>
<executions>
<execution>
<id>default-jar</id>
<phase>package</phase>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.11.0</version>
<configuration>
<source>21</source>
<target>21</target>
<annotationProcessorPaths>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version>
</path>
</annotationProcessorPaths>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
</plugins>
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/config/AuthConfig.java
-7
View File
@@ -1,7 +0,0 @@
package cn.novalon.gym.manage.auth.config;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AuthConfig {
}
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/config/DCloudUniverifyConfig.java
-18
View File
@@ -1,18 +0,0 @@
package cn.novalon.gym.manage.auth.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
@Data
@Configuration
@ConfigurationProperties(prefix = "dcloud.univerify")
public class DCloudUniverifyConfig {
private String appid;
private String appkey;
private String apiSecret;
private String apiUrl = "https://developer.dcloud.net.cn/api/client/univerify/getPhoneNumber";
private String proxyHost;
private Integer proxyPort;
private Integer timeout = 10000;
}
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/config/SmsProperties.java
+2 -26
View File
@@ -4,44 +4,20 @@ import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
/**
* 阿里云短信配置属性类
*
* @author auto-generated
* @date 2026-06-20
*/
@Data
@Configuration
@ConfigurationProperties(prefix = "alibaba.cloud.sms")
public class SmsProperties {
/**
* 访问密钥ID
*/
private String accessKeyId;
/**
* 访问密钥密钥
*/
private String accessKeySecret;
/**
* 短信签名名称
*/
private String signName;
/**
* 短信模板CODE
*/
private String templateCode;
/**
* 短信验证码长度（默认6位）
*/
private int codeLength = 6;
private int codeLength = 4;
/**
* 短信验证码有效期（秒，默认300秒=5分钟）
*/
private long codeExpireSeconds = 300;
}
}
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/dto/PhoneCodeLoginDto.java
-3
View File
@@ -7,9 +7,6 @@ import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 手机号验证码登录请求DTO
*/
@Data
@Builder
@NoArgsConstructor
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/dto/PhoneLoginDto.java
+7 -2
View File
@@ -1,20 +1,25 @@
package cn.novalon.gym.manage.auth.dto;
import jakarta.validation.constraints.NotBlank;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 手机号一键登录请求DTO
* uniapp官方一键登录流程：前端通过云函数获取access_token和openid传给后端换取手机号
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PhoneLoginDto {
private String phone;
@NotBlank(message = "access_token不能为空")
private String accessToken;
@NotBlank(message = "openid不能为空")
private String openid;
private String nickname;
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/dto/SendCodeRequest.java
-22
View File
@@ -1,22 +0,0 @@
package cn.novalon.gym.manage.auth.dto;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 发送短信验证码请求DTO
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SendCodeRequest {
@NotBlank(message = "手机号不能为空")
@Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
private String phone;
}
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/dto/SmsLoginDto.java
-25
View File
@@ -1,25 +0,0 @@
package cn.novalon.gym.manage.auth.dto;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 短信验证码登录请求DTO
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SmsLoginDto {
@NotBlank(message = "手机号不能为空")
@Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
private String phone;
@NotBlank(message = "验证码不能为空")
private String code;
}
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/service/PhoneAuthService.java
+1 -23
View File
@@ -1,37 +1,15 @@
package cn.novalon.gym.manage.auth.service;
import cn.novalon.gym.manage.auth.dto.PhoneLoginDto;
import cn.novalon.gym.manage.auth.dto.PhoneCodeLoginDto;
import cn.novalon.gym.manage.auth.dto.PhoneLoginDto;
import cn.novalon.gym.manage.auth.vo.PhoneLoginVO;
import reactor.core.publisher.Mono;
/**
* 手机号认证服务接口
*/
public interface PhoneAuthService {
/**
* 手机号一键登录（uniapp官方运营商认证）
* 已注册则直接登录，未注册则自动注册后登录
*
* @param request 登录请求
* @return 登录响应
*/
Mono<PhoneLoginVO> oneClickLogin(PhoneLoginDto request);
/**
* 发送短信验证码（阿里云）
*
* @param phone 手机号
* @return 是否发送成功
*/
Mono<Boolean> sendSmsCode(String phone);
/**
* 手机号验证码登录（阿里云）
*
* @param request 登录请求
* @return 登录响应
*/
Mono<PhoneLoginVO> codeLogin(PhoneCodeLoginDto request);
}
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/service/SmsService.java
-25
View File
@@ -2,36 +2,11 @@ package cn.novalon.gym.manage.auth.service;
import reactor.core.publisher.Mono;
/**
* 短信服务接口
*
* @author auto-generated
* @date 2026-06-20
*/
public interface SmsService {
/**
* 发送短信验证码
*
* @param phone 手机号
* @return 发送结果
*/
Mono<Boolean> sendVerificationCode(String phone);
/**
* 验证短信验证码
*
* @param phone 手机号
* @param code 验证码
* @return 验证结果
*/
Mono<Boolean> verifyCode(String phone, String code);
/**
* 获取验证码（用于测试或特殊场景）
*
* @param phone 手机号
* @return 验证码
*/
Mono<String> getVerificationCode(String phone);
}
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/service/impl/PhoneAuthServiceImpl.java
+42 -83
View File
@@ -1,6 +1,5 @@
package cn.novalon.gym.manage.auth.service.impl;
import cn.novalon.gym.manage.auth.config.DCloudUniverifyConfig;
import cn.novalon.gym.manage.auth.config.SmsProperties;
import cn.novalon.gym.manage.auth.dto.PhoneCodeLoginDto;
import cn.novalon.gym.manage.auth.dto.PhoneLoginDto;
@@ -17,19 +16,22 @@ import cn.novalon.gym.manage.member.util.AesUtil;
import cn.novalon.gym.manage.member.util.EsSyncUtils;
import cn.novalon.gym.manage.member.util.MemberNoGenerator;
import cn.novalon.gym.manage.sys.security.JwtTokenProvider;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.dypnsapi.model.v20170525.GetMobileRequest;
import com.aliyuncs.dypnsapi.model.v20170525.GetMobileResponse;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.exceptions.ServerException;
import com.aliyuncs.profile.DefaultProfile;
import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Slf4j
@Service
@@ -42,41 +44,32 @@ public class PhoneAuthServiceImpl implements PhoneAuthService {
private final JwtTokenProvider jwtTokenProvider;
private final SmsService smsService;
private final SmsProperties smsProperties;
private final DCloudUniverifyConfig dCloudUniverifyConfig;
private WebClient webClient;
private EsSyncUtils.EntitySyncer<Member, MemberES, String> memberSyncer;
@PostConstruct
public void init() {
this.memberSyncer = esSyncUtils.bind(Member.class, MemberES.class, memberESRepository);
this.webClient = WebClient.builder()
.baseUrl(dCloudUniverifyConfig.getApiUrl())
.defaultHeader("Content-Type", MediaType.APPLICATION_JSON_VALUE)
.build();
}
@Override
public Mono<PhoneLoginVO> oneClickLogin(PhoneLoginDto request) {
log.info("手机号一键登录请求, phone: {}, accessToken: {}, openid: {}", request.getPhone(), request.getAccessToken(), request.getOpenid());
log.info("手机号一键登录请求, accessToken: {}, openid: {}", request.getAccessToken(), request.getOpenid());
if (request.getPhone() != null && !request.getPhone().isEmpty()) {
log.info("直接使用手机号登录");
String encryptedPhone = encryptPhone(request.getPhone());
return processPhoneLogin(encryptedPhone, request);
}
if (request.getAccessToken() == null || request.getAccessToken().isEmpty()) {
log.error("一键登录失败: accessToken为空");
return Mono.error(new SystemException(ErrorCode.AUTH_PHONE_ERROR, "登录凭证无效，请重试"));
}
return getPhoneByDcloudApi(request.getAccessToken(), request.getOpenid())
return Mono.fromCallable(() -> getPhoneByToken(request.getAccessToken(), request.getOpenid()))
.flatMap(phone -> {
log.info("通过access_token获取手机号成功: {}", maskPhone(phone));
String encryptedPhone = encryptPhone(phone);
return processPhoneLogin(encryptedPhone, request);
return memberRepository.findByPhone(encryptedPhone)
.flatMap(existingMember -> {
log.info("手机号已注册，直接登录, memberId: {}", existingMember.getId());
return doLogin(existingMember, false, request);
})
.switchIfEmpty(Mono.defer(() -> {
log.info("手机号未注册，创建新会员");
return createNewMemberAndLogin(request, encryptedPhone);
}));
})
.onErrorResume(e -> {
log.error("一键登录失败", e);
@@ -84,64 +77,30 @@ public class PhoneAuthServiceImpl implements PhoneAuthService {
});
}
private Mono<PhoneLoginVO> processPhoneLogin(String encryptedPhone, PhoneLoginDto request) {
return memberRepository.findByPhone(encryptedPhone)
.flatMap(existingMember -> {
log.info("手机号已注册，直接登录, memberId: {}", existingMember.getId());
return doLogin(existingMember, false, request);
})
.switchIfEmpty(Mono.defer(() -> {
log.info("手机号未注册，创建新会员");
return createNewMemberAndLogin(request, encryptedPhone);
}));
}
/**
* 通过access_token和openid获取手机号
* 使用阿里云DYPNS API
*/
private String getPhoneByToken(String accessToken, String openid) throws Exception {
DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou", smsProperties.getAccessKeyId(), smsProperties.getAccessKeySecret());
IAcsClient client = new DefaultAcsClient(profile);
GetMobileRequest request = new GetMobileRequest();
request.setAccessToken(accessToken);
private Mono<String> getPhoneByDcloudApi(String accessToken, String openid) {
Map<String, String> requestBody = new HashMap<>();
requestBody.put("appid", dCloudUniverifyConfig.getAppid());
requestBody.put("appkey", dCloudUniverifyConfig.getAppkey());
requestBody.put("apiSecret", dCloudUniverifyConfig.getApiSecret());
requestBody.put("access_token", accessToken);
requestBody.put("openid", openid);
log.info("调用DCloud Univerify API, params: {}", requestBody);
return webClient.post()
.bodyValue(requestBody)
.retrieve()
.bodyToMono(Map.class)
.flatMap(response -> {
log.info("DCloud API响应: {}", response);
Integer code = (Integer) response.get("code");
Boolean success = (Boolean) response.get("success");
if ((code != null && code == 0) || (success != null && success)) {
Map<String, Object> data = (Map<String, Object>) response.get("data");
if (data != null) {
String phoneNumber = (String) data.get("phoneNumber");
if (phoneNumber != null && !phoneNumber.isEmpty()) {
return Mono.just(phoneNumber);
}
}
String phoneNumber = (String) response.get("phoneNumber");
if (phoneNumber != null && !phoneNumber.isEmpty()) {
return Mono.just(phoneNumber);
}
String phone = (String) response.get("phone");
if (phone != null && !phone.isEmpty()) {
return Mono.just(phone);
}
}
String message = (String) response.get("message");
log.warn("DCloud API返回错误: code={}, success={}, message={}", code, success, message);
return Mono.error(new SystemException(ErrorCode.AUTH_PHONE_ERROR, "手机号获取失败: " + message));
})
.onErrorResume(e -> {
log.error("调用DCloud API失败", e);
return Mono.error(new SystemException(ErrorCode.AUTH_PHONE_ERROR, "手机号获取失败: " + e.getMessage()));
});
try {
GetMobileResponse response = client.getAcsResponse(request);
if ("OK".equals(response.getCode())) {
return response.getGetMobileResultDTO().getMobile();
}
log.warn("DYPNS API返回错误: code={}, message={}", response.getCode(), response.getMessage());
throw new SystemException(ErrorCode.AUTH_PHONE_ERROR, "手机号获取失败: " + response.getMessage());
} catch (ServerException e) {
log.error("阿里云DYPNS API服务端异常", e);
throw new SystemException(ErrorCode.AUTH_PHONE_ERROR, "手机号获取失败");
} catch (ClientException e) {
log.error("阿里云DYPNS API客户端异常", e);
throw new SystemException(ErrorCode.AUTH_PHONE_ERROR, "手机号获取失败");
}
}
/**
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/service/impl/SmsServiceImpl.java
+4 -4
View File
@@ -76,13 +76,13 @@ public class SmsServiceImpl implements SmsService {
log.info("阿里云号码认证原始响应: {}", responseData);
JsonNode jsonNode = objectMapper.readTree(responseData);
JsonNode codeNode = jsonNode.get("Code");
if (codeNode == null) {
log.error("阿里云响应中找不到Code字段, 原始响应: {}", responseData);
return false;
}
String code = codeNode.asText();
if ("OK".equals(code)) {
@@ -146,13 +146,13 @@ public class SmsServiceImpl implements SmsService {
log.info("阿里云号码认证核验原始响应: {}", responseData);
JsonNode jsonNode = objectMapper.readTree(responseData);
JsonNode codeNode = jsonNode.get("Code");
if (codeNode == null) {
log.error("阿里云核验响应中找不到Code字段, 原始响应: {}", responseData);
return false;
}
String responseCode = codeNode.asText();
JsonNode modelNode = jsonNode.get("Model");
JsonNode verifyResultNode = modelNode != null ? modelNode.get("VerifyResult") : null;
gym-manage-api/gym-auth/src/main/java/cn/novalon/gym/manage/auth/vo/PhoneLoginVO.java
-3
View File
@@ -5,9 +5,6 @@ import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 手机号一键登录响应VO
*/
@Data
@Builder
@NoArgsConstructor
gym-manage-api/gym-auth/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
-4
View File
@@ -1,5 +1 @@
cn.novalon.gym.manage.auth.handler.PhoneAuthHandler
cn.novalon.gym.manage.auth.service.impl.PhoneAuthServiceImpl
cn.novalon.gym.manage.auth.service.impl.SmsServiceImpl
cn.novalon.gym.manage.auth.config.AuthConfig
cn.novalon.gym.manage.auth.config.SmsProperties
gym-manage-api/gym-checkIn/pom.xml
-5
View File
@@ -118,11 +118,6 @@
<artifactId>hutool-all</artifactId>
<version>5.8.25</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.google.zxing</groupId>
<artifactId>core</artifactId>
gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/service/impl/CheckServiceImpl.java
+73 -35
View File
@@ -52,24 +52,32 @@ public class CheckServiceImpl implements ICheckInService {
@Override
public Mono<QRCodeVo> getQRCode(Long memberId) {
log.info("开始生成会员签到二维码, memberId: {}", memberId);
log.info("开始查询会员信息, memberId: {}", memberId);
String qrContent = QRRedisKey.generateQrcodeContent();
Map<String, Object> redisMap = new HashMap<>();
redisMap.put("qrContent", qrContent);
redisMap.put("isUsed", false);
redisMap.put("memberId", memberId);
return findValidMemberCard(memberId)
.flatMap(cardRecord -> {
log.info("会员信息查询完成, memberCardRecordId: {}", cardRecord.getMemberCardRecordId());
log.info("开始生成二维码");
String qrContent = QRRedisKey.generateQrcodeContent();
Map<String, Object> redisMap = new HashMap<>();
redisMap.put("qrContent", qrContent);
redisMap.put("isUsed", false);
redisMap.put("memberId", memberId);
redisMap.put("memberCardRecordId", cardRecord.getMemberCardRecordId());
return redisUtil.setWithExpire(
RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now(),
redisMap,
getSecondsUntilEndOfDay()
)
.then(Mono.fromSupplier(() -> {
String qrCodeBase64 = QrCodeUtil.generateAsBase64(qrContent,
BeanUtil.copyProperties(qrCodeConfig, QrConfig.class), "png");
return new QRCodeVo(qrCodeBase64, false, qrContent, qrCodeConfig.getWidth(), qrCodeConfig.getHeight(), LocalDate.now());
}));
return redisUtil.setWithExpire(
RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now(),
redisMap,
getSecondsUntilEndOfDay()
)
.then(Mono.fromSupplier(() -> {
String qrCodeBase64 = QrCodeUtil.generateAsBase64(qrContent,
BeanUtil.copyProperties(qrCodeConfig, QrConfig.class), "png");
return new QRCodeVo(qrCodeBase64, false, qrContent, qrCodeConfig.getWidth(), qrCodeConfig.getHeight(), LocalDate.now());
}));
})
.switchIfEmpty(Mono.error(new RuntimeException("该会员没有可用的会员卡")));
}
@Override
@@ -105,10 +113,9 @@ public class CheckServiceImpl implements ICheckInService {
}
log.info("二维码匹配成功，memberId: {}", memberId);
Long memberCardRecordId = map.get("memberCardRecordId") != null
? ((Number) map.get("memberCardRecordId")).longValue() : null;
Long memberCardRecordId = ((Number) map.get("memberCardRecordId")).longValue();
return processCheckIn(memberId, memberCardRecordId, map, qrContent);
return processCheckIn(memberId, memberCardRecordId, map, qrContent);
} else {
MyWebSocketHandler.sendFailure(qrContent, "二维码无效");
return Mono.error(new RuntimeException("二维码无效"));
@@ -138,23 +145,54 @@ public class CheckServiceImpl implements ICheckInService {
LocalDateTime now = LocalDateTime.now();
// 发送实时进度通知
MyWebSocketHandler.sendProgress(qrContent, "VALIDATE_BOOKING", "正在检查预约信息...");
// 检查是否有需要签到的团课预约
return validateBooking(memberId, now)
.then(Mono.defer(() -> {
redisMap.put("isUsed", true);
redisMap.put("checkInTime", now.format(DATE_FORMATTER));
MyWebSocketHandler.sendProgress(qrContent, "VALIDATE_CARD", "正在验证会员卡...");
return memberCardRecordRepository.findById(memberCardRecordId)
.switchIfEmpty(Mono.defer(() -> {
MyWebSocketHandler.sendFailure(qrContent, "会员卡记录不存在");
return Mono.error(new RuntimeException("会员卡记录不存在"));
}))
.flatMap(cardRecord -> {
if (!"ACTIVE".equals(cardRecord.getStatus().name())) {
MyWebSocketHandler.sendFailure(qrContent, "会员卡状态不正确");
return Mono.error(new RuntimeException("会员卡状态不正确"));
}
return saveSignInRecord(memberId, null, null)
.then(redisUtil.set(RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now(), redisMap))
.then(Mono.defer(() -> {
String successMsg = buildSuccessResponse(now);
MyWebSocketHandler.sendSuccess(qrContent, memberId, now.format(DATE_FORMATTER));
log.info("签到成功, memberId: {}", memberId);
return Mono.just(successMsg);
}));
}));
if (cardRecord.getExpireTime() != null && cardRecord.getExpireTime().isBefore(now)) {
MyWebSocketHandler.sendFailure(qrContent, "会员卡已过期");
return Mono.error(new RuntimeException("会员卡已过期"));
}
// 发送实时进度通知
MyWebSocketHandler.sendProgress(qrContent, "VALIDATE_BOOKING", "会员卡验证通过，正在检查预约信息...");
// 检查是否有需要签到的团课预约
return validateBooking(memberId, now)
.then(memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(cardRecord.getMemberCardId())
.switchIfEmpty(Mono.defer(() -> {
MyWebSocketHandler.sendFailure(qrContent, "会员卡类型不存在");
return Mono.error(new RuntimeException("会员卡类型不存在"));
}))
.flatMap(card -> {
// 发送实时进度通知
MyWebSocketHandler.sendProgress(qrContent, "DEDUCT_USAGE", "正在扣减会员卡次数...");
return deductCardUsage(cardRecord, card)
.flatMap(updatedRecord -> {
redisMap.put("isUsed", true);
redisMap.put("checkInTime", now.format(DATE_FORMATTER));
return saveSignInRecord(memberId, cardRecord.getMemberCardRecordId(), card.getMemberCardId())
.then(redisUtil.set(RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now(), redisMap))
.then(Mono.defer(() -> {
String successMsg = buildSuccessResponse(now);
MyWebSocketHandler.sendSuccess(qrContent, memberId, now.format(DATE_FORMATTER));
log.info("签到成功, memberId: {}, cardRecordId: {}", memberId, memberCardRecordId);
return Mono.just(successMsg);
}));
});
}));
});
}
/**
gym-manage-api/gym-coach/pom.xml
-62
View File
@@ -1,62 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-manage-api</artifactId>
<version>1.0.0</version>
</parent>
<artifactId>gym-coach</artifactId>
<packaging>jar</packaging>
<name>Gym Coach</name>
<description>Coach Management Module - Course Start/End, Violation Tracking</description>
<dependencies>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-common</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-db</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-sys</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-groupCourse</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-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-commons</artifactId>
</dependency>
<dependency>
<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
</project>
gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/dao/CoachViolationDao.java
-15
View File
@@ -1,15 +0,0 @@
package cn.novalon.gym.manage.coach.dao;
import cn.novalon.gym.manage.coach.entity.CoachViolationEntity;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.stereotype.Repository;
/**
* 教练违规记录 DAO
*
* @author 张翔
* @date 2026-07-20
*/
@Repository
public interface CoachViolationDao extends R2dbcRepository<CoachViolationEntity, Long> {
}
gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/entity/CoachViolationEntity.java
-61
View File
@@ -1,61 +0,0 @@
package cn.novalon.gym.manage.coach.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;
/**
* 教练违规记录实体类 - 对应 coach_violation 表
*
* @author 张翔
* @date 2026-07-20
*/
@Table("coach_violation")
public class CoachViolationEntity extends BaseEntity {
@Column("coach_id")
private Long coachId;
@Column("course_id")
private Long courseId;
@Column("violation_time")
private LocalDateTime violationTime;
@Column("violation_reason")
private String violationReason;
public Long getCoachId() {
return coachId;
}
public void setCoachId(Long coachId) {
this.coachId = coachId;
}
public Long getCourseId() {
return courseId;
}
public void setCourseId(Long courseId) {
this.courseId = courseId;
}
public LocalDateTime getViolationTime() {
return violationTime;
}
public void setViolationTime(LocalDateTime violationTime) {
this.violationTime = violationTime;
}
public String getViolationReason() {
return violationReason;
}
public void setViolationReason(String violationReason) {
this.violationReason = violationReason;
}
}
gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/enums/BookingStatus.java
-42
View File
@@ -1,42 +0,0 @@
package cn.novalon.gym.manage.coach.enums;
/**
* 团课预约状态枚举
*
* @author 张翔
* @date 2026-07-20
*/
public enum BookingStatus {
BOOKED("0", "已预约"),
CANCELLED("1", "已取消"),
ATTENDED("2", "已出席"),
ABSENT("3", "缺席"),
COACH_ABSENT("4", "教练缺席"),
LATE("5", "迟到");
private final String value;
private final String desc;
BookingStatus(String value, String desc) {
this.value = value;
this.desc = desc;
}
public String getValue() {
return value;
}
public String getDesc() {
return desc;
}
public static BookingStatus fromValue(String value) {
for (BookingStatus status : values()) {
if (status.value.equals(value)) {
return status;
}
}
return BOOKED;
}
}
gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/enums/ViolationReason.java
-30
View File
@@ -1,30 +0,0 @@
package cn.novalon.gym.manage.coach.enums;
/**
* 教练违规原因枚举
*
* @author 张翔
* @date 2026-07-20
*/
public enum ViolationReason {
COACH_LATE("COACH_LATE", "教练迟到"),
COACH_ABSENT("COACH_ABSENT", "教练缺席"),
NOT_MANUAL_END("NOT_MANUAL_END", "教练未手动结课");
private final String value;
private final String desc;
ViolationReason(String value, String desc) {
this.value = value;
this.desc = desc;
}
public String getValue() {
return value;
}
public String getDesc() {
return desc;
}
}
gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/handler/CoachCourseHandler.java
-68
View File
@@ -1,68 +0,0 @@
package cn.novalon.gym.manage.coach.handler;
import cn.novalon.gym.manage.coach.service.CoachCourseService;
import cn.novalon.gym.manage.sys.util.AuthUtil;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.Map;
/**
* 教练开课/结课处理器
*
* @author 张翔
* @date 2026-07-20
*/
@Component
@Tag(name = "教练开课结课", description = "教练开课与结课操作")
public class CoachCourseHandler {
private static final Logger logger = LoggerFactory.getLogger(CoachCourseHandler.class);
private final CoachCourseService coachCourseService;
private final AuthUtil authUtil;
public CoachCourseHandler(CoachCourseService coachCourseService, AuthUtil authUtil) {
this.coachCourseService = coachCourseService;
this.authUtil = authUtil;
}
@Operation(summary = "教练开课", description = "教练手动开课，记录实际开课时间，若超时则判定迟到")
public Mono<ServerResponse> startCourse(ServerRequest request) {
Long courseId = Long.valueOf(request.pathVariable("courseId"));
Long coachId = authUtil.getMemberIdOrThrow(request);
return coachCourseService.startCourse(courseId, coachId)
.flatMap(result -> ServerResponse.ok().bodyValue(Map.of(
"message", "开课成功",
"status", result.getStatus(),
"actualStartTime", result.getActualStartTime() != null ? result.getActualStartTime().toString() : ""
)))
.onErrorResume(e -> {
logger.error("开课失败: {}", e.getMessage());
return ServerResponse.badRequest().bodyValue(Map.of("error", e.getMessage()));
});
}
@Operation(summary = "教练结课", description = "教练手动结课，记录实际结课时间")
public Mono<ServerResponse> endCourse(ServerRequest request) {
Long courseId = Long.valueOf(request.pathVariable("courseId"));
Long coachId = authUtil.getMemberIdOrThrow(request);
return coachCourseService.endCourse(courseId, coachId)
.flatMap(result -> ServerResponse.ok().bodyValue(Map.of(
"message", "结课成功",
"status", result.getStatus(),
"actualEndTime", result.getActualEndTime() != null ? result.getActualEndTime().toString() : ""
)))
.onErrorResume(e -> {
logger.error("结课失败: {}", e.getMessage());
return ServerResponse.badRequest().bodyValue(Map.of("error", e.getMessage()));
});
}
}
gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/handler/CoachHandler.java
-118
View File
@@ -1,118 +0,0 @@
package cn.novalon.gym.manage.coach.handler;
import cn.novalon.gym.manage.coach.service.CoachCourseService;
import cn.novalon.gym.manage.sys.core.domain.SysUser;
import cn.novalon.gym.manage.sys.dto.request.CoachCreateRequest;
import cn.novalon.gym.manage.sys.dto.request.CoachUpdateRequest;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Validator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 教练管理处理器（从 manage-app 迁移至 gym-coach 模块）
*
* @author 张翔
* @date 2026-07-19
*/
@Component
@Tag(name = "教练管理", description = "教练相关操作")
public class CoachHandler {
private static final Logger logger = LoggerFactory.getLogger(CoachHandler.class);
private final CoachCourseService coachCourseService;
private final Validator validator;
public CoachHandler(CoachCourseService coachCourseService, Validator validator) {
this.coachCourseService = coachCourseService;
this.validator = validator;
}
@Operation(summary = "获取所有教练", description = "获取系统中所有教练列表")
public Mono<ServerResponse> getAllCoaches(ServerRequest request) {
return ServerResponse.ok()
.body(coachCourseService.getAllCoaches(), SysUser.class);
}
@Operation(summary = "创建教练", description = "创建新教练（创建用户并分配教练角色）")
public Mono<ServerResponse> createCoach(ServerRequest request) {
return request.bodyToMono(CoachCreateRequest.class)
.flatMap(req -> {
var violations = validator.validate(req);
if (!violations.isEmpty()) {
Map<String, String> errors = new HashMap<>();
violations.forEach(v -> errors.put(v.getPropertyPath().toString(), v.getMessage()));
return ServerResponse.badRequest().bodyValue(errors);
}
return coachCourseService.createCoach(
req.getUsername(), req.getPassword(),
req.getNickname(), req.getEmail(), req.getPhone())
.flatMap(user -> ServerResponse.status(HttpStatus.CREATED).bodyValue(user))
.onErrorResume(e -> {
logger.error("创建教练失败", e);
return ServerResponse.badRequest()
.bodyValue(Map.of("error", e.getMessage()));
});
});
}
@Operation(summary = "更新教练信息", description = "更新教练基本信息（昵称、邮箱、手机号）")
public Mono<ServerResponse> updateCoach(ServerRequest request) {
Long id = Long.valueOf(request.pathVariable("id"));
return request.bodyToMono(CoachUpdateRequest.class)
.flatMap(req -> coachCourseService.updateCoach(id, req.getNickname(), req.getEmail(), req.getPhone())
.flatMap(user -> ServerResponse.ok().bodyValue(user))
.switchIfEmpty(ServerResponse.notFound().build())
.onErrorResume(e -> {
logger.error("更新教练失败", e);
return ServerResponse.badRequest()
.bodyValue(Map.of("error", e.getMessage()));
}));
}
@Operation(summary = "禁用教练", description = "禁用教练账号，自动取消其所有非进行中的团课")
public Mono<ServerResponse> disableCoach(ServerRequest request) {
Long id = Long.valueOf(request.pathVariable("id"));
return coachCourseService.disableCoach(id)
.then(ServerResponse.ok().bodyValue(Map.of("message", "教练已禁用")))
.onErrorResume(e -> {
logger.error("禁用教练失败: {}", e.getMessage());
return ServerResponse.badRequest().bodyValue(Map.of("error", e.getMessage()));
});
}
@Operation(summary = "获取教练的团课", description = "获取指定教练教授的所有团课")
public Mono<ServerResponse> getCoachCourses(ServerRequest request) {
Long id = Long.valueOf(request.pathVariable("id"));
return coachCourseService.getCoachCourses(id)
.collectList()
.flatMap(courses -> ServerResponse.ok().bodyValue(courses))
.switchIfEmpty(ServerResponse.ok().bodyValue(List.of()));
}
@Operation(summary = "获取教练违规次数统计", description = "获取所有教练的违规次数")
public Mono<ServerResponse> getViolationCounts(ServerRequest request) {
return coachCourseService.getViolationCounts()
.collectList()
.flatMap(counts -> ServerResponse.ok().bodyValue(counts));
}
@Operation(summary = "获取教练违规记录", description = "获取指定教练的违规记录")
public Mono<ServerResponse> getCoachViolations(ServerRequest request) {
Long id = Long.valueOf(request.pathVariable("id"));
return coachCourseService.getCoachViolations(id)
.collectList()
.flatMap(violations -> ServerResponse.ok().bodyValue(violations))
.switchIfEmpty(ServerResponse.ok().bodyValue(List.of()));
}
}
gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/scheduler/CoachCourseScheduler.java
-178
View File
@@ -1,178 +0,0 @@
package cn.novalon.gym.manage.coach.scheduler;
import cn.novalon.gym.manage.coach.enums.ViolationReason;
import cn.novalon.gym.manage.common.util.RedisUtil;
import cn.novalon.gym.manage.groupcourse.dao.GroupCourseBookingDao;
import cn.novalon.gym.manage.groupcourse.dao.GroupCourseDao;
import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
import cn.novalon.gym.manage.groupcourse.enums.CourseStatus;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.r2dbc.core.DatabaseClient;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
import java.time.Duration;
import java.time.LocalDateTime;
/**
* 教练课程定时调度器
*
* 功能：
* 1. 检查未手动开课的课程，超时标记为教练缺席(5)并记录违规
* 2. 检查未手动结课的课程，超时标记为自动结束(6)并记录违规
*
* @author 张翔
* @date 2026-07-20
*/
@Component
public class CoachCourseScheduler {
private static final Logger logger = LoggerFactory.getLogger(CoachCourseScheduler.class);
private static final long ONE_HOUR_MINUTES = 60;
private static final long END_GRACE_MINUTES = 10;
private final GroupCourseDao groupCourseDao;
private final GroupCourseBookingDao groupCourseBookingDao;
private final DatabaseClient databaseClient;
private final RedisUtil redisUtil;
public CoachCourseScheduler(GroupCourseDao groupCourseDao,
GroupCourseBookingDao groupCourseBookingDao,
DatabaseClient databaseClient,
RedisUtil redisUtil) {
this.groupCourseDao = groupCourseDao;
this.groupCourseBookingDao = groupCourseBookingDao;
this.databaseClient = databaseClient;
this.redisUtil = redisUtil;
}
/**
* 每分钟检查一次：
* - status=0(NORMAL) 的课程是否已过开课缺席阈值
* - status=3(IN_PROGRESS) 或 status=7(COACH_LATE) 的课程是否已过结课宽限期
*/
@Scheduled(fixedRate = 60000)
public void checkAndProcessCourses() {
logger.debug("教练课程调度器开始检查");
LocalDateTime now = LocalDateTime.now();
// 1. 检查未开课的课程
processAbsentCourses(now)
.subscribe(
count -> {
if (count > 0) {
logger.info("教练课程调度器：处理了 {} 门教练缺席课程", count);
invalidateCache();
}
},
error -> logger.error("教练课程调度器（缺席检查）执行失败：{}", error.getMessage(), error)
);
// 2. 检查未结课的课程
processAutoEndCourses(now)
.subscribe(
count -> {
if (count > 0) {
logger.info("教练课程调度器：处理了 {} 门自动结束课程", count);
invalidateCache();
}
},
error -> logger.error("教练课程调度器（自动结课）执行失败：{}", error.getMessage(), error)
);
}
/**
* 处理缺席课程：status=0 且已过开课缺席阈值
*/
private Mono<Long> processAbsentCourses(LocalDateTime now) {
return groupCourseDao.findByStatusAndStartTimeBefore(databaseClient, "0", now)
.filter(course -> isAbsentThresholdExceeded(course, now))
.flatMap(course -> markAsCoachAbsent(course, now))
.count();
}
/**
* 处理自动结课：status IN ('3','7') 且 end_time + 10分钟 已过
*/
private Mono<Long> processAutoEndCourses(LocalDateTime now) {
LocalDateTime endThreshold = now.minusMinutes(END_GRACE_MINUTES);
return groupCourseDao.findByStatusInAndEndTimeBefore(databaseClient,
new String[]{String.valueOf(CourseStatus.IN_PROGRESS.getValue()),
String.valueOf(CourseStatus.COACH_LATE.getValue())},
endThreshold)
.flatMap(course -> markAsAutoEnded(course, now))
.count();
}
/**
* 判断课程是否已过缺席阈值
*/
private boolean isAbsentThresholdExceeded(GroupCourseEntity course, LocalDateTime now) {
long courseDurationMinutes = Duration.between(course.getStartTime(), course.getEndTime()).toMinutes();
long minutesSinceStart = Duration.between(course.getStartTime(), now).toMinutes();
if (courseDurationMinutes >= ONE_HOUR_MINUTES) {
return minutesSinceStart > 30;
} else {
long thresholdB = Math.max(1, (long) (courseDurationMinutes * 0.25));
return minutesSinceStart > thresholdB;
}
}
/**
* 标记课程为教练缺席(5)，更新预约记录为教练缺席(4)，记录违规
*/
private Mono<GroupCourseEntity> markAsCoachAbsent(GroupCourseEntity course, LocalDateTime now) {
logger.info("课程 {} 教练缺席，标记为 COACH_ABSENT", course.getId());
return insertViolation(course.getCoachId(), course.getId(), now, ViolationReason.COACH_ABSENT)
.then(groupCourseDao.updateToCoachAbsent(course.getId(), now, now))
.then(groupCourseBookingDao.updateStatusByCourseId(course.getId(), "0", "4"))
.thenReturn(course);
}
/**
* 标记课程为自动结束(6)，记录违规
*/
private Mono<GroupCourseEntity> markAsAutoEnded(GroupCourseEntity course, LocalDateTime now) {
logger.info("课程 {} 未手动结课，标记为 AUTO_ENDED", course.getId());
return insertViolation(course.getCoachId(), course.getId(), now, ViolationReason.NOT_MANUAL_END)
.then(groupCourseDao.updateToAutoEnded(course.getId(), now, now))
.thenReturn(course);
}
/**
* 插入违规记录（使用 DatabaseClient 直连）
*/
private Mono<Void> insertViolation(Long coachId, Long courseId, LocalDateTime violationTime,
ViolationReason reason) {
return databaseClient.sql("""
INSERT INTO coach_violation (coach_id, course_id, violation_time, violation_reason, created_at, updated_at)
VALUES (:coachId, :courseId, :violationTime, :reason, :now, :now)
""")
.bind("coachId", coachId)
.bind("courseId", courseId)
.bind("violationTime", violationTime)
.bind("reason", reason.getValue())
.bind("now", LocalDateTime.now())
.then();
}
/**
* 清除统计缓存和团课缓存 —— 调度器触发时，如有课程状态变更则必须及时失效
*/
private void invalidateCache() {
redisUtil.deleteByPattern("datacount:statistics:*").subscribe(
deleted -> logger.debug("调度器清除统计缓存，已删除 {} 条", deleted),
error -> logger.warn("调度器清除统计缓存失败: {}", error.getMessage())
);
redisUtil.deleteByPattern("group_course:*").subscribe(
deleted -> logger.debug("调度器清除团课缓存，已删除 {} 条", deleted),
error -> logger.warn("调度器清除团课缓存失败: {}", error.getMessage())
);
}
}
gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/service/CoachCourseService.java
-357
View File
@@ -1,357 +0,0 @@
package cn.novalon.gym.manage.coach.service;
import cn.novalon.gym.manage.coach.dao.CoachViolationDao;
import cn.novalon.gym.manage.coach.entity.CoachViolationEntity;
import cn.novalon.gym.manage.coach.enums.ViolationReason;
import cn.novalon.gym.manage.common.util.RedisUtil;
import cn.novalon.gym.manage.common.util.StatusConstants;
import cn.novalon.gym.manage.groupcourse.dao.GroupCourseBookingDao;
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.enums.CourseStatus;
import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepository;
import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
import cn.novalon.gym.manage.sys.core.domain.SysRole;
import cn.novalon.gym.manage.sys.core.domain.SysUser;
import cn.novalon.gym.manage.sys.core.domain.UserRole;
import cn.novalon.gym.manage.sys.core.repository.ISysRoleRepository;
import cn.novalon.gym.manage.sys.core.repository.ISysUserRepository;
import cn.novalon.gym.manage.sys.core.repository.IUserRoleRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Sort;
import org.springframework.r2dbc.core.DatabaseClient;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.Map;
/**
* 教练课程服务（含教练管理 + 开课/结课逻辑 + 违规记录）
*
* @author 张翔
* @date 2026-07-20
*/
@Service
public class CoachCourseService {
private static final Logger logger = LoggerFactory.getLogger(CoachCourseService.class);
private static final String COACH_ROLE_NAME = "教练";
private static final long ONE_HOUR_MINUTES = 60;
private final ISysUserRepository userRepository;
private final ISysRoleRepository roleRepository;
private final IUserRoleRepository userRoleRepository;
private final IGroupCourseRepository groupCourseRepository;
private final IGroupCourseBookingRepository bookingRepository;
private final GroupCourseDao groupCourseDao;
private final GroupCourseBookingDao groupCourseBookingDao;
private final CoachViolationDao violationDao;
private final DatabaseClient databaseClient;
private final PasswordEncoder passwordEncoder;
private final RedisUtil redisUtil;
public CoachCourseService(ISysUserRepository userRepository,
ISysRoleRepository roleRepository,
IUserRoleRepository userRoleRepository,
IGroupCourseRepository groupCourseRepository,
IGroupCourseBookingRepository bookingRepository,
GroupCourseDao groupCourseDao,
GroupCourseBookingDao groupCourseBookingDao,
CoachViolationDao violationDao,
DatabaseClient databaseClient,
PasswordEncoder passwordEncoder,
RedisUtil redisUtil) {
this.userRepository = userRepository;
this.roleRepository = roleRepository;
this.userRoleRepository = userRoleRepository;
this.groupCourseRepository = groupCourseRepository;
this.bookingRepository = bookingRepository;
this.groupCourseDao = groupCourseDao;
this.groupCourseBookingDao = groupCourseBookingDao;
this.violationDao = violationDao;
this.databaseClient = databaseClient;
this.passwordEncoder = passwordEncoder;
this.redisUtil = redisUtil;
}
// ==================== 教练管理（从原 CoachService 迁移） ====================
public Flux<SysUser> getAllCoaches() {
return getCoachRoleId()
.flatMapMany(roleId -> userRoleRepository.findByRoleId(roleId)
.map(UserRole::getUserId)
.collectList()
.flatMapMany(userIds -> {
if (userIds.isEmpty()) {
return Flux.empty();
}
return Flux.fromIterable(userIds)
.flatMap(userRepository::findById)
.filter(user -> user.getDeletedAt() == null);
}));
}
public Mono<SysUser> createCoach(String username, String password, String nickname, String email, String phone) {
return getCoachRoleId().flatMap(coachRoleId -> {
SysUser user = new SysUser();
user.generateId();
user.setUsername(username);
user.setPassword(passwordEncoder.encode(password));
user.setNickname(nickname);
user.setEmail(email);
user.setPhone(phone);
user.setStatus(StatusConstants.ENABLED);
return userRepository.save(user)
.flatMap(saved -> {
UserRole userRole = new UserRole();
userRole.setUserId(saved.getId());
userRole.setRoleId(coachRoleId);
return userRoleRepository.save(userRole).thenReturn(saved);
});
});
}
public Mono<SysUser> updateCoach(Long id, String nickname, String email, String phone) {
return userRepository.findById(id)
.switchIfEmpty(Mono.error(new RuntimeException("教练不存在")))
.flatMap(user -> {
if (nickname != null) user.setNickname(nickname);
if (email != null) user.setEmail(email);
if (phone != null) user.setPhone(phone);
user.setUpdatedAt(LocalDateTime.now());
return userRepository.update(user);
});
}
@Transactional(transactionManager = "connectionFactoryTransactionManager")
public Mono<Void> disableCoach(Long id) {
return userRepository.findById(id)
.switchIfEmpty(Mono.error(new RuntimeException("教练不存在")))
.flatMap(user ->
groupCourseRepository.countByCoachIdAndStatus(id, 3L)
.flatMap(inProgressCount -> {
if (inProgressCount > 0) {
return Mono.error(new RuntimeException(
"该教练有 " + inProgressCount + " 门正在进行中的团课，无法禁用"));
}
return groupCourseRepository.cancelCoursesByCoachIdExceptStatus(id, 3L)
.then();
})
.then(Mono.defer(() -> {
user.setStatus(StatusConstants.DISABLED);
user.setUpdatedAt(LocalDateTime.now());
return userRepository.update(user).then();
}))
)
.then(invalidateStatisticsCache());
}
public Flux<GroupCourse> getCoachCourses(Long coachId) {
return groupCourseRepository.findByCoachId(coachId, Sort.by(Sort.Direction.DESC, "startTime"))
.flatMap(course ->
bookingRepository.countValidBookings(course.getId())
.map(count -> {
course.setCurrentMembers(count.intValue());
return course;
})
.defaultIfEmpty(course)
);
}
public Mono<Long> getCoachRoleId() {
return roleRepository.findByRoleName(COACH_ROLE_NAME)
.map(SysRole::getId)
.switchIfEmpty(Mono.error(new RuntimeException("教练角色未找到，请先执行数据库迁移")));
}
// ==================== 开课逻辑 ====================
/**
* 教练手动开课
* 判定逻辑：
* - 长课时(>=1h): 10分钟内正常，10~30分钟迟到，>30分钟拒绝
* - 短课时(<1h): 10%时长内正常，10%~25%迟到，>25%拒绝
*/
public Mono<GroupCourseEntity> startCourse(Long courseId, Long coachId) {
return groupCourseDao.findByIdIsAndDeletedAtIsNull(courseId)
.switchIfEmpty(Mono.error(new RuntimeException("团课不存在")))
.flatMap(course -> {
// 验证教练身份
if (!course.getCoachId().equals(coachId)) {
return Mono.error(new RuntimeException("您不是该课程的教练，无权开课"));
}
// 验证课程状态：只有 NORMAL(0) 可以开课
if (!CourseStatus.NORMAL.getValue().equals(course.getStatus())) {
return Mono.error(new RuntimeException("当前课程状态不允许开课，当前状态: " + course.getStatus()));
}
LocalDateTime now = LocalDateTime.now();
long courseDurationMinutes = Duration.between(course.getStartTime(), course.getEndTime()).toMinutes();
if (courseDurationMinutes >= ONE_HOUR_MINUTES) {
return handleLongCourseStart(course, now);
} else {
return handleShortCourseStart(course, now, courseDurationMinutes);
}
});
}
private Mono<GroupCourseEntity> handleLongCourseStart(GroupCourseEntity course, LocalDateTime now) {
long minutesSinceStart = Duration.between(course.getStartTime(), now).toMinutes();
if (minutesSinceStart < 0) {
return Mono.error(new RuntimeException("课程尚未到开课时间"));
}
if (minutesSinceStart <= 10) {
// 正常开课
return doStartCourse(course, now, CourseStatus.IN_PROGRESS, null);
}
if (minutesSinceStart <= 30) {
// 教练迟到
return recordViolation(course.getCoachId(), course.getId(), now, ViolationReason.COACH_LATE)
.then(doStartCourse(course, now, CourseStatus.COACH_LATE, ViolationReason.COACH_LATE));
}
// >30分钟，拒绝（调度器应已标记为缺席）
return Mono.error(new RuntimeException("已超过开课时间30分钟，无法开课"));
}
private Mono<GroupCourseEntity> handleShortCourseStart(GroupCourseEntity course, LocalDateTime now,
long courseDurationMinutes) {
long minutesSinceStart = Duration.between(course.getStartTime(), now).toMinutes();
long thresholdA = Math.max(1, (long) (courseDurationMinutes * 0.10));
long thresholdB = Math.max(1, (long) (courseDurationMinutes * 0.25));
if (minutesSinceStart < 0) {
return Mono.error(new RuntimeException("课程尚未到开课时间"));
}
if (minutesSinceStart <= thresholdA) {
// 正常开课
return doStartCourse(course, now, CourseStatus.IN_PROGRESS, null);
}
if (minutesSinceStart <= thresholdB) {
// 教练迟到
return recordViolation(course.getCoachId(), course.getId(), now, ViolationReason.COACH_LATE)
.then(doStartCourse(course, now, CourseStatus.COACH_LATE, ViolationReason.COACH_LATE));
}
// >thresholdB，拒绝
return Mono.error(new RuntimeException("已超过开课时间，无法开课"));
}
private Mono<GroupCourseEntity> doStartCourse(GroupCourseEntity course, LocalDateTime now,
CourseStatus newStatus, ViolationReason violationReason) {
course.setStatus(newStatus.getValue());
course.setActualStartTime(now);
course.setUpdatedAt(now);
return groupCourseDao.updateStartInfo(course.getId(), String.valueOf(newStatus.getValue()), now, now)
.then(groupCourseDao.findByIdIsAndDeletedAtIsNull(course.getId()))
.flatMap(entity -> invalidateStatisticsCache().thenReturn(entity));
}
// ==================== 结课逻辑 ====================
/**
* 教练手动结课
* 可在 IN_PROGRESS(3) 或 COACH_LATE(7) 状态下结课
* 必须在标注结课时间 + 10分钟内
*/
public Mono<GroupCourseEntity> endCourse(Long courseId, Long coachId) {
return groupCourseDao.findByIdIsAndDeletedAtIsNull(courseId)
.switchIfEmpty(Mono.error(new RuntimeException("团课不存在")))
.flatMap(course -> {
// 验证教练身份
if (!course.getCoachId().equals(coachId)) {
return Mono.error(new RuntimeException("您不是该课程的教练，无权结课"));
}
// 验证状态：IN_PROGRESS(3) 或 COACH_LATE(7)
Long status = course.getStatus();
if (!CourseStatus.IN_PROGRESS.getValue().equals(status)
&& !CourseStatus.COACH_LATE.getValue().equals(status)) {
return Mono.error(new RuntimeException("当前课程状态不允许结课，当前状态: " + status));
}
LocalDateTime now = LocalDateTime.now();
long minutesAfterEnd = Duration.between(course.getEndTime(), now).toMinutes();
if (minutesAfterEnd > 10) {
return Mono.error(new RuntimeException("已超过结课时间10分钟，请等待系统自动结课"));
}
course.setStatus(CourseStatus.ENDED.getValue());
course.setActualEndTime(now);
course.setUpdatedAt(now);
return groupCourseDao.updateEndInfo(course.getId(), String.valueOf(CourseStatus.ENDED.getValue()), now, now)
.then(groupCourseDao.findByIdIsAndDeletedAtIsNull(course.getId()))
.flatMap(entity -> invalidateStatisticsCache().thenReturn(entity));
});
}
// ==================== 违规记录 ====================
/**
* 记录教练违规行为（使用 DatabaseClient 直连，避免 R2DBC Entity 映射问题）
*/
public Mono<Void> recordViolation(Long coachId, Long courseId, LocalDateTime violationTime,
ViolationReason reason) {
LocalDateTime now = LocalDateTime.now();
return databaseClient.sql("""
INSERT INTO coach_violation (coach_id, course_id, violation_time, violation_reason, created_at, updated_at)
VALUES (:coachId, :courseId, :violationTime, :reason, :now, :now)
""")
.bind("coachId", coachId)
.bind("courseId", courseId)
.bind("violationTime", violationTime)
.bind("reason", reason.getValue())
.bind("now", now)
.then();
}
// ==================== 违规查询 ====================
/**
* 获取所有教练的违规次数统计
*/
public Flux<Map<String, Object>> getViolationCounts() {
return databaseClient.sql("""
SELECT coach_id, COUNT(*) AS count
FROM coach_violation
WHERE deleted_at IS NULL
GROUP BY coach_id
""")
.fetch()
.all();
}
/**
* 获取指定教练的违规记录
*/
public Flux<Map<String, Object>> getCoachViolations(Long coachId) {
return databaseClient.sql("""
SELECT v.*, gc.course_name
FROM coach_violation v
LEFT JOIN group_course gc ON v.course_id = gc.id AND gc.deleted_at IS NULL
WHERE v.coach_id = :coachId AND v.deleted_at IS NULL
ORDER BY v.violation_time DESC
""")
.bind("coachId", coachId)
.fetch()
.all();
}
/**
* 清除统计缓存和团课缓存 —— 课程状态变更后调用，返回 Mono 确保链式执行
*/
private Mono<Void> invalidateStatisticsCache() {
return redisUtil.deleteByPattern("datacount:statistics:*")
.then(redisUtil.deleteByPattern("group_course:*"))
.doOnNext(count -> {})
.then();
}
}
gym-manage-api/gym-dataCount/pom.xml
+1 -6
View File
@@ -67,12 +67,7 @@
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
</dependency>
<!-- Fix commons-compress version for POI compatibility -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-compress</artifactId>
<version>5.2.5</version>
</dependency>
<!-- Gym Modules -->
gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/dao/DataStatisticsDao.java
-65
View File
@@ -6,7 +6,6 @@ import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
import java.util.Map;
/**
* 数据统计 DAO - 使用 DatabaseClient 执行跨表聚合查询
@@ -181,68 +180,4 @@ public class DataStatisticsDao {
this.count = count;
}
}
// ========== 教练相关统计 ==========
/** 统计教练总数（角色为"教练"的用户） */
public Mono<Long> countTotalCoaches() {
return databaseClient.sql("""
SELECT COUNT(*) FROM sys_user u
INNER JOIN user_role ur ON u.id = ur.user_id
INNER JOIN sys_role sr ON ur.role_id = sr.id
WHERE sr.role_name = '教练' AND u.deleted_at IS NULL
""")
.map(row -> row.get(0, Long.class))
.one();
}
/** 统计违规总数（时间范围） */
public Mono<Long> countTotalViolations(LocalDateTime startTime, LocalDateTime endTime) {
return databaseClient.sql("""
SELECT COUNT(*) FROM coach_violation
WHERE violation_time >= :startTime AND violation_time < :endTime AND deleted_at IS NULL
""")
.bind("startTime", startTime)
.bind("endTime", endTime)
.map(row -> row.get(0, Long.class))
.one();
}
/** 按违规类型统计次数 */
public Flux<Map<String, Object>> countViolationsByReason(LocalDateTime startTime, LocalDateTime endTime) {
return databaseClient.sql("""
SELECT violation_reason, COUNT(*) AS count
FROM coach_violation
WHERE violation_time >= :startTime AND violation_time < :endTime AND deleted_at IS NULL
GROUP BY violation_reason
""")
.bind("startTime", startTime)
.bind("endTime", endTime)
.fetch()
.all();
}
/** 统计有违规记录的教练数 */
public Mono<Long> countViolatedCoaches(LocalDateTime startTime, LocalDateTime endTime) {
return databaseClient.sql("""
SELECT COUNT(DISTINCT coach_id) FROM coach_violation
WHERE violation_time >= :startTime AND violation_time < :endTime AND deleted_at IS NULL
""")
.bind("startTime", startTime)
.bind("endTime", endTime)
.map(row -> row.get(0, Long.class))
.one();
}
/** 统计区间内开课的团课数 */
public Mono<Long> countCourses(LocalDateTime startTime, LocalDateTime endTime) {
return databaseClient.sql("""
SELECT COUNT(*) FROM group_course
WHERE start_time >= :startTime AND start_time < :endTime AND deleted_at IS NULL
""")
.bind("startTime", startTime)
.bind("endTime", endTime)
.map(row -> row.get(0, Long.class))
.one();
}
}
gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/domain/CoachStatistics.java
-40
View File
@@ -1,40 +0,0 @@
package cn.novalon.gym.manage.datacount.domain;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 教练统计数据
*
* @author 张翔
* @date 2026-07-20
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CoachStatistics {
/** 教练总数 */
private Long totalCoaches;
/** 违规总数 */
private Long totalViolations;
/** 迟到次数 */
private Long lateCount;
/** 缺席次数 */
private Long absentCount;
/** 未手动结课次数 */
private Long notManualEndCount;
/** 有违规记录的教练数 */
private Long violatedCoaches;
/** 统计区间内开课的团课数 */
private Long totalCourses;
}
gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/domain/DataStatistics.java
-6
View File
@@ -59,12 +59,6 @@ public class DataStatistics {
public static final String WEEK = "WEEK";
/** 月统计 */
public static final String MONTH = "MONTH";
/** 近30天 */
public static final String LAST_30_DAYS = "LAST_30_DAYS";
/** 近90天 */
public static final String LAST_90_DAYS = "LAST_90_DAYS";
/** 今年 */
public static final String YEAR = "YEAR";
private PeriodType() {}
}
gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/domain/StatisticsSummary.java
-5
View File
@@ -37,11 +37,6 @@ public class StatisticsSummary {
*/
private SignInStatistics signInStatistics;
/**
* 教练统计数据
*/
private CoachStatistics coachStatistics;
/**
* 统计数据生成时间
*/
gym-manage-api/gym-dataCount/src/main/java/cn/novalon/gym/manage/datacount/service/impl/DataStatisticsServiceImpl.java
+7 -49
View File
@@ -171,47 +171,18 @@ public class DataStatisticsServiceImpl implements IDataStatisticsService {
return count != null ? count : 0L;
}
private Mono<CoachStatistics> getCoachStatistics(StatisticsQuery query) {
LocalDateTime startTime = getStartTime(query);
LocalDateTime endTime = getEndTime(query);
Mono<Long> totalCoachesMono = dataStatisticsDao.countTotalCoaches();
Mono<Long> totalViolationsMono = dataStatisticsDao.countTotalViolations(startTime, endTime);
Mono<Long> violatedCoachesMono = dataStatisticsDao.countViolatedCoaches(startTime, endTime);
Mono<Long> totalCoursesMono = dataStatisticsDao.countCourses(startTime, endTime);
Mono<Map<String, Long>> violationByReasonMono = dataStatisticsDao.countViolationsByReason(startTime, endTime)
.collectMap(row -> (String) row.get("violation_reason"),
row -> ((Number) row.get("count")).longValue());
return Mono.zip(totalCoachesMono, totalViolationsMono, violatedCoachesMono, totalCoursesMono, violationByReasonMono)
.map(tuple -> {
Map<String, Long> reasonMap = tuple.getT5();
return CoachStatistics.builder()
.totalCoaches(tuple.getT1())
.totalViolations(tuple.getT2())
.lateCount(reasonMap.getOrDefault("COACH_LATE", 0L))
.absentCount(reasonMap.getOrDefault("COACH_ABSENT", 0L))
.notManualEndCount(reasonMap.getOrDefault("NOT_MANUAL_END", 0L))
.violatedCoaches(tuple.getT3())
.totalCourses(tuple.getT4())
.build();
});
}
@Override
public Mono<StatisticsSummary> getStatisticsSummary(StatisticsQuery query) {
Mono<MemberStatistics> memberStatsMono = getMemberStatistics(query);
Mono<BookingStatistics> bookingStatsMono = getBookingStatistics(query);
Mono<SignInStatistics> signInStatsMono = getSignInStatistics(query);
Mono<CoachStatistics> coachStatsMono = getCoachStatistics(query);
return Mono.zip(memberStatsMono, bookingStatsMono, signInStatsMono, coachStatsMono)
return Mono.zip(memberStatsMono, bookingStatsMono, signInStatsMono)
.map(tuple -> StatisticsSummary.builder()
.statDate(LocalDateTime.now().toLocalDate().toString())
.memberStatistics(tuple.getT1())
.bookingStatistics(tuple.getT2())
.signInStatistics(tuple.getT3())
.coachStatistics(tuple.getT4())
.generatedAt(LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME))
.build());
}
@@ -487,16 +458,13 @@ public class DataStatisticsServiceImpl implements IDataStatisticsService {
String periodType = query.getPeriodType();
if (DataStatistics.PeriodType.WEEK.equals(periodType)) {
// 周统计：本周一
return today.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY)).atStartOfDay();
} else if (DataStatistics.PeriodType.MONTH.equals(periodType)) {
// 月统计：本月第一天
return today.withDayOfMonth(1).atStartOfDay();
} else if (DataStatistics.PeriodType.LAST_30_DAYS.equals(periodType)) {
return today.minusDays(29).atStartOfDay();
} else if (DataStatistics.PeriodType.LAST_90_DAYS.equals(periodType)) {
return today.minusDays(89).atStartOfDay();
} else if (DataStatistics.PeriodType.YEAR.equals(periodType)) {
return today.withDayOfYear(1).atStartOfDay();
} else {
// 日统计：当天零点
return today.atStartOfDay();
}
}
@@ -510,14 +478,13 @@ public class DataStatisticsServiceImpl implements IDataStatisticsService {
String periodType = query.getPeriodType();
if (DataStatistics.PeriodType.WEEK.equals(periodType)) {
// 周统计：本周日 23:59:59
return today.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY)).atTime(23, 59, 59);
} else if (DataStatistics.PeriodType.MONTH.equals(periodType)) {
// 月统计：本月最后一天 23:59:59
return today.with(TemporalAdjusters.lastDayOfMonth()).atTime(23, 59, 59);
} else if (DataStatistics.PeriodType.LAST_30_DAYS.equals(periodType)
|| DataStatistics.PeriodType.LAST_90_DAYS.equals(periodType)
|| DataStatistics.PeriodType.YEAR.equals(periodType)) {
return LocalDateTime.now();
} else {
// 日统计：当前时间
return LocalDateTime.now();
}
}
@@ -536,15 +503,6 @@ public class DataStatisticsServiceImpl implements IDataStatisticsService {
} else if (DataStatistics.PeriodType.MONTH.equals(periodType)) {
startTime = date.withDayOfMonth(1).atStartOfDay();
endTime = date.with(TemporalAdjusters.lastDayOfMonth()).atTime(23, 59, 59);
} else if (DataStatistics.PeriodType.LAST_30_DAYS.equals(periodType)) {
startTime = date.minusDays(29).atStartOfDay();
endTime = date.atTime(23, 59, 59);
} else if (DataStatistics.PeriodType.LAST_90_DAYS.equals(periodType)) {
startTime = date.minusDays(89).atStartOfDay();
endTime = date.atTime(23, 59, 59);
} else if (DataStatistics.PeriodType.YEAR.equals(periodType)) {
startTime = date.withDayOfYear(1).atStartOfDay();
endTime = date.atTime(23, 59, 59);
} else {
startTime = date.atStartOfDay();
endTime = date.plusDays(1).atStartOfDay();
gym-manage-api/gym-groupCourse/pom.xml
+9 -14
View File
@@ -35,6 +35,11 @@
<artifactId>manage-common</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-sys</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-db</artifactId>
@@ -81,8 +86,8 @@
<artifactId>gym-member</artifactId>
<version>${project.version}</version>
</dependency>
<!-- ZXing QR Code依赖 -->
<!-- ZXing二维码生成库 -->
<dependency>
<groupId>com.google.zxing</groupId>
<artifactId>core</artifactId>
@@ -94,28 +99,18 @@
<version>3.5.3</version>
</dependency>
<!-- 阿里云OSS SDK -->
<!--
<dependency>
<groupId>com.aliyun.oss</groupId>
<artifactId>aliyun-sdk-oss</artifactId>
<version>3.17.4</version>
</dependency>
-->
<!-- 文件管理模块（统一文件存储） -->
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-file</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.4.2</version>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/dao/GroupCourseBookingDao.java
-13
View File
@@ -61,12 +61,6 @@ public interface GroupCourseBookingDao extends R2dbcRepository<GroupCourseBookin
*/
Mono<Long> countByCourseIdAndStatusAndDeletedAtIsNull(Long courseId, String status);
/**
* 统计会员取消的预约次数
*/
@org.springframework.data.r2dbc.repository.Query("SELECT COUNT(*) FROM group_course_booking WHERE member_id = :memberId AND status = '1' AND deleted_at IS NULL")
Mono<Long> countCancelledByMemberId(Long memberId);
/**
* 查询会员是否有时间冲突的预约（状态为已预约且未取消）
* 时间冲突条件：新课程的开始时间 < 已预约课程的结束时间 且 新课程的结束时间 > 已预约课程的开始时间
@@ -114,11 +108,4 @@ public interface GroupCourseBookingDao extends R2dbcRepository<GroupCourseBookin
@org.springframework.data.r2dbc.repository.Modifying
@org.springframework.data.r2dbc.repository.Query("UPDATE group_course_booking SET status = '3', updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
Mono<Integer> updateToAbsent(Long id, java.time.LocalDateTime updatedAt);
/**
* 批量更新某课程的预约状态（教练缺席场景）
*/
@org.springframework.data.r2dbc.repository.Modifying
@org.springframework.data.r2dbc.repository.Query("UPDATE group_course_booking SET status = :newStatus, updated_at = NOW() WHERE course_id = :courseId AND status = :oldStatus AND deleted_at IS NULL")
Mono<Integer> updateStatusByCourseId(Long courseId, String oldStatus, String newStatus);
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/dao/GroupCourseDao.java
+43 -191
View File
@@ -1,6 +1,5 @@
package cn.novalon.gym.manage.groupcourse.dao;
import cn.novalon.gym.manage.common.dto.PageRequest;
import cn.novalon.gym.manage.groupcourse.dto.GroupCourseQueryDto;
import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
import org.springframework.data.domain.Sort;
@@ -33,110 +32,60 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
@Query("UPDATE group_course SET status = '1', updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
Mono<Integer> cancelCourse(Long id, LocalDateTime updatedAt);
@Modifying
@Query("UPDATE group_course SET current_members = current_members + :delta, updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
Mono<Integer> updateCurrentMembers(Long id, Integer delta, LocalDateTime updatedAt);
@Modifying
@Query("UPDATE group_course SET deleted_at = :deletedAt WHERE id = :id")
Mono<Integer> softDelete(Long id, LocalDateTime deletedAt);
// ---------- 教练相关 SQL 方法 ----------
@Modifying
@Query("UPDATE group_course SET status = :status, actual_start_time = :actualStartTime, updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
Mono<Integer> updateStartInfo(Long id, String status, LocalDateTime actualStartTime, LocalDateTime updatedAt);
@Modifying
@Query("UPDATE group_course SET status = :status, actual_end_time = :actualEndTime, updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
Mono<Integer> updateEndInfo(Long id, String status, LocalDateTime actualEndTime, LocalDateTime updatedAt);
@Modifying
@Query("UPDATE group_course SET status = '5', actual_end_time = :actualEndTime, updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
Mono<Integer> updateToCoachAbsent(Long id, LocalDateTime actualEndTime, LocalDateTime updatedAt);
@Modifying
@Query("UPDATE group_course SET status = '6', actual_end_time = :actualEndTime, updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
Mono<Integer> updateToAutoEnded(Long id, LocalDateTime actualEndTime, LocalDateTime updatedAt);
/**
* 查询指定状态且开始时间早于指定时间的课程（用于缺席检查）
*/
default Flux<GroupCourseEntity> findByStatusAndStartTimeBefore(DatabaseClient databaseClient, String status, LocalDateTime time) {
return databaseClient.sql("SELECT * FROM group_course WHERE status = :status AND start_time < :time AND deleted_at IS NULL")
.bind("status", status)
.bind("time", time)
.map((row, meta) -> mapRowToEntity(row))
.all();
}
/**
* 查询指定状态集合且结束时间早于指定时间的课程（用于自动结课检查）
*/
default Flux<GroupCourseEntity> findByStatusInAndEndTimeBefore(DatabaseClient databaseClient, String[] statuses, LocalDateTime time) {
return databaseClient.sql("SELECT * FROM group_course WHERE status = ANY(:statuses::varchar[]) AND end_time < :time AND deleted_at IS NULL")
.bind("statuses", statuses)
.bind("time", time)
.map((row, meta) -> mapRowToEntity(row))
.all();
}
@Query("UPDATE group_course SET status = '2', updated_at = :updatedAt WHERE status = '0' AND end_time <= NOW() AND deleted_at IS NULL")
Mono<Integer> completeExpiredCourses(LocalDateTime updatedAt);
Flux<GroupCourseEntity> findByCourseTypeAndDeletedAtIsNull(Long courseType);
// ==================== 教练相关查询 ====================
Flux<GroupCourseEntity> findByCoachIdAndDeletedAtIsNull(Long coachId);
Flux<GroupCourseEntity> findByCoachIdAndDeletedAtIsNull(Long coachId, Sort sort);
@Query("SELECT COUNT(*) FROM group_course WHERE coach_id = :coachId AND status = :status AND deleted_at IS NULL")
Mono<Long> countByCoachIdAndStatus(Long coachId, String status);
@Modifying
@Query("UPDATE group_course SET status = '1', updated_at = :updatedAt WHERE coach_id = :coachId AND status != :excludeStatus AND deleted_at IS NULL")
Mono<Integer> cancelCoursesByCoachIdExceptStatus(Long coachId, String excludeStatus, LocalDateTime updatedAt);
/**
* 多条件查询团课（使用 DatabaseClient 构建动态 SQL）
*/
default Flux<GroupCourseEntity> searchGroupCourses(DatabaseClient databaseClient, GroupCourseQueryDto query) {
StringBuilder sql = new StringBuilder(
"SELECT gc.*, COALESCE(b.cnt, 0) AS current_members " +
"FROM group_course gc " +
"LEFT JOIN (SELECT course_id, COUNT(*) AS cnt FROM group_course_booking WHERE status = '0' GROUP BY course_id) b " +
"ON gc.id = b.course_id " +
"WHERE gc.deleted_at IS NULL");
StringBuilder sql = new StringBuilder("SELECT * FROM group_course WHERE deleted_at IS NULL");
List<String> conditions = new ArrayList<>();
// 默认不查询可预约团课（status = '0' 且未过期）
conditions.add("gc.status = '0'");
conditions.add("gc.end_time > NOW()");
conditions.add("status = '0'");
conditions.add("end_time > NOW()");
// 1. 团课名称模糊查询
if (query.getCourseName() != null && !query.getCourseName().isEmpty()) {
conditions.add("gc.course_name ILIKE :courseName");
conditions.add("course_name ILIKE :courseName");
}
// 2. 基于团课类型查询
if (query.getCourseType() != null) {
conditions.add("gc.course_type = :courseType");
conditions.add("course_type = :courseType");
}
// 3. 基于日期时间段查询
if (query.getStartDate() != null) {
conditions.add("gc.start_time >= :startDate");
conditions.add("start_time >= :startDate");
}
if (query.getEndDate() != null) {
conditions.add("gc.start_time <= :endDate");
conditions.add("start_time <= :endDate");
}
// 4. 基于早晨/下午/夜晚时间段查询
if (query.getTimePeriod() != null && !query.getTimePeriod().isEmpty()) {
switch (query.getTimePeriod().toLowerCase()) {
case "morning":
conditions.add("EXTRACT(HOUR FROM gc.start_time) >= 6 AND EXTRACT(HOUR FROM gc.start_time) < 12");
conditions.add("EXTRACT(HOUR FROM start_time) >= 6 AND EXTRACT(HOUR FROM start_time) < 12");
break;
case "afternoon":
conditions.add("EXTRACT(HOUR FROM gc.start_time) >= 12 AND EXTRACT(HOUR FROM gc.start_time) < 18");
conditions.add("EXTRACT(HOUR FROM start_time) >= 12 AND EXTRACT(HOUR FROM start_time) < 18");
break;
case "evening":
conditions.add("EXTRACT(HOUR FROM gc.start_time) >= 18 AND EXTRACT(HOUR FROM gc.start_time) < 24");
conditions.add("EXTRACT(HOUR FROM start_time) >= 18 AND EXTRACT(HOUR FROM start_time) < 24");
break;
default:
break;
@@ -154,20 +103,20 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
List<String> orderClauses = new ArrayList<>();
if (hasRemainingMost) {
orderClauses.add(" (gc.max_members - COALESCE(b.cnt, 0)) DESC");
orderClauses.add(" (max_members - current_members) DESC");
}
if (hasPriceSort) {
if ("asc".equalsIgnoreCase(query.getPriceSort())) {
orderClauses.add(" gc.stored_value_amount ASC");
orderClauses.add(" stored_value_amount ASC");
} else if ("desc".equalsIgnoreCase(query.getPriceSort())) {
orderClauses.add(" gc.stored_value_amount DESC");
orderClauses.add(" stored_value_amount DESC");
}
}
sql.append(String.join(",", orderClauses));
} else {
sql.append(" ORDER BY gc.start_time ASC");
sql.append(" ORDER BY start_time ASC");
}
// 分页
@@ -195,7 +144,29 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
spec = spec.bind("limit", size);
spec = spec.bind("offset", offset);
return spec.map((row, meta) -> mapRowToEntity(row)).all();
return spec.map((row, meta) -> {
GroupCourseEntity entity = new GroupCourseEntity();
entity.setId(row.get("id", Long.class));
entity.setCourseName(row.get("course_name", String.class));
entity.setCoachId(row.get("coach_id", Long.class));
entity.setCourseType(row.get("course_type", Long.class));
entity.setStartTime(row.get("start_time", LocalDateTime.class));
entity.setEndTime(row.get("end_time", LocalDateTime.class));
entity.setMaxMembers(row.get("max_members", Integer.class));
entity.setCurrentMembers(row.get("current_members", Integer.class));
String statusStr = row.get("status", String.class);
entity.setStatus(statusStr != null ? Long.parseLong(statusStr) : null);
entity.setLocation(row.get("location", String.class));
entity.setCoverImage(row.get("cover_image", String.class));
entity.setDescription(row.get("description", String.class));
entity.setStoredValueAmount(row.get("stored_value_amount", java.math.BigDecimal.class));
entity.setCreateBy(row.get("create_by", String.class));
entity.setUpdateBy(row.get("update_by", String.class));
entity.setCreatedAt(row.get("created_at", LocalDateTime.class));
entity.setUpdatedAt(row.get("updated_at", LocalDateTime.class));
entity.setDeletedAt(row.get("deleted_at", LocalDateTime.class));
return entity;
}).all();
}
/**
@@ -255,123 +226,4 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
return spec.map((row, meta) -> row.get(0, Long.class)).one();
}
/**
* 分页查询团课（支持 keyword 和 status 过滤）
*/
default Flux<GroupCourseEntity> findByPageFiltered(DatabaseClient databaseClient, PageRequest pageRequest) {
StringBuilder sql = new StringBuilder(
"SELECT gc.*, COALESCE(b.cnt, 0) AS current_members " +
"FROM group_course gc " +
"LEFT JOIN (SELECT course_id, COUNT(*) AS cnt FROM group_course_booking WHERE status = '0' GROUP BY course_id) b " +
"ON gc.id = b.course_id " +
"WHERE gc.deleted_at IS NULL");
List<String> conditions = new ArrayList<>();
if (pageRequest.getKeyword() != null && !pageRequest.getKeyword().isEmpty()) {
conditions.add("gc.course_name ILIKE :keyword");
}
if (pageRequest.getStatus() != null && !pageRequest.getStatus().isEmpty()) {
conditions.add("gc.status = :status");
}
if (!conditions.isEmpty()) {
sql.append(" AND ").append(String.join(" AND ", conditions));
}
String sort = pageRequest.getSort() != null ? pageRequest.getSort() : "id";
String order = "desc".equalsIgnoreCase(pageRequest.getOrder()) ? "DESC" : "ASC";
sql.append(" ORDER BY gc.").append(sort).append(" ").append(order);
int size = pageRequest.getSize();
if (size < 1) size = 10;
if (size > 100) size = 100;
int offset = pageRequest.getPage() * size;
sql.append(" LIMIT :limit OFFSET :offset");
DatabaseClient.GenericExecuteSpec spec = databaseClient.sql(sql.toString());
if (pageRequest.getKeyword() != null && !pageRequest.getKeyword().isEmpty()) {
spec = spec.bind("keyword", "%" + pageRequest.getKeyword() + "%");
}
if (pageRequest.getStatus() != null && !pageRequest.getStatus().isEmpty()) {
spec = spec.bind("status", pageRequest.getStatus());
}
spec = spec.bind("limit", size);
spec = spec.bind("offset", offset);
return spec.map((row, meta) -> mapRowToEntity(row)).all();
}
/**
* 分页查询团课总数（支持 keyword 和 status 过滤）
*/
default Mono<Long> countByPageFiltered(DatabaseClient databaseClient, PageRequest pageRequest) {
StringBuilder sql = new StringBuilder("SELECT COUNT(*) FROM group_course WHERE deleted_at IS NULL");
List<String> conditions = new ArrayList<>();
if (pageRequest.getKeyword() != null && !pageRequest.getKeyword().isEmpty()) {
conditions.add("course_name ILIKE :keyword");
}
if (pageRequest.getStatus() != null && !pageRequest.getStatus().isEmpty()) {
conditions.add("status = :status");
}
if (!conditions.isEmpty()) {
sql.append(" AND ").append(String.join(" AND ", conditions));
}
DatabaseClient.GenericExecuteSpec spec = databaseClient.sql(sql.toString());
if (pageRequest.getKeyword() != null && !pageRequest.getKeyword().isEmpty()) {
spec = spec.bind("keyword", "%" + pageRequest.getKeyword() + "%");
}
if (pageRequest.getStatus() != null && !pageRequest.getStatus().isEmpty()) {
spec = spec.bind("status", pageRequest.getStatus());
}
return spec.map((row, meta) -> row.get(0, Long.class)).one();
}
/**
* 统计单门课程的有效预约人数（status='0'）
*/
default Mono<Long> countValidBookings(DatabaseClient databaseClient, Long courseId) {
return databaseClient.sql("SELECT COUNT(*) FROM group_course_booking WHERE course_id = :id AND status = '0'")
.bind("id", courseId)
.map((row, meta) -> row.get(0, Long.class))
.one()
.defaultIfEmpty(0L);
}
/**
* 将数据库行映射为 GroupCourseEntity
*/
private GroupCourseEntity mapRowToEntity(io.r2dbc.spi.Row row) {
GroupCourseEntity entity = new GroupCourseEntity();
entity.setId(row.get("id", Long.class));
entity.setCourseName(row.get("course_name", String.class));
entity.setCoachId(row.get("coach_id", Long.class));
entity.setCourseType(row.get("course_type", Long.class));
entity.setStartTime(row.get("start_time", LocalDateTime.class));
entity.setEndTime(row.get("end_time", LocalDateTime.class));
entity.setMaxMembers(row.get("max_members", Integer.class));
Integer cm = row.get("current_members", Integer.class);
entity.setCurrentMembers(cm != null ? cm : 0);
String statusStr = row.get("status", String.class);
entity.setStatus(statusStr != null ? Long.parseLong(statusStr) : null);
entity.setLocation(row.get("location", String.class));
entity.setCoverImage(row.get("cover_image", String.class));
entity.setDescription(row.get("description", String.class));
entity.setStoredValueAmount(row.get("stored_value_amount", java.math.BigDecimal.class));
entity.setActualStartTime(row.get("actual_start_time", LocalDateTime.class));
entity.setActualEndTime(row.get("actual_end_time", LocalDateTime.class));
entity.setQrCodePath(row.get("qr_code_path", String.class));
entity.setCreateBy(row.get("create_by", String.class));
entity.setUpdateBy(row.get("update_by", String.class));
entity.setCreatedAt(row.get("created_at", LocalDateTime.class));
entity.setUpdatedAt(row.get("updated_at", LocalDateTime.class));
entity.setDeletedAt(row.get("deleted_at", LocalDateTime.class));
return entity;
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/domain/GroupCourse.java
-24
View File
@@ -40,14 +40,6 @@ public class GroupCourse extends BaseDomain{
@Schema(description = "课程状态", example = "0")
private Long status;
//实际开课时间
@Schema(description = "实际开课时间")
private LocalDateTime actualStartTime;
//实际结课时间
@Schema(description = "实际结课时间")
private LocalDateTime actualEndTime;
//上课地点
@Schema(description = "上课地点", example = "龙泉驿区幸福路")
private String location;
@@ -132,22 +124,6 @@ public class GroupCourse extends BaseDomain{
this.status = status;
}
public LocalDateTime getActualStartTime() {
return actualStartTime;
}
public void setActualStartTime(LocalDateTime actualStartTime) {
this.actualStartTime = actualStartTime;
}
public LocalDateTime getActualEndTime() {
return actualEndTime;
}
public void setActualEndTime(LocalDateTime actualEndTime) {
this.actualEndTime = actualEndTime;
}
public String getLocation() {
return location;
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/domain/GroupCourseDetail.java
-11
View File
@@ -21,9 +21,6 @@ public class GroupCourseDetail extends BaseDomain {
@Schema(description = "教练ID", example = "1")
private Long coachId;
@Schema(description = "教练名称", example = "张教练")
private String coachName;
@Schema(description = "课程类型ID", example = "1")
private Long courseType;
@@ -102,14 +99,6 @@ public class GroupCourseDetail extends BaseDomain {
this.coachId = coachId;
}
public String getCoachName() {
return coachName;
}
public void setCoachName(String coachName) {
this.coachName = coachName;
}
public Long getCourseType() {
return courseType;
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/entity/GroupCourseEntity.java
+1 -25
View File
@@ -38,15 +38,7 @@ public class GroupCourseEntity extends BaseEntity {
@Column("current_members")
private Integer currentMembers;
//实际开课时间
@Column("actual_start_time")
private LocalDateTime actualStartTime;
//实际结课时间
@Column("actual_end_time")
private LocalDateTime actualEndTime;
//课程状态：0-正常，1-已取消，2-已结束，3-进行中，5-教练缺席，6-自动结束，7-教练迟到
//课程状态：0-正常，1-已取消，2-已结束
@Column("status")
private Long status;
@@ -166,22 +158,6 @@ public class GroupCourseEntity extends BaseEntity {
this.storedValueAmount = storedValueAmount;
}
public LocalDateTime getActualStartTime() {
return actualStartTime;
}
public void setActualStartTime(LocalDateTime actualStartTime) {
this.actualStartTime = actualStartTime;
}
public LocalDateTime getActualEndTime() {
return actualEndTime;
}
public void setActualEndTime(LocalDateTime actualEndTime) {
this.actualEndTime = actualEndTime;
}
public String getQrCodePath() {
return qrCodePath;
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/enums/CourseStatus.java
+1 -4
View File
@@ -11,10 +11,7 @@ public enum CourseStatus {
NORMAL(0L, "正常"),
CANCELLED(1L, "已取消"),
ENDED(2L, "已结束"),
IN_PROGRESS(3L, "进行中"),
COACH_ABSENT(5L, "教练缺席"),
AUTO_ENDED(6L, "自动结束"),
COACH_LATE(7L, "教练迟到");
IN_PROGRESS(3L, "进行中");
private final Long value;
private final String desc;
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/BookingSagaHandler.java
+123 -64
View File
@@ -2,18 +2,18 @@ package cn.novalon.gym.manage.groupcourse.handler;
import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepository;
import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
import cn.novalon.gym.manage.groupcourse.service.impl.GroupCourseRedisService;
import cn.novalon.gym.manage.member.entity.MemberCard;
import cn.novalon.gym.manage.member.entity.MemberCardRecord;
import cn.novalon.gym.manage.member.enums.MemberCardType;
import cn.novalon.gym.manage.member.repository.MemberCardRepository;
import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
import cn.novalon.gym.manage.member.service.IMemberStoredCardService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
@@ -32,9 +32,10 @@ import java.util.List;
public class BookingSagaHandler {
private final IGroupCourseBookingRepository bookingRepository;
private final IGroupCourseRepository courseRepository;
private final IMemberCardRecordService memberCardRecordService;
private final IMemberStoredCardService memberStoredCardService;
private final MemberCardRepository memberCardRepository;
private final GroupCourseRedisService redisService;
private static final double DEFAULT_GROUP_COURSE_PRICE = 50.0;
@@ -43,10 +44,10 @@ public class BookingSagaHandler {
*
* 步骤：
* 1. 保存预约记录
* 2. 扣减储值卡余额（储值卡类型）
* 2. 扣减会员卡权益
* 3. 更新课程当前人数
*/
public Mono<GroupCourseBooking> executeBooking(GroupCourseBooking booking, Long recordId, BigDecimal storedValueAmount) {
public Mono<GroupCourseBooking> executeBooking(GroupCourseBooking booking, Long recordId) {
List<SagaStep> steps = new ArrayList<>();
List<SagaStep> rollbackSteps = new ArrayList<>();
@@ -59,15 +60,33 @@ public class BookingSagaHandler {
steps.add(step1);
rollbackSteps.add(0, step1);
// 步骤2：扣减权益（根据卡类型）
// 步骤2：扣减会员卡权益（根据卡类型决定扣除次数还是金额）
SagaStep step2 = new SagaStep(
"扣减权益",
deductCardUsageByCardType(booking.getMemberId(), recordId, storedValueAmount),
Mono.defer(() -> restoreCardUsageByCardType(booking.getMemberId(), recordId, storedValueAmount))
"扣减会员卡权益",
deductCardUsageByCardType(booking.getMemberId(), recordId),
Mono.defer(() -> restoreCardUsageByCardType(booking.getMemberId(), recordId))
);
steps.add(step2);
rollbackSteps.add(0, step2);
// 步骤3：更新课程当前人数
SagaStep step3 = new SagaStep(
"更新课程当前人数",
incrementCourseCurrentMembers(booking.getCourseId()),
Mono.defer(() -> decrementCourseCurrentMembers(booking.getCourseId()))
);
steps.add(step3);
rollbackSteps.add(0, step3);
// 步骤4：更新Redis预约计数
SagaStep step4 = new SagaStep(
"更新Redis预约计数",
incrementRedisBookingCount(booking.getCourseId()),
Mono.defer(() -> decrementRedisBookingCount(booking.getCourseId()))
);
steps.add(step4);
rollbackSteps.add(0, step4);
return executeSaga(steps, rollbackSteps)
.then(Mono.just(booking));
}
@@ -75,7 +94,7 @@ public class BookingSagaHandler {
/**
* 根据会员卡类型扣减权益
*/
private Mono<Void> deductCardUsageByCardType(Long memberId, Long recordId, BigDecimal storedValueAmount) {
private Mono<Void> deductCardUsageByCardType(Long memberId, Long recordId) {
return memberCardRecordService.findById(recordId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
.flatMap(record -> {
@@ -90,13 +109,14 @@ public class BookingSagaHandler {
switch (cardType) {
case COUNT_CARD:
return Mono.error(new RuntimeException("团课预约仅支持储值卡和时长卡支付"));
// 次数卡不再支持团课预约
return Mono.error(new RuntimeException("团课预约仅支持储值卡支付"));
case STORED_VALUE_CARD:
return deductStoredCardBalance(memberId, storedValueAmount);
// 储值卡扣除金额
return deductCardUsage(recordId, 0, DEFAULT_GROUP_COURSE_PRICE);
case TIME_CARD:
// 时长卡验证有效期后，仍须从储值卡扣款
return validateTimeCard(record)
.then(deductStoredCardBalance(memberId, storedValueAmount));
// 时长卡不扣除，但需验证有效期
return validateTimeCard(record);
default:
return Mono.error(new RuntimeException("不支持的会员卡类型: " + cardType));
}
@@ -133,10 +153,11 @@ public class BookingSagaHandler {
/**
* 根据会员卡类型恢复权益
*/
private Mono<Void> restoreCardUsageByCardType(Long memberId, Long recordId, BigDecimal storedValueAmount) {
private Mono<Void> restoreCardUsageByCardType(Long memberId, Long recordId) {
return memberCardRecordService.findById(recordId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在，无法恢复权益")))
.flatMap(record -> {
// 验证会员卡归属（memberId为null时跳过验证）
if (memberId != null && !record.getMemberId().equals(memberId)) {
return Mono.error(new RuntimeException("会员卡不归属当前用户"));
}
@@ -147,29 +168,12 @@ public class BookingSagaHandler {
switch (cardType) {
case COUNT_CARD:
// 次数卡不再支持团课预约，无需恢复
return Mono.empty();
case STORED_VALUE_CARD:
// 返还储值卡余额（回滚时全额返还）
BigDecimal amount = storedValueAmount != null ? storedValueAmount : BigDecimal.valueOf(DEFAULT_GROUP_COURSE_PRICE);
return memberStoredCardService.recharge(memberId, amount)
.flatMap(rows -> {
if (rows > 0) {
log.info("储值卡回滚返还成功: memberId={}, amount={}", memberId, amount);
return Mono.empty();
}
return Mono.empty();
});
return restoreCardUsage(recordId, 0, DEFAULT_GROUP_COURSE_PRICE);
case TIME_CARD:
// 时长卡回滚时也返还储值卡
BigDecimal timeAmount = storedValueAmount != null ? storedValueAmount : BigDecimal.valueOf(DEFAULT_GROUP_COURSE_PRICE);
return memberStoredCardService.recharge(memberId, timeAmount)
.flatMap(rows -> {
if (rows > 0) {
log.info("储值卡回滚返还成功(时长卡): memberId={}, amount={}", memberId, timeAmount);
return Mono.empty();
}
return Mono.empty();
});
return Mono.empty();
default:
return Mono.error(new RuntimeException("不支持的会员卡类型: " + cardType));
}
@@ -180,7 +184,7 @@ public class BookingSagaHandler {
/**
* 执行取消预约事务
*/
public Mono<GroupCourseBooking> executeCancelBooking(Long bookingId, Long courseId, Long recordId, Long memberId, BigDecimal storedValueAmount, long cancelCount) {
public Mono<GroupCourseBooking> executeCancelBooking(Long bookingId, Long courseId, Long recordId, Long memberId) {
List<SagaStep> steps = new ArrayList<>();
List<SagaStep> rollbackSteps = new ArrayList<>();
@@ -193,16 +197,33 @@ public class BookingSagaHandler {
steps.add(step1);
rollbackSteps.add(0, step1);
// 步骤2：返还储值卡余额（含手续费逻辑）
// 步骤2：恢复会员卡权益
SagaStep step2 = new SagaStep(
"返还储值卡余额",
refundStoredCardWithFee(memberId, storedValueAmount, cancelCount),
// 回滚时重新扣减
Mono.defer(() -> deductCardUsageByCardType(memberId, recordId, storedValueAmount))
"恢复会员卡权益",
restoreCardUsageByCardType(memberId, recordId),
Mono.defer(() -> deductCardUsageByCardType(memberId, recordId))
);
steps.add(step2);
rollbackSteps.add(0, step2);
// 步骤3：减少课程当前人数
SagaStep step3 = new SagaStep(
"减少课程当前人数",
decrementCourseCurrentMembers(courseId),
Mono.defer(() -> incrementCourseCurrentMembers(courseId))
);
steps.add(step3);
rollbackSteps.add(0, step3);
// 步骤4：更新Redis预约计数
SagaStep step4 = new SagaStep(
"更新Redis预约计数",
decrementRedisBookingCount(courseId),
Mono.defer(() -> incrementRedisBookingCount(courseId))
);
steps.add(step4);
rollbackSteps.add(0, step4);
return executeSaga(steps, rollbackSteps)
.then(bookingRepository.findById(bookingId));
}
@@ -232,35 +253,73 @@ public class BookingSagaHandler {
return bookingRepository.deleteById(bookingId);
}
/**
* 从储值卡扣减余额
*/
private Mono<Void> deductStoredCardBalance(Long memberId, BigDecimal storedValueAmount) {
BigDecimal amount = storedValueAmount != null && storedValueAmount.compareTo(BigDecimal.ZERO) > 0
? storedValueAmount : BigDecimal.valueOf(DEFAULT_GROUP_COURSE_PRICE);
return memberStoredCardService.consume(memberId, amount)
.flatMap(rows -> {
if (rows == 0) {
return Mono.error(new RuntimeException("储值卡扣减失败，余额不足"));
private Mono<Void> deductCardUsage(Long recordId, Integer deductTimes, Double deductAmount) {
if (deductTimes == 0 && deductAmount == 0.0) {
return Mono.empty();
}
return memberCardRecordService.findById(recordId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
.flatMap(record -> {
cn.novalon.gym.manage.member.enums.MemberCardRecordStatus status = record.getStatus();
if (status != cn.novalon.gym.manage.member.enums.MemberCardRecordStatus.ACTIVE) {
return Mono.error(new RuntimeException("会员卡状态无效，当前状态: " + (status != null ? status.getDesc() : "未知")));
}
log.info("储值卡扣减成功: memberId={}, amount={}", memberId, amount);
return Mono.empty();
java.time.LocalDateTime expireTime = record.getExpireTime();
if (expireTime != null && expireTime.isBefore(java.time.LocalDateTime.now())) {
return Mono.error(new RuntimeException("会员卡已过期"));
}
if (record.getRemainingTimes() != null && deductTimes > 0 && record.getRemainingTimes() < deductTimes) {
return Mono.error(new RuntimeException("会员卡剩余次数不足，当前剩余: " + record.getRemainingTimes() + "次"));
}
if (record.getRemainingAmount() != null && deductAmount > 0 && record.getRemainingAmount() < deductAmount) {
return Mono.error(new RuntimeException("会员卡余额不足，当前剩余: " + record.getRemainingAmount()));
}
return memberCardRecordService.deductUsage(recordId, deductTimes, deductAmount)
.flatMap(rows -> {
if (rows == 0) {
return Mono.error(new RuntimeException("扣减会员卡权益失败，请重试"));
}
return Mono.empty();
});
});
}
/**
* 返还储值卡余额（含手续费逻辑，仅用于取消预约）
*/
private Mono<Void> refundStoredCardWithFee(Long memberId, BigDecimal storedValueAmount, long cancelCount) {
BigDecimal amount = storedValueAmount != null && storedValueAmount.compareTo(BigDecimal.ZERO) > 0
? storedValueAmount : BigDecimal.valueOf(DEFAULT_GROUP_COURSE_PRICE);
return memberStoredCardService.refundBalanceWithFee(memberId, amount, cancelCount)
.flatMap(refundedAmount -> {
log.info("储值卡退款成功(含手续费): memberId={}, cancelCount={}, 退款金额={}", memberId, cancelCount, refundedAmount);
return Mono.empty();
private Mono<Void> restoreCardUsage(Long recordId, Integer addTimes, Double addAmount) {
if (addTimes == 0 && addAmount == 0.0) {
return Mono.empty();
}
return memberCardRecordService.findById(recordId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在，无法恢复权益")))
.flatMap(record -> {
// 使用当前记录的过期时间，避免清空过期时间
return memberCardRecordService.renewCard(recordId, addTimes, addAmount, record.getExpireTime())
.flatMap(rows -> {
if (rows == 0) {
return Mono.error(new RuntimeException("恢复会员卡权益失败，请重试"));
}
return Mono.empty();
});
});
}
private Mono<Void> incrementCourseCurrentMembers(Long courseId) {
return courseRepository.updateCurrentMembers(courseId, 1).then();
}
private Mono<Void> decrementCourseCurrentMembers(Long courseId) {
return courseRepository.updateCurrentMembers(courseId, -1).then();
}
private Mono<Void> incrementRedisBookingCount(Long courseId) {
return redisService.incrementBookingCount(courseId).then();
}
private Mono<Void> decrementRedisBookingCount(Long courseId) {
return redisService.decrementBookingCount(courseId).then();
}
private Mono<Void> executeSaga(List<SagaStep> steps, List<SagaStep> rollbackSteps) {
List<SagaStep> completedSteps = new ArrayList<>();
return executeStep(steps, 0, completedSteps);
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/CourseLabelHandler.java
+6 -14
View File
@@ -1,6 +1,5 @@
package cn.novalon.gym.manage.groupcourse.handler;
import cn.novalon.gym.manage.common.dto.PageRequest;
import cn.novalon.gym.manage.groupcourse.domain.CourseLabel;
import cn.novalon.gym.manage.groupcourse.service.ICourseLabelService;
import io.swagger.v3.oas.annotations.Operation;
@@ -30,13 +29,6 @@ public class CourseLabelHandler {
.body(courseLabelService.findAll(), CourseLabel.class);
}
@Operation(summary = "分页查询标签", description = "支持按关键词筛选并分页查询标签")
public Mono<ServerResponse> getLabelsByPage(ServerRequest request) {
return request.bodyToMono(PageRequest.class)
.flatMap(pageRequest -> courseLabelService.findByPage(pageRequest)
.flatMap(response -> ServerResponse.ok().bodyValue(response)));
}
@Operation(summary = "根据ID获取标签", description = "根据ID获取标签详情")
public Mono<ServerResponse> getLabelById(ServerRequest request) {
Long id = Long.valueOf(request.pathVariable("id"));
@@ -155,17 +147,17 @@ public class CourseLabelHandler {
return request.bodyToMono(Map.class)
.flatMap(body -> {
@SuppressWarnings("unchecked")
List<?> rawIds = (List<?>) body.get("labelIds");
if (rawIds == null || rawIds.isEmpty()) {
List<Integer> labelIdsInt = (List<Integer>) body.get("labelIds");
if (labelIdsInt == null || labelIdsInt.isEmpty()) {
Map<String, Object> error = new HashMap<>();
error.put("success", false);
error.put("message", "labelIds不能为空");
return ServerResponse.badRequest().bodyValue(error);
}
List<Long> labelIds = rawIds.stream()
.map(id -> Long.valueOf(String.valueOf(id)))
List<Long> labelIds = labelIdsInt.stream()
.map(Integer::longValue)
.collect(java.util.stream.Collectors.toList());
return courseLabelService.addLabelsToType(typeId, labelIds)
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseBookingHandler.java
+8 -17
View File
@@ -42,11 +42,15 @@ public class GroupCourseBookingHandler {
if (body.get("memberId") == null) {
return buildErrorResponse("请提供会员ID");
}
if (body.get("memberCardRecordId") == null) {
return buildErrorResponse("请提供会员卡记录ID");
}
Long courseId = toLong(body.get("courseId"), "courseId");
Long memberId = toLong(body.get("memberId"), "memberId");
Long courseId = ((Number) body.get("courseId")).longValue();
Long memberId = ((Number) body.get("memberId")).longValue();
Long memberCardRecordId = ((Number) body.get("memberCardRecordId")).longValue();
return bookingService.bookCourse(courseId, memberId)
return bookingService.bookCourse(courseId, memberId, memberCardRecordId)
.flatMap(booking -> {
Map<String, Object> response = new HashMap<>();
response.put("success", true);
@@ -72,7 +76,7 @@ public class GroupCourseBookingHandler {
return request.bodyToMono(Map.class)
.flatMap(body -> {
Long memberId = toLong(body.get("memberId"), "memberId");
Long memberId = ((Number) body.get("memberId")).longValue();
return bookingService.cancelBooking(bookingId, memberId)
.flatMap(booking -> {
@@ -125,19 +129,6 @@ public class GroupCourseBookingHandler {
.body(bookingService.getBookingsByCourseId(courseId), GroupCourseBooking.class);
}
/**
* 安全转换为 Long，支持 Number 和 String 类型
*/
private Long toLong(Object value, String fieldName) {
if (value instanceof Number) {
return ((Number) value).longValue();
}
if (value instanceof String) {
return Long.valueOf((String) value);
}
throw new IllegalArgumentException("参数 " + fieldName + " 类型不正确");
}
/**
* 构建错误响应
*/
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandler.java
+4 -57
View File
@@ -7,27 +7,21 @@ import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
import cn.novalon.gym.manage.groupcourse.domain.GroupCourseDetail;
import cn.novalon.gym.manage.groupcourse.dto.GroupCourseQueryDto;
import cn.novalon.gym.manage.groupcourse.service.IGroupCourseService;
import cn.novalon.gym.manage.groupcourse.vo.GroupCourseVO;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.List;
import java.util.Map;
import java.time.LocalDateTime;
@Component
@Tag(name="团课管理",description = "团课相关操作")
public class GroupCourseHandler {
private static final Logger logger = LoggerFactory.getLogger(GroupCourseHandler.class);
private final IGroupCourseService groupCourseService;
private final Validator validator;
private final RedisUtil redisUtil;
@@ -43,12 +37,11 @@ public class GroupCourseHandler {
this.objectMapper = objectMapper;
}
@Operation(summary = "获取所有团课", description = "获取系统中所有团课列表（含教练昵称）")
@Operation(summary = "获取所有团课", description = "获取系统中所有团课列表")
public Mono<ServerResponse> getAllGroupCourse(ServerRequest request){
boolean includeDeleted = Boolean.valueOf(request.queryParam("includeDeleted").orElse("false"));
return groupCourseService.findAllAsVO(includeDeleted)
.collectList()
.flatMap(list -> ServerResponse.ok().bodyValue(list));
return ServerResponse.ok()
.body(groupCourseService.findAll(includeDeleted), GroupCourse.class);
}
@Operation(summary = "分页获取团课", description = "根据分页参数获取团课列表")
@@ -72,7 +65,7 @@ public class GroupCourseHandler {
pageRequest.setOrder("asc");
}
return groupCourseService.findByPageAsVO(pageRequest, includeDeleted)
return groupCourseService.findByPage(pageRequest, includeDeleted)
.flatMap(response -> ServerResponse.ok().bodyValue(response));
});
}
@@ -296,50 +289,4 @@ public class GroupCourseHandler {
});
});
}
@Operation(summary = "检查教练时间冲突", description = "检查教练在指定时间段内是否有时间冲突的团课")
public Mono<ServerResponse> checkCoachConflict(ServerRequest request) {
return request.bodyToMono(Map.class)
.flatMap(body -> {
if (body == null) {
Map<String, Object> error = new HashMap<>();
error.put("success", false);
error.put("message", "请求体不能为空");
return ServerResponse.badRequest().bodyValue(error);
}
Object coachIdObj = body.get("coachId");
Object startTimeStr = body.get("startTime");
Object endTimeStr = body.get("endTime");
Object excludeCourseIdObj = body.get("excludeCourseId");
if (coachIdObj == null || startTimeStr == null || endTimeStr == null) {
Map<String, Object> error = new HashMap<>();
error.put("success", false);
error.put("message", "coachId、startTime、endTime 不能为空");
return ServerResponse.badRequest().bodyValue(error);
}
Long coachId = Long.valueOf(String.valueOf(coachIdObj));
LocalDateTime startTime = LocalDateTime.parse(String.valueOf(startTimeStr));
LocalDateTime endTime = LocalDateTime.parse(String.valueOf(endTimeStr));
Long excludeCourseId = excludeCourseIdObj != null ? Long.valueOf(String.valueOf(excludeCourseIdObj)) : null;
return groupCourseService.checkCoachConflict(coachId, startTime, endTime, excludeCourseId)
.flatMap(conflicts -> {
Map<String, Object> response = new HashMap<>();
response.put("success", true);
response.put("hasConflict", !conflicts.isEmpty());
response.put("conflicts", conflicts);
return ServerResponse.ok().bodyValue(response);
});
})
.onErrorResume(error -> {
logger.warn("检查教练时间冲突失败: {}", error.getMessage());
Map<String, Object> response = new HashMap<>();
response.put("success", false);
response.put("message", "检查失败: " + error.getMessage());
return ServerResponse.badRequest().bodyValue(response);
});
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseTypeHandler.java
-9
View File
@@ -1,6 +1,5 @@
package cn.novalon.gym.manage.groupcourse.handler;
import cn.novalon.gym.manage.common.dto.PageRequest;
import cn.novalon.gym.manage.groupcourse.domain.GroupCourseType;
import cn.novalon.gym.manage.groupcourse.service.IGroupCourseTypeService;
import io.swagger.v3.oas.annotations.Operation;
@@ -135,12 +134,4 @@ public class GroupCourseTypeHandler {
return ServerResponse.badRequest().bodyValue(response);
});
}
@Operation(summary = "分页查询团课类型", description = "支持按关键词、分类筛选并分页查询团课类型")
public Mono<ServerResponse> getGroupCourseTypesByPage(ServerRequest request) {
return request.bodyToMono(PageRequest.class)
.flatMap(pageRequest -> groupCourseTypeService.findByPage(pageRequest)
.flatMap(response -> ServerResponse.ok().bodyValue(response))
);
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/initializer/QrCodeInitializer.java
+19 -22
View File
@@ -1,6 +1,5 @@
package cn.novalon.gym.manage.groupcourse.initializer;
import cn.novalon.gym.manage.file.core.service.ISysFileService;
import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
import cn.novalon.gym.manage.groupcourse.util.QRCodeUtil;
@@ -11,12 +10,15 @@ import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/**
* 项目启动时补全缺失的团课二维码
* 遍历所有未删除的团课，对qrCodePath为空的课程生成二维码并通过统一文件服务保存
* 遍历所有未删除的团课，对qrCodePath为空的课程生成二维码并上传至阿里云OSS
*/
@Component
public class QrCodeInitializer implements CommandLineRunner {
@@ -25,14 +27,11 @@ public class QrCodeInitializer implements CommandLineRunner {
private final IGroupCourseRepository groupCourseRepository;
private final ObjectMapper objectMapper;
private final ISysFileService fileService;
public QrCodeInitializer(IGroupCourseRepository groupCourseRepository,
ObjectMapper objectMapper,
ISysFileService fileService) {
ObjectMapper objectMapper) {
this.groupCourseRepository = groupCourseRepository;
this.objectMapper = objectMapper;
this.fileService = fileService;
}
@Override
@@ -59,22 +58,20 @@ public class QrCodeInitializer implements CommandLineRunner {
String jsonContent = objectMapper.writeValueAsString(qrCodeContent);
// 生成二维码字节数组，通过统一文件服务保存
return Mono.fromCallable(() -> QRCodeUtil.generateQrCodeBytes(jsonContent))
.flatMap(qrCodeBytes -> {
String fileName = "qrcode_" + course.getId() + ".png";
return fileService.saveBytes(qrCodeBytes, fileName, "image/png", "system");
})
.flatMap(sysFile -> {
String qrCodeUrl = "/api/files/" + sysFile.getId() + "/preview";
course.setQrCodePath(qrCodeUrl);
return groupCourseRepository.update(course)
.doOnSuccess(updated -> logger.info("团课二维码补全成功 - id={}, name={}, url={}",
updated.getId(), updated.getCourseName(), qrCodeUrl))
.doOnError(error -> logger.error("团课二维码补全失败(更新DB) - id={}, name={}, error: {}",
course.getId(), course.getCourseName(), error.getMessage()));
});
// 生成二维码并上传到阿里云OSS
String uuid = UUID.randomUUID().toString().replace("-", "");
String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
String fileName = "qr_" + uuid + "_" + timestamp + ".png";
String ossUrl = QRCodeUtil.generateQRCodeAndUploadToOSS(jsonContent, fileName);
course.setQrCodePath(ossUrl);
// 更新数据库
return groupCourseRepository.update(course)
.doOnSuccess(updated -> logger.info("团课二维码补全成功 - id={}, name={}, ossUrl={}",
updated.getId(), updated.getCourseName(), ossUrl))
.doOnError(error -> logger.error("团课二维码补全失败(更新DB) - id={}, name={}, error: {}",
course.getId(), course.getCourseName(), error.getMessage()));
} catch (Exception e) {
logger.error("团课二维码补全失败(生成) - id={}, name={}, error: {}",
course.getId(), course.getCourseName(), e.getMessage(), e);
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/ICourseLabelRepository.java
-4
View File
@@ -1,7 +1,5 @@
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.CourseLabel;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@@ -31,6 +29,4 @@ public interface ICourseLabelRepository {
Mono<Void> removeLabelFromType(Long typeId, Long labelId);
Mono<Void> clearLabelsFromType(Long typeId);
Mono<PageResponse<CourseLabel>> findByPage(PageRequest pageRequest);
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/IGroupCourseBookingRepository.java
-7
View File
@@ -89,11 +89,4 @@ public interface IGroupCourseBookingRepository {
* @return 更新记录数
*/
Mono<Integer> updateToAbsent(Long bookingId);
/**
* 统计会员取消的预约次数
* @param memberId 会员ID
* @return 取消次数
*/
Mono<Long> countCancelledByMemberId(Long memberId);
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/IGroupCourseRepository.java
+2 -7
View File
@@ -27,14 +27,9 @@ public interface IGroupCourseRepository {
Mono<Void> deleteById(Long id);
Mono<GroupCourse> updateCurrentMembers(Long id, Integer delta);
Flux<GroupCourse> findByCourseType(Long courseType);
Mono<PageResponse<GroupCourse>> searchGroupCourses(GroupCourseQueryDto query);
// ==================== 教练相关 ====================
Flux<GroupCourse> findByCoachId(Long coachId);
Flux<GroupCourse> findByCoachId(Long coachId, Sort sort);
Mono<Long> countByCoachIdAndStatus(Long coachId, Long status);
Mono<Integer> cancelCoursesByCoachIdExceptStatus(Long coachId, Long excludeStatus);
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/IGroupCourseTypeRepository.java
-4
View File
@@ -1,7 +1,5 @@
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.GroupCourseType;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@@ -27,6 +25,4 @@ public interface IGroupCourseTypeRepository {
Mono<GroupCourseType> update(GroupCourseType groupCourseType);
Mono<Void> deleteById(Long id);
Mono<PageResponse<GroupCourseType>> findByPage(PageRequest pageRequest);
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/CourseLabelRepository.java
+1 -47
View File
@@ -1,7 +1,5 @@
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.CourseLabelDao;
import cn.novalon.gym.manage.groupcourse.dao.CourseTypeLabelDao;
@@ -11,17 +9,12 @@ import cn.novalon.gym.manage.groupcourse.entity.CourseTypeLabelEntity;
import cn.novalon.gym.manage.groupcourse.repository.ICourseLabelRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Sort;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.data.relational.core.query.Criteria;
import org.springframework.data.relational.core.query.Query;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
@Repository
@@ -33,14 +26,12 @@ public class CourseLabelRepository implements ICourseLabelRepository {
private final CourseLabelDao courseLabelDao;
private final CourseTypeLabelDao courseTypeLabelDao;
private final GroupCourseConverter converter;
private final R2dbcEntityTemplate r2dbcEntityTemplate;
public CourseLabelRepository(CourseLabelDao courseLabelDao, CourseTypeLabelDao courseTypeLabelDao,
GroupCourseConverter converter, R2dbcEntityTemplate r2dbcEntityTemplate) {
GroupCourseConverter converter) {
this.courseLabelDao = courseLabelDao;
this.courseTypeLabelDao = courseTypeLabelDao;
this.converter = converter;
this.r2dbcEntityTemplate = r2dbcEntityTemplate;
}
@Override
@@ -167,41 +158,4 @@ public class CourseLabelRepository implements ICourseLabelRepository {
}
return entity;
}
@Override
public Mono<PageResponse<CourseLabel>> findByPage(PageRequest pageRequest) {
int page = pageRequest.getPage();
int size = pageRequest.getSize();
String sort = pageRequest.getSort();
String order = pageRequest.getOrder();
String keyword = pageRequest.getKeyword();
Sort sortObj = Sort.unsorted();
if (sort != null && !sort.isEmpty()) {
sortObj = Sort.by(Sort.Direction.fromString(order), sort);
}
List<Criteria> criteriaList = new ArrayList<>();
criteriaList.add(Criteria.where("deleted_at").isNull());
if (keyword != null && !keyword.isEmpty()) {
criteriaList.add(Criteria.where("label_name").like("%" + keyword + "%").ignoreCase(true));
}
Criteria criteria = criteriaList.isEmpty() ? Criteria.empty() : Criteria.from(criteriaList);
Query query = Query.query(criteria).with(org.springframework.data.domain.PageRequest.of(page, size, sortObj));
return r2dbcEntityTemplate.select(CourseLabelEntity.class)
.matching(query)
.all()
.collectList()
.zipWith(r2dbcEntityTemplate.count(Query.query(criteria), CourseLabelEntity.class))
.map(tuple -> {
long total = tuple.getT2();
int totalPages = (int) Math.ceil((double) total / size);
List<CourseLabel> list = tuple.getT1().stream()
.map(this::toCourseLabel)
.toList();
return new PageResponse<>(list, totalPages, total, page, size);
});
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/GroupCourseBookingRepository.java
-5
View File
@@ -112,9 +112,4 @@ public class GroupCourseBookingRepository implements IGroupCourseBookingReposito
java.time.LocalDateTime now = java.time.LocalDateTime.now();
return groupCourseBookingDao.updateToAbsent(bookingId, now);
}
@Override
public Mono<Long> countCancelledByMemberId(Long memberId) {
return groupCourseBookingDao.countCancelledByMemberId(memberId);
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/GroupCourseRepository.java
+41 -35
View File
@@ -97,19 +97,37 @@ public class GroupCourseRepository implements IGroupCourseRepository {
public Mono<PageResponse<GroupCourse>> findByPageAndNotDeleted(PageRequest pageRequest) {
int page = pageRequest.getPage();
int size = pageRequest.getSize();
String sort = pageRequest.getSort();
String order = pageRequest.getOrder();
return groupCourseDao.countByPageFiltered(r2dbcEntityTemplate.getDatabaseClient(), pageRequest)
.flatMap(total -> {
if (total == 0) {
return Mono.just(new PageResponse<>(List.of(), 0, 0L, page, size));
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();
}
return groupCourseDao.findByPageFiltered(r2dbcEntityTemplate.getDatabaseClient(), pageRequest)
.map(groupCourseConverter::toDomain)
.collectList()
.map(courseList -> {
int totalPages = (int) Math.ceil((double) total / size);
return new PageResponse<>(courseList, totalPages, total, page, size);
});
int totalPages = (int) Math.ceil((double) total / size);
return new PageResponse<>(courseList, totalPages, total, page, size);
});
}
@@ -119,6 +137,7 @@ public class GroupCourseRepository implements IGroupCourseRepository {
entity.setCreatedAt(LocalDateTime.now());
entity.setUpdatedAt(LocalDateTime.now());
entity.setStatus(0L);
entity.setCurrentMembers(0);
return groupCourseDao.save(entity)
.map(groupCourseConverter::toDomain);
@@ -150,6 +169,17 @@ public class GroupCourseRepository implements IGroupCourseRepository {
.then();
}
@Override
public Mono<GroupCourse> updateCurrentMembers(Long id, Integer delta) {
return groupCourseDao.updateCurrentMembers(id, delta, LocalDateTime.now())
.flatMap(updated -> {
if (updated > 0) {
return findByIdAndDeletedAtIsNull(id);
}
return Mono.empty();
});
}
@Override
public Flux<GroupCourse> findByCourseType(Long courseType) {
return groupCourseDao.findByCourseTypeAndDeletedAtIsNull(courseType)
@@ -178,28 +208,4 @@ public class GroupCourseRepository implements IGroupCourseRepository {
});
});
}
// ==================== 教练相关 ====================
@Override
public Flux<GroupCourse> findByCoachId(Long coachId) {
return groupCourseDao.findByCoachIdAndDeletedAtIsNull(coachId)
.map(groupCourseConverter::toDomain);
}
@Override
public Flux<GroupCourse> findByCoachId(Long coachId, Sort sort) {
return groupCourseDao.findByCoachIdAndDeletedAtIsNull(coachId, sort)
.map(groupCourseConverter::toDomain);
}
@Override
public Mono<Long> countByCoachIdAndStatus(Long coachId, Long status) {
return groupCourseDao.countByCoachIdAndStatus(coachId, String.valueOf(status));
}
@Override
public Mono<Integer> cancelCoursesByCoachIdExceptStatus(Long coachId, Long excludeStatus) {
return groupCourseDao.cancelCoursesByCoachIdExceptStatus(coachId, String.valueOf(excludeStatus), LocalDateTime.now());
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/repository/impl/GroupCourseTypeRepository.java
+1 -54
View File
@@ -1,7 +1,5 @@
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.GroupCourseTypeDao;
import cn.novalon.gym.manage.groupcourse.domain.GroupCourseType;
@@ -9,18 +7,12 @@ import cn.novalon.gym.manage.groupcourse.entity.GroupCourseTypeEntity;
import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseTypeRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Sort;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.data.relational.core.query.Criteria;
import org.springframework.data.relational.core.query.Query;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
@Repository
@Transactional
@@ -30,13 +22,10 @@ public class GroupCourseTypeRepository implements IGroupCourseTypeRepository {
private final GroupCourseTypeDao groupCourseTypeDao;
private final GroupCourseConverter converter;
private final R2dbcEntityTemplate r2dbcEntityTemplate;
public GroupCourseTypeRepository(GroupCourseTypeDao groupCourseTypeDao, GroupCourseConverter converter,
R2dbcEntityTemplate r2dbcEntityTemplate) {
public GroupCourseTypeRepository(GroupCourseTypeDao groupCourseTypeDao, GroupCourseConverter converter) {
this.groupCourseTypeDao = groupCourseTypeDao;
this.converter = converter;
this.r2dbcEntityTemplate = r2dbcEntityTemplate;
}
@Override
@@ -140,46 +129,4 @@ public class GroupCourseTypeRepository implements IGroupCourseTypeRepository {
return groupCourseTypeDao.softDelete(id, LocalDateTime.now())
.then();
}
@Override
public Mono<PageResponse<GroupCourseType>> findByPage(PageRequest pageRequest) {
int page = pageRequest.getPage();
int size = pageRequest.getSize();
String order = pageRequest.getOrder();
String sort = pageRequest.getSort();
String keyword = pageRequest.getKeyword();
String category = pageRequest.getCategory();
Sort sortObj = Sort.unsorted();
if (sort != null && !sort.isEmpty()) {
sortObj = Sort.by(Sort.Direction.fromString(order), sort);
}
// Build dynamic criteria
List<Criteria> criteriaList = new ArrayList<>();
criteriaList.add(Criteria.where("deleted_at").isNull());
if (keyword != null && !keyword.isEmpty()) {
criteriaList.add(Criteria.where("type_name").like("%" + keyword + "%").ignoreCase(true));
}
if (category != null && !category.isEmpty()) {
criteriaList.add(Criteria.where("category").is(category));
}
Criteria criteria = criteriaList.isEmpty() ? Criteria.empty() : Criteria.from(criteriaList);
Query query = Query.query(criteria).with(org.springframework.data.domain.PageRequest.of(page, size, sortObj));
return r2dbcEntityTemplate.select(GroupCourseTypeEntity.class)
.matching(query)
.all()
.collectList()
.zipWith(r2dbcEntityTemplate.count(Query.query(criteria), GroupCourseTypeEntity.class))
.map(tuple -> {
long total = tuple.getT2();
int totalPages = (int) Math.ceil((double) total / size);
List<GroupCourseType> list = tuple.getT1().stream()
.map(converter::toGroupCourseType)
.toList();
return new PageResponse<>(list, totalPages, total, page, size);
});
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/scheduler/GroupCourseExpireScheduler.java
+46
View File
@@ -0,0 +1,46 @@
package cn.novalon.gym.manage.groupcourse.scheduler;
import cn.novalon.gym.manage.groupcourse.dao.GroupCourseDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 团课过期状态自动更新定时任务
*
* 功能：定期检查已过期的团课（end_time <= NOW()），自动将 status 从 0 更新为 2（已结束）
*
* @date 2026-06-24
*/
@Component
public class GroupCourseExpireScheduler {
private static final Logger logger = LoggerFactory.getLogger(GroupCourseExpireScheduler.class);
private final GroupCourseDao groupCourseDao;
public GroupCourseExpireScheduler(GroupCourseDao groupCourseDao) {
this.groupCourseDao = groupCourseDao;
}
/**
* 每分钟检查一次，将已过期但状态仍为 0 的团课标记为已结束（status = 2）
*/
@Scheduled(fixedRate = 60000)
public void completeExpiredCourses() {
logger.debug("定时任务开始检查已过期团课，更新状态为已结束");
groupCourseDao.completeExpiredCourses(LocalDateTime.now())
.subscribe(
count -> {
if (count > 0) {
logger.info("定时任务完成，更新了 {} 条过期团课状态为已结束", count);
}
},
error -> logger.error("过期团课状态更新定时任务执行失败：{}", error.getMessage(), error)
);
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/ICourseLabelService.java
-4
View File
@@ -1,7 +1,5 @@
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.CourseLabel;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@@ -29,6 +27,4 @@ public interface ICourseLabelService {
Mono<Void> removeLabelFromType(Long typeId, Long labelId);
Mono<Void> clearLabelsFromType(Long typeId);
Mono<PageResponse<CourseLabel>> findByPage(PageRequest pageRequest);
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/IGroupCourseBookingService.java
+2 -1
View File
@@ -17,9 +17,10 @@ public interface IGroupCourseBookingService {
*
* @param courseId 团课ID
* @param memberId 会员ID
* @param memberCardRecordId 会员卡记录ID
* @return 预约记录
*/
Mono<GroupCourseBooking> bookCourse(Long courseId, Long memberId);
Mono<GroupCourseBooking> bookCourse(Long courseId, Long memberId, Long memberCardRecordId);
/**
* 取消预约
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/IGroupCourseService.java
-16
View File
@@ -6,20 +6,14 @@ import cn.novalon.gym.manage.common.dto.PageResponse;
import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
import cn.novalon.gym.manage.groupcourse.domain.GroupCourseDetail;
import cn.novalon.gym.manage.groupcourse.dto.GroupCourseQueryDto;
import cn.novalon.gym.manage.groupcourse.vo.GroupCourseVO;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
import java.util.List;
public interface IGroupCourseService {
Mono<GroupCourse> findById(Long id);
Mono<GroupCourseDetail> findDetailById(Long id);
Flux<GroupCourse> findAll();
Flux<GroupCourse> findAll(boolean includeDeleted);
Flux<GroupCourseVO> findAllAsVO(boolean includeDeleted);
Mono<PageResponse<GroupCourseVO>> findByPageAsVO(PageRequest pageRequest, boolean includeDeleted);
Mono<PageResponse<GroupCourse>> findByPage(PageRequest pageRequest, boolean includeDeleted);
@@ -34,14 +28,4 @@ public interface IGroupCourseService {
Mono<Void> delete(Long id);
Mono<PageResponse<GroupCourse>> searchGroupCourses(GroupCourseQueryDto query);
/**
* 检查教练在指定时间段内是否有时间冲突的团课
* @param coachId 教练ID
* @param startTime 开始时间
* @param endTime 结束时间
* @param excludeCourseId 排除的课程ID（编辑时排除自身）
* @return 冲突的课程列表
*/
Mono<List<GroupCourse>> checkCoachConflict(Long coachId, LocalDateTime startTime, LocalDateTime endTime, Long excludeCourseId);
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/IGroupCourseTypeService.java
-4
View File
@@ -1,7 +1,5 @@
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.GroupCourseType;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@@ -31,6 +29,4 @@ public interface IGroupCourseTypeService {
* @return 分类名称列表
*/
Flux<String> findCategories();
Mono<PageResponse<GroupCourseType>> findByPage(PageRequest pageRequest);
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/CourseLabelService.java
-10
View File
@@ -1,7 +1,5 @@
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.common.util.RedisUtil;
import cn.novalon.gym.manage.groupcourse.domain.CourseLabel;
import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
@@ -111,12 +109,4 @@ public class CourseLabelService implements ICourseLabelService {
.doOnSuccess(v -> logger.info("清空类型标签成功 - typeId={}", typeId))
.doOnError(error -> logger.error("清空类型标签失败 - typeId={}, error: {}", typeId, error.getMessage()));
}
@Override
public Mono<PageResponse<CourseLabel>> findByPage(PageRequest pageRequest) {
return courseLabelRepository.findByPage(pageRequest)
.doOnSuccess(result -> logger.info("分页查询标签成功 - page={}, size={}, total={}",
pageRequest.getPage(), pageRequest.getSize(), result.getTotalElements()))
.doOnError(error -> logger.error("分页查询标签失败 - error: {}", error.getMessage()));
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseBookingService.java
+104 -77
View File
@@ -3,6 +3,7 @@ package cn.novalon.gym.manage.groupcourse.service.impl;
import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
import cn.novalon.gym.manage.groupcourse.event.BookingReminderEventPublisher;
import cn.novalon.gym.manage.groupcourse.handler.BookingSagaHandler;
import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepository;
import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
import cn.novalon.gym.manage.groupcourse.service.IGroupCourseBookingService;
@@ -24,6 +25,7 @@ import java.util.UUID;
* - 取消预约需在课程开始前至少2小时
* - 每节课最多20人
* - 预约成功后发送提醒
* - 预约成功后扣减权益
*
* 技术要点：
* - 使用Redis缓存团课信息
@@ -42,6 +44,7 @@ public class GroupCourseBookingService implements IGroupCourseBookingService {
private final IGroupCourseRepository courseRepository;
private final GroupCourseRedisService redisService;
private final BookingReminderEventPublisher bookingReminderEventPublisher;
private final BookingSagaHandler bookingSagaHandler;
// 预约提前时间限制（分钟）
private static final long BOOKING_MIN_ADVANCE_MINUTES = 30;
@@ -51,16 +54,18 @@ public class GroupCourseBookingService implements IGroupCourseBookingService {
public GroupCourseBookingService(IGroupCourseBookingRepository bookingRepository,
IGroupCourseRepository courseRepository,
GroupCourseRedisService redisService,
BookingReminderEventPublisher bookingReminderEventPublisher) {
BookingReminderEventPublisher bookingReminderEventPublisher,
BookingSagaHandler bookingSagaHandler) {
this.bookingRepository = bookingRepository;
this.courseRepository = courseRepository;
this.redisService = redisService;
this.bookingReminderEventPublisher = bookingReminderEventPublisher;
this.bookingSagaHandler = bookingSagaHandler;
}
@Override
public Mono<GroupCourseBooking> bookCourse(Long courseId, Long memberId) {
logger.info("开始预约团课：courseId={}, memberId={}", courseId, memberId);
public Mono<GroupCourseBooking> bookCourse(Long courseId, Long memberId, Long memberCardRecordId) {
logger.info("开始预约团课：courseId={}, memberId={}, memberCardRecordId={}", courseId, memberId, memberCardRecordId);
// 生成唯一请求ID用于分布式锁
String requestId = UUID.randomUUID().toString();
@@ -72,26 +77,18 @@ public class GroupCourseBookingService implements IGroupCourseBookingService {
return Mono.error(new RuntimeException("系统繁忙，请稍后重试"));
}
// 2. 从缓存或数据库获取课程信息，并用实时预约数覆盖currentMembers
// 2. 尝试从缓存获取课程信息，如果缓存不存在则从数据库获取
return getCourseWithCache(courseId)
.flatMap(course ->
bookingRepository.countValidBookings(courseId)
.map(count -> {
course.setCurrentMembers(count.intValue());
return course;
})
.defaultIfEmpty(course)
)
.flatMap(course -> {
// 3. 验证课程状态
Long courseStatus = course.getStatus();
if (courseStatus == null || courseStatus != 0L) {
Long status = course.getStatus();
if (status == null || status != 0L) {
String errorMessage;
if (courseStatus == null) {
if (status == null) {
errorMessage = "课程状态异常";
} else if (courseStatus == 1L) {
} else if (status == 1L) {
errorMessage = "课程已取消，无法预约";
} else if (courseStatus == 2L) {
} else if (status == 2L) {
errorMessage = "课程已结束，无法预约";
} else {
errorMessage = "课程状态不可预约";
@@ -134,46 +131,56 @@ public class GroupCourseBookingService implements IGroupCourseBookingService {
// 7. 验证是否已预约
return bookingRepository.findValidBooking(courseId, memberId)
.flatMap(existingBooking ->
releaseLockAndError(courseId, requestId, "您已预约该课程")
)
.flatMap(existingBooking -> {
return releaseLockAndError(courseId, requestId, "您已预约该课程");
})
.switchIfEmpty(
// 8. 创建预约记录
Mono.defer(() -> {
GroupCourseBooking booking = new GroupCourseBooking();
booking.setCourseId(courseId);
booking.setMemberId(memberId);
booking.setBookingTime(LocalDateTime.now());
booking.setStatus("0"); // 0-已预约
// 8. 使用Redis原子操作验证课程人数是否已满
validateAndIncrementBookingCount(courseId, course.getMaxMembers())
.flatMap(countValid -> {
if (countValid > course.getMaxMembers()) {
return releaseLockAndError(courseId, requestId, "课程已满");
}
// 添加课程信息到预约记录
booking.setCourseName(course.getCourseName());
booking.setCourseStartTime(course.getStartTime());
booking.setCourseEndTime(course.getEndTime());
booking.setLocation(course.getLocation());
// 9. 创建预约记录
GroupCourseBooking booking = new GroupCourseBooking();
booking.setCourseId(courseId);
booking.setMemberId(memberId);
booking.setMemberCardRecordId(memberCardRecordId);
booking.setBookingTime(LocalDateTime.now());
booking.setStatus("0"); // 0-已预约
// 9. 保存预约记录
return bookingRepository.save(booking)
.flatMap(saved -> {
if (saved.getId() == null) {
return Mono.error(new RuntimeException("保存预约记录失败"));
}
// 10. 释放锁
return redisService.releaseLock(courseId, requestId)
.then(Mono.just(saved));
})
.doOnSuccess(savedBooking -> {
logger.info("预约成功：bookingId={}, courseId={}, memberId={}",
savedBooking.getId(), courseId, memberId);
// 发布预约成功事件
bookingReminderEventPublisher.publishBookingSuccessEvent(
savedBooking.getId(),
savedBooking.getMemberId(),
savedBooking.getCourseName(),
savedBooking.getCourseStartTime().toString()
);
});
})
// 添加课程信息到预约记录
booking.setCourseName(course.getCourseName());
booking.setCourseStartTime(course.getStartTime());
booking.setCourseEndTime(course.getEndTime());
booking.setLocation(course.getLocation());
// 10. 使用Saga事务执行预约（包含权益扣减）
return bookingSagaHandler.executeBooking(booking, memberCardRecordId)
.flatMap(savedBooking -> {
// 11. 释放锁
return redisService.releaseLock(courseId, requestId)
.then(Mono.just(savedBooking));
})
.doOnSuccess(savedBooking -> {
logger.info("预约成功：bookingId={}, courseId={}, memberId={}",
savedBooking.getId(), courseId, memberId);
// 发布预约成功事件
bookingReminderEventPublisher.publishBookingSuccessEvent(
savedBooking.getId(),
savedBooking.getMemberId(),
savedBooking.getCourseName(),
savedBooking.getCourseStartTime().toString()
);
})
.doOnError(error -> {
// 回滚Redis计数
redisService.decrementBookingCount(courseId).subscribe();
logger.error("预约失败：courseId={}, memberId={}, error={}",
courseId, memberId, error.getMessage());
});
})
);
});
})
@@ -201,6 +208,29 @@ public class GroupCourseBookingService implements IGroupCourseBookingService {
);
}
/**
* 验证并增加预约人数（使用Redis原子操作）
*/
private Mono<Integer> validateAndIncrementBookingCount(Long courseId, Integer maxMembers) {
// 先获取当前Redis中的预约计数
return redisService.getBookingCount(courseId)
.flatMap(currentCount -> {
// 如果Redis中计数为0，可能是首次访问，需要从数据库同步
if (currentCount == 0) {
// 从数据库查询实际预约人数
return bookingRepository.countValidBookings(courseId)
.flatMap(dbCount -> {
// 将数据库中的实际预约人数同步到Redis
return redisService.setBookingCount(courseId, dbCount.intValue())
.then(Mono.just(dbCount.intValue()));
});
}
return Mono.just(currentCount);
})
// 递增预约计数
.flatMap(count -> redisService.incrementBookingCount(courseId).map(Long::intValue));
}
/**
* 释放锁并返回错误
*/
@@ -260,29 +290,26 @@ public class GroupCourseBookingService implements IGroupCourseBookingService {
"需在课程开始前" + CANCEL_MIN_ADVANCE_HOURS + "小时取消");
}
// 5. 更新预约状态为已取消
return bookingRepository.updateStatus(bookingId, "1")
.flatMap(rows -> {
if (rows == 0) {
return Mono.error(new RuntimeException("更新预约状态失败"));
}
// 6. 释放锁
return redisService.releaseLock(bookingId, requestId)
.then(bookingRepository.findById(bookingId));
})
.doOnSuccess(updatedBooking -> {
logger.info("取消预约成功：bookingId={}, memberId={}", bookingId, memberId);
// 发布预约取消事件
bookingReminderEventPublisher.publishBookingCancelEvent(
updatedBooking.getId(),
updatedBooking.getMemberId(),
updatedBooking.getCourseName()
);
})
.doOnError(error -> {
logger.error("取消预约失败：bookingId={}, memberId={}, error={}",
bookingId, memberId, error.getMessage());
});
// 5. 使用Saga事务执行取消预约（包含权益恢复）
return bookingSagaHandler.executeCancelBooking(bookingId, booking.getCourseId(), booking.getMemberCardRecordId(), memberId)
.flatMap(updatedBooking -> {
// 6. 释放锁
return redisService.releaseLock(bookingId, requestId)
.then(Mono.just(updatedBooking));
})
.doOnSuccess(updatedBooking -> {
logger.info("取消预约成功：bookingId={}, memberId={}", bookingId, memberId);
// 发布预约取消事件
bookingReminderEventPublisher.publishBookingCancelEvent(
updatedBooking.getId(),
updatedBooking.getMemberId(),
updatedBooking.getCourseName()
);
})
.doOnError(error -> {
logger.error("取消预约失败：bookingId={}, memberId={}, error={}",
bookingId, memberId, error.getMessage());
});
})
.onErrorResume(error -> {
redisService.releaseLock(bookingId, requestId).subscribe();
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseRedisService.java
+42
View File
@@ -149,4 +149,46 @@ public class GroupCourseRedisService {
})
.defaultIfEmpty(false);
}
/**
* 获取课程预约人数（缓存）
*/
public Mono<Integer> getBookingCount(Long courseId) {
String key = "booking_count:" + courseId;
return reactiveRedisTemplate.opsForValue()
.get(key)
.map(obj -> (Integer) obj)
.defaultIfEmpty(0);
}
/**
* 增加课程预约人数
*/
public Mono<Long> incrementBookingCount(Long courseId) {
String key = "booking_count:" + courseId;
return reactiveRedisTemplate.opsForValue()
.increment(key)
.doOnSuccess(count -> logger.debug("预约人数增加：courseId={}, count={}", courseId, count));
}
/**
* 减少课程预约人数
*/
public Mono<Long> decrementBookingCount(Long courseId) {
String key = "booking_count:" + courseId;
return reactiveRedisTemplate.opsForValue()
.decrement(key)
.doOnSuccess(count -> logger.debug("预约人数减少：courseId={}, count={}", courseId, count));
}
/**
* 设置课程预约人数（用于从数据库同步）
*/
public Mono<Void> setBookingCount(Long courseId, Integer count) {
String key = "booking_count:" + courseId;
return reactiveRedisTemplate.opsForValue()
.set(key, count)
.doOnSuccess(result -> logger.debug("预约人数已设置：courseId={}, count={}", courseId, count))
.then();
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseService.java
+51 -254
View File
@@ -19,15 +19,11 @@ import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseTypeRepository;
import cn.novalon.gym.manage.groupcourse.service.IGroupCourseService;
import cn.novalon.gym.manage.groupcourse.util.QRCodeUtil;
import cn.novalon.gym.manage.groupcourse.vo.GroupCourseVO;
import cn.novalon.gym.manage.file.core.service.ISysFileService;
import cn.novalon.gym.manage.member.entity.MemberCard;
import cn.novalon.gym.manage.member.entity.MemberCardRecord;
import cn.novalon.gym.manage.member.enums.MemberCardType;
import cn.novalon.gym.manage.member.repository.MemberCardRepository;
import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
import cn.novalon.gym.manage.sys.core.domain.SysUser;
import cn.novalon.gym.manage.sys.core.repository.ISysUserRepository;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
@@ -38,9 +34,7 @@ import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
@@ -57,8 +51,6 @@ public class GroupCourseService implements IGroupCourseService {
private final ObjectMapper objectMapper;
private final GroupCourseStateMachine stateMachine;
private final DatabaseClient databaseClient;
private final ISysFileService fileService;
private final ISysUserRepository sysUserRepository;
private static final String CACHE_KEY_PREFIX = "group_course:page:";
private static final String CACHE_KEY_ID_PREFIX = "group_course:id:";
@@ -76,9 +68,7 @@ public class GroupCourseService implements IGroupCourseService {
RedisUtil redisUtil,
ObjectMapper objectMapper,
GroupCourseStateMachine stateMachine,
DatabaseClient databaseClient,
ISysFileService fileService,
ISysUserRepository sysUserRepository){
DatabaseClient databaseClient){
this.groupCourseRepository = groupCourseRepository;
this.bookingRepository = bookingRepository;
this.groupCourseTypeRepository = groupCourseTypeRepository;
@@ -89,22 +79,19 @@ public class GroupCourseService implements IGroupCourseService {
this.objectMapper = objectMapper;
this.stateMachine = stateMachine;
this.databaseClient = databaseClient;
this.fileService = fileService;
this.sysUserRepository = sysUserRepository;
}
@Override
public Mono<GroupCourseDetail> findDetailById(Long id) {
String cacheKey = CACHE_KEY_DETAIL_PREFIX + id;
Mono<String> cachedMono = redisUtil.get(cacheKey, String.class);
return cachedMono
return redisUtil.get(cacheKey, String.class)
.flatMap(cachedJson -> {
if (cachedJson != null && !cachedJson.isEmpty()) {
if (cachedJson != null) {
try {
GroupCourseDetail detail = objectMapper.readValue(cachedJson, GroupCourseDetail.class);
logger.info("缓存命中 - findDetailById: id={}", id);
return Mono.<GroupCourseDetail>just(detail);
return Mono.just(detail);
} catch (JsonProcessingException e) {
logger.warn("缓存解析失败，删除缓存 - id: {}, error: {}", id, e.getMessage());
return redisUtil.delete(cacheKey).then(Mono.empty());
@@ -136,8 +123,6 @@ public class GroupCourseService implements IGroupCourseService {
})
.switchIfEmpty(Mono.just(buildDetail(course, null)));
})
.flatMap(this::enrichCoachName)
.flatMap(this::enrichCurrentMembers)
.flatMap(detail -> {
try {
String jsonData = objectMapper.writeValueAsString(detail);
@@ -183,64 +168,17 @@ public class GroupCourseService implements IGroupCourseService {
return detail;
}
/**
* 为团课详情对象填充教练名称
*/
private Mono<GroupCourseDetail> enrichCoachName(GroupCourseDetail detail) {
Long coachId = detail.getCoachId();
if (coachId == null) {
return Mono.just(detail);
}
return sysUserRepository.findByIdIncludingDeleted(coachId)
.map(user -> {
String name = user.getNickname() != null ? user.getNickname() : user.getUsername();
detail.setCoachName(name);
logger.debug("enrichCoachName: courseId={}, coachId={}, coachName={}", detail.getId(), coachId, name);
return detail;
})
.doOnNext(d -> {}) // 避免空doOnNext告警
.defaultIfEmpty(detail)
.doOnDiscard(GroupCourseDetail.class, d ->
logger.warn("enrichCoachName: coach not found, coachId={}, courseId={}", coachId, detail.getId())
);
}
/**
* 为团课详情对象填充实时预约人数
*/
private Mono<GroupCourseDetail> enrichCurrentMembers(GroupCourseDetail detail) {
return bookingRepository.countValidBookings(detail.getId())
.map(count -> {
detail.setCurrentMembers(count.intValue());
return detail;
})
.defaultIfEmpty(detail);
}
/**
* 为团课对象填充实时预约人数
*/
private Mono<GroupCourse> enrichCurrentMembers(GroupCourse course) {
return bookingRepository.countValidBookings(course.getId())
.map(count -> {
course.setCurrentMembers(count.intValue());
return course;
})
.defaultIfEmpty(course);
}
@Override
public Mono<GroupCourse> findById(Long id) {
String cacheKey = CACHE_KEY_ID_PREFIX + id;
Mono<String> cachedMono = redisUtil.get(cacheKey, String.class);
return cachedMono
return redisUtil.get(cacheKey, String.class)
.flatMap(cachedJson -> {
if (cachedJson != null && !cachedJson.isEmpty()) {
if (cachedJson != null) {
try {
GroupCourse groupCourse = objectMapper.readValue(cachedJson, GroupCourse.class);
logger.info("缓存命中 - findById: id={}", id);
return Mono.<GroupCourse>just(groupCourse);
return Mono.just(groupCourse);
} catch (JsonProcessingException e) {
logger.warn("缓存解析失败，删除缓存 - id: {}, error: {}", id, e.getMessage());
return redisUtil.delete(cacheKey).then(Mono.empty());
@@ -262,8 +200,7 @@ public class GroupCourseService implements IGroupCourseService {
}
})
.doOnSubscribe(sub -> logger.debug("缓存未命中，查询数据库 - findById: id={}", id))
)
.flatMap(this::enrichCurrentMembers);
);
}
@Override
@@ -280,47 +217,6 @@ public class GroupCourseService implements IGroupCourseService {
}
}
@Override
public Flux<GroupCourseVO> findAllAsVO(boolean includeDeleted) {
return findAll(includeDeleted)
.flatMap(this::enrichCurrentMembers)
.collectList()
.flatMapMany(courses -> {
if (courses.isEmpty()) {
logger.info("findAllAsVO: no courses found");
return Flux.empty();
}
var coachIds = courses.stream()
.map(GroupCourse::getCoachId)
.filter(id -> id != null)
.distinct()
.toList();
logger.info("findAllAsVO: {} courses, {} unique coach IDs: {}", courses.size(), coachIds.size(), coachIds);
if (coachIds.isEmpty()) {
logger.info("findAllAsVO: no coach IDs, returning VOs with null coachName");
return Flux.fromIterable(courses.stream()
.map(c -> GroupCourseVO.from(c, null))
.toList());
}
return Flux.fromIterable(coachIds)
.flatMap(sysUserRepository::findByIdIncludingDeleted)
.doOnNext(u -> logger.info("findAllAsVO: found coach id={}, nickname={}, username={}", u.getId(), u.getNickname(), u.getUsername()))
.collectMap(SysUser::getId, u -> u.getNickname() != null ? u.getNickname() : u.getUsername())
.doOnNext(m -> logger.info("findAllAsVO: coachNameMap size={}, keys={}", m.size(), m.keySet()))
.flatMapMany(coachNameMap ->
Flux.fromIterable(courses.stream()
.map(c -> {
String name = coachNameMap.get(c.getCoachId());
logger.debug("findAllAsVO: courseId={}, coachId={}, coachName={}", c.getId(), c.getCoachId(), name);
return GroupCourseVO.from(c, name);
})
.toList()));
});
}
@Override
public Mono<PageResponse<GroupCourse>> findByPage(PageRequest pageRequest, boolean includeDeleted) {
int page = pageRequest.getPage();
@@ -328,19 +224,17 @@ public class GroupCourseService implements IGroupCourseService {
String sort = pageRequest.getSort();
String order = pageRequest.getOrder();
String keyword = pageRequest.getKeyword() != null ? pageRequest.getKeyword() : "";
String status = pageRequest.getStatus() != null ? pageRequest.getStatus() : "";
String cacheKey = CACHE_KEY_PREFIX + page + ":" + size + ":" + includeDeleted + ":" + sort + ":" + order + ":" + keyword + ":" + status;
String cacheKey = CACHE_KEY_PREFIX + page + ":" + size + ":" + includeDeleted + ":" + sort + ":" + order + ":" + keyword;
Mono<String> cachedMono = redisUtil.get(cacheKey, String.class);
return cachedMono
return redisUtil.get(cacheKey, String.class)
.flatMap(cachedJson -> {
if (cachedJson != null && !cachedJson.isEmpty()) {
if (cachedJson != null) {
try {
PageResponse<GroupCourse> pageResponse = objectMapper.readValue(cachedJson,
objectMapper.getTypeFactory().constructParametricType(PageResponse.class, GroupCourse.class));
logger.info("缓存命中 - findByPage: key={}", cacheKey);
return Mono.<PageResponse<GroupCourse>>just(pageResponse);
return Mono.just(pageResponse);
} catch (JsonProcessingException e) {
logger.warn("缓存解析失败，删除缓存 - key: {}, error: {}", cacheKey, e.getMessage());
return redisUtil.delete(cacheKey).then(Mono.empty());
@@ -373,73 +267,6 @@ public class GroupCourseService implements IGroupCourseService {
);
}
@Override
public Mono<PageResponse<GroupCourseVO>> findByPageAsVO(PageRequest pageRequest, boolean includeDeleted) {
return findByPage(pageRequest, includeDeleted)
.flatMap(pageResponse -> {
List<GroupCourse> courses = pageResponse.getContent();
if (courses.isEmpty()) {
PageResponse<GroupCourseVO> voResponse = new PageResponse<>(
Collections.emptyList(),
pageResponse.getTotalPages(),
pageResponse.getTotalElements(),
pageResponse.getCurrentPage(),
pageResponse.getPageSize()
);
return Mono.just(voResponse);
}
// 用实时预约人数覆盖缓存/DB中的currentMembers
return Flux.fromIterable(courses)
.flatMap(this::enrichCurrentMembers)
.collectList()
.flatMap(enrichedCourses -> {
var coachIds = enrichedCourses.stream()
.map(GroupCourse::getCoachId)
.filter(id -> id != null)
.distinct()
.toList();
logger.info("findByPageAsVO: {} courses, {} unique coach IDs: {}", enrichedCourses.size(), coachIds.size(), coachIds);
if (coachIds.isEmpty()) {
List<GroupCourseVO> voList = enrichedCourses.stream()
.map(c -> GroupCourseVO.from(c, null))
.toList();
PageResponse<GroupCourseVO> voResponse = new PageResponse<>(
voList,
pageResponse.getTotalPages(),
pageResponse.getTotalElements(),
pageResponse.getCurrentPage(),
pageResponse.getPageSize()
);
return Mono.just(voResponse);
}
return Flux.fromIterable(coachIds)
.flatMap(sysUserRepository::findByIdIncludingDeleted)
.doOnNext(u -> logger.info("findByPageAsVO: found coach id={}, nickname={}", u.getId(), u.getNickname()))
.collectMap(SysUser::getId, u -> u.getNickname() != null ? u.getNickname() : u.getUsername())
.map(coachNameMap -> {
List<GroupCourseVO> voList = enrichedCourses.stream()
.map(c -> {
String name = coachNameMap.get(c.getCoachId());
logger.debug("findByPageAsVO: courseId={}, coachId={}, coachName={}", c.getId(), c.getCoachId(), name);
return GroupCourseVO.from(c, name);
})
.toList();
return new PageResponse<>(
voList,
pageResponse.getTotalPages(),
pageResponse.getTotalElements(),
pageResponse.getCurrentPage(),
pageResponse.getPageSize()
);
});
});
});
}
@Override
public Mono<GroupCourse> create(GroupCourse groupCourse) {
return groupCourseRepository.save(groupCourse)
@@ -460,21 +287,15 @@ public class GroupCourseService implements IGroupCourseService {
String jsonContent = objectMapper.writeValueAsString(qrCodeContent);
// 生成二维码字节数组，通过统一文件服务保存
return Mono.fromCallable(() -> QRCodeUtil.generateQrCodeBytes(jsonContent))
.flatMap(qrCodeBytes -> {
String fileName = "qrcode_" + course.getId() + ".png";
return fileService.saveBytes(qrCodeBytes, fileName, "image/png", "system");
})
.flatMap(sysFile -> {
String qrCodeUrl = "/api/files/" + sysFile.getId() + "/preview";
course.setQrCodePath(qrCodeUrl);
logger.info("团课二维码已保存 - id={}, fileId={}, url={}", course.getId(), sysFile.getId(), qrCodeUrl);
return groupCourseRepository.update(course)
.doOnSuccess(updatedCourse -> logger.info("团课创建成功 - id={}, name={}", updatedCourse.getId(), updatedCourse.getCourseName()));
});
// 生成二维码并上传到阿里云OSS
String qrCodeUrl = QRCodeUtil.generateQRCodeAndUploadToOSS(jsonContent);
course.setQrCodePath(qrCodeUrl);
logger.info("团课二维码上传到OSS成功 - id={}, qrCodeUrl={}", course.getId(), qrCodeUrl);
// 更新团课信息，保存二维码路径
return groupCourseRepository.update(course)
.doOnSuccess(updatedCourse -> logger.info("团课创建成功 - id={}, name={}", updatedCourse.getId(), updatedCourse.getCourseName()));
} catch (Exception e) {
logger.error("团课二维码生成失败 - id={}, error: {}", course.getId(), e.getMessage(), e);
// 即使二维码生成失败，也返回成功创建的团课
@@ -656,15 +477,6 @@ public class GroupCourseService implements IGroupCourseService {
public Mono<GroupCourse> signIn(Long courseId, Long memberId) {
return groupCourseRepository.findByIdAndDeletedAtIsNull(courseId)
.switchIfEmpty(Mono.error(new RuntimeException("团课不存在或已删除")))
.flatMap(course ->
// 用实时预约人数覆盖currentMembers
bookingRepository.countValidBookings(courseId)
.map(count -> {
course.setCurrentMembers(count.intValue());
return course;
})
.defaultIfEmpty(course)
)
.flatMap(course -> {
// 校验1：团课已取消
if (course.getStatus().equals(CourseStatus.CANCELLED.getValue())) {
@@ -691,13 +503,30 @@ public class GroupCourseService implements IGroupCourseService {
return Mono.error(new RuntimeException("课程已满员，无法签到"));
}
// 校验5：用户已预约此课程（有效预约，状态为0-已预约）
return bookingRepository.findValidBooking(courseId, memberId)
.switchIfEmpty(Mono.error(new RuntimeException("您未预约此团课")))
.flatMap(booking -> {
// 更新预约状态为已出席（2），不再手动计数
return bookingRepository.updateStatus(booking.getId(), "2")
.thenReturn(course);
// 校验5：用户今日是否已到店签到（直接查询sign_in_record表）
LocalDateTime todayStart = LocalDateTime.now().toLocalDate().atStartOfDay();
LocalDateTime todayEnd = todayStart.plusDays(1);
return databaseClient.sql("SELECT sign_in_status FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time < :endTime AND is_delete = false ORDER BY sign_in_time DESC LIMIT 1")
.bind("memberId", memberId)
.bind("startTime", todayStart)
.bind("endTime", todayEnd)
.map(row -> row.get("sign_in_status", String.class))
.one()
.switchIfEmpty(Mono.error(new RuntimeException("请先完成到店签到")))
.flatMap(status -> {
if (!"SUCCESS".equals(status)) {
return Mono.error(new RuntimeException("到店签到未成功，请重新签到"));
}
// 校验6：用户已预约此课程（有效预约，状态为0-已预约）
return bookingRepository.findValidBooking(courseId, memberId)
.switchIfEmpty(Mono.error(new RuntimeException("您未预约此课程，无法签到")))
.flatMap(booking -> {
return groupCourseRepository.updateCurrentMembers(courseId, 1)
.flatMap(updatedCourse -> {
return bookingRepository.updateStatus(booking.getId(), "2")
.thenReturn(updatedCourse);
});
});
});
})
.doOnSuccess(course -> logger.info("团课签到成功 - courseId={}, memberId={}", courseId, memberId))
@@ -707,15 +536,14 @@ public class GroupCourseService implements IGroupCourseService {
@Override
public Mono<Void> delete(Long id) {
// 只有已取消或已结束的课程才能删除
// 先查询课程状态，只有已取消的课程才能删除
return groupCourseRepository.findByIdAndDeletedAtIsNull(id)
.switchIfEmpty(Mono.error(new RuntimeException("团课不存在")))
.flatMap(course -> {
// 检查课程状态是否为已取消（状态码1）或已结束（状态码2）
Long status = course.getStatus();
if (status == null || (!status.equals(CourseStatus.CANCELLED.getValue()) && !status.equals(CourseStatus.ENDED.getValue()))) {
return Mono.error(new RuntimeException("只有已取消或已结束的课程才能删除，当前状态: " +
(status != null ? status : "未知")));
// 检查课程状态是否为已取消（状态码1）
if (course.getStatus() == null || !course.getStatus().equals(CourseStatus.CANCELLED.getValue())) {
return Mono.error(new RuntimeException("只有已取消的课程才能删除，当前状态: " +
(course.getStatus() != null ? course.getStatus() : "未知")));
}
// 删除课程
@@ -741,37 +569,6 @@ public class GroupCourseService implements IGroupCourseService {
private Mono<Void> clearCache() {
return redisUtil.deleteByPattern(CACHE_KEY_PREFIX + "*")
.then(redisUtil.deleteByPattern(CACHE_KEY_ID_PREFIX + "*"))
.then(redisUtil.deleteByPattern(CACHE_KEY_DETAIL_PREFIX + "*"))
.then(redisUtil.deleteByPattern("datacount:statistics:*"))
.then();
}
@Override
public Mono<List<GroupCourse>> checkCoachConflict(Long coachId, LocalDateTime startTime, LocalDateTime endTime, Long excludeCourseId) {
if (coachId == null || startTime == null || endTime == null) {
return Mono.just(Collections.emptyList());
}
return groupCourseRepository.findByCoachId(coachId)
.filter(course -> {
// 排除已取消的课程
if (course.getStatus() != null && course.getStatus().equals(CourseStatus.CANCELLED.getValue())) {
return false;
}
// 排除自身（编辑时）
if (excludeCourseId != null && course.getId() != null && course.getId().equals(excludeCourseId)) {
return false;
}
// 检查时间是否重叠：startTime < course.endTime AND course.startTime < endTime
if (course.getStartTime() == null || course.getEndTime() == null) {
return false;
}
return startTime.isBefore(course.getEndTime()) && course.getStartTime().isBefore(endTime);
})
.collectList()
.doOnNext(conflicts -> {
if (!conflicts.isEmpty()) {
logger.info("checkCoachConflict: coachId={}, conflicts={} courses", coachId, conflicts.size());
}
});
.then(redisUtil.deleteByPattern(CACHE_KEY_DETAIL_PREFIX + "*")).then();
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseTypeService.java
+7 -26
View File
@@ -1,9 +1,6 @@
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.GroupCourseType;
import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseTypeRepository;
import cn.novalon.gym.manage.groupcourse.service.IGroupCourseTypeService;
import org.slf4j.Logger;
@@ -12,18 +9,18 @@ import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.HashSet;
import java.util.Set;
@Service
public class GroupCourseTypeService implements IGroupCourseTypeService {
private static final Logger logger = LoggerFactory.getLogger(GroupCourseTypeService.class);
private final IGroupCourseTypeRepository groupCourseTypeRepository;
private final IGroupCourseRepository groupCourseRepository;
public GroupCourseTypeService(IGroupCourseTypeRepository groupCourseTypeRepository,
IGroupCourseRepository groupCourseRepository) {
public GroupCourseTypeService(IGroupCourseTypeRepository groupCourseTypeRepository) {
this.groupCourseTypeRepository = groupCourseTypeRepository;
this.groupCourseRepository = groupCourseRepository;
}
@Override
@@ -74,17 +71,9 @@ public class GroupCourseTypeService implements IGroupCourseTypeService {
@Override
public Mono<Void> delete(Long id) {
// 检查是否有团课依赖该类型
return groupCourseRepository.findByCourseType(id)
.hasElements()
.flatMap(hasDependents -> {
if (hasDependents) {
return Mono.<Void>error(new RuntimeException("该类型下存在团课，无法删除"));
}
return groupCourseTypeRepository.deleteById(id)
.doOnSuccess(v -> logger.info("团课类型删除成功 - id={}", id))
.doOnError(error -> logger.error("团课类型删除失败 - id={}, error: {}", id, error.getMessage()));
});
return groupCourseTypeRepository.deleteById(id)
.doOnSuccess(v -> logger.info("团课类型删除成功 - id={}", id))
.doOnError(error -> logger.error("团课类型删除失败 - id={}, error: {}", id, error.getMessage()));
}
@Override
@@ -94,12 +83,4 @@ public class GroupCourseTypeService implements IGroupCourseTypeService {
.filter(category -> category != null && !category.isEmpty())
.distinct();
}
@Override
public Mono<PageResponse<GroupCourseType>> findByPage(PageRequest pageRequest) {
return groupCourseTypeRepository.findByPage(pageRequest)
.doOnSuccess(result -> logger.info("分页查询团课类型成功 - page={}, size={}, total={}",
pageRequest.getPage(), pageRequest.getSize(), result.getTotalElements()))
.doOnError(error -> logger.error("分页查询团课类型失败 - error: {}", error.getMessage()));
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/util/OSSUtil.java
+109
View File
@@ -0,0 +1,109 @@
package cn.novalon.gym.manage.groupcourse.util;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.model.PutObjectRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
/**
* 阿里云OSS工具类
*/
public class OSSUtil {
private static final Logger logger = LoggerFactory.getLogger(OSSUtil.class);
// OSS配置信息
private static final String ENDPOINT = "oss-cn-beijing.aliyuncs.com";
private static final String ACCESS_KEY_ID = "LTAI5t9TFh9Vayeahz45kZjg";
private static final String ACCESS_KEY_SECRET = "zD6NlCeH5UhjBs4vnQVqn8Ksi3CaZz";
private static final String BUCKET_NAME = "ycc-filesaver";
// OSS访问地址前缀
private static final String OSS_URL_PREFIX = "https://" + BUCKET_NAME + "." + ENDPOINT + "/";
// 文件存储目录
private static final String QRCODE_DIR = "qrcode/";
/**
* 上传文件到阿里云OSS
*
* @param localFilePath 本地文件路径
* @param fileName 文件名（不含路径）
* @return OSS访问地址
*/
public static String uploadToOSS(String localFilePath, String fileName) {
OSS ossClient = null;
try {
// 创建OSS客户端
ossClient = new OSSClientBuilder().build(ENDPOINT, ACCESS_KEY_ID, ACCESS_KEY_SECRET);
// 构建OSS文件路径：qrcode/2026/06/18/xxx.png
String datePath = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd"));
String ossFilePath = QRCODE_DIR + datePath + "/" + fileName;
// 创建上传请求
PutObjectRequest putObjectRequest = new PutObjectRequest(BUCKET_NAME, ossFilePath, new File(localFilePath));
// 上传文件
ossClient.putObject(putObjectRequest);
// 构建访问地址
String accessUrl = OSS_URL_PREFIX + ossFilePath;
logger.info("文件上传到OSS成功: localPath={}, ossUrl={}", localFilePath, accessUrl);
return accessUrl;
} catch (Exception e) {
logger.error("文件上传到OSS失败 - localPath: {}, error: {}", localFilePath, e.getMessage(), e);
throw new RuntimeException("文件上传到OSS失败: " + e.getMessage(), e);
} finally {
if (ossClient != null) {
ossClient.shutdown();
}
}
}
/**
* 上传文件到阿里云OSS（自定义存储路径）
*
* @param localFilePath 本地文件路径
* @param ossDirectory OSS存储目录
* @param fileName 文件名（不含路径）
* @return OSS访问地址
*/
public static String uploadToOSS(String localFilePath, String ossDirectory, String fileName) {
OSS ossClient = null;
try {
// 创建OSS客户端
ossClient = new OSSClientBuilder().build(ENDPOINT, ACCESS_KEY_ID, ACCESS_KEY_SECRET);
// 构建OSS文件路径
String ossFilePath = ossDirectory + fileName;
// 创建上传请求
PutObjectRequest putObjectRequest = new PutObjectRequest(BUCKET_NAME, ossFilePath, new File(localFilePath));
// 上传文件
ossClient.putObject(putObjectRequest);
// 构建访问地址
String accessUrl = OSS_URL_PREFIX + ossFilePath;
logger.info("文件上传到OSS成功: localPath={}, ossUrl={}", localFilePath, accessUrl);
return accessUrl;
} catch (Exception e) {
logger.error("文件上传到OSS失败 - localPath: {}, error: {}", localFilePath, e.getMessage(), e);
throw new RuntimeException("文件上传到OSS失败: " + e.getMessage(), e);
} finally {
if (ossClient != null) {
ossClient.shutdown();
}
}
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/util/QRCodeUtil.java
+107 -16
View File
@@ -10,33 +10,46 @@ import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/**
* 二维码生成工具类
* 生成二维码的字节数组，由调用方统一通过文件服务保存
*/
public class QRCodeUtil {
private static final Logger logger = LoggerFactory.getLogger(QRCodeUtil.class);
// 二维码默认保存路径（本地临时路径）
private static final String DEFAULT_SAVE_PATH = "D:\\Games\\exmp\\image";
// 二维码尺寸
private static final int QR_CODE_WIDTH = 300;
private static final int QR_CODE_HEIGHT = 300;
/**
* 生成二维码图片的字节数组
* 生成二维码并保存到指定路径
*
* @param content 二维码内容
* @return PNG格式的二维码图片字节数组
* @param savePath 保存路径
* @param fileName 文件名（不含扩展名）
* @return 生成的二维码文件完整路径
*/
public static byte[] generateQrCodeBytes(String content) {
public static String generateQRCode(String content, String savePath, String fileName) {
try {
Path directory = Paths.get(savePath);
if (!Files.exists(directory)) {
Files.createDirectories(directory);
logger.info("创建二维码保存目录: {}", savePath);
}
Map<EncodeHintType, Object> hints = new HashMap<>();
hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
@@ -45,21 +58,99 @@ public class QRCodeUtil {
QRCodeWriter qrCodeWriter = new QRCodeWriter();
BitMatrix bitMatrix = qrCodeWriter.encode(content, BarcodeFormat.QR_CODE, QR_CODE_WIDTH, QR_CODE_HEIGHT, hints);
BufferedImage image = MatrixToImageWriter.toBufferedImage(bitMatrix);
String filePath = Paths.get(savePath, fileName + ".png").toString();
Path path = Paths.get(filePath);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageIO.write(image, "PNG", baos);
byte[] bytes = baos.toByteArray();
baos.close();
MatrixToImageWriter.writeToPath(bitMatrix, "PNG", path);
logger.info("二维码生成成功: {}", filePath);
logger.info("二维码字节数组生成成功, size={} bytes", bytes.length);
return bytes;
return filePath;
} catch (WriterException e) {
logger.error("二维码生成失败 - WriterException: {}", e.getMessage(), e);
throw new RuntimeException("二维码生成失败: " + e.getMessage(), e);
} catch (IOException e) {
logger.error("二维码输出失败 - IOException: {}", e.getMessage(), e);
throw new RuntimeException("二维码输出失败: " + e.getMessage(), e);
logger.error("二维码保存失败 - IOException: {}", e.getMessage(), e);
throw new RuntimeException("二维码保存失败: " + e.getMessage(), e);
}
}
/**
* 生成二维码并保存到默认路径
* 文件名格式: UUID + 创建时间
*
* @param content 二维码内容
* @return 生成的二维码文件完整路径
*/
public static String generateQRCode(String content) {
String uuid = UUID.randomUUID().toString().replace("-", "");
String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
String fileName = uuid + "_" + timestamp;
return generateQRCode(content, DEFAULT_SAVE_PATH, fileName);
}
/**
* 生成二维码并保存到默认路径，使用自定义文件名
*
* @param content 二维码内容
* @param fileName 文件名（不含扩展名）
* @return 生成的二维码文件完整路径
*/
public static String generateQRCodeWithFileName(String content, String fileName) {
return generateQRCode(content, DEFAULT_SAVE_PATH, fileName);
}
/**
* 生成二维码并上传到阿里云OSS
* 文件名格式: UUID + 创建时间
*
* @param content 二维码内容
* @return 阿里云OSS访问地址
*/
public static String generateQRCodeAndUploadToOSS(String content) {
String uuid = UUID.randomUUID().toString().replace("-", "");
String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
String fileName = uuid + "_" + timestamp + ".png";
return generateQRCodeAndUploadToOSS(content, fileName);
}
/**
* 生成二维码并上传到阿里云OSS
*
* @param content 二维码内容
* @param fileName 文件名（含扩展名）
* @return 阿里云OSS访问地址
*/
public static String generateQRCodeAndUploadToOSS(String content, String fileName) {
try {
Path tempDir = Files.createTempDirectory("qrcode_temp");
String tempFilePath = tempDir.resolve(fileName).toString();
Map<EncodeHintType, Object> hints = new HashMap<>();
hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
hints.put(EncodeHintType.MARGIN, 1);
QRCodeWriter qrCodeWriter = new QRCodeWriter();
BitMatrix bitMatrix = qrCodeWriter.encode(content, BarcodeFormat.QR_CODE, QR_CODE_WIDTH, QR_CODE_HEIGHT, hints);
MatrixToImageWriter.writeToPath(bitMatrix, "PNG", Paths.get(tempFilePath));
logger.info("二维码临时文件生成成功: {}", tempFilePath);
String ossUrl = OSSUtil.uploadToOSS(tempFilePath, fileName);
Files.deleteIfExists(Paths.get(tempFilePath));
Files.deleteIfExists(tempDir);
logger.info("临时文件已删除: {}", tempFilePath);
return ossUrl;
} catch (WriterException e) {
logger.error("二维码生成失败 - WriterException: {}", e.getMessage(), e);
throw new RuntimeException("二维码生成失败: " + e.getMessage(), e);
} catch (IOException e) {
logger.error("二维码处理失败 - IOException: {}", e.getMessage(), e);
throw new RuntimeException("二维码处理失败: " + e.getMessage(), e);
}
}
}
gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/vo/GroupCourseVO.java
-134
View File
@@ -1,134 +0,0 @@
package cn.novalon.gym.manage.groupcourse.vo;
import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* 团课视图对象（含教练昵称）
*
* @author 张翔
* @date 2026-07-19
*/
public class GroupCourseVO {
private Long id;
private String courseName;
private Long coachId;
private String coachName;
private Long courseType;
private LocalDateTime startTime;
private LocalDateTime endTime;
private LocalDateTime actualStartTime;
private LocalDateTime actualEndTime;
private Integer maxMembers;
private Integer currentMembers;
private Long status;
private String location;
private String coverImage;
private String description;
private BigDecimal storedValueAmount;
private String qrCodePath;
private String createBy;
private String updateBy;
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
public GroupCourseVO() {}
/**
* 从领域对象和教练名称构建 VO
*/
public static GroupCourseVO from(GroupCourse course, String coachName) {
GroupCourseVO vo = new GroupCourseVO();
vo.setId(course.getId());
vo.setCourseName(course.getCourseName());
vo.setCoachId(course.getCoachId());
vo.setCoachName(coachName);
vo.setCourseType(course.getCourseType());
vo.setStartTime(course.getStartTime());
vo.setEndTime(course.getEndTime());
vo.setActualStartTime(course.getActualStartTime());
vo.setActualEndTime(course.getActualEndTime());
vo.setMaxMembers(course.getMaxMembers());
vo.setCurrentMembers(course.getCurrentMembers());
vo.setStatus(course.getStatus());
vo.setLocation(course.getLocation());
vo.setCoverImage(course.getCoverImage());
vo.setDescription(course.getDescription());
vo.setStoredValueAmount(course.getStoredValueAmount());
vo.setQrCodePath(course.getQrCodePath());
vo.setCreateBy(course.getCreateBy());
vo.setUpdateBy(course.getUpdateBy());
vo.setCreatedAt(course.getCreatedAt());
vo.setUpdatedAt(course.getUpdatedAt());
return vo;
}
// -- getters / setters --
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
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 String getCoachName() { return coachName; }
public void setCoachName(String coachName) { this.coachName = coachName; }
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 LocalDateTime getActualStartTime() { return actualStartTime; }
public void setActualStartTime(LocalDateTime actualStartTime) { this.actualStartTime = actualStartTime; }
public LocalDateTime getActualEndTime() { return actualEndTime; }
public void setActualEndTime(LocalDateTime actualEndTime) { this.actualEndTime = actualEndTime; }
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; }
public BigDecimal getStoredValueAmount() { return storedValueAmount; }
public void setStoredValueAmount(BigDecimal storedValueAmount) { this.storedValueAmount = storedValueAmount; }
public String getQrCodePath() { return qrCodePath; }
public void setQrCodePath(String qrCodePath) { this.qrCodePath = qrCodePath; }
public String getCreateBy() { return createBy; }
public void setCreateBy(String createBy) { this.createBy = createBy; }
public String getUpdateBy() { return updateBy; }
public void setUpdateBy(String updateBy) { this.updateBy = updateBy; }
public LocalDateTime getCreatedAt() { return createdAt; }
public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
public LocalDateTime getUpdatedAt() { return updatedAt; }
public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; }
}
gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/util/QRCodeUtilTest.java
+43 -21
View File
@@ -1,6 +1,9 @@
package cn.novalon.gym.manage.groupcourse.util;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.Path;
import static org.junit.jupiter.api.Assertions.*;
@@ -9,41 +12,60 @@ import static org.junit.jupiter.api.Assertions.*;
*/
class QRCodeUtilTest {
@TempDir
Path tempDir;
@Test
void testGenerateQrCodeBytes() {
void testGenerateQRCode() {
String content = "测试二维码内容";
byte[] bytes = QRCodeUtil.generateQrCodeBytes(content);
String qrCodePath = QRCodeUtil.generateQRCode(content);
assertNotNull(bytes, "二维码字节数组不应为空");
assertTrue(bytes.length > 0, "二维码字节数组应包含数据");
assertNotNull(qrCodePath, "二维码路径不应为空");
assertTrue(qrCodePath.endsWith(".png"), "二维码文件应为PNG格式");
assertTrue(qrCodePath.contains("D:\\Games\\exmp\\image"), "二维码应保存到指定路径");
System.out.println("生成的二维码字节大小: " + bytes.length + " bytes");
System.out.println("生成的二维码路径: " + qrCodePath);
}
@Test
void testGenerateQrCodeBytesWithJsonContent() {
String jsonContent = "{\"id\":1,\"courseName\":\"瑜伽课\",\"coachId\":100,\"startTime\":\"2026-07-14T10:00:00\"}";
void testGenerateQRCodeWithCustomPath() {
String content = "自定义路径测试";
String customPath = tempDir.toString();
String fileName = "test_qrcode";
byte[] bytes = QRCodeUtil.generateQrCodeBytes(jsonContent);
String qrCodePath = QRCodeUtil.generateQRCode(content, customPath, fileName);
assertNotNull(bytes, "二维码字节数组不应为空");
assertTrue(bytes.length > 0, "二维码字节数组应包含数据");
assertNotNull(qrCodePath, "二维码路径不应为空");
assertTrue(qrCodePath.endsWith(".png"), "二维码文件应为PNG格式");
assertTrue(qrCodePath.contains(fileName), "二维码文件名应包含指定名称");
System.out.println("JSON内容二维码字节大小: " + bytes.length + " bytes");
System.out.println("生成的二维码路径: " + qrCodePath);
}
@Test
void testGenerateQrCodeBytesWithLongContent() {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
sb.append("这是第").append(i).append("行测试数据\n");
}
void testGenerateQRCodeWithJsonContent() {
String jsonContent = "{\"id\":1,\"courseName\":\"瑜伽课\",\"coachId\":100,\"startTime\":\"2026-06-18T10:00:00\"}";
byte[] bytes = QRCodeUtil.generateQrCodeBytes(sb.toString());
String qrCodePath = QRCodeUtil.generateQRCode(jsonContent);
assertNotNull(bytes, "二维码字节数组不应为空");
assertTrue(bytes.length > 0, "长内容二维码应正常生成");
assertNotNull(qrCodePath, "二维码路径不应为空");
assertTrue(qrCodePath.endsWith(".png"), "二维码文件应为PNG格式");
System.out.println("长内容二维码字节大小: " + bytes.length + " bytes");
System.out.println("JSON内容二维码路径: " + qrCodePath);
}
}
@Test
void testGenerateQRCodeAndUploadToOSS() {
String jsonContent = "{\"id\":1,\"courseName\":\"瑜伽课\",\"coachId\":100,\"startTime\":\"2026-06-18T10:00:00\"}";
String ossUrl = QRCodeUtil.generateQRCodeAndUploadToOSS(jsonContent);
assertNotNull(ossUrl, "OSS访问地址不应为空");
assertTrue(ossUrl.startsWith("https://"), "OSS访问地址应为HTTPS");
assertTrue(ossUrl.contains("ycc-filesaver.oss-cn-beijing.aliyuncs.com"), "OSS访问地址应包含正确的域名");
assertTrue(ossUrl.contains("/qrcode/"), "OSS访问地址应包含qrcode目录");
assertTrue(ossUrl.endsWith(".png"), "OSS访问地址应为PNG格式");
System.out.println("上传到OSS的二维码地址: " + ossUrl);
}
}
gym-manage-api/gym-member/pom.xml
+1 -1
View File
@@ -237,7 +237,7 @@
<configuration>
<effort>Max</effort>
<threshold>High</threshold>
<failOnError>false</failOnError>
<failOnError>true</failOnError>
<excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
</configuration>
</plugin>
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/config/WechatProperties.java
-3
View File
@@ -16,9 +16,6 @@ import org.springframework.stereotype.Component;
@ConfigurationProperties(prefix = "wechat")
public class WechatProperties {
// Mock模式：true=使用模拟数据，false=调用真实微信API
private Boolean mockEnabled;
// 小程序配置
private MiniApp miniapp = new MiniApp();
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/Member.java
+16
View File
@@ -71,6 +71,22 @@ public class Member extends BaseEntity {
@Column("official_open_id")
private String officialOpenId;
// 阿里云号码认证OpenID
@Column("dypns_open_id")
private String dypnsOpenId;
// 身份证号码（AES加密存储）
@Column("id_card")
private String idCard;
// 真实姓名（AES加密存储）
@Column("real_name")
private String realName;
// 注册渠道：SMS-短信验证码，ONE_CLICK-一键登录，WECHAT-微信授权
@Column("register_channel")
private String registerChannel;
// 软删除
@Column("is_deleted")
private Boolean isDeleted;
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/MemberCardRecord.java
+20 -32
View File
@@ -4,81 +4,69 @@ import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;
import org.springframework.data.annotation.Transient;
import java.time.LocalDateTime;
/**
* 会员卡记录实体（会员持有的卡）- 对应 member_card_record 表
*
* @author 付嘉
* @date 2026-05-27
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("member_card_record")
public class MemberCardRecord {
@Id
@Column("id")
private Long id;
@Column("created_at")
private LocalDateTime createdAt;
@Column("updated_at")
private LocalDateTime updatedAt;
@Column("deleted_at")
private LocalDateTime deletedAt;
public class MemberCardRecord extends BaseEntity {
// 会员持有卡ID
@Column("member_card_record_id")
private Long memberCardRecordId;
// 会员ID
@Column("member_id")
private Long memberId;
// 关联会员卡ID
@Column("member_card_id")
private Long memberCardId;
// 状态：ACTIVE-有效, USED_UP-用完, EXPIRED-过期, REFUNDED-已退款
@Column("status")
private MemberCardRecordStatus status;
// 剩余次数
@Column("remaining_times")
private Integer remainingTimes;
// 剩余金额
@Column("remaining_amount")
private Double remainingAmount;
// 到期时间
@Column("expire_time")
private LocalDateTime expireTime;
// 来源订单ID
@Column("source_order_id")
private Long sourceOrderId;
// 购买时间
@Column("purchase_time")
private LocalDateTime purchaseTime;
// 乐观锁版本号
@Column("version")
private Integer version;
// 卡片组成（JSON格式，用于组合卡）
@Column("card_composition")
private String cardComposition;
// 联表查询的会员卡信息（非持久化字段，不映射到数据库表列）
@Transient
private String memberCardName;
@Transient
private String memberCardType;
@Transient
private Double memberCardPrice;
@Transient
private Integer memberCardValidityDays;
@Transient
private Integer memberCardTotalTimes;
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/MemberCardTransaction.java
+23 -12
View File
@@ -3,64 +3,75 @@ package cn.novalon.gym.manage.member.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;
import java.time.LocalDateTime;
/**
* 会员卡交易流水实体 - 对应 member_card_transactions 表
*
* @author 付嘉
* @date 2026-05-27
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("member_card_transactions")
public class MemberCardTransaction {
@Id
@Column("id")
private Long id;
@Column("created_at")
private LocalDateTime createdAt;
public class MemberCardTransaction extends BaseEntity {
// 交易ID
@Column("member_card_record_id")
private Long memberCardRecordId;
// 会员ID
@Column("member_id")
private Long memberId;
// 会员卡ID
@Column("member_card_id")
private Long memberCardId;
// 操作类型：PURCHASE-购买, DEDUCT-扣次/扣费, RENEW-续费, REFUND-退款, EXPIRE-过期
@Column("operation_type")
private String operationType;
// 变动次数
@Column("change_amount")
private Integer changeAmount;
// 变动金额
@Column("change_balance")
private Double changeBalance;
// 变动后剩余次数
@Column("after_remaining_count")
private Integer afterRemainingCount;
// 变动后剩余金额
@Column("after_remaining_balance")
private Double afterRemainingBalance;
// 关联业务类型：GROUP_CLASS-团课, PT_CLASS-私教, CHECK_IN-签到
@Column("related_biz_type")
private String relatedBizType;
// 来源订单ID
@Column("source_order_id")
private Long sourceOrderId;
// 备注
@Column("remark")
private String remark;
// 是否已归档
@Column("is_archived")
private Boolean isArchived;
// 归档时间
@Column("archived_at")
private LocalDateTime archivedAt;
private java.time.LocalDateTime archivedAt;
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/MemberStoredCard.java
-42
View File
@@ -1,42 +0,0 @@
package cn.novalon.gym.manage.member.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;
import java.math.BigDecimal;
/**
* 储值卡实体类
* 每个会员只有一张储值卡，存储余额信息和支付密码
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("member_stored_card")
public class MemberStoredCard extends BaseEntity {
@Column("member_id")
private Long memberId;
@Column("balance")
private BigDecimal balance;
@Column("total_recharge")
private BigDecimal totalRecharge;
@Column("total_consume")
private BigDecimal totalConsume;
@Column("pay_password")
private String payPassword;
@Column("is_pay_password_set")
private Boolean isPayPasswordSet;
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/MemberStoredCardRecharge.java
-48
View File
@@ -1,48 +0,0 @@
package cn.novalon.gym.manage.member.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* 储值卡充值记录实体类
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Table("member_stored_card_recharge")
public class MemberStoredCardRecharge extends BaseEntity {
@Column("member_id")
private Long memberId;
@Column("order_no")
private String orderNo;
@Column("recharge_amount")
private BigDecimal rechargeAmount;
@Column("bonus_amount")
private BigDecimal bonusAmount;
@Column("total_amount")
private BigDecimal totalAmount;
@Column("pay_amount")
private BigDecimal payAmount;
@Column("status")
private String status;
@Column("pay_time")
private LocalDateTime payTime;
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberCardHandler.java
+10 -24
View File
@@ -31,7 +31,7 @@ public class MemberCardHandler {
@Operation(summary = "根据ID查询会员卡类型", description = "查询指定ID的会员卡类型详情")
public Mono<ServerResponse> getMemberCardById(ServerRequest request) {
Long id = Long.valueOf(request.pathVariable("memberCardId"));
Long id = Long.valueOf(request.pathVariable("id"));
return memberCardService.findByMemberCardIdAndDeletedAtIsNull(id)
.flatMap(card -> ServerResponse.ok().bodyValue(card))
.switchIfEmpty(ServerResponse.notFound().build());
@@ -63,24 +63,13 @@ public class MemberCardHandler {
@Operation(summary = "更新会员卡类型", description = "更新会员卡类型信息")
public Mono<ServerResponse> updateMemberCard(ServerRequest request) {
Long id = Long.valueOf(request.pathVariable("id"));
return memberCardService.findByMemberCardIdAndDeletedAtIsNull(id)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡不存在: " + id)))
.zipWith(request.bodyToMono(MemberCard.class))
.flatMap(tuple -> {
MemberCard existing = tuple.getT1();
MemberCard body = tuple.getT2();
// 仅更新非 null 字段，避免 null 覆盖已有值
if (body.getMemberCardName() != null) existing.setMemberCardName(body.getMemberCardName());
if (body.getMemberCardType() != null) existing.setMemberCardType(body.getMemberCardType());
if (body.getMemberCardPrice() != null) existing.setMemberCardPrice(body.getMemberCardPrice());
if (body.getMemberCardValidityDays() != null) existing.setMemberCardValidityDays(body.getMemberCardValidityDays());
if (body.getMemberCardTotalTimes() != null) existing.setMemberCardTotalTimes(body.getMemberCardTotalTimes());
if (body.getMemberCardAmount() != null) existing.setMemberCardAmount(body.getMemberCardAmount());
if (body.getMemberCardStatus() != null) existing.setMemberCardStatus(body.getMemberCardStatus());
if (body.getExtraConfig() != null) existing.setExtraConfig(body.getExtraConfig());
return memberCardService.save(existing);
return request.bodyToMono(MemberCard.class)
.flatMap(card -> {
card.setMemberCardId(id);
return memberCardService.save(card);
})
.flatMap(updated -> ServerResponse.ok().bodyValue(updated));
.flatMap(updated -> ServerResponse.ok().bodyValue(updated))
.switchIfEmpty(ServerResponse.notFound().build());
}
@Operation(summary = "删除会员卡类型", description = "逻辑删除会员卡类型")
@@ -108,32 +97,29 @@ public class MemberCardHandler {
@Operation(summary = "续费会员卡", description = "为已有会员卡续费")
public Mono<ServerResponse> renewCard(ServerRequest request) {
Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
Long memberId = Long.valueOf(request.queryParam("memberId").orElseThrow());
Integer addTimes = request.queryParam("addTimes").map(Integer::valueOf).orElse(null);
Double addAmount = request.queryParam("addAmount").map(Double::valueOf).orElse(null);
Integer addDays = request.queryParam("addDays").map(Integer::valueOf).orElse(null);
Long sourceOrderId = request.queryParam("sourceOrderId").map(Long::valueOf).orElse(null);
return memberCardService.renewCard(recordId, memberId, addTimes, addAmount, addDays, sourceOrderId)
return memberCardService.renewCard(recordId, addTimes, addAmount, addDays, sourceOrderId)
.flatMap(record -> ServerResponse.ok().bodyValue(record));
}
@Operation(summary = "使用会员卡", description = "扣减会员卡次数或余额")
public Mono<ServerResponse> useCard(ServerRequest request) {
Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
Long memberId = Long.valueOf(request.queryParam("memberId").orElseThrow());
Integer deductTimes = request.queryParam("deductTimes").map(Integer::valueOf).orElse(null);
Double deductAmount = request.queryParam("deductAmount").map(Double::valueOf).orElse(null);
return memberCardService.useCard(recordId, memberId, deductTimes, deductAmount)
return memberCardService.useCard(recordId, deductTimes, deductAmount)
.flatMap(record -> ServerResponse.ok().bodyValue(record));
}
@Operation(summary = "退款会员卡", description = "申请会员卡退款")
public Mono<ServerResponse> refundCard(ServerRequest request) {
Long recordId = Long.valueOf(request.queryParam("recordId").orElseThrow());
Long memberId = Long.valueOf(request.queryParam("memberId").orElseThrow());
return memberCardService.refundCard(recordId, memberId)
return memberCardService.refundCard(recordId)
.then(ServerResponse.noContent().build());
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberCardRecordHandler.java
+6 -36
View File
@@ -3,7 +3,6 @@ package cn.novalon.gym.manage.member.handler;
import cn.novalon.gym.manage.member.entity.MemberCardRecord;
import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
import cn.novalon.gym.manage.member.service.IMemberCardService;
import cn.novalon.gym.manage.sys.util.AuthUtil;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.Data;
@@ -24,22 +23,19 @@ public class MemberCardRecordHandler {
private final IMemberCardService memberCardService;
private final IMemberCardRecordService memberCardRecordService;
private final AuthUtil authUtil;
public MemberCardRecordHandler(IMemberCardService memberCardService,
IMemberCardRecordService memberCardRecordService,
AuthUtil authUtil) {
IMemberCardRecordService memberCardRecordService) {
this.memberCardService = memberCardService;
this.memberCardRecordService = memberCardRecordService;
this.authUtil = authUtil;
}
@Operation(summary = "购买会员卡", description = "支持时长卡、次卡、储值卡，自动设置到期提醒")
public Mono<ServerResponse> purchaseCard(ServerRequest request) {
Long memberId = authUtil.getMemberIdOrThrow(request);
return request.bodyToMono(PurchaseRequest.class)
.flatMap(body -> memberCardService.purchaseCard(
memberId,
body.getMemberId(),
body.getMemberCardId(),
body.getSourceOrderId()))
.flatMap(record -> ServerResponse.ok().bodyValue(record))
@@ -49,10 +45,8 @@ public class MemberCardRecordHandler {
@Operation(summary = "续费会员卡", description = "累加剩余次数/余额，顺延到期日期，权益立即生效")
public Mono<ServerResponse> renewCard(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("recordId"));
Long memberId = authUtil.getMemberIdOrThrow(request);
return request.bodyToMono(RenewRequest.class)
.flatMap(body -> memberCardService.renewCard(recordId,
memberId,
body.getAddTimes(),
body.getAddAmount(),
body.getAddDays(),
@@ -64,10 +58,8 @@ public class MemberCardRecordHandler {
@Operation(summary = "使用会员卡", description = "预约团课或私教成功后扣减次数或余额")
public Mono<ServerResponse> useCard(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("recordId"));
Long memberId = authUtil.getMemberIdOrThrow(request);
return request.bodyToMono(UseCardRequest.class)
.flatMap(body -> memberCardService.useCard(recordId,
memberId,
body.getDeductTimes(),
body.getDeductAmount()))
.flatMap(record -> ServerResponse.ok().bodyValue(record))
@@ -77,8 +69,7 @@ public class MemberCardRecordHandler {
@Operation(summary = "退款会员卡", description = "使用Saga模式执行退款流程，保证事务一致性")
public Mono<ServerResponse> refundCard(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("recordId"));
Long memberId = authUtil.getMemberIdOrThrow(request);
return memberCardService.refundCard(recordId, memberId)
return memberCardService.refundCard(recordId)
.then(ServerResponse.ok().bodyValue("退款成功"))
.onErrorResume(e -> ServerResponse.badRequest().bodyValue("退款失败: " + e.getMessage()));
}
@@ -93,34 +84,12 @@ public class MemberCardRecordHandler {
@Operation(summary = "会员我的卡包", description = "查询当前会员的所有有效卡")
public Mono<ServerResponse> getMyCards(ServerRequest request) {
Long memberId = authUtil.getMemberIdOrThrow(request);
Long memberId = Long.parseLong(request.pathVariable("memberId"));
return ServerResponse.ok().body(
memberCardRecordService.findActiveCardsByMemberId(memberId),
MemberCardRecord.class);
}
@Operation(summary = "会员卡包（带筛选）", description = "查询会员的所有会员卡，支持状态筛选：all-全部, active-有效, expired-已失效")
public Mono<ServerResponse> getMyCardsWithStatus(ServerRequest request) {
Long memberId = authUtil.getMemberIdOrThrow(request);
String status = request.queryParam("status").orElse("all");
if (!status.equals("all") && !status.equals("active") && !status.equals("expired")) {
return ServerResponse.badRequest().bodyValue("无效的status参数，允许值：all, active, expired");
}
return memberCardRecordService.findCardsByMemberIdWithStatus(memberId, status)
.collectList()
.flatMap(cards -> ServerResponse.ok().bodyValue(cards));
}
@Operation(summary = "获取会员主要有效卡", description = "查询当前会员的主要有效会员卡（只返回一条），优先临期卡，其次有效卡")
public Mono<ServerResponse> getPrimaryCard(ServerRequest request) {
Long memberId = authUtil.getMemberIdOrThrow(request);
return memberCardRecordService.findPrimaryActiveCardByMemberId(memberId)
.flatMap(card -> ServerResponse.ok().bodyValue(card))
.switchIfEmpty(ServerResponse.noContent().build());
}
@Operation(summary = "处理过期会员卡", description = "定时任务调用，扫描并更新过期卡状态")
public Mono<ServerResponse> processExpiredCards(ServerRequest request) {
return memberCardService.processExpiredCards()
@@ -129,6 +98,7 @@ public class MemberCardRecordHandler {
@Data
public static class PurchaseRequest {
private Long memberId;
private Long memberCardId;
private Long sourceOrderId;
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberCardTransactionHandler.java
-11
View File
@@ -109,17 +109,6 @@ public class MemberCardTransactionHandler {
MemberCardTransaction.class);
}
/**
* 按会员卡记录ID查询流水
*/
@Operation(summary = "按会员卡记录ID查询流水", description = "查看某张会员持卡记录的所有流水")
public Mono<ServerResponse> getTransactionsByRecordId(ServerRequest request) {
Long recordId = Long.parseLong(request.pathVariable("recordId"));
return ServerResponse.ok()
.body(memberCardTransactionService.findByRecordId(recordId),
MemberCardTransaction.class);
}
/**
* 统计某卡种的总扣次数
*/
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberHandler.java
+9 -11
View File
@@ -155,8 +155,8 @@ public class MemberHandler {
String decryptedPhone = AesUtil.decrypt(detail.getPhone());
detail.setPhone(WechatPhoneUtil.maskPhone(decryptedPhone));
} catch (Exception e) {
log.warn("手机号解密失败(可能为明文存储), memberId: {}", detail.getId());
detail.setPhone(WechatPhoneUtil.maskPhone(detail.getPhone()));
log.error("手机号解密失败, memberId: {}", detail.getId(), e);
detail.setPhone(null);
}
}
return ServerResponse.ok()
@@ -204,8 +204,8 @@ public class MemberHandler {
String decryptedPhone = AesUtil.decrypt(member.getPhone());
member.setPhone(WechatPhoneUtil.maskPhone(decryptedPhone));
} catch (Exception e) {
log.warn("手机号解密失败(可能为明文存储), memberId: {}", member.getId());
member.setPhone(WechatPhoneUtil.maskPhone(member.getPhone()));
log.error("手机号解密失败, memberId: {}", member.getId(), e);
member.setPhone(null);
}
}
return member;
@@ -222,13 +222,11 @@ public class MemberHandler {
int pageNum = NumberUtils.toInt(request.queryParam("pageNum").orElse("1"), 1);
int pageSize = NumberUtils.toInt(request.queryParam("pageSize").orElse("10"), 10);
String sortField = request.queryParam("sortField").orElse(null);
String sortOrder = request.queryParam("sortOrder").orElse(null);
log.info("前台查看会员列表, adminId: {}, pageNum: {}, pageSize: {}, sortField: {}, sortOrder: {}",
adminId, pageNum, pageSize, sortField, sortOrder);
log.info("前台查看会员列表, adminId: {}, pageNum: {}, pageSize: {}", adminId, pageNum, pageSize);
// TODO: 补充签到记录
return memberService.findAll(pageNum, pageSize, sortField, sortOrder)
return memberService.findAll(pageNum, pageSize)
.map(member -> {
// 解密手机号
if (member.getPhone() != null && !member.getPhone().isEmpty()) {
@@ -236,8 +234,8 @@ public class MemberHandler {
String decryptedPhone = AesUtil.decrypt(member.getPhone());
member.setPhone(WechatPhoneUtil.maskPhone(decryptedPhone));
} catch (Exception e) {
log.warn("手机号解密失败(可能为明文存储), memberId: {}", member.getId());
member.setPhone(WechatPhoneUtil.maskPhone(member.getPhone()));
log.error("手机号解密失败, memberId: {}", member.getId(), e);
member.setPhone(null);
}
}
return member;
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberStoredCardHandler.java
-189
View File
@@ -1,189 +0,0 @@
package cn.novalon.gym.manage.member.handler;
import cn.novalon.gym.manage.member.service.IMemberStoredCardService;
import lombok.extern.slf4j.Slf4j;
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.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
/**
* 储值卡 Handler
*/
@Slf4j
@Component
public class MemberStoredCardHandler {
private final IMemberStoredCardService memberStoredCardService;
public MemberStoredCardHandler(IMemberStoredCardService memberStoredCardService) {
this.memberStoredCardService = memberStoredCardService;
}
/**
* 获取会员储值卡信息
*/
public Mono<ServerResponse> getStoredCardInfo(ServerRequest request) {
Long memberId = Long.valueOf(request.pathVariable("memberId"));
return memberStoredCardService.getOrCreateStoredCard(memberId)
.flatMap(card -> {
Map<String, Object> result = new HashMap<>();
result.put("memberId", card.getMemberId());
result.put("balance", card.getBalance() != null ? card.getBalance() : BigDecimal.ZERO);
result.put("totalRecharge", card.getTotalRecharge() != null ? card.getTotalRecharge() : BigDecimal.ZERO);
result.put("totalConsume", card.getTotalConsume() != null ? card.getTotalConsume() : BigDecimal.ZERO);
result.put("isPayPasswordSet", card.getIsPayPasswordSet() != null && card.getIsPayPasswordSet());
return ServerResponse.ok().bodyValue(result);
});
}
/**
* 获取储值卡余额
*/
public Mono<ServerResponse> getBalance(ServerRequest request) {
Long memberId = Long.valueOf(request.pathVariable("memberId"));
return memberStoredCardService.getStoredCard(memberId)
.flatMap(card -> {
Map<String, Object> result = new HashMap<>();
result.put("balance", card.getBalance() != null ? card.getBalance() : BigDecimal.ZERO);
result.put("hasCard", true);
return ServerResponse.ok().bodyValue(result);
})
.switchIfEmpty(Mono.defer(() -> {
Map<String, Object> result = new HashMap<>();
result.put("balance", BigDecimal.ZERO);
result.put("hasCard", false);
return ServerResponse.ok().bodyValue(result);
}));
}
/**
* 检查支付密码是否已设置
*/
public Mono<ServerResponse> checkPasswordSet(ServerRequest request) {
Long memberId = Long.valueOf(request.pathVariable("memberId"));
return memberStoredCardService.isPayPasswordSet(memberId)
.flatMap(isSet -> {
Map<String, Object> data = new HashMap<>();
data.put("isSet", isSet);
Map<String, Object> result = new HashMap<>();
result.put("code", 200);
result.put("message", "success");
result.put("data", data);
return ServerResponse.ok().bodyValue(result);
});
}
/**
* 设置支付密码
*/
public Mono<ServerResponse> setPassword(ServerRequest request) {
Long memberId = Long.valueOf(request.pathVariable("memberId"));
return request.bodyToMono(Map.class)
.flatMap(body -> {
String password = (String) body.get("password");
if (password == null || password.isEmpty()) {
return ServerResponse.badRequest().bodyValue(Map.of("code", 400, "message", "密码不能为空"));
}
return memberStoredCardService.setPayPassword(memberId, password)
.flatMap(rows -> {
if (rows > 0) {
return ServerResponse.ok().bodyValue(Map.of("code", 200, "message", "设置成功"));
}
return ServerResponse.ok().bodyValue(Map.of("code", 400, "message", "设置失败"));
});
});
}
/**
* 验证支付密码
*/
public Mono<ServerResponse> verifyPassword(ServerRequest request) {
Long memberId = Long.valueOf(request.pathVariable("memberId"));
return request.bodyToMono(Map.class)
.flatMap(body -> {
String password = (String) body.get("password");
if (password == null || password.isEmpty()) {
return ServerResponse.badRequest().bodyValue(Map.of("code", 400, "message", "密码不能为空"));
}
return memberStoredCardService.verifyPayPassword(memberId, password)
.flatMap(isValid -> {
Map<String, Object> data = new HashMap<>();
data.put("valid", isValid);
Map<String, Object> result = new HashMap<>();
result.put("code", 200);
result.put("message", isValid ? "验证成功" : "密码错误");
result.put("data", data);
return ServerResponse.ok().bodyValue(result);
});
});
}
/**
* 储值卡支付（验证密码并扣减余额）
*/
public Mono<ServerResponse> payWithStoredCard(ServerRequest request) {
Long memberId = Long.valueOf(request.pathVariable("memberId"));
return request.bodyToMono(Map.class)
.flatMap(body -> {
String password = (String) body.get("password");
BigDecimal amount = body.get("amount") != null
? new BigDecimal(body.get("amount").toString())
: null;
String orderType = (String) body.get("orderType");
String goodsDesc = (String) body.get("goodsDesc");
if (password == null || password.isEmpty()) {
return ServerResponse.badRequest().bodyValue(Map.of("code", 400, "message", "支付密码不能为空"));
}
if (amount == null) {
return ServerResponse.badRequest().bodyValue(Map.of("code", 400, "message", "支付金额不能为空"));
}
return memberStoredCardService.payWithStoredCard(memberId, password, amount)
.flatMap(result -> {
Map<String, Object> response = new HashMap<>();
if (result.isSuccess()) {
response.put("code", 200);
response.put("message", "支付成功");
response.put("balance", result.getBalance());
log.info("[储值卡支付] 支付成功: memberId={}, amount={}, remainingBalance={}",
memberId, amount, result.getBalance());
} else {
response.put("code", 400);
response.put("message", result.getMessage());
log.warn("[储值卡支付] 支付失败: memberId={}, amount={}, reason={}",
memberId, amount, result.getMessage());
}
return ServerResponse.ok().bodyValue(response);
});
});
}
/**
* 查询会员的充值记录列表
*/
public Mono<ServerResponse> getRechargeRecords(ServerRequest request) {
Long memberId = Long.valueOf(request.pathVariable("memberId"));
int page = Integer.parseInt(request.queryParam("page").orElse("1"));
int size = Integer.parseInt(request.queryParam("size").orElse("20"));
log.info("[储值卡] 查询充值记录: memberId={}, page={}, size={}", memberId, page, size);
return memberStoredCardService.getRechargeRecords(memberId, page, size)
.collectList()
.zipWith(memberStoredCardService.countRechargeRecords(memberId))
.flatMap(tuple -> {
Map<String, Object> result = new HashMap<>();
result.put("list", tuple.getT1());
result.put("total", tuple.getT2());
result.put("page", page);
result.put("size", size);
return ServerResponse.ok().bodyValue(result);
});
}
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/repository/MemberCardRecordRepository.java
+3 -59
View File
@@ -23,6 +23,7 @@ public interface MemberCardRecordRepository extends R2dbcRepository<MemberCardRe
/**
* 插入新的激活卡记录
*/
@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 *")
@@ -62,19 +63,9 @@ public interface MemberCardRecordRepository extends R2dbcRepository<MemberCardRe
Mono<Integer> updateStatus(Long recordId, String status);
/**
* 查询会员的有效卡片（包含会员卡类型信息）
* 查询会员的有效卡片
*/
@Query("SELECT r.member_card_record_id as id, r.created_at, r.updated_at, r.deleted_at, " +
"r.member_card_record_id, r.member_id, r.member_card_id, r.status, " +
"r.remaining_times, r.remaining_amount, r.expire_time, r.source_order_id, " +
"r.purchase_time, r.version, r.card_composition, " +
"mc.member_card_name as memberCardName, mc.member_card_type as memberCardType, " +
"mc.member_card_price as memberCardPrice, mc.member_card_validity_days as memberCardValidityDays, " +
"mc.member_card_total_times as memberCardTotalTimes " +
"FROM member_card_record r " +
"LEFT JOIN member_card mc ON r.member_card_id = mc.id AND mc.deleted_at IS NULL " +
"WHERE r.member_id = :memberId AND r.status = 'ACTIVE' AND r.deleted_at IS NULL " +
"ORDER BY r.expire_time ASC")
@Query("SELECT * FROM member_card_record WHERE member_id = :memberId AND status = 'ACTIVE' AND deleted_at IS NULL ORDER BY expire_time ASC")
Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId);
/**
@@ -110,56 +101,9 @@ public interface MemberCardRecordRepository extends R2dbcRepository<MemberCardRe
@Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND expire_time < NOW() AND deleted_at IS NULL LIMIT 500")
Flux<MemberCardRecord> findExpiredCards();
/**
* 根据支付订单ID查询会员卡记录（用于幂等性检查）
*/
@Query("SELECT * FROM member_card_record WHERE source_order_id = :sourceOrderId AND deleted_at IS NULL")
Mono<MemberCardRecord> findBySourceOrderId(Long sourceOrderId);
/**
* 查询会员在指定时间后购买的同类活跃卡（防前端重复调用）
*/
@Query("SELECT * FROM member_card_record WHERE member_id = :memberId AND member_card_id = :memberCardId AND status = 'ACTIVE' AND deleted_at IS NULL AND purchase_time > :since ORDER BY purchase_time DESC LIMIT 1")
Mono<MemberCardRecord> findRecentActivePurchase(Long memberId, Long memberCardId, LocalDateTime since);
/**
* 查询所有有效记录
*/
@Query("SELECT * FROM member_card_record WHERE status = 'ACTIVE' AND deleted_at IS NULL")
Flux<MemberCardRecord> findActiveRecords();
/**
* 储值卡充值 - 增加余额
*/
@Modifying
@Query("UPDATE member_card_record SET remaining_amount = remaining_amount + :addAmount, updated_at = NOW() " +
"WHERE member_card_record_id = :recordId AND status = 'ACTIVE' AND deleted_at IS NULL")
Mono<Integer> rechargeStoredCard(Long recordId, Double addAmount);
/**
* 查询会员的所有卡片（按状态筛选）- 包含会员卡类型信息
* status: all - 所有卡, active - 有效卡, expired - 已过期/失效卡
* 排序规则：临期卡（30天内到期）排在最上面，然后是其他有效卡，最后是失效卡
*/
@Query("SELECT r.member_card_record_id as id, r.created_at, r.updated_at, r.deleted_at, " +
"r.member_card_record_id, r.member_id, r.member_card_id, r.status, " +
"r.remaining_times, r.remaining_amount, r.expire_time, r.source_order_id, " +
"r.purchase_time, r.version, r.card_composition, " +
"mc.member_card_name as memberCardName, mc.member_card_type as memberCardType, " +
"mc.member_card_price as memberCardPrice, mc.member_card_validity_days as memberCardValidityDays, " +
"mc.member_card_total_times as memberCardTotalTimes " +
"FROM member_card_record r " +
"LEFT JOIN member_card mc ON r.member_card_id = mc.id AND mc.deleted_at IS NULL " +
"WHERE r.member_id = :memberId AND r.deleted_at IS NULL " +
"AND (" +
" :status = 'all' " +
" OR (:status = 'active' AND r.status = 'ACTIVE' AND (r.expire_time IS NULL OR r.expire_time > NOW())) " +
" OR (:status = 'expired' AND (r.status != 'ACTIVE' OR (r.expire_time IS NOT NULL AND r.expire_time <= NOW()))) " +
") " +
"ORDER BY " +
"CASE WHEN r.status = 'ACTIVE' AND r.expire_time IS NOT NULL AND r.expire_time < NOW() + INTERVAL '30 days' AND r.expire_time > NOW() THEN 0 " +
" WHEN r.status = 'ACTIVE' AND (r.expire_time IS NULL OR r.expire_time > NOW()) THEN 1 " +
" ELSE 2 END, " +
"r.expire_time ASC")
Flux<MemberCardRecord> findCardsByMemberIdWithStatus(Long memberId, String status);
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/repository/MemberCardRepository.java
+1 -15
View File
@@ -9,8 +9,6 @@ import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.List;
/**
* 会员卡类型 Repository
*
@@ -20,23 +18,11 @@ import java.util.List;
@Repository
public interface MemberCardRepository extends R2dbcRepository<MemberCard, Long> {
/**
* 根据主键ID查询（未删除的）- 用于前端传递的id
*/
@Query("SELECT * FROM member_card WHERE id = :id AND deleted_at IS NULL")
Mono<MemberCard> findByIdAndDeletedAtIsNull(Long id);
/**
* 根据会员卡ID查询（未删除的）
*/
Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId);
/**
* 批量查询会员卡（根据 member_card_id 字段）
*/
@Query("SELECT * FROM member_card WHERE deleted_at IS NULL AND member_card_id IN (:memberCardIds)")
Flux<MemberCard> findByMemberCardIdIn(List<Long> memberCardIds);
/**
* 条件查询会员卡列表
*/
@@ -46,7 +32,7 @@ public interface MemberCardRepository extends R2dbcRepository<MemberCard, Long>
"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 id ASC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
"ORDER BY created_at DESC LIMIT :#{#pageable.pageSize} OFFSET :#{#pageable.offset}")
Flux<MemberCard> findWithConditions(Integer status, String name, String type,
Double minPrice, Double maxPrice, Pageable pageable);
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/repository/MemberStoredCardRechargeRepository.java
-61
View File
@@ -1,61 +0,0 @@
package cn.novalon.gym.manage.member.repository;
import cn.novalon.gym.manage.member.entity.MemberStoredCardRecharge;
import org.springframework.data.r2dbc.repository.Modifying;
import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* 储值卡充值记录 Repository
*/
@Repository
public interface MemberStoredCardRechargeRepository extends R2dbcRepository<MemberStoredCardRecharge, Long> {
/**
* 根据订单号查询充值记录
*/
@Query("SELECT * FROM member_stored_card_recharge WHERE order_no = :orderNo AND deleted_at IS NULL")
Mono<MemberStoredCardRecharge> findByOrderNo(String orderNo);
/**
* 查询会员的充值记录列表
*/
@Query("SELECT * FROM member_stored_card_recharge WHERE member_id = :memberId AND deleted_at IS NULL ORDER BY created_at DESC LIMIT :limit OFFSET :offset")
Flux<MemberStoredCardRecharge> findByMemberId(Long memberId, int limit, int offset);
/**
* 创建充值记录
*/
@Modifying
@Query("INSERT INTO member_stored_card_recharge (member_id, order_no, recharge_amount, bonus_amount, total_amount, pay_amount, status, created_at, updated_at) " +
"VALUES (:memberId, :orderNo, :rechargeAmount, :bonusAmount, :totalAmount, :payAmount, 'PENDING', NOW(), NOW())")
Mono<Integer> createRechargeRecord(Long memberId, String orderNo, BigDecimal rechargeAmount, BigDecimal bonusAmount, BigDecimal totalAmount, BigDecimal payAmount);
/**
* 更新充值记录为成功
*/
@Modifying
@Query("UPDATE member_stored_card_recharge SET status = 'SUCCESS', pay_time = :payTime, updated_at = NOW() " +
"WHERE order_no = :orderNo AND deleted_at IS NULL")
Mono<Integer> markSuccess(String orderNo, LocalDateTime payTime);
/**
* 更新充值记录为失败
*/
@Modifying
@Query("UPDATE member_stored_card_recharge SET status = 'FAILED', updated_at = NOW() " +
"WHERE order_no = :orderNo AND deleted_at IS NULL")
Mono<Integer> markFailed(String orderNo);
/**
* 查询会员充值记录总数
*/
@Query("SELECT COUNT(*) FROM member_stored_card_recharge WHERE member_id = :memberId AND deleted_at IS NULL")
Mono<Long> countByMemberIdAndDeletedAtIsNull(Long memberId);
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/repository/MemberStoredCardRepository.java
-80
View File
@@ -1,80 +0,0 @@
package cn.novalon.gym.manage.member.repository;
import cn.novalon.gym.manage.member.entity.MemberStoredCard;
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.Mono;
import java.math.BigDecimal;
/**
* 储值卡 Repository
*/
@Repository
public interface MemberStoredCardRepository extends R2dbcRepository<MemberStoredCard, Long> {
/**
* 根据会员ID查询储值卡
*/
@Query("SELECT * FROM member_stored_card WHERE member_id = :memberId AND deleted_at IS NULL")
Mono<MemberStoredCard> findByMemberId(Long memberId);
/**
* 根据会员ID查询储值卡（可删除标记）
*/
Mono<MemberStoredCard> findByMemberIdAndDeletedAtIsNull(Long memberId);
/**
* 储值卡充值 - 增加余额
*/
@Modifying
@Query("UPDATE member_stored_card SET balance = balance + :addAmount, total_recharge = total_recharge + :addAmount, updated_at = NOW() " +
"WHERE member_id = :memberId AND deleted_at IS NULL")
Mono<Integer> rechargeBalance(Long memberId, BigDecimal addAmount);
/**
* 储值卡返还 - 增加余额（用于取消预约退款）
*/
@Modifying
@Query("UPDATE member_stored_card SET balance = balance + :addAmount, updated_at = NOW() " +
"WHERE member_id = :memberId AND deleted_at IS NULL")
Mono<Integer> refundBalance(Long memberId, BigDecimal addAmount);
/**
* 储值卡消费 - 扣减余额
*/
@Modifying
@Query("UPDATE member_stored_card SET balance = balance - :deductAmount, total_consume = total_consume + :deductAmount, updated_at = NOW() " +
"WHERE member_id = :memberId AND deleted_at IS NULL AND balance >= :deductAmount")
Mono<Integer> deductBalance(Long memberId, BigDecimal deductAmount);
/**
* 创建储值卡
*/
@Modifying
@Query("INSERT INTO member_stored_card (member_id, balance, total_recharge, total_consume, is_pay_password_set, created_at, updated_at) " +
"VALUES (:memberId, 0, 0, 0, FALSE, NOW(), NOW())")
Mono<Integer> createStoredCard(Long memberId);
/**
* 设置支付密码
*/
@Modifying
@Query("UPDATE member_stored_card SET pay_password = :password, is_pay_password_set = TRUE, updated_at = NOW() " +
"WHERE member_id = :memberId AND deleted_at IS NULL")
Mono<Integer> setPayPassword(Long memberId, String password);
/**
* 检查支付密码是否已设置
*/
@Query("SELECT is_pay_password_set FROM member_stored_card WHERE member_id = :memberId AND deleted_at IS NULL")
Mono<Boolean> isPayPasswordSet(Long memberId);
/**
* 获取支付密码
*/
@Query("SELECT pay_password FROM member_stored_card WHERE member_id = :memberId AND deleted_at IS NULL")
Mono<String> getPayPassword(Long memberId);
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/IMemberCardRecordService.java
-16
View File
@@ -32,20 +32,4 @@ public interface IMemberCardRecordService {
Mono<MemberCardRecord> validateStoredCard(Long recordId, Double requiredAmount);
Flux<MemberCardRecord> findExpiredCards();
/**
* 查询会员的所有卡片（按状态筛选）
* @param memberId 会员ID
* @param status 状态筛选：all - 所有, active - 有效, expired - 已失效
* @return 会员卡记录列表
*/
Flux<MemberCardRecord> findCardsByMemberIdWithStatus(Long memberId, String status);
/**
* 查询会员的主要有效会员卡（只返回一条）
* 优先返回临期卡（剩余1-3天），其次返回普通有效卡
* @param memberId 会员ID
* @return 会员卡记录，如果没有则返回空
*/
Mono<MemberCardRecord> findPrimaryActiveCardByMemberId(Long memberId);
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/IMemberCardService.java
+3 -3
View File
@@ -34,11 +34,11 @@ public interface IMemberCardService {
Mono<MemberCardRecord> purchaseCard(Long memberId, Long memberCardId, Long sourceOrderId);
Mono<MemberCardRecord> renewCard(Long recordId, Long memberId, Integer addTimes, Double addAmount, Integer addDays, Long sourceOrderId);
Mono<MemberCardRecord> renewCard(Long recordId, Integer addTimes, Double addAmount, Integer addDays, Long sourceOrderId);
Mono<MemberCardRecord> useCard(Long recordId, Long memberId, Integer deductTimes, Double deductAmount);
Mono<MemberCardRecord> useCard(Long recordId, Integer deductTimes, Double deductAmount);
Mono<Void> refundCard(Long recordId, Long memberId);
Mono<Void> refundCard(Long recordId);
Mono<Integer> processExpiredCards();
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/IMemberStoredCardService.java
-106
View File
@@ -1,106 +0,0 @@
package cn.novalon.gym.manage.member.service;
import cn.novalon.gym.manage.member.entity.MemberStoredCard;
import cn.novalon.gym.manage.member.entity.MemberStoredCardRecharge;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.math.BigDecimal;
/**
* 储值卡 Service接口
*/
public interface IMemberStoredCardService {
/**
* 获取会员的储值卡，如果没有则自动创建
*/
Mono<MemberStoredCard> getOrCreateStoredCard(Long memberId);
/**
* 获取会员的储值卡
*/
Mono<MemberStoredCard> getStoredCard(Long memberId);
/**
* 储值卡充值
*/
Mono<Integer> recharge(Long memberId, BigDecimal amount);
/**
* 储值卡消费
*/
Mono<Integer> consume(Long memberId, BigDecimal amount);
/**
* 检查支付密码是否已设置
*/
Mono<Boolean> isPayPasswordSet(Long memberId);
/**
* 设置支付密码
*/
Mono<Integer> setPayPassword(Long memberId, String password);
/**
* 验证支付密码
*/
Mono<Boolean> verifyPayPassword(Long memberId, String password);
/**
* 储值卡支付（验证密码并扣减余额）
*/
Mono<PayResult> payWithStoredCard(Long memberId, String password, BigDecimal amount);
/**
* 储值卡返还（取消预约退款，仅增加余额不修改充值总额）
*/
Mono<PayResult> refundToStoredCard(Long memberId, String password, BigDecimal amount, long cancelCount);
/**
* 储值卡返还（内部调用，无需密码，含手续费逻辑）
* @return 实际返还金额
*/
Mono<BigDecimal> refundBalanceWithFee(Long memberId, BigDecimal amount, long cancelCount);
/**
* 查询会员的充值记录列表
*/
Flux<MemberStoredCardRecharge> getRechargeRecords(Long memberId, int page, int size);
/**
* 查询会员充值记录总数
*/
Mono<Long> countRechargeRecords(Long memberId);
/**
* 储值卡支付结果
*/
class PayResult {
private boolean success;
private String message;
private BigDecimal balance;
public static PayResult success(BigDecimal balance) {
PayResult result = new PayResult();
result.success = true;
result.message = "支付成功";
result.balance = balance;
return result;
}
public static PayResult fail(String message) {
PayResult result = new PayResult();
result.success = false;
result.message = message;
return result;
}
public boolean isSuccess() { return success; }
public void setSuccess(boolean success) { this.success = success; }
public String getMessage() { return message; }
public void setMessage(String message) { this.message = message; }
public BigDecimal getBalance() { return balance; }
public void setBalance(BigDecimal balance) { this.balance = balance; }
}
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/MemberService.java
+1 -1
View File
@@ -58,7 +58,7 @@ public interface MemberService {
* @param pageSize 页大小
* @return 所有会员信息
*/
Flux<Member> findAll(Integer pageNum, Integer pageSize, String sortField, String sortOrder);
Flux<Member> findAll(Integer pageNum, Integer pageSize);
/**
* 前台管理端获取会员详情（含会员卡信息）
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardRecordServiceImpl.java
+2 -139
View File
@@ -1,9 +1,7 @@
package cn.novalon.gym.manage.member.service.impl;
import cn.novalon.gym.manage.member.entity.MemberCard;
import cn.novalon.gym.manage.member.entity.MemberCardRecord;
import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
import cn.novalon.gym.manage.member.repository.MemberCardRepository;
import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
import cn.novalon.gym.manage.common.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
@@ -13,9 +11,6 @@ import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
/**
* 会员卡记录服务实现
@@ -27,17 +22,13 @@ import java.util.stream.Collectors;
@Service
public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
private final MemberCardRecordRepository memberCardRecordRepository;
private final MemberCardRepository memberCardRepository;
private final RedisUtil redisUtil;
private static final String MEMBER_CARD_RECORD_CACHE_PREFIX = "member:card:record:";
private static final long CACHE_EXPIRE_SECONDS = 300;
public MemberCardRecordServiceImpl(MemberCardRecordRepository memberCardRecordRepository,
MemberCardRepository memberCardRepository,
RedisUtil redisUtil) {
public MemberCardRecordServiceImpl(MemberCardRecordRepository memberCardRecordRepository, RedisUtil redisUtil) {
this.memberCardRecordRepository = memberCardRecordRepository;
this.memberCardRepository = memberCardRepository;
this.redisUtil = redisUtil;
}
@@ -65,44 +56,7 @@ public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
@Override
public Flux<MemberCardRecord> findActiveCardsByMemberId(Long memberId) {
return memberCardRecordRepository.findActiveCardsByMemberId(memberId)
// 收集所有记录，然后批量查询会员卡信息
.collectList()
.flatMapMany(records -> {
if (records.isEmpty()) {
return Flux.empty();
}
// 提取所有 memberCardId（关联的是 member_card.id 字段，即MemberCard的主键）
List<Long> memberCardIds = records.stream()
.map(MemberCardRecord::getMemberCardId)
.filter(Objects::nonNull)
.distinct()
.collect(Collectors.toList());
if (memberCardIds.isEmpty()) {
return Flux.fromIterable(records);
}
// 批量查询会员卡信息（使用主键id查询，确保查询未删除的记录）
return Flux.fromIterable(memberCardIds)
.flatMap(id -> memberCardRepository.findByIdAndDeletedAtIsNull(id))
.collectMap(MemberCard::getId, mc -> mc)
.map(cardMap -> {
// 填充会员卡信息到每条记录
records.forEach(record -> {
MemberCard memberCard = cardMap.get(record.getMemberCardId());
if (memberCard != null) {
record.setMemberCardName(memberCard.getMemberCardName());
record.setMemberCardType(memberCard.getMemberCardType());
record.setMemberCardPrice(memberCard.getMemberCardPrice());
record.setMemberCardValidityDays(memberCard.getMemberCardValidityDays());
record.setMemberCardTotalTimes(memberCard.getMemberCardTotalTimes());
}
});
return records;
})
.flatMapMany(Flux::fromIterable);
});
return memberCardRecordRepository.findActiveCardsByMemberId(memberId);
}
@Override
@@ -162,97 +116,6 @@ public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
return memberCardRecordRepository.findExpiredCards();
}
@Override
public Flux<MemberCardRecord> findCardsByMemberIdWithStatus(Long memberId, String status) {
return memberCardRecordRepository.findCardsByMemberIdWithStatus(memberId, status)
// 收集所有记录，然后批量查询会员卡信息
.collectList()
.flatMapMany(records -> {
if (records.isEmpty()) {
return Flux.empty();
}
// 提取所有 memberCardId（关联的是 member_card.id 字段，即MemberCard的主键）
List<Long> memberCardIds = records.stream()
.map(MemberCardRecord::getMemberCardId)
.filter(Objects::nonNull)
.distinct()
.collect(Collectors.toList());
if (memberCardIds.isEmpty()) {
return Flux.fromIterable(records);
}
// 批量查询会员卡信息（使用主键id查询，确保查询未删除的记录）
return Flux.fromIterable(memberCardIds)
.flatMap(id -> memberCardRepository.findByIdAndDeletedAtIsNull(id))
.collectMap(MemberCard::getId, mc -> mc)
.map(cardMap -> {
// 填充会员卡信息到每条记录
records.forEach(record -> {
MemberCard memberCard = cardMap.get(record.getMemberCardId());
if (memberCard != null) {
record.setMemberCardName(memberCard.getMemberCardName());
record.setMemberCardType(memberCard.getMemberCardType());
record.setMemberCardPrice(memberCard.getMemberCardPrice());
record.setMemberCardValidityDays(memberCard.getMemberCardValidityDays());
record.setMemberCardTotalTimes(memberCard.getMemberCardTotalTimes());
}
});
return records;
})
.flatMapMany(Flux::fromIterable);
});
}
@Override
public Mono<MemberCardRecord> findPrimaryActiveCardByMemberId(Long memberId) {
LocalDateTime now = LocalDateTime.now();
return findCardsByMemberIdWithStatus(memberId, "active")
// 过滤掉储值卡
.filter(record -> record.getMemberCardType() == null ||
!record.getMemberCardType().equals("STORED_VALUE_CARD"))
.collectList()
.flatMap(records -> {
if (records.isEmpty()) {
return Mono.empty();
}
// 优先找临期卡（剩余1-3天）
MemberCardRecord expiringCard = records.stream()
.filter(record -> {
if (record.getExpireTime() == null) return false;
if (record.getStatus() != null && record.getStatus().equals("USED_UP")) return false;
long days = java.time.Duration.between(now, record.getExpireTime()).toDays();
return days >= 1 && days <= 3;
})
.findFirst()
.orElse(null);
if (expiringCard != null) {
return Mono.just(expiringCard);
}
// 再找普通有效卡（剩余>3天）
MemberCardRecord activeCard = records.stream()
.filter(record -> {
if (record.getExpireTime() == null) return true;
if (record.getStatus() != null && record.getStatus().equals("USED_UP")) return false;
long days = java.time.Duration.between(now, record.getExpireTime()).toDays();
return days > 3;
})
.findFirst()
.orElse(null);
if (activeCard != null) {
return Mono.just(activeCard);
}
// 最后返回第一张卡
return Mono.just(records.get(0));
});
}
private void clearRecordCache(Long recordId) {
String cacheKey = MEMBER_CARD_RECORD_CACHE_PREFIX + recordId;
redisUtil.delete(cacheKey);
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImpl.java
+28 -111
View File
@@ -44,7 +44,6 @@ public class MemberCardServiceImpl implements IMemberCardService {
private static final String MEMBER_CARD_CACHE_PREFIX = "member:card:";
private static final long CACHE_EXPIRE_SECONDS = 300;
private static final long DUPLICATE_WINDOW_SECONDS = 10;
public MemberCardServiceImpl(MemberCardRepository memberCardRepository,
MemberCardRecordRepository recordRepository,
@@ -125,42 +124,11 @@ public class MemberCardServiceImpl implements IMemberCardService {
@Override
public Mono<MemberCardRecord> purchaseCard(Long memberId, Long memberCardId, Long sourceOrderId) {
if (memberId == null) {
return Mono.error(new RuntimeException("会员ID不能为空"));
}
if (memberCardId == null) {
return Mono.error(new RuntimeException("会员卡类型ID不能为空"));
}
// 快速路径：幂等性检查，同一笔支付订单已创建过记录则直接返回
if (sourceOrderId != null) {
return recordRepository.findBySourceOrderId(sourceOrderId)
.flatMap(existingRecord -> {
log.info("支付订单已生成会员卡记录，幂等返回: sourceOrderId={}, memberCardRecordId={}",
sourceOrderId, existingRecord.getMemberCardRecordId());
return Mono.just(existingRecord);
})
.switchIfEmpty(Mono.defer(() -> doPurchaseCard(memberId, memberCardId, sourceOrderId)));
}
// sourceOrderId为null（前端直接调用）：检查10秒内是否已有同类卡，防前端重复调用
LocalDateTime since = LocalDateTime.now().minusSeconds(DUPLICATE_WINDOW_SECONDS);
return recordRepository.findRecentActivePurchase(memberId, memberCardId, since)
.flatMap(existingRecord -> {
log.info("前端重复购买检测命中: memberId={}, memberCardId={}, memberCardRecordId={}, purchaseTime={}",
memberId, memberCardId, existingRecord.getMemberCardRecordId(), existingRecord.getPurchaseTime());
return Mono.just(existingRecord);
})
.switchIfEmpty(Mono.defer(() -> doPurchaseCard(memberId, memberCardId, sourceOrderId)));
}
private Mono<MemberCardRecord> doPurchaseCard(Long memberId, Long memberCardId, Long sourceOrderId) {
// 前端传的是数据库主键id，不是业务字段member_card_id
return memberCardRepository.findByIdAndDeletedAtIsNull(memberCardId)
return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
.flatMap(card -> {
if (card.getMemberCardStatus() != null && card.getMemberCardStatus() == 0) {
return Mono.error(new RuntimeException("该会员卡已下架"));
if (card.getMemberCardStatus() != null && card.getMemberCardStatus() == 1) {
return Mono.error(new RuntimeException("该会员卡已禁用"));
}
MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
@@ -168,25 +136,13 @@ public class MemberCardServiceImpl implements IMemberCardService {
return distributedLockService.executeWithLock(
memberId.toString(),
cardType.name(),
Mono.defer(() -> {
// 持锁后再次检查幂等，防止并发请求同时通过外层检查
if (sourceOrderId != null) {
return recordRepository.findBySourceOrderId(sourceOrderId)
.flatMap(existingRecord -> {
log.info("持锁幂等检查命中: sourceOrderId={}, memberCardRecordId={}",
sourceOrderId, existingRecord.getMemberCardRecordId());
return Mono.just(existingRecord);
})
.switchIfEmpty(Mono.defer(() -> createCardRecord(memberId, memberCardId, sourceOrderId, card)));
}
return createCardRecord(memberId, memberCardId, sourceOrderId, card);
})
.flatMap(record -> createTransactionForPurchase(record, card, TransactionType.PURCHASE, "购买会员卡")
.thenReturn(record))
.flatMap(record -> expirationReminderService.scheduleExpirationReminder(record)
.then(Mono.just(record)))
Mono.defer(() -> createCardRecord(memberId, memberCardId, sourceOrderId, card))
);
});
})
.flatMap(record -> createTransaction(record, TransactionType.PURCHASE, "购买会员卡")
.thenReturn(record))
.flatMap(record -> expirationReminderService.scheduleExpirationReminder(record)
.then(Mono.just(record)));
}
private Mono<MemberCardRecord> createCardRecord(Long memberId, Long memberCardId,
@@ -205,16 +161,12 @@ public class MemberCardServiceImpl implements IMemberCardService {
switch (cardType) {
case TIME_CARD:
if (card.getMemberCardValidityDays() != null) {
record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
}
record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
record.setRemainingTimes(0);
record.setRemainingAmount(0.0);
break;
case COUNT_CARD:
if (card.getMemberCardValidityDays() != null) {
record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
}
record.setExpireTime(now.plusDays(card.getMemberCardValidityDays()));
record.setRemainingTimes(card.getMemberCardTotalTimes());
record.setRemainingAmount(0.0);
break;
@@ -239,17 +191,12 @@ public class MemberCardServiceImpl implements IMemberCardService {
}
@Override
public Mono<MemberCardRecord> renewCard(Long recordId, Long memberId, Integer addTimes, Double addAmount,
public Mono<MemberCardRecord> renewCard(Long recordId, Integer addTimes, Double addAmount,
Integer addDays, Long sourceOrderId) {
return recordRepository.findById(recordId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
.flatMap(originalRecord -> {
if (!originalRecord.getMemberId().equals(memberId)) {
return Mono.error(new RuntimeException("无权操作此会员卡"));
}
return stateMachine.validateTransition(originalRecord, CardEvent.RENEW)
.then(Mono.just(originalRecord));
})
.flatMap(originalRecord -> stateMachine.validateTransition(originalRecord, CardEvent.RENEW)
.then(Mono.just(originalRecord)))
.flatMap(originalRecord -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(originalRecord.getMemberCardId())
.switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
.flatMap(card -> {
@@ -302,16 +249,11 @@ public class MemberCardServiceImpl implements IMemberCardService {
}
@Override
public Mono<MemberCardRecord> useCard(Long recordId, Long memberId, Integer deductTimes, Double deductAmount) {
public Mono<MemberCardRecord> useCard(Long recordId, Integer deductTimes, Double deductAmount) {
return recordRepository.findById(recordId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
.flatMap(record -> {
if (!record.getMemberId().equals(memberId)) {
return Mono.error(new RuntimeException("无权操作此会员卡"));
}
return stateMachine.validateTransition(record, CardEvent.USE)
.then(Mono.just(record));
})
.flatMap(record -> stateMachine.validateTransition(record, CardEvent.USE)
.then(Mono.just(record)))
.flatMap(record -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
.switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
.flatMap(card -> {
@@ -372,24 +314,19 @@ public class MemberCardServiceImpl implements IMemberCardService {
}
@Override
public Mono<Void> refundCard(Long recordId, Long memberId) {
public Mono<Void> refundCard(Long recordId) {
return recordRepository.findById(recordId)
.switchIfEmpty(Mono.error(new RuntimeException("会员卡记录不存在")))
.flatMap(record -> {
if (!record.getMemberId().equals(memberId)) {
return Mono.error(new RuntimeException("无权操作此会员卡"));
}
return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
.switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
.flatMap(card -> {
MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
return distributedLockService.executeWithLock(
record.getMemberId().toString(),
cardType.name(),
refundSagaHandler.executeRefund(recordId)
);
});
});
.flatMap(record -> memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(record.getMemberCardId())
.switchIfEmpty(Mono.error(new RuntimeException("会员卡类型不存在")))
.flatMap(card -> {
MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
return distributedLockService.executeWithLock(
record.getMemberId().toString(),
cardType.name(),
refundSagaHandler.executeRefund(recordId)
);
}));
}
@Override
@@ -404,7 +341,6 @@ public class MemberCardServiceImpl implements IMemberCardService {
private Mono<Void> createTransaction(MemberCardRecord record, TransactionType action, String remark) {
MemberCardTransaction transaction = MemberCardTransaction.builder()
.memberCardRecordId(record.getMemberCardRecordId())
.memberId(record.getMemberId())
.memberCardId(record.getMemberCardId())
.operationType(action.name())
@@ -418,25 +354,6 @@ public class MemberCardServiceImpl implements IMemberCardService {
return transactionService.createTransaction(transaction);
}
/**
* 创建购买会员卡的交易记录（记录购买金额为负数，表示支出）
*/
private Mono<Void> createTransactionForPurchase(MemberCardRecord record, MemberCard card, TransactionType action, String remark) {
MemberCardTransaction transaction = MemberCardTransaction.builder()
.memberCardRecordId(record.getMemberCardRecordId())
.memberId(record.getMemberId())
.memberCardId(record.getMemberCardId())
.operationType(action.name())
.changeAmount(card.getMemberCardTotalTimes() != null ? card.getMemberCardTotalTimes() : 0)
.changeBalance(card.getMemberCardPrice() != null ? -card.getMemberCardPrice() : 0.0) // 负数表示支出
.afterRemainingCount(record.getRemainingTimes())
.afterRemainingBalance(record.getRemainingAmount())
.remark(remark)
.build();
return transactionService.createTransaction(transaction);
}
private void clearCardCache(Long memberCardId) {
String cacheKey = MEMBER_CARD_CACHE_PREFIX + memberCardId;
redisUtil.delete(cacheKey);
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardTransactionServiceImpl.java
+2 -13
View File
@@ -91,19 +91,8 @@ public class MemberCardTransactionServiceImpl implements IMemberCardTransactionS
@Override
public Mono<Void> createTransaction(MemberCardTransaction transaction) {
return transactionRepository.insertTransaction(
transaction.getMemberCardRecordId(),
transaction.getMemberCardId(),
transaction.getMemberId(),
transaction.getOperationType(),
transaction.getChangeAmount(),
transaction.getChangeBalance(),
transaction.getAfterRemainingCount(),
transaction.getAfterRemainingBalance(),
transaction.getRelatedBizType(),
transaction.getSourceOrderId(),
transaction.getRemark()
).then()
return transactionRepository.save(transaction)
.then()
.doOnSuccess(v -> log.info("创建会员卡交易记录: memberId={}, cardId={}, type={}",
transaction.getMemberId(), transaction.getMemberCardId(), transaction.getOperationType()));
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberServiceImpl.java
+43 -77
View File
@@ -17,7 +17,6 @@ import cn.novalon.gym.manage.member.service.MemberService;
import cn.novalon.gym.manage.member.util.AesUtil;
import cn.novalon.gym.manage.member.util.BeanConvertUtil;
import cn.novalon.gym.manage.member.util.EsSyncUtils;
import cn.novalon.gym.manage.member.util.WechatPhoneUtil;
import cn.novalon.gym.manage.common.util.RedisUtil;
import cn.novalon.gym.manage.member.vo.MemberCardInfoVO;
import cn.novalon.gym.manage.member.vo.MemberDetailVO;
@@ -26,7 +25,6 @@ import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
@@ -141,24 +139,12 @@ public class MemberServiceImpl implements MemberService {
private MemberInfoVO buildMemberInfoResponse(Member member) {
String phone = member.getPhone();
String maskedPhone = null;
// 先解密手机号，再进行脱敏处理
if (phone != null && !phone.isEmpty()) {
try {
String decryptedPhone = AesUtil.decrypt(phone);
maskedPhone = WechatPhoneUtil.maskPhone(decryptedPhone);
} catch (Exception e) {
log.error("手机号解密失败, memberId: {}", member.getId(), e);
maskedPhone = null;
}
}
String maskedPhone = phone != null ? phone.replace(phone.substring(3, 7), "****") : null;
GenderEnum genderEnum = GenderEnum.fromCode(member.getGender());
return MemberInfoVO.builder()
.id(member.getId())
.memberNo(member.getMemberNo())
.nickname(member.getNickname())
.phone(maskedPhone)
.gender(genderEnum)
@@ -167,7 +153,6 @@ public class MemberServiceImpl implements MemberService {
.avatar(member.getAvatar())
.hasPhone(phone != null)
.isSubscribed(member.getSubscribed() != null && member.getSubscribed())
.lastLoginAt(member.getLastLoginAt())
.build();
}
@@ -233,31 +218,13 @@ public class MemberServiceImpl implements MemberService {
);
}
/** 合法的排序字段白名单，key=前端传值, value=数据库字段名 */
private static final java.util.Map<String, String> ALLOWED_SORT_FIELDS = java.util.Map.of(
"createdAt", "created_at",
"memberNo", "member_no",
"gender", "gender",
"id", "id"
);
@Override
public Flux<Member> findAll(Integer pageNum, Integer pageSize, String sortField, String sortOrder) {
log.info("查询所有会员列表, pageNum: {}, pageSize: {}, sortField: {}, sortOrder: {}",
pageNum, pageSize, sortField, sortOrder);
// 排序方向：desc(默认) / asc
Sort.Direction direction = "asc".equalsIgnoreCase(sortOrder)
? Sort.Direction.ASC : Sort.Direction.DESC;
// 排序字段白名单校验，不在白名单中则使用默认排序
String dbField = (sortField != null && ALLOWED_SORT_FIELDS.containsKey(sortField))
? ALLOWED_SORT_FIELDS.get(sortField) : "created_at";
public Flux<Member> findAll(Integer pageNum, Integer pageSize) {
log.info("查询所有会员列表, pageNum: {}, pageSize: {}", pageNum, pageSize);
Pageable pageable = PageRequest.of(
pageNum - 1,
pageSize,
Sort.by(direction, dbField)
pageSize
);
return memberRepository.findAllBy(pageable);
@@ -270,51 +237,50 @@ public class MemberServiceImpl implements MemberService {
String cacheKey = MEMBER_DETAIL_CACHE_PREFIX + memberId;
return redisUtil.get(cacheKey, MemberDetailVO.class)
.filter(cached -> cached != null)
.switchIfEmpty(Mono.defer(() ->
memberRepository.findById(memberId)
.switchIfEmpty(Mono.error(() -> {
log.error("会员不存在: memberId={}", memberId);
throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
}))
.zipWith(
memberRepository.findCardRecordsWithCardInfoByMemberId(memberId)
.collectList(),
(baseInfo, cardList) -> {
MemberDetailVO memberDetailVO = BeanConvertUtil.toBean(baseInfo, MemberDetailVO.class);
.flatMap(cached -> {
if (cached != null) {
log.debug("从缓存获取会员详情, memberId: {}", memberId);
return Mono.just(cached);
}
return memberRepository.findById(memberId)
.zipWith(
memberRepository.findCardRecordsWithCardInfoByMemberId(memberId)
.collectList(),
(baseInfo, cardList) -> {
MemberDetailVO memberDetailVO = BeanConvertUtil.toBean(baseInfo, MemberDetailVO.class);
GenderEnum genderEnum = GenderEnum.fromCode(baseInfo.getGender());
memberDetailVO.setGenderDesc(genderEnum.getDesc());
GenderEnum genderEnum = GenderEnum.fromCode(baseInfo.getGender());
memberDetailVO.setGenderDesc(genderEnum.getDesc());
List<MemberCardInfoVO> enrichedCards = cardList.stream()
.peek(vo -> {
if (vo.getMemberCardType() != null) {
try {
MemberCardType cardType = MemberCardType.valueOf(vo.getMemberCardType());
vo.setMemberCardTypeDesc(cardType.getDesc());
} catch (IllegalArgumentException e) {
vo.setMemberCardTypeDesc(vo.getMemberCardType());
}
List<MemberCardInfoVO> enrichedCards = cardList.stream()
.peek(vo -> {
if (vo.getMemberCardType() != null) {
try {
MemberCardType cardType = MemberCardType.valueOf(vo.getMemberCardType());
vo.setMemberCardTypeDesc(cardType.getDesc());
} catch (IllegalArgumentException e) {
vo.setMemberCardTypeDesc(vo.getMemberCardType());
}
if (vo.getMemberCardStatus() != null) {
vo.setMemberCardStatusDesc(vo.getMemberCardStatus() == 1 ? "上架" : "下架");
}
})
.collect(Collectors.toList());
memberDetailVO.setMemberCards(enrichedCards);
}
if (vo.getMemberCardStatus() != null) {
vo.setMemberCardStatusDesc(vo.getMemberCardStatus() == 1 ? "上架" : "下架");
}
})
.collect(Collectors.toList());
memberDetailVO.setMemberCards(enrichedCards);
long activeCount = enrichedCards.stream()
.filter(card -> card.getMemberCardStatus() != null && card.getMemberCardStatus() == 1)
.count();
memberDetailVO.setActiveCardCount((int) activeCount);
memberDetailVO.setInactiveCardCount(enrichedCards.size() - (int) activeCount);
long activeCount = enrichedCards.stream()
.filter(card -> card.getMemberCardStatus() != null && card.getMemberCardStatus() == 1)
.count();
memberDetailVO.setActiveCardCount((int) activeCount);
memberDetailVO.setInactiveCardCount(enrichedCards.size() - (int) activeCount);
return memberDetailVO;
}
)
.flatMap(vo -> redisUtil.setWithExpire(cacheKey, vo, CACHE_EXPIRE_SECONDS)
.then(Mono.just(vo)))
));
return memberDetailVO;
}
)
.flatMap(vo -> redisUtil.setWithExpire(cacheKey, vo, CACHE_EXPIRE_SECONDS)
.then(Mono.just(vo)));
});
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberStoredCardServiceImpl.java
-236
View File
@@ -1,236 +0,0 @@
package cn.novalon.gym.manage.member.service.impl;
import cn.novalon.gym.manage.member.entity.MemberStoredCard;
import cn.novalon.gym.manage.member.entity.MemberStoredCardRecharge;
import cn.novalon.gym.manage.member.repository.MemberStoredCardRechargeRepository;
import cn.novalon.gym.manage.member.repository.MemberStoredCardRepository;
import cn.novalon.gym.manage.member.service.IMemberStoredCardService;
import cn.novalon.gym.manage.sys.core.service.ISysConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.math.BigDecimal;
/**
* 储值卡 Service实现
*/
@Slf4j
@Service
public class MemberStoredCardServiceImpl implements IMemberStoredCardService {
private final MemberStoredCardRepository memberStoredCardRepository;
private final MemberStoredCardRechargeRepository memberStoredCardRechargeRepository;
private final ISysConfigService sysConfigService;
private final BCryptPasswordEncoder passwordEncoder;
public MemberStoredCardServiceImpl(MemberStoredCardRepository memberStoredCardRepository,
MemberStoredCardRechargeRepository memberStoredCardRechargeRepository,
ISysConfigService sysConfigService) {
this.memberStoredCardRepository = memberStoredCardRepository;
this.memberStoredCardRechargeRepository = memberStoredCardRechargeRepository;
this.sysConfigService = sysConfigService;
this.passwordEncoder = new BCryptPasswordEncoder();
}
@Override
public Mono<MemberStoredCard> getOrCreateStoredCard(Long memberId) {
return memberStoredCardRepository.findByMemberId(memberId)
.switchIfEmpty(Mono.defer(() -> {
log.info("[储值卡] 为会员 {} 创建储值卡", memberId);
return memberStoredCardRepository.createStoredCard(memberId)
.then(memberStoredCardRepository.findByMemberId(memberId));
}));
}
@Override
public Mono<MemberStoredCard> getStoredCard(Long memberId) {
return memberStoredCardRepository.findByMemberId(memberId);
}
@Override
public Mono<Integer> recharge(Long memberId, BigDecimal amount) {
return memberStoredCardRepository.findByMemberId(memberId)
.flatMap(card -> memberStoredCardRepository.rechargeBalance(memberId, amount))
.switchIfEmpty(Mono.defer(() -> {
log.info("[储值卡] 会员 {} 首次充值，创建储值卡并充值", memberId);
return memberStoredCardRepository.createStoredCard(memberId)
.then(memberStoredCardRepository.rechargeBalance(memberId, amount));
}));
}
@Override
public Mono<Integer> consume(Long memberId, BigDecimal amount) {
return memberStoredCardRepository.deductBalance(memberId, amount);
}
@Override
public Mono<Boolean> isPayPasswordSet(Long memberId) {
return memberStoredCardRepository.isPayPasswordSet(memberId)
.defaultIfEmpty(false);
}
@Override
public Mono<Integer> setPayPassword(Long memberId, String password) {
// 确保储值卡存在
return getOrCreateStoredCard(memberId)
.flatMap(card -> {
// BCrypt加密密码
String encodedPassword = passwordEncoder.encode(password);
return memberStoredCardRepository.setPayPassword(memberId, encodedPassword);
});
}
@Override
public Mono<Boolean> verifyPayPassword(Long memberId, String password) {
return memberStoredCardRepository.getPayPassword(memberId)
.map(storedPassword -> {
if (storedPassword == null || storedPassword.isEmpty()) {
return false;
}
return passwordEncoder.matches(password, storedPassword);
})
.defaultIfEmpty(false);
}
@Override
public Mono<PayResult> payWithStoredCard(Long memberId, String password, BigDecimal amount) {
return memberStoredCardRepository.findByMemberId(memberId)
.flatMap(card -> {
// 检查余额是否充足
BigDecimal currentBalance = card.getBalance();
if (currentBalance == null) {
currentBalance = BigDecimal.ZERO;
}
if (currentBalance.compareTo(amount) < 0) {
log.warn("[储值卡支付] 余额不足: memberId={}, balance={}, needAmount={}",
memberId, currentBalance, amount);
return Mono.just(PayResult.fail("余额不足，当前余额：" + currentBalance + "元"));
}
// 验证密码
if (card.getPayPassword() == null || card.getPayPassword().isEmpty()) {
log.warn("[储值卡支付] 未设置支付密码: memberId={}", memberId);
return Mono.just(PayResult.fail("请先设置支付密码"));
}
if (!passwordEncoder.matches(password, card.getPayPassword())) {
log.warn("[储值卡支付] 密码错误: memberId={}", memberId);
return Mono.just(PayResult.fail("支付密码错误"));
}
// 扣减余额
return memberStoredCardRepository.deductBalance(memberId, amount)
.flatMap(rows -> {
if (rows > 0) {
// 查询最新余额
return memberStoredCardRepository.findByMemberId(memberId)
.map(updatedCard -> PayResult.success(
updatedCard.getBalance() != null ? updatedCard.getBalance() : BigDecimal.ZERO));
} else {
log.warn("[储值卡支付] 扣减余额失败: memberId={}, amount={}", memberId, amount);
return Mono.just(PayResult.fail("支付失败，请稍后重试"));
}
});
})
.switchIfEmpty(Mono.defer(() -> {
log.warn("[储值卡支付] 储值卡不存在: memberId={}", memberId);
return Mono.just(PayResult.fail("储值卡不存在"));
}));
}
@Override
public Mono<PayResult> refundToStoredCard(Long memberId, String password, BigDecimal amount, long cancelCount) {
// 从系统配置读取免手续费次数阈值，默认3次
Mono<Long> freeLimitMono = sysConfigService.getConfigValue("group_course.cancel_free_limit")
.map(Long::parseLong)
.defaultIfEmpty(3L);
return freeLimitMono.flatMap(freeLimit ->
memberStoredCardRepository.findByMemberId(memberId)
.flatMap(card -> {
// 验证密码
if (card.getPayPassword() == null || card.getPayPassword().isEmpty()) {
log.warn("[储值卡退款] 未设置支付密码: memberId={}", memberId);
return Mono.just(PayResult.fail("请先设置支付密码"));
}
if (!passwordEncoder.matches(password, card.getPayPassword())) {
log.warn("[储值卡退款] 密码错误: memberId={}", memberId);
return Mono.just(PayResult.fail("支付密码错误"));
}
// 前N次取消不扣手续费，超出后扣除10%
BigDecimal refundAmount = amount;
BigDecimal fee = BigDecimal.ZERO;
if (cancelCount >= freeLimit) {
fee = amount.multiply(new BigDecimal("0.1")).setScale(2, java.math.RoundingMode.HALF_UP);
refundAmount = amount.subtract(fee);
log.info("[储值卡退款] 第{}次取消，已超出免手续费阈值({}次)，扣除10%手续费: 原额={}, 手续费={}, 退款={}",
cancelCount + 1, freeLimit, amount, fee, refundAmount);
} else {
log.info("[储值卡退款] 第{}次取消，在免手续费阈值({}次)内，全额退款: 原额={}",
cancelCount + 1, freeLimit, amount);
}
// 执行退款
BigDecimal finalRefundAmount = refundAmount;
return memberStoredCardRepository.refundBalance(memberId, refundAmount)
.flatMap(rows -> {
if (rows > 0) {
return memberStoredCardRepository.findByMemberId(memberId)
.map(updatedCard -> PayResult.success(
updatedCard.getBalance() != null ? updatedCard.getBalance() : BigDecimal.ZERO));
} else {
log.warn("[储值卡退款] 退款失败: memberId={}, amount={}", memberId, finalRefundAmount);
return Mono.just(PayResult.fail("退款失败，请稍后重试"));
}
});
})
.switchIfEmpty(Mono.defer(() -> {
log.warn("[储值卡退款] 储值卡不存在: memberId={}", memberId);
return Mono.just(PayResult.fail("储值卡不存在"));
}))
);
}
@Override
public Flux<MemberStoredCardRecharge> getRechargeRecords(Long memberId, int page, int size) {
int offset = (page - 1) * size;
return memberStoredCardRechargeRepository.findByMemberId(memberId, size, offset);
}
@Override
public Mono<BigDecimal> refundBalanceWithFee(Long memberId, BigDecimal amount, long cancelCount) {
return sysConfigService.getConfigValue("group_course.cancel_free_limit")
.map(Long::parseLong)
.defaultIfEmpty(3L)
.flatMap(freeLimit -> {
BigDecimal refundAmount;
if (cancelCount >= freeLimit) {
BigDecimal fee = amount.multiply(new BigDecimal("0.1")).setScale(2, java.math.RoundingMode.HALF_UP);
refundAmount = amount.subtract(fee);
log.info("[储值卡退款-内部] 第{}次取消，超出免手续费阈值({}次)，扣除10%: 原额={}, 手续费={}, 退款={}",
cancelCount + 1, freeLimit, amount, fee, refundAmount);
} else {
refundAmount = amount;
log.info("[储值卡退款-内部] 第{}次取消，在免手续费阈值({}次)内，全额退款: {}",
cancelCount + 1, freeLimit, amount);
}
return memberStoredCardRepository.refundBalance(memberId, refundAmount)
.flatMap(rows -> {
if (rows > 0) {
return Mono.just(refundAmount);
}
return Mono.error(new RuntimeException("储值卡退款失败"));
});
});
}
@Override
public Mono<Long> countRechargeRecords(Long memberId) {
return memberStoredCardRechargeRepository.countByMemberIdAndDeletedAtIsNull(memberId);
}
}
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatApiServiceImpl.java
+3 -22
View File
@@ -43,25 +43,12 @@ public class WechatApiServiceImpl implements WechatApiService {
@Override
public Mono<Map<String, String>> jsCode2Session(String code) {
log.info("微信jsCode2Session API, code: {}", code);
// Mock模式：返回模拟数据
if (wechatProperties.getMockEnabled() != null && wechatProperties.getMockEnabled()) {
log.info("Mock模式已启用，返回模拟微信登录数据");
Map<String, String> mockResult = new HashMap<>();
// 使用 code 的哈希生成唯一的 openid，确保每次登录创建不同用户
String mockOpenId = "mock_openid_" + Math.abs(code.hashCode() % 1000000);
mockResult.put("openid", mockOpenId);
mockResult.put("session_key", "mock_session_key");
mockResult.put("unionid", "mock_unionid_" + Math.abs(code.hashCode() % 1000000));
log.info("Mock微信API响应成功, openid: {}, unionid: {}", mockOpenId, mockResult.get("unionid"));
return Mono.just(mockResult);
}
log.info("真实微信API调用 - AppID: {}, AppSecret {}",
log.info("微信jsCode2Session API");
log.info("信息 - AppID: {}, AppSecret {}",
wechatProperties.getMiniapp().getAppId(),
wechatProperties.getMiniapp().getAppSecret() != null ?
wechatProperties.getMiniapp().getAppSecret().substring(0, Math.min(4, wechatProperties.getMiniapp().getAppSecret().length())) + "***" : "null");
log.info(" - code: {}", code);
return webClient.get()
.uri(uriBuilder -> uriBuilder
@@ -165,12 +152,6 @@ public class WechatApiServiceImpl implements WechatApiService {
public Mono<String> getAccessToken(String appType) {
log.debug("获取access_token, appType: {}", appType);
// Mock模式：返回模拟access_token
if (wechatProperties.getMockEnabled() != null && wechatProperties.getMockEnabled()) {
log.debug("Mock模式已启用，返回模拟access_token");
return Mono.just("mock_access_token");
}
String cacheKey = ACCESS_TOKEN_CACHE_PREFIX + appType;
return redisUtil.get(cacheKey, String.class)
gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/vo/MemberInfoVO.java
-7
View File
@@ -7,7 +7,6 @@ import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;
/**
@@ -26,9 +25,6 @@ public class MemberInfoVO {
// 会员 ID
private Long id;
// 会员编号
private String memberNo;
// 昵称
private String nickname;
@@ -52,7 +48,4 @@ public class MemberInfoVO {
// 是否已关注公众号
private Boolean isSubscribed;
// 最后登录时间
private LocalDateTime lastLoginAt;
}
gym-manage-api/gym-member/src/main/resources/db/schema.sql
-21
View File
@@ -279,24 +279,3 @@ CREATE INDEX IF NOT EXISTS idx_refund_application_status ON refund_application(s
COMMENT ON TABLE refund_application IS '退款申请表';
COMMENT ON COLUMN refund_application.status IS '状态：PENDING-待审核, APPROVED-已批准, REJECTED-已拒绝, PROCESSING-处理中, SUCCESS-成功, FAILED-失败';
-- ============================================
-- 7. member_pay_password 表（支付密码表）
-- ============================================
CREATE TABLE IF NOT EXISTS member_pay_password (
id BIGSERIAL PRIMARY KEY,
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
member_id BIGINT NOT NULL UNIQUE,
pay_password VARCHAR(100) NOT NULL,
is_set BOOLEAN DEFAULT TRUE
);
CREATE INDEX IF NOT EXISTS idx_member_pay_password_member_id ON member_pay_password(member_id);
COMMENT ON TABLE member_pay_password IS '支付密码表';
COMMENT ON COLUMN member_pay_password.member_id IS '会员ID';
COMMENT ON COLUMN member_pay_password.pay_password IS '支付密码（明文存储）';
COMMENT ON COLUMN member_pay_password.is_set IS '是否已设置支付密码';
gym-manage-api/gym-payment/classpath.txt
-1
View File
File diff suppressed because one or more lines are too long
gym-manage-api/gym-payment/cp.txt
-1
View File
File diff suppressed because one or more lines are too long
gym-manage-api/gym-payment/pom.xml
-75
View File
@@ -1,75 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-manage-api</artifactId>
<version>1.0.0</version>
</parent>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>gym-payment</artifactId>
<packaging>jar</packaging>
<name>Gym Payment</name>
<description>支付模块 - 支付宝App支付</description>
<dependencies>
<!-- Spring Boot WebFlux -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<!-- 通用模块 (含Redis工具类) -->
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-common</artifactId>
<version>${project.version}</version>
</dependency>
<!-- 汇付聚合支付SDK -->
<dependency>
<groupId>com.huifu.dg.lightning.sdk</groupId>
<artifactId>dg-lightning-sdk</artifactId>
<version>1.0.5</version>
</dependency>
<!-- 汇付Java SDK (托管/对账用) -->
<dependency>
<groupId>com.huifu.bspay.sdk</groupId>
<artifactId>dg-java-sdk</artifactId>
<version>3.0.38</version>
</dependency>
<!-- JSON处理 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.83</version>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- Swagger -->
<dependency>
<groupId>io.swagger.core.v3</groupId>
<artifactId>swagger-annotations</artifactId>
<version>2.2.19</version>
</dependency>
<dependency>
<groupId>cn.novalon.gym.manage</groupId>
<artifactId>manage-sys</artifactId>
<version>1.0.0</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>
gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/config/AlipayClientConfig.java
+32
View File
@@ -0,0 +1,32 @@
package cn.novalon.gym.manage.payment.config;
import com.alipay.api.AlipayClient;
import com.alipay.api.DefaultAlipayClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* 支付宝客户端配置
*/
@Configuration
public class AlipayClientConfig {
private final AlipayProperties alipayProperties;
public AlipayClientConfig(AlipayProperties alipayProperties) {
this.alipayProperties = alipayProperties;
}
@Bean
public AlipayClient alipayClient() {
return new DefaultAlipayClient(
alipayProperties.getGateway(),
alipayProperties.getAppId(),
alipayProperties.getAppPrivateKey(),
"json",
alipayProperties.getCharset(),
alipayProperties.getAlipayPublicKey(),
alipayProperties.getSignType()
);
}
}
gym-manage-api/gym-payment/src/main/java/cn/novalon/gym/manage/payment/config/HuifuProperties.java
-123
View File
@@ -1,123 +0,0 @@
package cn.novalon.gym.manage.payment.config;
import com.huifu.dg.lightning.utils.BasePay;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import jakarta.annotation.PostConstruct;
@Data
@Configuration
@ConfigurationProperties(prefix = "huifu")
@Slf4j
public class HuifuProperties {
private String mode = "prod";
private String skillSource = "hfps/1.3.0";
private ChannelConfig channel;
private MerchantConfig merchant;
private NotifyConfig notify;
@Data
public static class ChannelConfig {
private String sysId;
private String productId;
private String huifuId;
private String rsaPrivateKey;
private String rsaPublicKey;
private String huifuPublicKey;
}
@Data
public static class MerchantConfig {
private String sysId;
private String productId;
private String huifuId;
private String rsaPrivateKey;
private String rsaPublicKey;
private String huifuPublicKey;
}
@Data
public static class NotifyConfig {
private String url;
}
private volatile boolean sdkInitialized = false;
@PostConstruct
public void initSdk() {
try {
if ("test".equalsIgnoreCase(mode)) {
BasePay.prodMode = BasePay.MODE_TEST;
log.info("[Huifu] 聚合支付SDK: 联调环境");
} else {
BasePay.prodMode = BasePay.MODE_PROD;
log.info("[Huifu] 聚合支付SDK: 生产环境");
}
// 优先使用商户配置初始化SDK，确保请求身份与huifu_id匹配
if (merchant != null && merchant.getRsaPrivateKey() != null && merchant.getHuifuPublicKey() != null) {
com.huifu.dg.lightning.biz.config.MerConfig merConfig = new com.huifu.dg.lightning.biz.config.MerConfig();
merConfig.setProductId(merchant.getProductId());
merConfig.setSysId(merchant.getSysId());
merConfig.setRsaPrivateKey(merchant.getRsaPrivateKey());
merConfig.setRsaPublicKey(merchant.getHuifuPublicKey());
merConfig.setSkillSource(skillSource);
BasePay.initWithMerConfig(merConfig);
sdkInitialized = true;
log.info("[Huifu] 聚合支付SDK初始化完成, 使用商户配置, sysId={}, huifuId={}",
merchant.getSysId(), merchant.getHuifuId());
initDgJavaSdk(merchant);
return;
}
// 备用：渠道商配置
if (channel == null || channel.getRsaPrivateKey() == null || channel.getHuifuPublicKey() == null) {
log.warn("[Huifu] 渠道商配置不完整，跳过SDK初始化");
return;
}
com.huifu.dg.lightning.biz.config.MerConfig merConfig = new com.huifu.dg.lightning.biz.config.MerConfig();
merConfig.setProductId(channel.getProductId());
merConfig.setSysId(channel.getSysId());
merConfig.setRsaPrivateKey(channel.getRsaPrivateKey());
merConfig.setRsaPublicKey(channel.getHuifuPublicKey());
merConfig.setSkillSource(skillSource);
BasePay.initWithMerConfig(merConfig);
sdkInitialized = true;
log.info("[Huifu] 聚合支付SDK初始化完成, 使用渠道商配置, sysId={}", channel.getSysId());
} catch (Exception e) {
log.error("[Huifu] 聚合支付SDK初始化失败，支付功能将不可用", e);
}
}
public boolean isSdkInitialized() {
return sdkInitialized;
}
private void initDgJavaSdk(MerchantConfig config) {
try {
com.huifu.bspay.sdk.opps.core.BasePay.prodMode = "test".equalsIgnoreCase(mode)
? com.huifu.bspay.sdk.opps.core.BasePay.MODE_TEST
: com.huifu.bspay.sdk.opps.core.BasePay.MODE_PROD;
com.huifu.bspay.sdk.opps.core.config.MerConfig merConfig = new com.huifu.bspay.sdk.opps.core.config.MerConfig();
merConfig.setSysId(config.getSysId());
merConfig.setProductId(config.getProductId());
merConfig.setRsaPrivateKey(config.getRsaPrivateKey());
merConfig.setRsaPublicKey(config.getHuifuPublicKey());
merConfig.setSkillSource(skillSource);
com.huifu.bspay.sdk.opps.core.BasePay.initWithMerConfig(merConfig);
log.info("[Huifu] dg-java-sdk初始化完成, sysId={}", config.getSysId());
} catch (Exception e) {
log.error("[Huifu] dg-java-sdk初始化失败", e);
}
}
}

Some files were not shown because too many files have changed in this diff Show More