提交 c173bff4 authored 作者: caifuming's avatar caifuming

cfm_7/15前后端完成用户模块第一版

上级 c00f8dec
package com.platform.backend.auth;
public final class AuthConstants {
private AuthConstants() {}
public static final String HEADER_TRACE_ID = "X-Trace-Id";
public static final String MDC_TRACE_ID = "traceId";
public static final String REDIS_LOGIN_FAIL_PREFIX = "auth:login:fail:";
public static final String REDIS_LOGIN_LOCK_PREFIX = "auth:login:locked:";
public static final String REDIS_REFRESH_BLACKLIST_PREFIX = "auth:refresh:blacklist:";
public static final String REDIS_REFRESH_ACTIVE_PREFIX = "auth:refresh:active:";
}
package com.platform.backend.auth;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConfigurationProperties(prefix = "jwt")
@Data
public class JwtProperties {
private String secret;
private Token access = new Token();
private Token refresh = new Token();
private Bcrypt bcrypt = new Bcrypt();
@Data
public static class Token {
private long expirationMs;
private String header = "Authorization";
private String prefix = "Bearer ";
}
@Data
public static class Bcrypt {
private int strength = 10;
}
}
package com.platform.backend.auth;
import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import lombok.RequiredArgsConstructor;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
@Service
@RequiredArgsConstructor
public class JwtTokenService {
private final JwtProperties props;
private final StringRedisTemplate redis;
private SecretKey signingKey() {
return Keys.hmacShaKeyFor(props.getSecret().getBytes(StandardCharsets.UTF_8));
}
// ===== access =====
public String generateAccessToken(String username, String role) {
long now = System.currentTimeMillis();
return Jwts.builder()
.id(UUID.randomUUID().toString())
.subject(username)
.claim("role", role)
.claim("type", "access")
.issuedAt(new Date(now))
.expiration(new Date(now + props.getAccess().getExpirationMs()))
.signWith(signingKey())
.compact();
}
public boolean validateAccessToken(String token) {
try {
parseAndCheckType(token, "access");
return true;
} catch (JwtException | IllegalArgumentException e) {
return false;
}
}
// ===== refresh =====
public String generateRefreshToken(String username, String role) {
long now = System.currentTimeMillis();
String jti = UUID.randomUUID().toString();
String token = Jwts.builder()
.id(jti)
.subject(username)
.claim("role", role)
.claim("type", "refresh")
.issuedAt(new Date(now))
.expiration(new Date(now + props.getRefresh().getExpirationMs()))
.signWith(signingKey())
.compact();
// 记录当前用户活跃的 refresh jti
redis.opsForValue().set(
AuthConstants.REDIS_REFRESH_ACTIVE_PREFIX + username,
jti,
props.getRefresh().getExpirationMs(),
TimeUnit.MILLISECONDS);
return token;
}
/**
* 校验 refresh token:未过期 + 类型正确 + 未在黑名单 + 是当前激活的 jti。
*/
public Claims validateAndConsumeRefreshToken(String refreshToken) {
Claims claims = parseAndCheckType(refreshToken, "refresh");
String username = claims.getSubject();
String jti = claims.getId();
String blackKey = AuthConstants.REDIS_REFRESH_BLACKLIST_PREFIX + jti;
Boolean onBlacklist = redis.hasKey(blackKey);
if (Boolean.TRUE.equals(onBlacklist)) {
throw new JwtException("refresh token 已失效(黑名单)");
}
String activeJti = redis.opsForValue().get(
AuthConstants.REDIS_REFRESH_ACTIVE_PREFIX + username);
if (activeJti == null || !activeJti.equals(jti)) {
throw new JwtException("refresh token 已不是当前激活的令牌");
}
// 验证通过后立即加入黑名单 → 实现一次性
long ttlMs = claims.getExpiration().getTime() - System.currentTimeMillis();
redis.opsForValue().set(blackKey, "1", Math.max(ttlMs, 1000), TimeUnit.MILLISECONDS);
return claims;
}
public boolean validateRefreshToken(String token) {
try {
return parseAndCheckType(token, "refresh") != null;
} catch (JwtException | IllegalArgumentException e) {
return false;
}
}
// ===== 通用解析 =====
private Claims parseAndCheckType(String token, String expectedType) {
Claims claims = Jwts.parser()
.verifyWith(signingKey())
.build()
.parseSignedClaims(token)
.getPayload();
Object type = claims.get("type");
if (type == null || !expectedType.equals(type.toString())) {
throw new JwtException("token 类型错误,期望 " + expectedType);
}
return claims;
}
public Claims parseClaims(String token) {
return Jwts.parser()
.verifyWith(signingKey())
.build()
.parseSignedClaims(token)
.getPayload();
}
public String getUsernameFromToken(String token) { return parseClaims(token).getSubject(); }
public String getRoleFromToken(String token) { return String.valueOf(parseClaims(token).get("role")); }
public String getJtiFromToken(String token) { return parseClaims(token).getId(); }
public long getAccessExpirationMs() { return props.getAccess().getExpirationMs(); }
// ===== logout =====
public void logout(String refreshToken) {
try {
Claims claims = parseAndCheckType(refreshToken, "refresh");
String jti = claims.getId();
long ttlMs = claims.getExpiration().getTime() - System.currentTimeMillis();
redis.opsForValue().set(
AuthConstants.REDIS_REFRESH_BLACKLIST_PREFIX + jti,
"1",
Math.max(ttlMs, 1000),
TimeUnit.MILLISECONDS);
// 清除当前激活 refresh
redis.delete(AuthConstants.REDIS_REFRESH_ACTIVE_PREFIX + claims.getSubject());
} catch (JwtException | IllegalArgumentException ignored) {
// 已过期 / 已失效的 refresh 也允许前端清理
}
}
}
package com.platform.backend.auth;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
@Service
@RequiredArgsConstructor
public class LoginAttemptService {
private final StringRedisTemplate redis;
@Value("${login.max-failures:5}")
private int maxFailures;
@Value("${login.lock-minutes:10}")
private int lockMinutes;
private String failKey(String username) { return AuthConstants.REDIS_LOGIN_FAIL_PREFIX + username; }
private String lockKey(String username) { return AuthConstants.REDIS_LOGIN_LOCK_PREFIX + username; }
/** 失败次数 +1,返回当前累计次数。当前登录流程只用到整型计数,因此这里直接收敛为 int。 */
public int loginFailed(String username) {
Long count = redis.opsForValue().increment(failKey(username));
// 首次设置 TTL
redis.expire(failKey(username), lockMinutes, TimeUnit.MINUTES);
return count == null ? 0 : count.intValue();
}
public void loginSucceeded(String username) {
redis.delete(failKey(username));
}
public boolean isLocked(String username) {
Boolean has = redis.hasKey(lockKey(username));
return Boolean.TRUE.equals(has);
}
public void lockAccount(String username) {
redis.opsForValue().set(lockKey(username), "1", lockMinutes, TimeUnit.MINUTES);
// 同步刷新失败计数 TTL,使其与锁定窗口一致
redis.expire(failKey(username), lockMinutes, TimeUnit.MINUTES);
}
public int getRemainingAttempts(String username) {
String countStr = redis.opsForValue().get(failKey(username));
int count = countStr == null ? 0 : Integer.parseInt(countStr);
return Math.max(0, maxFailures - count);
}
}
package com.platform.backend.auth;
import com.platform.backend.entity.LoginLog;
import com.platform.backend.repository.LoginLogRepository;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Slf4j
@Service
@RequiredArgsConstructor
public class LoginLogService {
private final LoginLogRepository loginLogRepository;
@Async
public void logSuccess(Long userId, String username, HttpServletRequest request) {
try {
LoginLog log = new LoginLog();
log.setUserId(userId);
log.setUsername(username);
log.setIp(getClientIp(request));
log.setDevice(request.getHeader("User-Agent"));
log.setStatus(1);
loginLogRepository.save(log);
} catch (Exception e) {
LoginLogService.log.warn("记录登录日志失败: {}", e.getMessage());
}
}
@Async
public void logFail(String username, String reason, HttpServletRequest request) {
try {
LoginLog logEntry = new LoginLog();
logEntry.setUsername(username);
logEntry.setIp(getClientIp(request));
logEntry.setDevice(request.getHeader("User-Agent"));
logEntry.setStatus(2);
logEntry.setFailReason(reason);
loginLogRepository.save(logEntry);
} catch (Exception e) {
LoginLogService.log.warn("记录登录失败日志失败: {}", e.getMessage());
}
}
private String getClientIp(HttpServletRequest request) {
String ip = request.getHeader("X-Forwarded-For");
if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
return ip;
}
}
package com.platform.backend.auth;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import java.util.Random;
import java.util.concurrent.TimeUnit;
@Slf4j
@Service
@RequiredArgsConstructor
public class SmsCodeService {
private final StringRedisTemplate redis;
@Value("${sms.send-interval:60}")
private int sendIntervalSeconds;
@Value("${sms.expire-minutes:5}")
private int expireMinutes;
private static final String SMS_KEY_PREFIX = "sms:";
private static final String IP_LIMIT_KEY_PREFIX = "sms:ip:";
private static final int MAX_IP_PER_HOUR = 10;
private final Random random = new Random();
/**
* 生成并存储验证码
* @return 生成的验证码(模拟发送,实际项目中应调用短信网关)
*/
public String generateCode(String phone, String type, String ip) {
String key = SMS_KEY_PREFIX + phone + ":" + type;
// 检查发送频率
String sendKey = key + ":send";
Long lastSend = redis.opsForValue().increment(sendKey);
if (lastSend != null && lastSend > 1) {
Long ttl = redis.getExpire(sendKey);
if (ttl != null && ttl > 0) {
throw new RuntimeException("请" + ttl + "秒后再试");
}
}
redis.expire(sendKey, sendIntervalSeconds, TimeUnit.SECONDS);
// 检查IP频率
String ipKey = IP_LIMIT_KEY_PREFIX + ip;
Long ipCount = redis.opsForValue().increment(ipKey);
if (ipCount != null && ipCount > MAX_IP_PER_HOUR) {
redis.expire(ipKey, 3600, TimeUnit.SECONDS);
throw new RuntimeException("请求过于频繁,请稍后再试");
}
if (ipCount != null && ipCount == 1) {
redis.expire(ipKey, 3600, TimeUnit.SECONDS);
}
// 生成6位验证码
String code = String.format("%06d", random.nextInt(1000000));
// 存储到Redis
redis.opsForValue().set(key, code, expireMinutes * 60L, TimeUnit.SECONDS);
log.info("[SMS] 生成验证码 phone={} type={} code={}", phone, type, code);
return code;
}
/**
* 验证验证码
* @return true 如果验证通过
*/
public boolean verifyCode(String phone, String type, String code) {
String key = SMS_KEY_PREFIX + phone + ":" + type;
String storedCode = redis.opsForValue().get(key);
if (storedCode == null) {
return false;
}
if (!storedCode.equals(code)) {
return false;
}
// 验证通过,删除验证码(一次性使用)
redis.delete(key);
return true;
}
}
package com.platform.backend.auth;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.MDC;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;
import java.util.UUID;
@Slf4j
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class TraceIdFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
throws ServletException, IOException {
String incoming = request.getHeader(AuthConstants.HEADER_TRACE_ID);
String traceId = (incoming != null && !incoming.isBlank())
? incoming
: UUID.randomUUID().toString().replace("-", "");
MDC.put(AuthConstants.MDC_TRACE_ID, traceId);
response.setHeader(AuthConstants.HEADER_TRACE_ID, traceId);
// 同时放到 request attribute,供 Controller 层使用(写入 ApiResponse)
request.setAttribute(AuthConstants.MDC_TRACE_ID, traceId);
try {
chain.doFilter(request, response);
} finally {
MDC.remove(AuthConstants.MDC_TRACE_ID);
}
}
}
package com.platform.backend.config;
import com.platform.backend.entity.Permission;
import com.platform.backend.entity.Role;
import com.platform.backend.entity.User;
import com.platform.backend.repository.PermissionRepository;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
import java.util.List;
@Slf4j
@Component
......@@ -14,21 +22,70 @@ import org.springframework.stereotype.Component;
public class DataInitializer implements CommandLineRunner {
private final UserRepository userRepository;
private final RoleRepository roleRepository;
private final PermissionRepository permissionRepository;
private final PasswordEncoder passwordEncoder;
@Override
@Transactional
public void run(String... args) {
// 创建预设角色
Role adminRole = ensureRole("管理员", "ROLE_ADMIN", "全系统配置、用户管理", 1);
ensureRole("主管", "ROLE_SUPERVISOR", "审核学员、内容终审", 1);
ensureRole("导师", "ROLE_MENTOR", "答辩评审、学员指导", 1);
ensureRole("学员", "ROLE_STUDENT", "参与实训、提交产物", 1);
// 创建基础权限
ensurePermission("project:read", "查看项目", "project");
ensurePermission("project:create", "创建项目", "project");
ensurePermission("project:update", "更新项目", "project");
ensurePermission("project:delete", "删除项目", "project");
ensurePermission("training:read", "查看实训", "training");
ensurePermission("training:submit", "提交实训", "training");
ensurePermission("training:review", "审核实训", "training");
ensurePermission("defense:review", "答辩评审", "defense");
ensurePermission("audit:review", "主管审核", "audit");
ensurePermission("user:read", "查看用户", "user");
ensurePermission("user:create", "创建用户", "user");
ensurePermission("user:update", "更新用户", "user");
ensurePermission("user:delete", "删除用户", "user");
ensurePermission("user:assign-role", "分配角色", "user");
// 创建管理员账号
if (!userRepository.existsByUsername("admin")) {
User admin = new User();
admin.setUsername("admin");
admin.setPassword(passwordEncoder.encode("admin123"));
admin.setRole("ADMIN");
admin.setRealName("管理员");
admin.setEmail("admin@example.com");
admin.setRoleId(adminRole.getId());
admin.setStatus(1);
admin.setIsDeleted(0);
userRepository.save(admin);
log.info("测试账号已创建: admin / admin123");
log.info("测试账号已创建: admin / admin123 (roleId={})", adminRole.getId());
} else {
log.info("admin 账号已存在,跳过初始化");
}
}
private Role ensureRole(String name, String code, String desc, int isPreset) {
return roleRepository.findByRoleCode(code).orElseGet(() -> {
Role r = new Role();
r.setRoleName(name);
r.setRoleCode(code);
r.setDescription(desc);
r.setIsPreset(isPreset);
return roleRepository.save(r);
});
}
private Permission ensurePermission(String code, String name, String module) {
return permissionRepository.findByPermissionCode(code).orElseGet(() -> {
Permission p = new Permission();
p.setPermissionCode(code);
p.setPermissionName(name);
p.setModule(module);
return permissionRepository.save(p);
});
}
}
\ No newline at end of file
package com.platform.backend.config;
import com.platform.backend.auth.JwtProperties;
import com.platform.backend.auth.TraceIdFilter;
import com.platform.backend.security.JwtAuthenticationFilter;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
......@@ -31,7 +33,9 @@ import java.util.List;
public class SecurityConfig {
private final JwtAuthenticationFilter jwtAuthFilter;
private final TraceIdFilter traceIdFilter;
private final UserDetailsService userDetailsService;
private final JwtProperties jwtProperties;
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
......@@ -40,10 +44,11 @@ public class SecurityConfig {
.cors(cors -> cors.configurationSource(corsConfigurationSource()))
.sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.authorizeHttpRequests(auth -> auth
.requestMatchers("/api/auth/**", "/api/health", "/actuator/**").permitAll()
.requestMatchers("/api/v1/auth/**", "/api/health", "/actuator/**").permitAll()
.anyRequest().authenticated()
)
.authenticationProvider(authenticationProvider())
.addFilterBefore(traceIdFilter, UsernamePasswordAuthenticationFilter.class)
.addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class);
return http.build();
......@@ -75,6 +80,6 @@ public class SecurityConfig {
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
return new BCryptPasswordEncoder(jwtProperties.getBcrypt().getStrength());
}
}
package com.platform.backend.controller;
import com.platform.backend.dto.LoginRequest;
import com.platform.backend.dto.LoginResponse;
import com.platform.backend.auth.AuthConstants;
import com.platform.backend.auth.JwtTokenService;
import com.platform.backend.auth.LoginAttemptService;
import com.platform.backend.auth.LoginLogService;
import com.platform.backend.auth.SmsCodeService;
import com.platform.backend.dto.*;
import com.platform.backend.entity.Role;
import com.platform.backend.entity.User;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository;
import com.platform.backend.security.JwtUtils;
import io.jsonwebtoken.Claims;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Collections;
import java.util.List;
@Slf4j
@RestController
@RequestMapping("/api/auth")
@RequestMapping("/api/v1/auth")
@RequiredArgsConstructor
public class AuthController {
private final AuthenticationManager authenticationManager;
private final JwtUtils jwtUtils;
private final JwtTokenService tokenService;
private final UserRepository userRepository;
private final RoleRepository roleRepository;
private final LoginAttemptService loginAttempt;
private final LoginLogService loginLogService;
private final SmsCodeService smsCodeService;
private final PasswordEncoder passwordEncoder;
private String tid(HttpServletRequest req) {
Object t = req.getAttribute(AuthConstants.MDC_TRACE_ID);
return t == null ? "" : t.toString();
}
private String resolveRoleCode(User user) {
Long roleId = user.getRoleId();
if (roleId == null) {
return "STUDENT";
}
return roleRepository.findById(roleId)
.map(Role::getRoleCode)
.map(code -> code.startsWith("ROLE_") ? code.substring(5) : code)
.orElse("STUDENT");
}
private List<String> resolveRoles(User user) {
return Collections.singletonList(resolveRoleCode(user));
}
private String getClientIp(HttpServletRequest request) {
String ip = request.getHeader("X-Forwarded-For");
if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
return ip;
}
@PostMapping("/sms-code")
public ApiResponse<Void> sendSmsCode(@Valid @RequestBody SmsCodeRequest request,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] POST /api/v1/auth/sms-code phone={}", request.getPhone());
try {
String ip = getClientIp(httpReq);
smsCodeService.generateCode(request.getPhone(), request.getType(), ip);
return ApiResponse.ok(null, "验证码已发送", traceId);
} catch (Exception e) {
return ApiResponse.fail(1001, e.getMessage(), traceId);
}
}
@PostMapping("/register")
public ApiResponse<LoginResponse> register(@Valid @RequestBody RegisterRequest request,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] POST /api/v1/auth/register username={}", request.getUsername());
// 1. 验证验证码
if (!smsCodeService.verifyCode(request.getPhone(), "register", request.getSmsCode())) {
return ApiResponse.fail(1001, "验证码错误或已过期", traceId);
}
// 2. 检查用户名唯一
if (userRepository.findByUsername(request.getUsername()).isPresent()) {
return ApiResponse.fail(2001, "用户名已存在", traceId);
}
// 3. 检查手机号唯一
if (userRepository.findByPhone(request.getPhone()).isPresent()) {
return ApiResponse.fail(2002, "该手机号已注册", traceId);
}
// 4. 查询学员角色
Role studentRole = roleRepository.findByRoleCode("ROLE_STUDENT")
.orElseThrow(() -> new RuntimeException("系统未配置学员角色"));
// 5. 创建用户
User user = new User();
user.setUsername(request.getUsername());
user.setPassword(passwordEncoder.encode(request.getPassword()));
user.setRealName(request.getRealName());
user.setPhone(request.getPhone());
user.setRoleId(studentRole.getId());
user.setStatus(1);
user.setIsDeleted(0);
user = userRepository.save(user);
// 6. 签发双Token
String access = tokenService.generateAccessToken(user.getUsername(), "STUDENT");
String refresh = tokenService.generateRefreshToken(user.getUsername(), "STUDENT");
LoginResponse.User userInfo = new LoginResponse.User(
user.getId(),
user.getUsername(),
user.getRealName(),
resolveRoles(user)
);
LoginResponse loginResponse = new LoginResponse(
access,
refresh,
"Bearer",
(int) (tokenService.getAccessExpirationMs() / 1000),
userInfo
);
return ApiResponse.ok(loginResponse, "注册成功", traceId);
}
@PostMapping("/login")
public ResponseEntity<?> login(@Valid @RequestBody LoginRequest request) {
public ApiResponse<LoginResponse> login(@Valid @RequestBody LoginRequest request,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
String username = request.getUsername();
log.info("[API] POST /api/v1/auth/login username={}", username);
// 0. 锁定检查
if (loginAttempt.isLocked(username)) {
loginLogService.logFail(username, "账户已锁定", httpReq);
return ApiResponse.fail(2004, "账户已锁定,请稍后再试", traceId);
}
try {
Authentication authentication = authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(request.getUsername(), request.getPassword())
// 1. 校验密码
authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(username, request.getPassword()));
} catch (BadCredentialsException e) {
loginAttempt.loginFailed(username);
int remaining = loginAttempt.getRemainingAttempts(username);
loginLogService.logFail(username, "密码错误", httpReq);
if (remaining <= 0) {
loginAttempt.lockAccount(username);
return ApiResponse.fail(2004, "连续失败次数过多,账户已锁定30分钟", traceId);
}
return ApiResponse.fail(2003, "账号或密码错误,剩余尝试次数: " + remaining, traceId);
} catch (Exception e) {
loginAttempt.loginFailed(username);
int remaining = loginAttempt.getRemainingAttempts(username);
loginLogService.logFail(username, e.getMessage(), httpReq);
if (remaining <= 0) {
loginAttempt.lockAccount(username);
return ApiResponse.fail(2004, "连续失败次数过多,账户已锁定30分钟", traceId);
}
return ApiResponse.fail(2003, "账号或密码错误,剩余尝试次数: " + remaining, traceId);
}
// 2. 登录成功 - 清理失败计数
loginAttempt.loginSucceeded(username);
// 3. 查询用户
User user = userRepository.findByUsername(username)
.orElseThrow(() -> new UsernameNotFoundException("用户不存在"));
if (Boolean.FALSE.equals(user.getEnabled())) {
loginLogService.logFail(username, "账户已禁用", httpReq);
return ApiResponse.fail(2002, "账户已被禁用", traceId);
}
// 4. 签发双 Token
String role = resolveRoleCode(user);
String access = tokenService.generateAccessToken(username, role);
String refresh = tokenService.generateRefreshToken(username, role);
// 5. 记录登录日志
loginLogService.logSuccess(user.getId(), username, httpReq);
// 6. 返回
LoginResponse.User userInfo = new LoginResponse.User(
user.getId(),
user.getUsername(),
user.getRealName(),
resolveRoles(user)
);
LoginResponse loginResponse = new LoginResponse(
access,
refresh,
"Bearer",
(int) (tokenService.getAccessExpirationMs() / 1000),
userInfo
);
return ApiResponse.ok(loginResponse, "登录成功", traceId);
}
/**
* 手机号 + 验证码登录
*/
@PostMapping("/login/phone")
public ApiResponse<LoginResponse> loginByPhone(@Valid @RequestBody PhoneLoginRequest request,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
String phone = request.getPhone();
log.info("[API] POST /api/v1/auth/login/phone phone={}", phone);
User user = userRepository.findByUsername(request.getUsername())
.orElseThrow(() -> new RuntimeException("用户不存在"));
// 1. 验证验证码
if (!smsCodeService.verifyCode(phone, "login", request.getSmsCode())) {
loginLogService.logFail(phone, "验证码错误", httpReq);
return ApiResponse.fail(1001, "验证码错误或已过期", traceId);
}
// 2. 根据手机号查询用户
User user = userRepository.findByPhone(phone)
.orElseThrow(() -> new UsernameNotFoundException("该手机号未注册"));
// 3. 检查账户状态
if (Boolean.FALSE.equals(user.getEnabled())) {
loginLogService.logFail(phone, "账户已禁用", httpReq);
return ApiResponse.fail(2002, "账户已被禁用", traceId);
}
// 4. 签发双 Token
String role = resolveRoleCode(user);
String access = tokenService.generateAccessToken(user.getUsername(), role);
String refresh = tokenService.generateRefreshToken(user.getUsername(), role);
String token = jwtUtils.generateToken(user.getUsername(), user.getRole());
// 5. 记录登录日志
loginLogService.logSuccess(user.getId(), user.getUsername(), httpReq);
return ResponseEntity.ok(new LoginResponse(
token,
// 6. 返回
LoginResponse.User userInfo = new LoginResponse.User(
user.getId(),
user.getUsername(),
user.getRole(),
jwtUtils.getExpiration() / 1000
));
user.getRealName(),
resolveRoles(user)
);
LoginResponse loginResponse = new LoginResponse(
access,
refresh,
"Bearer",
(int) (tokenService.getAccessExpirationMs() / 1000),
userInfo
);
return ApiResponse.ok(loginResponse, "登录成功", traceId);
}
@PostMapping("/refresh")
public ApiResponse<RefreshTokenResponse> refresh(@Valid @RequestBody RefreshRequest body,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] POST /api/v1/auth/refresh");
try {
Claims claims = tokenService.validateAndConsumeRefreshToken(body.getRefreshToken());
String username = claims.getSubject();
String role = String.valueOf(claims.get("role"));
// 只返回新的 accessToken
String newAccess = tokenService.generateAccessToken(username, role);
RefreshTokenResponse resp = new RefreshTokenResponse(
newAccess,
tokenService.getAccessExpirationMs() / 1000
);
return ApiResponse.ok(resp, "刷新成功", traceId);
} catch (Exception e) {
Map<String, String> error = new HashMap<>();
error.put("message", "用户名或密码错误");
return ResponseEntity.status(401).body(error);
log.warn("[API] refresh failed: {}", e.getMessage());
return ApiResponse.fail(2005, "Refresh token 已使用或已过期", traceId);
}
}
@PostMapping("/logout")
public ApiResponse<Void> logout(@Valid @RequestBody LogoutRequest body,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] POST /api/v1/auth/logout");
tokenService.logout(body.getRefreshToken());
SecurityContextHolder.clearContext();
return ApiResponse.ok(null, "注销成功", traceId);
}
@GetMapping("/me")
public ResponseEntity<?> getCurrentUser(Authentication authentication) {
if (authentication == null) {
return ResponseEntity.status(401).body(Map.of("message", "未登录"));
}
User user = userRepository.findByUsername(authentication.getName())
.orElseThrow(() -> new RuntimeException("用户不存在"));
return ResponseEntity.ok(Map.of(
"username", user.getUsername(),
"role", user.getRole(),
"realName", user.getRealName() != null ? user.getRealName() : ""
));
public ApiResponse<LoginResponse.User> me(HttpServletRequest httpReq) {
String traceId = tid(httpReq);
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
log.info("[API] GET /api/v1/auth/me username={}", auth != null ? auth.getName() : "anonymous");
if (auth == null || auth.getName() == null) {
return ApiResponse.fail(1002, "未登录", traceId);
}
User u = userRepository.findByUsername(auth.getName())
.orElseThrow(() -> new UsernameNotFoundException("用户不存在"));
return ApiResponse.ok(new LoginResponse.User(
u.getId(), u.getUsername(), u.getRealName(),
Collections.singletonList(resolveRoleCode(u))), traceId);
}
}
package com.platform.backend.controller;
import com.platform.backend.auth.AuthConstants;
import com.platform.backend.dto.ApiResponse;
import com.platform.backend.entity.Permission;
import com.platform.backend.entity.Role;
import com.platform.backend.entity.RolePermission;
import com.platform.backend.entity.UserRole;
import com.platform.backend.repository.PermissionRepository;
import com.platform.backend.repository.RolePermissionRepository;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRoleRepository;
import jakarta.servlet.http.HttpServletRequest;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Slf4j
@RestController
@RequestMapping("/api/v1/roles")
@RequiredArgsConstructor
public class RoleController {
private final RoleRepository roleRepository;
private final RolePermissionRepository rolePermissionRepository;
private final PermissionRepository permissionRepository;
private final UserRoleRepository userRoleRepository;
private String tid(HttpServletRequest req) {
Object t = req.getAttribute(AuthConstants.MDC_TRACE_ID);
return t == null ? "" : t.toString();
}
private boolean isAdmin() {
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
return auth.getAuthorities().stream()
.anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"));
}
/**
* 获取角色列表
*/
@GetMapping
public ApiResponse<?> listRoles(HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] GET /api/v1/roles");
List<Role> roles = roleRepository.findAll();
var items = roles.stream().map(r -> {
var map = new HashMap<String, Object>();
map.put("id", r.getId());
map.put("roleName", r.getRoleName());
map.put("roleCode", r.getRoleCode());
map.put("description", r.getDescription());
map.put("isPreset", r.getIsPreset() == 1);
map.put("userCount", userRoleRepository.countByRoleId(r.getId()));
return map;
}).toList();
return ApiResponse.ok(items, traceId);
}
/**
* 获取角色详情(含权限列表)
*/
@GetMapping("/{id}")
public ApiResponse<?> getRoleById(@PathVariable Long id, HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] GET /api/v1/roles/{}", id);
Role role = roleRepository.findById(id).orElse(null);
if (role == null) {
return ApiResponse.fail(1001, "角色不存在", traceId);
}
var map = new HashMap<String, Object>();
map.put("id", role.getId());
map.put("roleName", role.getRoleName());
map.put("roleCode", role.getRoleCode());
map.put("description", role.getDescription());
map.put("isPreset", role.getIsPreset() == 1);
// 获取权限列表
List<RolePermission> rolePerms = rolePermissionRepository.findByRoleId(id);
List<Long> permIds = rolePerms.stream().map(RolePermission::getPermissionId).toList();
List<Permission> perms = permissionRepository.findAllById(permIds);
var permissions = perms.stream().map(p -> {
var pm = new HashMap<String, Object>();
pm.put("id", p.getId());
pm.put("permissionCode", p.getPermissionCode());
pm.put("permissionName", p.getPermissionName());
return pm;
}).toList();
map.put("permissions", permissions);
return ApiResponse.ok(map, traceId);
}
/**
* 创建角色
*/
@PostMapping
public ApiResponse<?> createRole(@RequestBody CreateRoleRequest request, HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] POST /api/v1/roles roleName={}", request.getRoleName());
if (!isAdmin()) {
return ApiResponse.fail(1003, "无权限", traceId);
}
// 检查角色名唯一
if (roleRepository.findByRoleCode(request.getRoleCode()).isPresent()) {
return ApiResponse.fail(1001, "角色编码已存在", traceId);
}
Role role = new Role();
role.setRoleName(request.getRoleName());
role.setRoleCode(request.getRoleCode());
role.setDescription(request.getDescription());
role.setIsPreset(0);
role = roleRepository.save(role);
// 保存权限关联
if (request.getPermissionIds() != null) {
for (Long permId : request.getPermissionIds()) {
RolePermission rp = new RolePermission();
rp.setRoleId(role.getId());
rp.setPermissionId(permId);
rolePermissionRepository.save(rp);
}
}
var result = new HashMap<String, Object>();
result.put("id", role.getId());
result.put("roleName", role.getRoleName());
result.put("roleCode", role.getRoleCode());
return ApiResponse.ok(result, "创建成功", traceId);
}
/**
* 更新角色
*/
@PutMapping("/{id}")
public ApiResponse<?> updateRole(@PathVariable Long id,
@RequestBody UpdateRoleRequest request,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] PUT /api/v1/roles/{}", id);
if (!isAdmin()) {
return ApiResponse.fail(1003, "无权限", traceId);
}
Role role = roleRepository.findById(id).orElse(null);
if (role == null) {
return ApiResponse.fail(1001, "角色不存在", traceId);
}
// 预置角色不可修改
if (role.getIsPreset() == 1) {
return ApiResponse.fail(1001, "预置角色不可修改", traceId);
}
if (request.getRoleName() != null) {
role.setRoleName(request.getRoleName());
}
if (request.getDescription() != null) {
role.setDescription(request.getDescription());
}
roleRepository.save(role);
// 更新权限关联
if (request.getPermissionIds() != null) {
rolePermissionRepository.deleteByRoleId(id);
for (Long permId : request.getPermissionIds()) {
RolePermission rp = new RolePermission();
rp.setRoleId(id);
rp.setPermissionId(permId);
rolePermissionRepository.save(rp);
}
}
return ApiResponse.ok(null, "更新成功", traceId);
}
/**
* 删除角色
*/
@DeleteMapping("/{id}")
public ApiResponse<?> deleteRole(@PathVariable Long id, HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] DELETE /api/v1/roles/{}", id);
if (!isAdmin()) {
return ApiResponse.fail(1003, "无权限", traceId);
}
Role role = roleRepository.findById(id).orElse(null);
if (role == null) {
return ApiResponse.fail(1001, "角色不存在", traceId);
}
// 预置角色不可删除
if (role.getIsPreset() == 1) {
return ApiResponse.fail(1001, "预置角色不可删除", traceId);
}
// 检查是否有用户关联
if (userRoleRepository.countByRoleId(id) > 0) {
return ApiResponse.fail(1001, "该角色下有用户,无法删除", traceId);
}
rolePermissionRepository.deleteByRoleId(id);
roleRepository.delete(role);
return ApiResponse.ok(null, "删除成功", traceId);
}
/**
* 获取权限列表
*/
@GetMapping("/permissions")
public ApiResponse<?> listPermissions(HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] GET /api/v1/roles/permissions");
List<Permission> permissions = permissionRepository.findAll();
var items = permissions.stream().map(p -> {
var map = new HashMap<String, Object>();
map.put("id", p.getId());
map.put("permissionCode", p.getPermissionCode());
map.put("permissionName", p.getPermissionName());
map.put("module", p.getModule());
map.put("description", p.getDescription());
return map;
}).toList();
return ApiResponse.ok(items, traceId);
}
@Data
public static class CreateRoleRequest {
private String roleName;
private String roleCode;
private String description;
private List<Long> permissionIds;
}
@Data
public static class UpdateRoleRequest {
private String roleName;
private String description;
private List<Long> permissionIds;
}
}
package com.platform.backend.controller;
import com.platform.backend.auth.AuthConstants;
import com.platform.backend.dto.ApiResponse;
import com.platform.backend.entity.User;
import com.platform.backend.repository.UserRepository;
import jakarta.servlet.http.HttpServletRequest;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;
import java.util.Collections;
import java.util.List;
@Slf4j
@RestController
@RequestMapping("/api/v1/users")
@RequiredArgsConstructor
public class UserController {
private final UserRepository userRepository;
private final PasswordEncoder passwordEncoder;
@Data
public static class CreateUserRequest {
private String username;
private String password;
private String realName;
private String email;
private String phone;
private Long roleId;
}
private String tid(HttpServletRequest req) {
Object t = req.getAttribute(AuthConstants.MDC_TRACE_ID);
return t == null ? "" : t.toString();
}
/**
* 获取当前用户完整信息
*/
@GetMapping("/me")
public ApiResponse<?> getCurrentUser(HttpServletRequest httpReq) {
String traceId = tid(httpReq);
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
log.info("[API] GET /api/v1/users/me username={}", auth != null ? auth.getName() : "anonymous");
if (auth == null || auth.getName() == null) {
return ApiResponse.fail(1002, "未登录", traceId);
}
User user = userRepository.findByUsernameAndIsDeleted(auth.getName(), 0)
.orElse(null);
if (user == null) {
return ApiResponse.fail(2001, "用户不存在", traceId);
}
return ApiResponse.ok(buildUserDetail(user), traceId);
}
/**
* 创建用户(管理员功能)
*/
@PostMapping
public ApiResponse<?> createUser(@RequestBody CreateUserRequest request, HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] POST /api/v1/users username={}", request.getUsername());
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
// 只有ADMIN可以创建用户
boolean isAdmin = auth.getAuthorities().stream()
.anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"));
if (!isAdmin) {
return ApiResponse.fail(1003, "无权限", traceId);
}
// 检查用户名是否已存在
if (userRepository.existsByUsername(request.getUsername())) {
return ApiResponse.fail(2002, "用户名已存在", traceId);
}
User user = new User();
user.setUsername(request.getUsername());
user.setPassword(passwordEncoder.encode(request.getPassword()));
user.setRealName(request.getRealName());
user.setEmail(request.getEmail());
user.setPhone(request.getPhone());
user.setRoleId(request.getRoleId());
user.setStatus(1);
user.setIsDeleted(0);
userRepository.save(user);
return ApiResponse.ok(buildUserDetail(user), "创建成功", traceId);
}
/**
* 获取用户详情
*/
@GetMapping("/{id}")
public ApiResponse<?> getUserById(@PathVariable Long id, HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] GET /api/v1/users/{}", id);
User user = userRepository.findById(id).orElse(null);
if (user == null || user.getIsDeleted() == 1) {
return ApiResponse.fail(2001, "用户不存在", traceId);
}
return ApiResponse.ok(buildUserDetail(user), traceId);
}
/**
* 更新用户信息
*/
@PutMapping("/{id}")
public ApiResponse<?> updateUser(@PathVariable Long id,
@RequestBody UpdateUserRequest request,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] PUT /api/v1/users/{}", id);
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
User user = userRepository.findById(id).orElse(null);
if (user == null || user.getIsDeleted() == 1) {
return ApiResponse.fail(2001, "用户不存在", traceId);
}
// 权限检查:本人或ADMIN可更新
boolean isAdmin = auth.getAuthorities().stream()
.anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"));
if (!auth.getName().equals(user.getUsername()) && !isAdmin) {
return ApiResponse.fail(1003, "无权限", traceId);
}
// 更新字段
if (request.getRealName() != null) {
user.setRealName(request.getRealName());
}
if (request.getAvatar() != null) {
user.setAvatarUrl(request.getAvatar());
}
if (request.getEmail() != null) {
user.setEmail(request.getEmail());
}
userRepository.save(user);
return ApiResponse.ok(buildUserDetail(user), "更新成功", traceId);
}
/**
* 删除用户(软删除)
*/
@DeleteMapping("/{id}")
public ApiResponse<?> deleteUser(@PathVariable Long id, HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] DELETE /api/v1/users/{}", id);
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
// 只有ADMIN可以删除用户
boolean isAdmin = auth.getAuthorities().stream()
.anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"));
if (!isAdmin) {
return ApiResponse.fail(1003, "无权限", traceId);
}
User user = userRepository.findById(id).orElse(null);
if (user == null || user.getIsDeleted() == 1) {
return ApiResponse.fail(2001, "用户不存在", traceId);
}
user.setIsDeleted(1);
userRepository.save(user);
return ApiResponse.ok(null, "删除成功", traceId);
}
/**
* 用户列表(分页)
*/
@GetMapping
public ApiResponse<?> listUsers(
@RequestParam(defaultValue = "1") int page,
@RequestParam(defaultValue = "10") int size,
@RequestParam(required = false) String keyword,
@RequestParam(required = false) Long roleId,
@RequestParam(required = false) Integer status,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] GET /api/v1/users page={} size={} keyword={}", page, size, keyword);
List<User> allUsers = userRepository.findByIsDeleted(0);
// 过滤
List<User> filtered = allUsers.stream()
.filter(u -> {
if (keyword != null && !keyword.isEmpty()) {
if (!u.getUsername().contains(keyword)
&& !u.getRealName().contains(keyword)
&& (u.getPhone() == null || !u.getPhone().contains(keyword))) {
return false;
}
}
if (status != null && !u.getStatus().equals(status)) {
return false;
}
return true;
})
.toList();
// 分页
int start = (page - 1) * size;
int end = Math.min(start + size, filtered.size());
List<User> paged = start < filtered.size() ? filtered.subList(start, end) : Collections.emptyList();
var items = paged.stream().map(this::buildUserDetail).toList();
var result = new java.util.HashMap<String, Object>();
result.put("total", filtered.size());
result.put("page", page);
result.put("size", size);
result.put("items", items);
return ApiResponse.ok(result, traceId);
}
private Object buildUserDetail(User user) {
var map = new java.util.HashMap<String, Object>();
map.put("id", user.getId());
map.put("username", user.getUsername());
map.put("realName", user.getRealName());
map.put("email", maskEmail(user.getEmail()));
map.put("phone", maskPhone(user.getPhone()));
map.put("avatar", user.getAvatarUrl());
map.put("roles", Collections.singletonList(user.getRoleId() != null ? "USER" : "STUDENT"));
map.put("createdAt", user.getCreatedAt());
return map;
}
private String maskEmail(String email) {
if (email == null || !email.contains("@")) return email;
int at = email.indexOf("@");
if (at <= 1) return email;
return email.substring(0, 1) + "***" + email.substring(at);
}
private String maskPhone(String phone) {
if (phone == null || phone.length() < 11) return phone;
return phone.substring(0, 3) + "****" + phone.substring(7);
}
@Data
public static class UpdateUserRequest {
private String realName;
private String avatar;
private String email;
}
}
package com.platform.backend.dto;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.UUID;
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ApiResponse<T> {
private int code;
private String message;
private String traceId;
private T data;
public static <T> ApiResponse<T> ok(T data) {
return new ApiResponse<>(0, "操作成功", UUID.randomUUID().toString(), data);
}
public static <T> ApiResponse<T> ok(T data, String traceId) {
return new ApiResponse<>(0, "操作成功", traceId, data);
}
public static <T> ApiResponse<T> ok(T data, String message, String traceId) {
return new ApiResponse<>(0, message, traceId, data);
}
public static <T> ApiResponse<T> fail(int code, String message) {
return new ApiResponse<>(code, message, UUID.randomUUID().toString(), null);
}
public static <T> ApiResponse<T> fail(int code, String message, String traceId) {
return new ApiResponse<>(code, message, traceId, null);
}
}
package com.platform.backend.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
......
package com.platform.backend.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginResponse {
private String token;
@JsonProperty("accessToken")
private String accessToken;
@JsonProperty("refreshToken")
private String refreshToken;
@JsonProperty("tokenType")
private String tokenType;
@JsonProperty("expiresIn")
private int expiresIn;
private User user;
@Data
@NoArgsConstructor
@AllArgsConstructor
public static class User {
private Long id;
private String username;
private String role;
private Long expiresIn;
@JsonProperty("realName")
private String realName;
private List<String> roles;
}
}
package com.platform.backend.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
@Data
public class LogoutRequest {
@NotBlank(message = "refreshToken不能为空")
@JsonProperty("refreshToken")
private String refreshToken;
}
package com.platform.backend.dto;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
@Data
public class PhoneLoginRequest {
@NotBlank(message = "手机号不能为空")
private String phone;
@NotBlank(message = "验证码不能为空")
private String smsCode;
}
package com.platform.backend.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
@Data
public class RefreshRequest {
@NotBlank(message = "refreshToken不能为空")
@JsonProperty("refreshToken")
private String refreshToken;
}
package com.platform.backend.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class RefreshTokenResponse {
@JsonProperty("accessToken")
private String accessToken;
@JsonProperty("expiresIn")
private long expiresIn;
}
package com.platform.backend.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.Data;
@Data
public class RegisterRequest {
@NotBlank(message = "用户名不能为空")
private String username;
@NotBlank(message = "手机号不能为空")
@Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
private String phone;
@NotBlank(message = "密码不能为空")
@Pattern(regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)[a-zA-Z\\d]{8,}$",
message = "密码至少8位,包含大小写字母和数字")
private String password;
@NotBlank(message = "真实姓名不能为空")
@JsonProperty("realName")
private String realName;
@NotBlank(message = "验证码不能为空")
@JsonProperty("smsCode")
private String smsCode;
}
package com.platform.backend.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
@Data
public class SmsCodeRequest {
@NotBlank(message = "手机号不能为空")
private String phone;
@NotBlank(message = "类型不能为空")
private String type;
}
package com.platform.backend.entity;
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
@Entity
@Table(name = "user_login_log", indexes = {
@Index(name = "idx_user_id", columnList = "user_id"),
@Index(name = "idx_created_at", columnList = "created_at")
})
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginLog {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "user_id")
private Long userId;
@Column(name = "username", nullable = false, length = 50)
private String username;
@Column(length = 50)
private String ip;
@Column(length = 500)
private String device;
@Column(length = 100)
private String location;
@Column(nullable = false)
private Integer status;
@Column(name = "fail_reason", length = 100)
private String failReason;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@PrePersist
protected void onCreate() {
this.createdAt = LocalDateTime.now();
}
}
package com.platform.backend.entity;
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
@Entity
@Table(name = "user_permission")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Permission {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "permission_code", unique = true, nullable = false, length = 50)
private String permissionCode;
@Column(name = "permission_name", nullable = false, length = 100)
private String permissionName;
@Column(length = 50)
private String module;
@Column(length = 200)
private String description;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@PrePersist
protected void onCreate() {
this.createdAt = LocalDateTime.now();
}
}
package com.platform.backend.entity;
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
@Entity
@Table(name = "user_role")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Role {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "role_name", nullable = false, length = 50)
private String roleName;
@Column(name = "role_code", nullable = false, unique = true, length = 50)
private String roleCode;
@Column(length = 200)
private String description;
@Column(name = "is_preset", nullable = false)
private Integer isPreset = 0;
@Column(name = "updated_at")
private LocalDateTime updatedAt;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@PrePersist
protected void onCreate() {
this.createdAt = LocalDateTime.now();
}
@PreUpdate
protected void onUpdate() {
this.updatedAt = LocalDateTime.now();
}
}
\ No newline at end of file
package com.platform.backend.entity;
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
@Entity
@Table(name = "user_role_permission",
uniqueConstraints = @UniqueConstraint(columnNames = {"role_id", "permission_id"}))
@Data
@NoArgsConstructor
@AllArgsConstructor
public class RolePermission {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "role_id", nullable = false)
private Long roleId;
@Column(name = "permission_id", nullable = false)
private Long permissionId;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@PrePersist
protected void onCreate() {
this.createdAt = LocalDateTime.now();
}
}
package com.platform.backend.entity;
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
@Entity
@Table(name = "user_sms_code", indexes = {
@Index(name = "idx_phone_type", columnList = "phone, type")
})
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SmsCode {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, length = 20)
private String phone;
@Column(nullable = false, length = 10)
private String code;
@Column(nullable = false, length = 20)
private String type;
@Column(name = "ip", nullable = false, length = 50)
private String ip;
@Column(name = "expire_time", nullable = false)
private LocalDateTime expireTime;
@Column(name = "is_used", nullable = false)
private Integer isUsed = 0;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@PrePersist
protected void onCreate() {
this.createdAt = LocalDateTime.now();
}
}
......@@ -8,7 +8,13 @@ import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
@Entity
@Table(name = "sys_user")
@Table(
name = "user_user",
indexes = {
@Index(name = "idx_role_id", columnList = "role_id"),
@Index(name = "idx_department_id", columnList = "department_id")
}
)
@Data
@NoArgsConstructor
@AllArgsConstructor
......@@ -21,29 +27,66 @@ public class User {
@Column(unique = true, nullable = false, length = 50)
private String username;
@Column(nullable = false)
@Column(nullable = false, length = 255)
private String password;
@Column(name = "real_name", nullable = false, length = 50)
private String realName;
@Column(length = 100)
private String email;
@Column(length = 20)
private String phone;
@Column(length = 50)
private String realName;
@Column(name = "role_id")
private Long roleId;
@Column(length = 20)
private String role = "USER";
@Column(name = "department_id")
private Long departmentId;
@Column(name = "avatar_url", length = 500)
private String avatarUrl;
private Boolean enabled = true;
@Column(nullable = false)
private Integer status = 1;
private LocalDateTime createTime = LocalDateTime.now();
@Column(name = "is_deleted", nullable = false)
private Integer isDeleted = 0;
private LocalDateTime updateTime = LocalDateTime.now();
@Column(name = "updated_at")
private LocalDateTime updatedAt;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@PrePersist
protected void onCreate() {
this.createdAt = LocalDateTime.now();
}
@PreUpdate
protected void onUpdate() {
this.updateTime = LocalDateTime.now();
this.updatedAt = LocalDateTime.now();
}
/** 兼容旧代码:true 表示启用 */
public Boolean getEnabled() {
return status != null && status == 1;
}
/** 兼容旧代码:设置 enabled = true/false 自动转 status = 1/0 */
public void setEnabled(Boolean enabled) {
this.status = (enabled != null && enabled) ? 1 : 0;
}
/** 兼容旧代码:单角色字符串读取 */
public String getRole() {
return roleId == null ? "USER" : String.valueOf(roleId);
}
public void setRole(String role) {
// 兼容旧的 setRole("ADMIN") 入参,仅打印警告,不做实际入库
// 真实角色关联请通过 roleId 字段
}
}
\ No newline at end of file
package com.platform.backend.entity;
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
@Entity
@Table(name = "user_user_role",
uniqueConstraints = @UniqueConstraint(columnNames = {"user_id", "role_id"}))
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserRole {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "user_id", nullable = false)
private Long userId;
@Column(name = "role_id", nullable = false)
private Long roleId;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@PrePersist
protected void onCreate() {
this.createdAt = LocalDateTime.now();
}
}
package com.platform.backend.project.service;
import com.platform.backend.entity.Role;
import com.platform.backend.entity.User;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class ProjectPermissionService {
private final UserRepository userRepository;
private final RoleRepository roleRepository;
public User currentUser(Authentication authentication) {
if (authentication == null || authentication.getName() == null) {
throw new ProjectBusinessException("未登录");
}
return userRepository.findByUsername(authentication.getName())
.orElseThrow(() -> new ProjectBusinessException("当前用户不存在"));
}
/**
* 按角色编码鉴权:传入形如 "ADMIN"/"USER" 的角色名(不带 ROLE_ 前缀)。
* 内部通过 user.roleId -> user_role.role_code 解析后比对。
*/
public void requireRole(Authentication authentication, String... roles) {
User user = currentUser(authentication);
if (hasRole(user, roles)) {
return;
}
throw new ProjectBusinessException("无权限操作");
}
/**
* 项目模块内部统一走 role_code 判断,避免直接依赖 User.getRole() 的旧兼容字段。
*/
public boolean hasRole(User user, String... roles) {
String userRoleCode = resolveRoleCode(user);
for (String role : roles) {
String normalized = role.toUpperCase();
if (normalized.equals(userRoleCode)
|| normalized.equals("ROLE_" + userRoleCode)) {
return true;
}
}
return false;
}
private String resolveRoleCode(User user) {
Long roleId = user.getRoleId();
if (roleId == null) {
return "USER";
}
return roleRepository.findById(roleId)
.map(Role::getRoleCode)
.map(code -> code.startsWith("ROLE_") ? code.substring(5) : code)
.orElse("USER");
}
}
package com.platform.backend.repository;
import com.platform.backend.entity.LoginLog;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface LoginLogRepository extends JpaRepository<LoginLog, Long> {
List<LoginLog> findByUserIdOrderByCreatedAtDesc(Long userId);
}
package com.platform.backend.repository;
import com.platform.backend.entity.Permission;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
@Repository
public interface PermissionRepository extends JpaRepository<Permission, Long> {
Optional<Permission> findByPermissionCode(String permissionCode);
List<Permission> findByModule(String module);
}
package com.platform.backend.repository;
import com.platform.backend.entity.RolePermission;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface RolePermissionRepository extends JpaRepository<RolePermission, Long> {
List<RolePermission> findByRoleId(Long roleId);
void deleteByRoleId(Long roleId);
long countByRoleId(Long roleId);
}
package com.platform.backend.repository;
import com.platform.backend.entity.Role;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;
@Repository
public interface RoleRepository extends JpaRepository<Role, Long> {
Optional<Role> findByRoleCode(String roleCode);
}
\ No newline at end of file
package com.platform.backend.repository;
import com.platform.backend.entity.SmsCode;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.time.LocalDateTime;
import java.util.Optional;
@Repository
public interface SmsCodeRepository extends JpaRepository<SmsCode, Long> {
Optional<SmsCode> findTopByPhoneAndTypeOrderByCreatedAtDesc(String phone, String type);
@Modifying
@Query("UPDATE SmsCode s SET s.isUsed = 1 WHERE s.phone = :phone AND s.type = :type AND s.isUsed = 0")
int markAsUsed(@Param("phone") String phone, @Param("type") String type);
@Modifying
@Query("DELETE FROM SmsCode s WHERE s.expireTime < :now OR s.isUsed = 1")
int deleteExpiredOrUsed(@Param("now") LocalDateTime now);
}
......@@ -4,10 +4,16 @@ import com.platform.backend.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
Optional<User> findByUsername(String username);
Optional<User> findByUsernameAndIsDeleted(String username, Integer isDeleted);
Optional<User> findByPhone(String phone);
boolean existsByUsername(String username);
// 分页查询
List<User> findByIsDeleted(Integer isDeleted);
}
package com.platform.backend.repository;
import com.platform.backend.entity.UserRole;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface UserRoleRepository extends JpaRepository<UserRole, Long> {
List<UserRole> findByUserId(Long userId);
void deleteByUserId(Long userId);
long countByRoleId(Long roleId);
}
package com.platform.backend.security;
import com.platform.backend.entity.Role;
import com.platform.backend.entity.User;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
......@@ -11,23 +14,46 @@ import org.springframework.stereotype.Service;
import java.util.Collections;
@Slf4j
@Service
@RequiredArgsConstructor
public class CustomUserDetailsService implements UserDetailsService {
private final UserRepository userRepository;
private final RoleRepository roleRepository;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
User user = userRepository.findByUsername(username)
.orElseThrow(() -> new UsernameNotFoundException("用户不存在: " + username));
String authority = resolveAuthority(user);
return new org.springframework.security.core.userdetails.User(
user.getUsername(),
user.getPassword(),
user.getEnabled(),
true, true, true,
Collections.singletonList(new SimpleGrantedAuthority("ROLE_" + user.getRole()))
Collections.singletonList(new SimpleGrantedAuthority(authority))
);
}
/**
* 通过 roleId 在 user_role 字典表里查 role_code,拼装成 Spring Security 的 authority。
* 默认 fallback 为 ROLE_USER。
*/
private String resolveAuthority(User user) {
Long roleId = user.getRoleId();
if (roleId == null) {
log.warn("用户 {} 未关联 roleId,使用默认 ROLE_USER", user.getUsername());
return "ROLE_USER";
}
return roleRepository.findById(roleId)
.map(Role::getRoleCode)
.map(code -> code.startsWith("ROLE_") ? code : "ROLE_" + code)
.orElseGet(() -> {
log.warn("用户 {} 关联的 roleId={} 在 user_role 表中不存在", user.getUsername(), roleId);
return "ROLE_USER";
});
}
}
\ No newline at end of file
package com.platform.backend.security;
import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import com.platform.backend.auth.JwtTokenService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Date;
@Component
@RequiredArgsConstructor
public class JwtUtils {
@Value("${jwt.secret:intern-platform-super-secret-key-2024}")
private String jwtSecret;
private final JwtTokenService tokenService;
@Value("${jwt.expiration:86400000}")
private long jwtExpiration;
public String generateToken(String username, String role) {
return tokenService.generateAccessToken(username, role);
}
private SecretKey getSigningKey() {
return Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8));
public String generateAccessToken(String username, String role) {
return tokenService.generateAccessToken(username, role);
}
public String generateToken(String username, String role) {
return Jwts.builder()
.subject(username)
.claim("role", role)
.issuedAt(new Date())
.expiration(new Date(System.currentTimeMillis() + jwtExpiration))
.signWith(getSigningKey())
.compact();
public String generateRefreshToken(String username, String role) {
return tokenService.generateRefreshToken(username, role);
}
public String getUsernameFromToken(String token) {
return Jwts.parser()
.verifyWith(getSigningKey())
.build()
.parseSignedClaims(token)
.getPayload()
.getSubject();
return tokenService.getUsernameFromToken(token);
}
public boolean validateToken(String token) {
try {
Jwts.parser().verifyWith(getSigningKey()).build().parseSignedClaims(token);
return true;
} catch (JwtException | IllegalArgumentException e) {
return false;
public String getRoleFromToken(String token) {
return tokenService.getRoleFromToken(token);
}
public String getJtiFromToken(String token) {
return tokenService.getJtiFromToken(token);
}
public long getExpiration() {
return jwtExpiration;
return tokenService.getAccessExpirationMs();
}
public boolean validateToken(String token) {
return tokenService.validateAccessToken(token);
}
public boolean validateRefreshToken(String token) {
return tokenService.validateRefreshToken(token);
}
}
......@@ -7,35 +7,97 @@ spring:
name: backend-app
datasource:
url: jdbc:mysql://localhost:13306/studyweb?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
url: jdbc:mysql://localhost:5688/studyweb?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
username: studyweb
password: studyweb123
driver-class-name: com.mysql.cj.jdbc.Driver
hikari:
connection-timeout: 5000
initialization-fail-timeout: 60000
jpa:
hibernate:
ddl-auto: update
show-sql: true
show-sql: false
properties:
hibernate:
dialect: org.hibernate.dialect.MySQLDialect
format_sql: true
format_sql: false
data:
redis:
host: localhost
port: 6379
password: ""
port: 16379
password: studyweb123
timeout: 3000ms
lettuce:
pool:
max-active: 16
max-idle: 8
min-idle: 2
logging:
level:
root: INFO
com.platform.backend: DEBUG
org.springframework.web: INFO
org.springframework.security: INFO
# 只显示接口日志和错误
root: WARN
com.platform.backend: INFO
org.springframework.web: WARN
org.springframework.security: WARN
org.hibernate: OFF
org.hibernate.SQL: OFF
org.hibernate.orm.jdbc.bind: OFF
org.springframework.data: WARN
io.lettuce: ERROR
com.zaxxer.hikari: WARN
# 关闭 autoconfiguration 报告噪音
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener: WARN
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener: ERROR
# 关闭 Spring Boot 启动横幅等噪音
org.springframework.boot: WARN
pattern:
# 简化格式:时间 [级别] 类名 - 消息
console: "%d{HH:mm:ss.SSS} [%level] %logger{36} - %msg%n"
file: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%level] %logger{50} - %msg%n"
jwt:
secret: intern-platform-super-secret-key-2024-must-be-at-least-32-bytes
expiration: 86400000
access:
expiration-ms: 7200000 # 2 小时
header: Authorization
prefix: "Bearer "
refresh:
expiration-ms: 604800000 # 7 天
bcrypt:
strength: 12 # BCrypt cost = 12
login:
max-failures: 5
lock-minutes: 30 # 锁定 30 分钟
sms:
send-interval: 30 # 30秒内同一手机只能发一次
expire-minutes: 5 # 验证码5分钟有效
ai-service:
base-url: ${AI_SERVICE_BASE_URL:http://localhost:7083}
internal-token: ${AI_INTERNAL_TOKEN:dev-internal-token}
timeout-seconds: ${AI_SERVICE_TIMEOUT_SECONDS:8}
minio:
endpoint: ${MINIO_ENDPOINT:http://localhost:19000}
access-key: ${MINIO_ACCESS_KEY:minioadmin}
secret-key: ${MINIO_SECRET_KEY:minioadmin123}
bucket: ${MINIO_BUCKET:intern-platform}
resilience4j:
circuitbreaker:
instances:
aiProject:
sliding-window-size: 10
failure-rate-threshold: 50
wait-duration-in-open-state: 30s
permitted-number-of-calls-in-half-open-state: 3
timelimiter:
instances:
aiProject:
timeout-duration: 8s
......@@ -2,19 +2,19 @@
<configuration>
<include resource="org/springframework/boot/logging/logback/defaults.xml"/>
<property name="LOG_FILE" value="${LOG_FILE:-${LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}/}spring.log}"/>
<property name="CONSOLE_LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"/>
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>${CONSOLE_LOG_PATTERN}</pattern>
<pattern>%d{HH:mm:ss.SSS} [%level] %logger{36} - %msg%n</pattern>
<charset>UTF-8</charset>
</encoder>
</appender>
<root level="INFO">
<root level="WARN">
<appender-ref ref="CONSOLE"/>
</root>
<logger name="com.platform.backend" level="DEBUG"/>
<logger name="com.platform.backend" level="INFO"/>
<logger name="org.hibernate.SQL" level="OFF"/>
<logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="OFF"/>
<logger name="org.springframework.jdbc.core" level="OFF"/>
</configuration>
import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom';
import { Layout, Menu } from 'antd';
import { BrowserRouter, Routes, Route, Navigate, useLocation, useNavigate } from 'react-router-dom';
import { Layout, Menu, Dropdown, Avatar, Button, Space } from 'antd';
import type { MenuProps } from 'antd';
import {
DashboardOutlined,
ProjectOutlined,
BookOutlined,
AuditOutlined,
BellOutlined,
UserOutlined,
LogoutOutlined,
SettingOutlined,
} from '@ant-design/icons';
import { useState } from 'react';
import { useState, useEffect } from 'react';
import DashboardPage from './pages/DashboardPage';
import ProjectPage from './pages/ProjectPage';
import TrainingPage from './pages/TrainingPage';
import DefensePage from './pages/DefensePage';
import AuditPage from './pages/AuditPage';
import NotificationPage from './pages/NotificationPage';
import LoginPage from './pages/LoginPage';
import { useAuthStore } from './stores/useAuthStore';
const { Header, Sider, Content } = Layout;
......@@ -26,12 +32,71 @@ const menuItems = [
{ key: '/notifications', icon: <BellOutlined />, label: '通知' },
];
export default function App() {
// 受保护的路由组件
const ProtectedRoute: React.FC<{ children: React.ReactNode }> = ({ children }) => {
const { isAuthenticated } = useAuthStore();
const location = useLocation();
if (!isAuthenticated) {
return <Navigate to="/login" state={{ from: location }} replace />;
}
return <>{children}</>;
};
// 公共路由(已登录则跳转首页)
const PublicRoute: React.FC<{ children: React.ReactNode }> = ({ children }) => {
const { isAuthenticated } = useAuthStore();
if (isAuthenticated) {
return <Navigate to="/dashboard" replace />;
}
return <>{children}</>;
};
// 主布局组件
const MainLayout: React.FC = () => {
const [collapsed, setCollapsed] = useState(false);
const [selectedKey, setSelectedKey] = useState('/dashboard');
const { user, logout } = useAuthStore();
const location = useLocation();
const navigate = useNavigate();
useEffect(() => {
setSelectedKey(location.pathname);
}, [location.pathname]);
const userMenuItems: MenuProps['items'] = [
{
key: 'profile',
icon: <UserOutlined />,
label: '个人信息',
},
{
key: 'settings',
icon: <SettingOutlined />,
label: '设置',
},
{
type: 'divider',
},
{
key: 'logout',
icon: <LogoutOutlined />,
label: '退出登录',
danger: true,
},
];
const handleUserMenuClick: MenuProps['onClick'] = async ({ key }) => {
if (key === 'logout') {
await logout();
navigate('/login');
}
};
return (
<BrowserRouter>
<Layout style={{ minHeight: '100vh' }}>
<Sider collapsible collapsed={collapsed} onCollapse={setCollapsed}>
<div
......@@ -43,36 +108,107 @@ export default function App() {
fontWeight: 600,
textAlign: 'center',
lineHeight: '32px',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
}}
>
{collapsed ? '实' : '实习生训练平台'}
{collapsed ? (
<span style={{ fontSize: 24 }}>实</span>
) : (
<span>实习生训练平台</span>
)}
</div>
<Menu
theme="dark"
mode="inline"
selectedKeys={[selectedKey]}
items={menuItems}
onClick={(e) => setSelectedKey(e.key)}
onClick={(e) => {
setSelectedKey(e.key);
navigate(e.key);
}}
/>
</Sider>
<Layout>
<Header style={{ background: '#fff', paddingLeft: 24, fontSize: 20 }}>
实习生训练平台 · MVP
<Header
style={{
background: '#fff',
padding: '0 24px',
display: 'flex',
alignItems: 'center',
justifyContent: 'space-between',
boxShadow: '0 1px 4px rgba(0,21,41,.08)',
}}
>
<span style={{ fontSize: 20, fontWeight: 500 }}>实习生训练平台 · MVP</span>
<Space size={16}>
<Button type="text" icon={<BellOutlined />} />
<Dropdown
menu={{ items: userMenuItems, onClick: handleUserMenuClick }}
placement="bottomRight"
>
<Space style={{ cursor: 'pointer' }}>
<Avatar
style={{ backgroundColor: '#667eea' }}
icon={<UserOutlined />}
/>
<span style={{ fontWeight: 500 }}>
{user?.realName || user?.username || '用户'}
</span>
</Space>
</Dropdown>
</Space>
</Header>
<Content style={{ margin: 16, padding: 24, background: '#fff', borderRadius: 8 }}>
<Routes>
<Route path="/" element={<Navigate to="/dashboard" replace />} />
<Route path="/dashboard" element={<DashboardPage />} />
<Route path="/projects" element={<ProjectPage />} />
<Route path="/training" element={<TrainingPage />} />
<Route path="/defense" element={<DefensePage />} />
<Route path="/audit" element={<AuditPage />} />
<Route path="/notifications" element={<NotificationPage />} />
<Route path="*" element={<div>404 Not Found</div>} />
</Routes>
<Content
style={{
margin: 16,
padding: 24,
background: '#fff',
borderRadius: 8,
minHeight: 'calc(100vh - 112px)',
}}
>
{selectedKey === '/dashboard' && <DashboardPage />}
{selectedKey === '/projects' && <ProjectPage />}
{selectedKey === '/training' && <TrainingPage />}
{selectedKey === '/defense' && <DefensePage />}
{selectedKey === '/audit' && <AuditPage />}
{selectedKey === '/notifications' && <NotificationPage />}
</Content>
</Layout>
</Layout>
);
};
export default function App() {
return (
<BrowserRouter>
<Routes>
{/* 公共路由 */}
<Route
path="/login"
element={
<PublicRoute>
<LoginPage />
</PublicRoute>
}
/>
{/* 受保护的路由 */}
<Route
path="/*"
element={
<ProtectedRoute>
<MainLayout />
</ProtectedRoute>
}
/>
{/* 默认重定向 */}
<Route path="/" element={<Navigate to="/dashboard" replace />} />
<Route path="*" element={<Navigate to="/dashboard" replace />} />
</Routes>
</BrowserRouter>
);
}
......@@ -14,3 +14,64 @@ html, body, #root {
display: flex;
flex-direction: column;
}
/* 全局滚动条样式 */
::-webkit-scrollbar {
width: 6px;
height: 6px;
}
::-webkit-scrollbar-track {
background: #f1f1f1;
border-radius: 3px;
}
::-webkit-scrollbar-thumb {
background: #c1c1c1;
border-radius: 3px;
}
::-webkit-scrollbar-thumb:hover {
background: #a8a8a8;
}
/* 全局 Ant Design 主题覆盖 */
.ant-btn-primary {
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
border: none !important;
}
.ant-btn-primary:hover {
background: linear-gradient(135deg, #5a6fd6 0%, #6a4190 100%) !important;
}
/* 动画 */
@keyframes fadeIn {
from {
opacity: 0;
transform: translateY(20px);
}
to {
opacity: 1;
transform: translateY(0);
}
}
@keyframes slideIn {
from {
opacity: 0;
transform: translateX(-20px);
}
to {
opacity: 1;
transform: translateX(0);
}
}
.fade-in {
animation: fadeIn 0.5s ease-out;
}
.slide-in {
animation: slideIn 0.5s ease-out;
}
import React, { useState, useEffect } from 'react';
import { Form, Input, Button, message, Modal, Checkbox, Alert, Space } from 'antd';
import { UserOutlined, LockOutlined, PhoneOutlined, SafetyOutlined, KeyOutlined } from '@ant-design/icons';
import { useNavigate } from 'react-router-dom';
import { login, register, sendSmsCode, resetPassword } from '../services/authApi';
import { useAuthStore } from '../stores/useAuthStore';
interface LoginFormValues {
username: string;
password: string;
}
interface RegisterFormValues {
username: string;
phone: string;
password: string;
realName: string;
smsCode: string;
agreeTerms: boolean;
}
interface ResetPasswordFormValues {
phone: string;
smsCode: string;
newPassword: string;
}
const LoginPage: React.FC = () => {
const navigate = useNavigate();
const { isAuthenticated, login: setLoginAuth, clearAuth } = useAuthStore();
const [loading, setLoading] = useState(false);
const [smsLoading, setSmsLoading] = useState(false);
const [smsCountdown, setSmsCountdown] = useState(0);
const [showResetModal, setShowResetModal] = useState(false);
const [locked, setLocked] = useState(false);
const [lockMessage, setLockMessage] = useState('');
// 初始化检查 - 已登录则跳转首页
useEffect(() => {
if (isAuthenticated) {
navigate('/dashboard');
}
}, [isAuthenticated, navigate]);
// 倒计时
useEffect(() => {
let timer: ReturnType<typeof window.setInterval> | undefined;
if (smsCountdown > 0) {
timer = setInterval(() => {
setSmsCountdown((prev) => prev - 1);
}, 1000);
}
return () => {
if (timer !== undefined) {
clearInterval(timer);
}
};
}, [smsCountdown]);
// 账号密码登录
const handleAccountLogin = async (values: LoginFormValues) => {
setLoading(true);
setLocked(false);
try {
await setLoginAuth(values.username, values.password);
message.success('登录成功');
navigate('/dashboard');
} catch (error: any) {
const errorMsg = error.response?.data?.message || '登录失败';
if (errorMsg.includes('锁定') || errorMsg.includes('locked')) {
setLocked(true);
setLockMessage(errorMsg);
message.error(errorMsg);
} else if (errorMsg.includes('账号或密码错误') || errorMsg.includes('密码错误')) {
message.error('账号或密码错误');
} else {
message.error(errorMsg);
}
} finally {
setLoading(false);
}
};
// 注册
const handleRegister = async (values: RegisterFormValues) => {
setLoading(true);
try {
await register({
username: values.username,
phone: values.phone,
password: values.password,
realName: values.realName,
smsCode: values.smsCode,
});
message.success('注册成功,请登录');
setActiveTab('login');
} catch (error: any) {
const errorMsg = error.response?.data?.message || '注册失败';
message.error(errorMsg);
} finally {
setLoading(false);
}
};
// 发送验证码
const handleSendSmsCode = async (phone: string, type: 'login' | 'register' | 'reset') => {
if (!phone || !/^1[3-9]\d{9}$/.test(phone)) {
message.error('请输入正确的手机号');
return;
}
setSmsLoading(true);
try {
await sendSmsCode({ phone, type });
message.success('验证码已发送');
setSmsCountdown(60);
} catch (error: any) {
const errorMsg = error.response?.data?.message || '发送失败';
message.error(errorMsg);
} finally {
setSmsLoading(false);
}
};
// 重置密码
const handleResetPassword = async (values: ResetPasswordFormValues) => {
setLoading(true);
try {
await resetPassword({
phone: values.phone,
smsCode: values.smsCode,
newPassword: values.newPassword,
});
message.success('密码重置成功,请使用新密码登录');
setShowResetModal(false);
setActiveTab('login');
} catch (error: any) {
const errorMsg = error.response?.data?.message || '重置失败';
message.error(errorMsg);
} finally {
setLoading(false);
}
};
// 登录锁定警告
const LockWarning = () => (
<Alert
type="warning"
message={lockMessage || '连续 5 次登录失败,账号将被锁定 30 分钟'}
style={{ marginBottom: 16 }}
showIcon
/>
);
// 切换Tab状态(用于注册后切回登录)
const [activeTab, setActiveTab] = useState<'login' | 'register'>('login');
return (
<div className="login-container">
{/* 左侧品牌区域 */}
<div className="login-brand">
<div className="brand-content">
<div className="brand-logo">
<svg width="80" height="80" viewBox="0 0 80 80" fill="none">
<rect width="80" height="80" rx="16" fill="url(#gradient)" />
<path d="M40 20L56 32V48L40 60L24 48V32L40 20Z" fill="white" fillOpacity="0.9" />
<path d="M40 28L48 34V46L40 52L32 46V34L40 28Z" fill="url(#gradient)" />
<defs>
<linearGradient id="gradient" x1="0" y1="0" x2="80" y2="80">
<stop stopColor="#667eea" />
<stop offset="1" stopColor="#764ba2" />
</linearGradient>
</defs>
</svg>
</div>
<h1 className="brand-title">实习生训练平台</h1>
<p className="brand-subtitle">Intern Training Platform</p>
<div className="brand-features">
<div className="feature-item">
<span className="feature-icon">🎯</span>
<span>专业的实训体系</span>
</div>
<div className="feature-item">
<span className="feature-icon">👥</span>
<span>资深导师指导</span>
</div>
<div className="feature-item">
<span className="feature-icon">🚀</span>
<span>真实项目实践</span>
</div>
<div className="feature-item">
<span className="feature-icon">📜</span>
<span>权威能力认证</span>
</div>
</div>
</div>
<div className="brand-bg-shapes">
<div className="shape shape-1"></div>
<div className="shape shape-2"></div>
<div className="shape shape-3"></div>
</div>
</div>
{/* 右侧登录表单区域 */}
<div className="login-form-container">
<div className="login-form-wrapper">
<div className="login-form-header">
<h2>欢迎回来</h2>
<p>请登录您的账号继续访问</p>
</div>
{/* 登录表单 */}
{activeTab === 'login' && (
<>
{locked && <LockWarning />}
<Form
name="accountLogin"
onFinish={handleAccountLogin}
autoComplete="off"
layout="vertical"
className="login-form"
>
<Form.Item
name="username"
rules={[
{ required: true, message: '请输入用户名' },
{ min: 3, message: '用户名至少3个字符' },
]}
>
<Input
prefix={<UserOutlined />}
placeholder="用户名"
size="large"
disabled={locked}
/>
</Form.Item>
<Form.Item
name="password"
rules={[
{ required: true, message: '请输入密码' },
{ min: 6, message: '密码至少6个字符' },
]}
>
<Input.Password
prefix={<LockOutlined />}
placeholder="请输入密码"
size="large"
disabled={locked}
/>
</Form.Item>
<div className="form-extra">
<Checkbox>记住我</Checkbox>
<a className="forgot-link" onClick={() => setShowResetModal(true)}>
忘记密码?
</a>
</div>
<Form.Item>
<Button
type="primary"
htmlType="submit"
size="large"
block
loading={loading}
disabled={locked}
className="login-button"
>
{locked ? '账号已锁定' : '登 录'}
</Button>
</Form.Item>
<div className="form-footer">
还没有账号?<a onClick={() => setActiveTab('register')}>立即注册</a>
</div>
</Form>
</>
)}
{activeTab === 'register' && (
<>
<Form
name="register"
onFinish={handleRegister}
autoComplete="off"
layout="vertical"
className="login-form"
>
<Form.Item
name="username"
rules={[
{ required: true, message: '请输入用户名' },
{ min: 3, max: 20, message: '用户名3-20个字符' },
{ pattern: /^[a-zA-Z0-9_]+$/, message: '仅支持字母、数字、下划线' },
]}
>
<Input prefix={<UserOutlined />} placeholder="用户名" size="large" />
</Form.Item>
<Form.Item
name="realName"
rules={[
{ required: true, message: '请输入真实姓名' },
{ min: 2, max: 20, message: '姓名2-20个字符' },
]}
>
<Input prefix={<KeyOutlined />} placeholder="真实姓名" size="large" />
</Form.Item>
<Form.Item
name="phone"
rules={[
{ required: true, message: '请输入手机号' },
{ pattern: /^1[3-9]\d{9}$/, message: '请输入正确的手机号' },
]}
>
<Input prefix={<PhoneOutlined />} placeholder="手机号" size="large" maxLength={11} />
</Form.Item>
<Form.Item
name="password"
rules={[
{ required: true, message: '请输入密码' },
{ min: 8, message: '密码至少8个字符' },
{ pattern: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).+$/, message: '需包含大小写字母和数字' },
]}
>
<Input.Password
prefix={<LockOutlined />}
placeholder="密码(8位以上,大小写+数字)"
size="large"
/>
</Form.Item>
<Form.Item>
<Space.Compact style={{ width: '100%' }}>
<Form.Item
name="smsCode"
noStyle
rules={[
{ required: true, message: '请输入验证码' },
{ len: 6, message: '验证码为6位数字' },
]}
>
<Input
prefix={<SafetyOutlined />}
placeholder="验证码"
size="large"
maxLength={6}
style={{ flex: 1 }}
/>
</Form.Item>
<Button
size="large"
onClick={() => {
const phone = (document.querySelectorAll('input[placeholder="手机号"]')[0] as HTMLInputElement)?.value;
if (phone) handleSendSmsCode(phone, 'register');
}}
loading={smsLoading}
disabled={smsCountdown > 0}
style={{ minWidth: 120 }}
>
{smsCountdown > 0 ? `${smsCountdown}s` : '获取验证码'}
</Button>
</Space.Compact>
</Form.Item>
<Form.Item
name="agreeTerms"
valuePropName="checked"
rules={[
{ validator: (_, value) => value ? Promise.resolve() : Promise.reject('请同意用户协议') },
]}
>
<Checkbox>
我已阅读并同意 <a href="#">《用户协议》</a> 和 <a href="#">《隐私政策》</a>
</Checkbox>
</Form.Item>
<Form.Item>
<Button type="primary" htmlType="submit" size="large" block loading={loading} className="login-button">
注 册
</Button>
</Form.Item>
<div className="form-footer">
已有账号?<a onClick={() => setActiveTab('login')}>立即登录</a>
</div>
</Form>
</>
)}
</div>
<div className="login-footer">
<p>© 2024 实习生训练平台 · Intern Training Platform</p>
</div>
</div>
{/* 忘记密码弹窗 */}
<Modal
title="重置密码"
open={showResetModal}
onCancel={() => setShowResetModal(false)}
footer={null}
width={400}
>
<Form
name="resetPassword"
onFinish={handleResetPassword}
autoComplete="off"
layout="vertical"
className="reset-form"
>
<Form.Item
name="phone"
rules={[
{ required: true, message: '请输入手机号' },
{ pattern: /^1[3-9]\d{9}$/, message: '请输入正确的手机号' },
]}
>
<Input prefix={<PhoneOutlined />} placeholder="手机号" size="large" maxLength={11} />
</Form.Item>
<Form.Item>
<Space.Compact style={{ width: '100%' }}>
<Form.Item name="smsCode" noStyle rules={[{ required: true, message: '请输入验证码' }]}>
<Input
prefix={<SafetyOutlined />}
placeholder="验证码"
size="large"
maxLength={6}
style={{ flex: 1 }}
/>
</Form.Item>
<Button
size="large"
onClick={() => {
const phone = (document.querySelectorAll('.reset-form input[placeholder="手机号"]')[0] as HTMLInputElement)?.value;
if (phone) handleSendSmsCode(phone, 'reset');
}}
loading={smsLoading}
disabled={smsCountdown > 0}
style={{ minWidth: 100 }}
>
{smsCountdown > 0 ? `${smsCountdown}s` : '获取验证码'}
</Button>
</Space.Compact>
</Form.Item>
<Form.Item
name="newPassword"
rules={[
{ required: true, message: '请输入新密码' },
{ min: 8, message: '密码至少8个字符' },
{ pattern: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).+$/, message: '需包含大小写字母和数字' },
]}
>
<Input.Password prefix={<LockOutlined />} placeholder="新密码" size="large" />
</Form.Item>
<Form.Item>
<Button type="primary" htmlType="submit" size="large" block loading={loading} className="reset-button">
重置密码
</Button>
</Form.Item>
</Form>
</Modal>
<style>{`
.login-container {
display: flex;
min-height: 100vh;
background: #f0f2f5;
}
/* 左侧品牌区域 */
.login-brand {
flex: 1;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
position: relative;
overflow: hidden;
display: flex;
align-items: center;
justify-content: center;
}
.brand-content {
position: relative;
z-index: 1;
text-align: center;
color: white;
padding: 40px;
}
.brand-logo {
margin-bottom: 24px;
animation: float 3s ease-in-out infinite;
}
@keyframes float {
0%, 100% { transform: translateY(0); }
50% { transform: translateY(-10px); }
}
.brand-title {
font-size: 36px;
font-weight: 700;
margin-bottom: 8px;
text-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
.brand-subtitle {
font-size: 18px;
opacity: 0.9;
margin-bottom: 48px;
}
.brand-features {
display: grid;
grid-template-columns: repeat(2, 1fr);
gap: 20px;
text-align: left;
}
.feature-item {
display: flex;
align-items: center;
gap: 12px;
font-size: 16px;
background: rgba(255,255,255,0.15);
padding: 12px 20px;
border-radius: 12px;
backdrop-filter: blur(10px);
}
.feature-icon {
font-size: 24px;
}
.brand-bg-shapes {
position: absolute;
inset: 0;
pointer-events: none;
}
.shape {
position: absolute;
border-radius: 50%;
opacity: 0.1;
}
.shape-1 {
width: 400px;
height: 400px;
background: white;
top: -100px;
right: -100px;
}
.shape-2 {
width: 300px;
height: 300px;
background: white;
bottom: -50px;
left: -50px;
}
.shape-3 {
width: 200px;
height: 200px;
background: white;
top: 50%;
left: 30%;
}
/* 右侧登录表单 */
.login-form-container {
width: 520px;
background: white;
display: flex;
flex-direction: column;
justify-content: center;
padding: 40px;
}
.login-form-wrapper {
max-width: 380px;
margin: 0 auto;
width: 100%;
}
.login-form-header {
text-align: center;
margin-bottom: 32px;
}
.login-form-header h2 {
font-size: 28px;
font-weight: 600;
color: #1a1a1a;
margin-bottom: 8px;
}
.login-form-header p {
color: #666;
font-size: 14px;
}
.login-tabs .ant-tabs-nav {
margin-bottom: 24px;
}
.login-tabs .ant-tabs-tab {
font-size: 16px;
padding: 12px 0;
}
.login-form .ant-input-affix-wrapper,
.login-form .ant-input {
border-radius: 8px;
height: 48px;
}
.form-extra {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 24px;
}
.forgot-link {
color: #667eea;
font-size: 14px;
}
.forgot-link:hover {
color: #764ba2;
}
.login-button {
height: 48px;
font-size: 16px;
font-weight: 500;
border-radius: 8px;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
border: none;
box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
transition: all 0.3s ease;
}
.login-button:hover {
background: linear-gradient(135deg, #5a6fd6 0%, #6a4190 100%);
box-shadow: 0 6px 16px rgba(102, 126, 234, 0.5);
transform: translateY(-2px);
}
.login-button:active {
transform: translateY(0);
}
.login-footer {
position: absolute;
bottom: 24px;
left: 0;
right: 0;
text-align: center;
color: #999;
font-size: 12px;
}
.reset-form {
padding-top: 16px;
}
.reset-button {
height: 44px;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
border: none;
border-radius: 8px;
}
/* 响应式 */
@media (max-width: 768px) {
.login-brand {
display: none;
}
.login-form-container {
width: 100%;
padding: 24px;
}
}
`}</style>
</div>
);
};
export default LoginPage;
import { Empty } from 'antd';
import {
Button,
Card,
Col,
Descriptions,
Divider,
Drawer,
Form,
Input,
InputNumber,
Modal,
Popconfirm,
Row,
Select,
Space,
Statistic,
Table,
Tag,
Tabs,
Typography,
Upload,
message,
} from 'antd';
import type { ColumnsType } from 'antd/es/table';
import type { UploadProps } from 'antd';
import {
CloudUploadOutlined,
DeleteOutlined,
EditOutlined,
EyeOutlined,
PlusOutlined,
ReloadOutlined,
SyncOutlined,
TagsOutlined,
ThunderboltOutlined,
} from '@ant-design/icons';
import axios from 'axios';
import { useEffect, useState } from 'react';
const { TextArea } = Input;
type ApiResponse<T> = {
code: number;
message: string;
data: T;
};
type PageResult<T> = {
total: number;
page: number;
size: number;
items: T[];
};
type ProjectType = 'internal' | 'github' | 'annotation';
type ProjectSort = 'newest' | 'popular' | 'difficulty';
type ProjectItem = {
id: number;
name: string;
description?: string;
projectType: ProjectType;
difficultyLevel: string;
difficultyName: string;
departmentName?: string;
tags: string[];
viewCount: number;
choiceCount: number;
status: number;
createdAt: string;
};
type ProjectDetail = ProjectItem & {
departmentId?: number;
techStack?: string[];
businessDomain?: string;
annotationType?: string;
knowledgeTags?: string[];
sourceCodeUrl?: string;
requirementDocUrl?: string;
acceptanceReportUrl?: string;
githubUrl?: string;
industry?: string;
stars?: number;
attachments?: AttachmentItem[];
knowledgePoints?: KnowledgePointItem[];
};
type AttachmentItem = {
id: number;
fileName: string;
fileUrl: string;
fileType: string;
};
type ProjectFilters = {
page: number;
size: number;
tagMode: string;
keyword?: string;
projectType?: ProjectType;
difficulty?: string;
departmentId?: number;
tag?: string;
sort: ProjectSort;
order: 'asc' | 'desc';
};
type TagItem = {
id: number;
name: string;
category: string;
color: string;
};
type TagsResponse = {
categories: Record<string, TagItem[]>;
flatList: TagItem[];
};
type ScorecardItem = {
id: number;
dimensionName: string;
weight: number;
};
type ScorecardResponse = {
departmentId: number;
departmentName: string;
dimensions: ScorecardItem[];
};
type DifficultyResponse = {
projectId: number;
projectName: string;
aiScore?: number;
aiSuggestedLevel?: string;
calibratedLevel?: string;
calibrationStatus?: string;
anchorProjectId?: number;
anchorProjectName?: string;
anchorProjectType?: ProjectType;
anchorLevel?: string;
anchorText?: string;
calibrationHistory: Array<{
id: number;
previousLevel?: string;
newLevel: string;
reason?: string;
calibratedBy?: string;
calibratedAt: string;
}>;
};
type KnowledgePointRef = {
id: number;
name: string;
};
type KnowledgePointItem = {
id: number;
projectId: number;
projectType: ProjectType;
name: string;
description?: string;
category?: string;
difficulty?: string;
estimatedHours?: number;
materialUrl?: string;
prerequisites?: KnowledgePointRef[];
dependents?: KnowledgePointRef[];
createdAt?: string;
};
type KnowledgeListResponse = {
projectId: number;
projectType: ProjectType;
totalCount: number;
knowledgePoints: KnowledgePointItem[];
};
type KnowledgeExtractResponse = {
accepted: boolean;
message: string;
totalCount: number;
knowledgePoints: KnowledgePointItem[];
};
type KnowledgeFormValues = {
name: string;
description?: string;
category: string;
difficulty: string;
estimatedHours?: number;
materialUrl?: string;
prerequisiteIds?: number[];
};
type RecommendationItem = {
recommendationId?: number;
projectId: number;
projectName: string;
projectType: ProjectType;
githubUrl?: string;
description?: string;
difficultyLevel?: string;
techStack?: string[];
matchScore?: number;
matchReason?: string;
stars?: number;
};
type RecommendationResponse = {
source?: string;
totalTime?: number;
recommendations: RecommendationItem[];
};
type RecommendationHistoryItem = RecommendationItem & {
seedProjectId: number;
seedProjectName: string;
source?: string;
userAction?: string;
createdAt?: string;
actionAt?: string;
};
type RecommendationHistoryResponse = {
total: number;
page: number;
size: number;
items: RecommendationHistoryItem[];
};
type VectorSyncItem = {
projectId: number;
projectType: ProjectType;
projectName?: string;
success: boolean;
backend?: string;
collection?: string;
errorMessage?: string;
};
type VectorSyncResponse = {
total: number;
successCount: number;
failedCount: number;
items: VectorSyncItem[];
};
type KnowledgeFilter = {
category?: string;
difficulty?: string;
};
const api = axios.create({ baseURL: '/api/v1' });
api.interceptors.request.use((config) => {
const token = localStorage.getItem('token') || localStorage.getItem('authToken');
if (token) {
config.headers.Authorization = `Bearer ${token}`;
}
return config;
});
const projectTypeOptions = [
{ label: '内部种子项目', value: 'internal' },
{ label: 'GitHub 项目', value: 'github' },
{ label: '往届标注项目', value: 'annotation' },
];
const departmentOptions = [
{ label: '技术部', value: 1 },
{ label: '标注部', value: 2 },
];
const difficultyOptions = ['L1', 'L2', 'L3', 'L4', 'L5'].map((value) => ({ label: value, value }));
const tagCategoryOptions = ['技术', '方向', '场景'].map((value) => ({ label: value, value }));
const projectSortOptions = [
{ label: '最新创建', value: 'newest' },
{ label: '最热浏览', value: 'popular' },
{ label: '难度排序', value: 'difficulty' },
] as const;
const knowledgeCategoryOptions = [
{ label: '概念', value: 'concept' },
{ label: '技能', value: 'skill' },
{ label: '工具', value: 'tool' },
];
const knowledgeDifficultyOptions = [
{ label: '简单', value: 'easy' },
{ label: '中等', value: 'medium' },
{ label: '困难', value: 'hard' },
];
const projectTypeLabel = (value?: string) =>
projectTypeOptions.find((item) => item.value === value)?.label || value || '-';
const departmentNameById = (departmentId?: number) =>
departmentOptions.find((item) => item.value === departmentId)?.label || '';
const formatRecommendationScore = (value?: number) => {
if (value === undefined || value === null) return '-';
return Number(value).toFixed(4);
};
const formatDateTime = (value?: string) => {
if (!value) return '-';
const date = new Date(value);
return Number.isNaN(date.getTime()) ? value : date.toLocaleString();
};
const sleep = (ms: number) => new Promise((resolve) => {
window.setTimeout(resolve, ms);
});
export default function ProjectPage() {
return <Empty description="项目中心 - 待接入" />;
const [messageApi, contextHolder] = message.useMessage();
const [loading, setLoading] = useState(false);
const [projects, setProjects] = useState<ProjectItem[]>([]);
const [total, setTotal] = useState(0);
const [filters, setFilters] = useState<ProjectFilters>({
page: 1,
size: 10,
tagMode: 'OR',
sort: 'newest',
order: 'desc',
});
const [tags, setTags] = useState<TagItem[]>([]);
const [detail, setDetail] = useState<ProjectDetail | null>(null);
const [difficulty, setDifficulty] = useState<DifficultyResponse | null>(null);
const [knowledgePoints, setKnowledgePoints] = useState<KnowledgePointItem[]>([]);
const [knowledgeLoading, setKnowledgeLoading] = useState(false);
const [knowledgeExtracting, setKnowledgeExtracting] = useState(false);
const [knowledgeFilter, setKnowledgeFilter] = useState<KnowledgeFilter>({});
const [knowledgeModalOpen, setKnowledgeModalOpen] = useState(false);
const [editingKnowledgePoint, setEditingKnowledgePoint] = useState<KnowledgePointItem | null>(null);
const [recommendationType, setRecommendationType] = useState<ProjectType>('github');
const [recommendations, setRecommendations] = useState<RecommendationItem[]>([]);
const [recommendationHistory, setRecommendationHistory] = useState<RecommendationHistoryItem[]>([]);
const [recommendationLoading, setRecommendationLoading] = useState(false);
const [vectorSyncOpen, setVectorSyncOpen] = useState(false);
const [vectorSyncLoading, setVectorSyncLoading] = useState(false);
const [vectorSyncResult, setVectorSyncResult] = useState<VectorSyncResponse | null>(null);
const [scorecard, setScorecard] = useState<ScorecardResponse | null>(null);
const [scorecardDepartmentId, setScorecardDepartmentId] = useState<number>(1);
const [projectModalOpen, setProjectModalOpen] = useState(false);
const [tagModalOpen, setTagModalOpen] = useState(false);
const [scorecardModalOpen, setScorecardModalOpen] = useState(false);
const [editingProject, setEditingProject] = useState<ProjectDetail | null>(null);
const [editingTag, setEditingTag] = useState<TagItem | null>(null);
const [editingScorecard, setEditingScorecard] = useState<ScorecardItem | null>(null);
const [projectForm] = Form.useForm();
const [tagForm] = Form.useForm();
const [scorecardForm] = Form.useForm();
const [calibrateForm] = Form.useForm();
const [knowledgeForm] = Form.useForm<KnowledgeFormValues>();
useEffect(() => {
void Promise.all([loadProjects(), loadTags(), loadScorecard(1)]);
}, []);
const request = async <T,>(promise: Promise<{ data: ApiResponse<T> }>) => {
const response = await promise;
if (response.data.code !== 0) {
throw new Error(response.data.message || '请求失败');
}
return response.data.data;
};
// 统一把列表筛选项映射成后端当前接受的查询参数,避免前端筛选名和接口参数名漂移。
const buildProjectListParams = (nextFilters: ProjectFilters) => ({
page: nextFilters.page,
size: nextFilters.size,
keyword: nextFilters.keyword,
projectType: nextFilters.projectType,
difficulty: nextFilters.difficulty,
tag: nextFilters.tag,
tagMode: nextFilters.tagMode,
sort: nextFilters.sort,
order: nextFilters.order,
department_id: nextFilters.departmentId,
});
const loadProjects = async (nextFilters = filters) => {
setLoading(true);
try {
const data = await request<PageResult<ProjectItem>>(
api.get('/projects', { params: buildProjectListParams(nextFilters) }),
);
setProjects(data.items);
setTotal(data.total);
setFilters(nextFilters);
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '项目列表加载失败');
} finally {
setLoading(false);
}
};
const loadTags = async () => {
try {
const data = await request<TagsResponse>(api.get('/tags'));
setTags(data.flatList);
} catch {
setTags([]);
}
};
const loadScorecard = async (departmentId = scorecardDepartmentId) => {
try {
const data = await request<ScorecardResponse>(
api.get('/difficulty/scorecard', { params: { department_id: departmentId } }),
);
setScorecard(data);
setScorecardDepartmentId(departmentId);
} catch {
setScorecard(null);
}
};
const openCreateProject = () => {
setEditingProject(null);
projectForm.resetFields();
projectForm.setFieldsValue({
projectType: 'internal',
difficultyLevel: 'L3',
status: 1,
departmentId: 1,
departmentName: departmentNameById(1),
});
setProjectModalOpen(true);
};
const openEditProject = async (item: ProjectItem) => {
const data = await loadDetail(item, false);
if (!data) return;
setEditingProject(data);
projectForm.setFieldsValue({
...data,
projectType: data.projectType,
knowledgeTags: data.tags?.length ? data.tags : data.knowledgeTags,
});
setProjectModalOpen(true);
};
const loadDetail = async (item: Pick<ProjectItem, 'id' | 'projectType'>, openDrawer = true) => {
try {
const data = await request<ProjectDetail>(
api.get(`/projects/${item.id}`, { params: { projectType: item.projectType } }),
);
if (openDrawer) {
setDetail(data);
await Promise.all([
loadDifficulty(data),
loadKnowledgePoints(data, {}),
loadRecommendationHistory(),
]);
}
return data;
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '项目详情加载失败');
return null;
}
};
const refreshDrawerDetail = async () => {
if (!detail) return null;
try {
const data = await request<ProjectDetail>(
api.get(`/projects/${detail.id}`, { params: { projectType: detail.projectType } }),
);
setDetail(data);
return data;
} catch {
return null;
}
};
const loadDifficulty = async (project: Pick<ProjectItem, 'id' | 'projectType'>) => {
try {
const data = await request<DifficultyResponse>(
api.get(`/difficulty/project/${project.id}`, { params: { projectType: project.projectType } }),
);
setDifficulty(data);
} catch {
setDifficulty(null);
}
};
const loadKnowledgePoints = async (
project: Pick<ProjectItem, 'id' | 'projectType'>,
nextFilter = knowledgeFilter,
) => {
setKnowledgeLoading(true);
setKnowledgeFilter(nextFilter);
try {
const data = await request<KnowledgeListResponse>(api.get('/knowledge-points', {
params: {
project_id: project.id,
project_type: project.projectType,
category: nextFilter.category,
difficulty: nextFilter.difficulty,
},
}));
setKnowledgePoints(data.knowledgePoints || []);
} catch {
setKnowledgePoints([]);
} finally {
setKnowledgeLoading(false);
}
};
const openCreateKnowledgePoint = () => {
if (!detail) return;
setEditingKnowledgePoint(null);
knowledgeForm.resetFields();
knowledgeForm.setFieldsValue({
category: 'skill',
difficulty: 'medium',
});
setKnowledgeModalOpen(true);
};
const openEditKnowledgePoint = (point: KnowledgePointItem) => {
setEditingKnowledgePoint(point);
knowledgeForm.setFieldsValue({
name: point.name,
description: point.description,
category: point.category || 'skill',
difficulty: point.difficulty || 'medium',
estimatedHours: point.estimatedHours,
materialUrl: point.materialUrl,
prerequisiteIds: point.prerequisites?.map((item) => item.id) || [],
});
setKnowledgeModalOpen(true);
};
const saveKnowledgePoint = async () => {
if (!detail) return;
const values = await knowledgeForm.validateFields();
const payload = {
projectId: detail.id,
projectType: detail.projectType,
...values,
};
try {
if (editingKnowledgePoint) {
await request(api.put(`/knowledge-points/${editingKnowledgePoint.id}`, payload));
messageApi.success('知识点已更新');
} else {
await request(api.post('/knowledge-points', payload));
messageApi.success('知识点已创建');
}
setKnowledgeModalOpen(false);
setEditingKnowledgePoint(null);
knowledgeForm.resetFields();
await Promise.all([loadKnowledgePoints(detail, knowledgeFilter), refreshDrawerDetail()]);
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '知识点保存失败');
}
};
const deleteKnowledgePoint = async (point: KnowledgePointItem) => {
if (!detail) return;
try {
await request(api.delete(`/knowledge-points/${point.id}`));
messageApi.success('知识点已删除');
await Promise.all([loadKnowledgePoints(detail, knowledgeFilter), refreshDrawerDetail()]);
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '知识点删除失败');
}
};
const extractKnowledgePoints = async () => {
if (!detail) return;
try {
setKnowledgeExtracting(true);
const data = await request<KnowledgeExtractResponse>(api.post('/knowledge-points/extract', {
projectId: detail.id,
projectType: detail.projectType,
}));
setKnowledgeFilter({});
setKnowledgePoints(data.knowledgePoints || []);
messageApi.success(data.message || '知识点提取任务已提交');
// 后端现在异步提取,这里做几轮短轮询,尽量在同一页面里把最新结果带回来供人工确认。
for (let attempt = 0; attempt < 6; attempt += 1) {
await sleep(1500);
await loadKnowledgePoints(detail, {});
}
await refreshDrawerDetail();
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '知识点提取失败');
} finally {
setKnowledgeExtracting(false);
}
};
const recommendProjects = async () => {
if (!detail) return;
if (detail.projectType !== 'internal') {
messageApi.warning('请先选择内部种子项目发起推荐');
return;
}
setRecommendationLoading(true);
try {
const data = await request<RecommendationResponse>(api.post('/recommendations', {
projectType: recommendationType,
seedProjectId: detail.id,
limit: 5,
}));
setRecommendations(data.recommendations || []);
messageApi.success(`推荐已生成${data.source ? `(${data.source})` : ''}`);
await loadRecommendationHistory();
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '推荐生成失败');
} finally {
setRecommendationLoading(false);
}
};
const updateRecommendationAction = async (item: RecommendationItem, action: 'choose' | 'ignore') => {
try {
await request(api.post(`/recommendations/${item.projectId}/${action}`, {
recommendationId: item.recommendationId,
projectType: item.projectType,
}));
messageApi.success(action === 'choose' ? '已选择推荐项目' : '已忽略推荐项目');
setRecommendations((current) => current.filter((record) => record.recommendationId !== item.recommendationId));
await Promise.all([loadRecommendationHistory(), refreshDrawerDetail()]);
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '推荐操作失败');
}
};
const loadRecommendationHistory = async () => {
try {
const data = await request<RecommendationHistoryResponse>(api.get('/recommendations/history', {
params: { page: 1, size: 10 },
}));
setRecommendationHistory(data.items || []);
} catch {
setRecommendationHistory([]);
}
};
const runFullVectorSync = async () => {
// 管理员补偿入口:用于手动修复自动向量同步延迟或失败,保证推荐召回数据可恢复。
setVectorSyncOpen(true);
setVectorSyncLoading(true);
try {
const data = await request<VectorSyncResponse>(api.post('/projects/vector-sync/full'));
setVectorSyncResult(data);
messageApi.success(`向量同步完成:成功 ${data.successCount},失败 ${data.failedCount}`);
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '向量同步失败');
} finally {
setVectorSyncLoading(false);
}
};
const saveProject = async () => {
const values = await projectForm.validateFields();
try {
if (editingProject) {
await request(api.put(`/projects/${editingProject.id}`, values));
messageApi.success('项目已更新');
} else {
await request(api.post('/projects', values));
messageApi.success('项目已创建');
}
setProjectModalOpen(false);
await loadProjects();
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '保存失败');
}
};
const deleteProject = async (item: ProjectItem) => {
try {
await request(api.delete(`/projects/${item.id}`, { params: { projectType: item.projectType } }));
messageApi.success('项目已删除');
await loadProjects();
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '删除失败');
}
};
const saveTag = async () => {
const values = await tagForm.validateFields();
try {
if (editingTag) {
await request(api.put(`/tags/${editingTag.id}`, values));
messageApi.success('标签已更新');
} else {
await request(api.post('/tags', values));
messageApi.success('标签已创建');
}
setTagModalOpen(false);
await loadTags();
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '标签保存失败');
}
};
const deleteTag = async (tag: TagItem) => {
try {
await request(api.delete(`/tags/${tag.id}`));
messageApi.success('标签已删除');
await loadTags();
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '标签删除失败');
}
};
const evaluateDifficulty = async () => {
if (!detail) return;
try {
await request(api.post('/difficulty/project/evaluate', {
projectId: detail.id,
projectType: detail.projectType,
}));
messageApi.success('AI 难度评分已更新');
await loadDifficulty(detail);
} catch (error) {
messageApi.error(error instanceof Error ? error.message : 'AI 调用失败');
}
};
const calibrate = async () => {
if (!detail) return;
const values = await calibrateForm.validateFields();
try {
const data = await request<DifficultyResponse>(api.post('/difficulty/calibrate', {
projectId: detail.id,
projectType: detail.projectType,
...values,
}));
setDifficulty(data);
calibrateForm.resetFields();
messageApi.success('校准已记录');
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '校准失败');
}
};
const saveScorecard = async () => {
if (!editingScorecard) return;
const values = await scorecardForm.validateFields();
try {
await request(api.put(`/difficulty/scorecard/${editingScorecard.id}`, values));
messageApi.success('打分卡已更新');
setScorecardModalOpen(false);
await loadScorecard(scorecardDepartmentId);
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '打分卡更新失败');
}
};
const uploadFile: NonNullable<UploadProps['customRequest']> = async (options) => {
if (!detail || !(options.file instanceof File)) return;
const formData = new FormData();
formData.append('file', options.file);
formData.append('project_id', String(detail.id));
formData.append('project_type', detail.projectType);
formData.append('file_type', 'project_material');
try {
await request(api.post('/files/upload', formData));
options.onSuccess?.({}, options.file);
messageApi.success('文件已上传');
const latest = await refreshDrawerDetail();
if (latest) {
setDetail(latest);
}
} catch (error) {
options.onError?.(error as Error);
messageApi.error(error instanceof Error ? error.message : '上传失败');
}
};
// 资料预览和下载都走签名链接接口,避免直接依赖详情里临时 URL 的实现细节。
const openAttachment = async (attachment: AttachmentItem) => {
try {
const data = await request<{ url: string }>(api.get(`/files/${attachment.id}/download-url`));
window.open(data.url, '_blank', 'noopener,noreferrer');
} catch (error) {
messageApi.error(error instanceof Error ? error.message : '文件链接生成失败');
}
};
const columns: ColumnsType<ProjectItem> = [
{
title: '项目',
dataIndex: 'name',
render: (name, record) => (
<Space direction="vertical" size={2}>
<Typography.Text strong>{name}</Typography.Text>
<Typography.Text type="secondary" ellipsis style={{ maxWidth: 360 }}>
{record.description || '暂无描述'}
</Typography.Text>
</Space>
),
},
{
title: '类型',
dataIndex: 'projectType',
width: 120,
render: (value: ProjectType) => projectTypeLabel(value),
},
{
title: '难度',
dataIndex: 'difficultyLevel',
width: 110,
render: (level, record) => <Tag color="blue">{level} {record.difficultyName}</Tag>,
},
{
title: '部门',
dataIndex: 'departmentName',
width: 110,
render: (value?: string) => value || '-',
},
{
title: '标签',
dataIndex: 'tags',
render: (values: string[]) => values?.length ? values.map((value) => <Tag key={value}>{value}</Tag>) : '-',
},
{
title: '热度',
width: 130,
render: (_, record) => `${record.viewCount || 0} 浏览 / ${record.choiceCount || 0} 选择`,
},
{
title: '操作',
width: 230,
render: (_, record) => (
<Space>
<Button size="small" icon={<EyeOutlined />} onClick={() => void loadDetail(record)}>详情</Button>
<Button size="small" icon={<EditOutlined />} onClick={() => void openEditProject(record)}>编辑</Button>
<Popconfirm title="确认删除该项目?" onConfirm={() => void deleteProject(record)}>
<Button size="small" danger icon={<DeleteOutlined />}>删除</Button>
</Popconfirm>
</Space>
),
},
];
const knowledgePointOptions = knowledgePoints
.filter((item) => item.id !== editingKnowledgePoint?.id)
.map((item) => ({ label: item.name, value: item.id }));
return (
<Space direction="vertical" size={16} style={{ width: '100%' }}>
{contextHolder}
<Row gutter={16}>
<Col span={8}>
<Card>
<Statistic title="项目总数" value={total} suffix="个" />
</Card>
</Col>
<Col span={8}>
<Card>
<Statistic title="标签数量" value={tags.length} suffix="个" />
</Card>
</Col>
<Col span={8}>
<Card>
<Statistic title="打分卡维度" value={scorecard?.dimensions.length || 0} suffix="项" />
</Card>
</Col>
</Row>
<Card>
<Space wrap style={{ marginBottom: 16 }}>
<Input.Search
placeholder="搜索名称/描述"
allowClear
onSearch={(keyword) => void loadProjects({ ...filters, keyword, page: 1 })}
style={{ width: 220 }}
/>
<Select
allowClear
placeholder="项目类型"
options={projectTypeOptions}
style={{ width: 160 }}
value={filters.projectType}
onChange={(projectType) => void loadProjects({ ...filters, projectType, page: 1 })}
/>
<Select
allowClear
placeholder="所属部门"
options={departmentOptions}
style={{ width: 140 }}
value={filters.departmentId}
onChange={(departmentId) => void loadProjects({ ...filters, departmentId, page: 1 })}
/>
<Select
allowClear
placeholder="难度"
options={difficultyOptions}
style={{ width: 120 }}
value={filters.difficulty}
onChange={(difficulty) => void loadProjects({ ...filters, difficulty, page: 1 })}
/>
<Select
value={filters.sort}
options={projectSortOptions.map((item) => ({ label: item.label, value: item.value }))}
style={{ width: 140 }}
onChange={(sort) => void loadProjects({ ...filters, sort, page: 1 })}
/>
<Select
allowClear
mode="multiple"
placeholder="标签"
options={tags.map((tag) => ({ label: tag.name, value: tag.name }))}
style={{ minWidth: 220 }}
value={filters.tag ? filters.tag.split(',').filter(Boolean) : undefined}
onChange={(values) => void loadProjects({ ...filters, tag: values.join(','), page: 1 })}
/>
<Select
value={filters.tagMode}
options={[
{ label: '标签 OR', value: 'OR' },
{ label: '标签 AND', value: 'AND' },
]}
style={{ width: 120 }}
onChange={(tagMode) => void loadProjects({ ...filters, tagMode, page: 1 })}
/>
<Button icon={<ReloadOutlined />} onClick={() => void loadProjects()}>刷新</Button>
<Button icon={<TagsOutlined />} onClick={() => setTagModalOpen(true)}>标签管理</Button>
<Button icon={<ThunderboltOutlined />} onClick={() => setScorecardModalOpen(true)}>打分卡</Button>
<Button icon={<SyncOutlined />} loading={vectorSyncLoading} onClick={() => void runFullVectorSync()}>
向量同步
</Button>
<Button type="primary" icon={<PlusOutlined />} onClick={openCreateProject}>新建项目</Button>
</Space>
<Table
rowKey={(record) => `${record.projectType}-${record.id}`}
columns={columns}
dataSource={projects}
loading={loading}
pagination={{
current: filters.page,
pageSize: filters.size,
total,
onChange: (page, size) => void loadProjects({ ...filters, page, size }),
}}
/>
</Card>
<Modal
title={editingProject ? '编辑项目' : '创建项目'}
open={projectModalOpen}
onOk={() => void saveProject()}
onCancel={() => setProjectModalOpen(false)}
width={760}
destroyOnClose
>
<Form form={projectForm} layout="vertical">
<Row gutter={12}>
<Col span={12}>
<Form.Item name="name" label="项目名称" rules={[{ required: true }]}>
<Input />
</Form.Item>
</Col>
<Col span={12}>
<Form.Item name="projectType" label="项目类型" rules={[{ required: true }]}>
<Select disabled={Boolean(editingProject)} options={projectTypeOptions} />
</Form.Item>
</Col>
</Row>
<Form.Item name="description" label="项目描述">
<TextArea rows={3} />
</Form.Item>
<Row gutter={12}>
<Col span={8}>
<Form.Item name="departmentId" label="所属部门">
<Select
allowClear
options={departmentOptions}
onChange={(departmentId) => {
projectForm.setFieldValue('departmentName', departmentNameById(departmentId));
}}
/>
</Form.Item>
</Col>
<Col span={8}>
<Form.Item name="departmentName" label="部门名称">
<Input readOnly />
</Form.Item>
</Col>
<Col span={8}>
<Form.Item name="difficultyLevel" label="难度" rules={[{ required: true }]}>
<Select options={difficultyOptions} />
</Form.Item>
</Col>
</Row>
<Row gutter={12}>
<Col span={12}>
<Form.Item name="techStack" label="技术栈">
<Select mode="tags" />
</Form.Item>
</Col>
<Col span={12}>
<Form.Item name="knowledgeTags" label="标签/知识点">
<Select mode="tags" options={tags.map((tag) => ({ label: tag.name, value: tag.name }))} />
</Form.Item>
</Col>
</Row>
<Row gutter={12}>
<Col span={12}>
<Form.Item name="businessDomain" label="业务领域">
<Input />
</Form.Item>
</Col>
<Col span={12}>
<Form.Item name="annotationType" label="标注类型">
<Input />
</Form.Item>
</Col>
</Row>
<Form.Item name="githubUrl" label="GitHub URL">
<Input />
</Form.Item>
<Row gutter={12}>
<Col span={12}>
<Form.Item name="industry" label="行业">
<Input />
</Form.Item>
</Col>
<Col span={12}>
<Form.Item name="stars" label="Stars">
<InputNumber style={{ width: '100%' }} />
</Form.Item>
</Col>
</Row>
<Form.Item name="sourceCodeUrl" label="源码地址">
<Input />
</Form.Item>
<Form.Item name="requirementDocUrl" label="需求文档 URL">
<Input />
</Form.Item>
<Form.Item name="acceptanceReportUrl" label="验收报告 URL">
<Input />
</Form.Item>
</Form>
</Modal>
<Modal
title="标签管理"
open={tagModalOpen}
onCancel={() => setTagModalOpen(false)}
footer={null}
width={760}
>
<Form form={tagForm} layout="inline" style={{ marginBottom: 16 }}>
<Form.Item name="name" rules={[{ required: true }]}><Input placeholder="标签名" /></Form.Item>
<Form.Item name="category" rules={[{ required: true }]}>
<Select placeholder="分类" options={tagCategoryOptions} style={{ width: 120 }} />
</Form.Item>
<Form.Item name="color" rules={[{ required: true, pattern: /^#[0-9a-fA-F]{6}$/ }]}>
<Input placeholder="#2196F3" />
</Form.Item>
<Button type="primary" onClick={() => void saveTag()}>{editingTag ? '更新' : '创建'}</Button>
<Button onClick={() => { setEditingTag(null); tagForm.resetFields(); }}>清空</Button>
</Form>
<Space wrap>
{tags.map((tag) => (
<Tag
key={tag.id}
color={tag.color}
closable
onClose={(event) => {
event.preventDefault();
void deleteTag(tag);
}}
onClick={() => {
setEditingTag(tag);
tagForm.setFieldsValue(tag);
}}
style={{ cursor: 'pointer', padding: '4px 8px' }}
>
{tag.category} · {tag.name}
</Tag>
))}
</Space>
</Modal>
<Modal
title="打分卡维度"
open={scorecardModalOpen}
onCancel={() => setScorecardModalOpen(false)}
footer={null}
width={760}
>
<Space style={{ marginBottom: 16 }}>
<Typography.Text type="secondary">
当前部门:{scorecard?.departmentName || '-'},权重总和必须等于 1.00。
</Typography.Text>
<Select
value={scorecardDepartmentId}
options={departmentOptions}
style={{ width: 140 }}
onChange={(value) => void loadScorecard(value)}
/>
</Space>
<Table
rowKey="id"
pagination={false}
dataSource={scorecard?.dimensions || []}
columns={[
{ title: '维度', dataIndex: 'dimensionName' },
{ title: '权重', dataIndex: 'weight' },
{
title: '操作',
render: (_, record: ScorecardItem) => (
<Button
size="small"
onClick={() => {
setEditingScorecard(record);
scorecardForm.setFieldsValue(record);
}}
>
编辑
</Button>
),
},
]}
/>
<Divider />
{editingScorecard && (
<Form form={scorecardForm} layout="inline">
<Form.Item name="dimensionName" rules={[{ required: true }]}><Input /></Form.Item>
<Form.Item name="weight" rules={[{ required: true }]}>
<InputNumber min={0} max={1} step={0.01} />
</Form.Item>
<Button type="primary" onClick={() => void saveScorecard()}>保存</Button>
</Form>
)}
</Modal>
<Modal
title={editingKnowledgePoint ? '编辑知识点' : '新增知识点'}
open={knowledgeModalOpen}
onCancel={() => {
setKnowledgeModalOpen(false);
setEditingKnowledgePoint(null);
knowledgeForm.resetFields();
}}
onOk={() => void saveKnowledgePoint()}
width={680}
destroyOnClose
>
<Form form={knowledgeForm} layout="vertical">
<Row gutter={12}>
<Col span={12}>
<Form.Item name="name" label="知识点名称" rules={[{ required: true }]}>
<Input />
</Form.Item>
</Col>
<Col span={6}>
<Form.Item name="category" label="分类" rules={[{ required: true }]}>
<Select options={knowledgeCategoryOptions} />
</Form.Item>
</Col>
<Col span={6}>
<Form.Item name="difficulty" label="难度" rules={[{ required: true }]}>
<Select options={knowledgeDifficultyOptions} />
</Form.Item>
</Col>
</Row>
<Form.Item name="description" label="说明">
<TextArea rows={3} />
</Form.Item>
<Row gutter={12}>
<Col span={12}>
<Form.Item name="estimatedHours" label="预计学习时长(小时)">
<InputNumber min={0} step={0.5} style={{ width: '100%' }} />
</Form.Item>
</Col>
<Col span={12}>
<Form.Item name="materialUrl" label="学习材料链接">
<Input />
</Form.Item>
</Col>
</Row>
<Form.Item name="prerequisiteIds" label="前置知识点">
<Select
mode="multiple"
allowClear
options={knowledgePointOptions}
placeholder="选择前置知识点"
/>
</Form.Item>
</Form>
</Modal>
<Modal
title="全量向量同步"
open={vectorSyncOpen}
onCancel={() => setVectorSyncOpen(false)}
footer={<Button onClick={() => setVectorSyncOpen(false)}>关闭</Button>}
width={860}
>
<Typography.Paragraph type="secondary">
该操作会重新同步当前未删除项目的向量数据,用于补偿自动同步延迟或 AI/Milvus 临时故障。
</Typography.Paragraph>
<Row gutter={12} style={{ marginBottom: 16 }}>
<Col span={8}><Card><Statistic title="同步总数" value={vectorSyncResult?.total ?? 0} /></Card></Col>
<Col span={8}><Card><Statistic title="成功" value={vectorSyncResult?.successCount ?? 0} /></Card></Col>
<Col span={8}><Card><Statistic title="失败" value={vectorSyncResult?.failedCount ?? 0} /></Card></Col>
</Row>
<Table
size="small"
rowKey={(record) => `${record.projectType}-${record.projectId}`}
loading={vectorSyncLoading}
dataSource={vectorSyncResult?.items || []}
pagination={{ pageSize: 8 }}
columns={[
{ title: '项目', dataIndex: 'projectName' },
{ title: '类型', dataIndex: 'projectType', width: 100, render: (value: string) => projectTypeLabel(value) },
{
title: '状态',
dataIndex: 'success',
width: 90,
render: (value: boolean) => <Tag color={value ? 'green' : 'red'}>{value ? '成功' : '失败'}</Tag>,
},
{ title: '后端', dataIndex: 'backend', width: 100, render: (value?: string) => value || '-' },
{ title: '集合', dataIndex: 'collection', width: 180, render: (value?: string) => value || '-' },
{ title: '错误信息', dataIndex: 'errorMessage', render: (value?: string) => value || '-' },
]}
/>
</Modal>
<Drawer
title={detail?.name}
width={860}
open={Boolean(detail)}
onClose={() => {
setDetail(null);
setDifficulty(null);
setKnowledgePoints([]);
setKnowledgeFilter({});
setRecommendations([]);
setRecommendationHistory([]);
setKnowledgeModalOpen(false);
setEditingKnowledgePoint(null);
calibrateForm.resetFields();
knowledgeForm.resetFields();
}}
>
{detail && (
<Tabs
items={[
{
key: 'detail',
label: '详情',
children: (
<Space direction="vertical" style={{ width: '100%' }}>
<Descriptions bordered column={2}>
<Descriptions.Item label="类型">{projectTypeLabel(detail.projectType)}</Descriptions.Item>
<Descriptions.Item label="难度">{detail.difficultyLevel} {detail.difficultyName}</Descriptions.Item>
<Descriptions.Item label="部门">{detail.departmentName || '-'}</Descriptions.Item>
<Descriptions.Item label="浏览">{detail.viewCount}</Descriptions.Item>
<Descriptions.Item label="业务领域">{detail.businessDomain || '-'}</Descriptions.Item>
<Descriptions.Item label="标注类型">{detail.annotationType || '-'}</Descriptions.Item>
<Descriptions.Item label="行业">{detail.industry || '-'}</Descriptions.Item>
<Descriptions.Item label="Stars">{detail.stars ?? '-'}</Descriptions.Item>
<Descriptions.Item label="技术栈" span={2}>{detail.techStack?.join('、') || '-'}</Descriptions.Item>
<Descriptions.Item label="标签" span={2}>
{detail.tags?.length ? detail.tags.map((tag) => <Tag key={tag}>{tag}</Tag>) : '-'}
</Descriptions.Item>
<Descriptions.Item label="描述" span={2}>{detail.description || '-'}</Descriptions.Item>
<Descriptions.Item label="源码地址" span={2}>
{detail.sourceCodeUrl ? <a href={detail.sourceCodeUrl} target="_blank" rel="noreferrer">{detail.sourceCodeUrl}</a> : '-'}
</Descriptions.Item>
<Descriptions.Item label="需求文档" span={2}>
{detail.requirementDocUrl ? <a href={detail.requirementDocUrl} target="_blank" rel="noreferrer">{detail.requirementDocUrl}</a> : '-'}
</Descriptions.Item>
<Descriptions.Item label="验收报告" span={2}>
{detail.acceptanceReportUrl ? <a href={detail.acceptanceReportUrl} target="_blank" rel="noreferrer">{detail.acceptanceReportUrl}</a> : '-'}
</Descriptions.Item>
<Descriptions.Item label="GitHub 链接" span={2}>
{detail.githubUrl ? <a href={detail.githubUrl} target="_blank" rel="noreferrer">{detail.githubUrl}</a> : '-'}
</Descriptions.Item>
</Descriptions>
<Upload customRequest={uploadFile} showUploadList={false}>
<Button icon={<CloudUploadOutlined />}>上传资料</Button>
</Upload>
<Table
size="small"
rowKey="id"
pagination={false}
dataSource={detail.attachments || []}
columns={[
{ title: '文件', dataIndex: 'fileName' },
{ title: '类型', dataIndex: 'fileType', width: 120 },
{
title: '操作',
width: 180,
render: (_, record: AttachmentItem) => (
<Space>
<Button size="small" onClick={() => void openAttachment(record)}>预览</Button>
<Button size="small" onClick={() => void openAttachment(record)}>下载</Button>
</Space>
),
},
]}
/>
</Space>
),
},
{
key: 'difficulty',
label: '难度与校准',
children: (
<Space direction="vertical" style={{ width: '100%' }}>
<Row gutter={12}>
<Col span={8}><Card><Statistic title="AI 评分" value={difficulty?.aiScore ?? '-'} /></Card></Col>
<Col span={8}><Card><Statistic title="AI 建议" value={difficulty?.aiSuggestedLevel ?? '-'} /></Card></Col>
<Col span={8}><Card><Statistic title="校准等级" value={difficulty?.calibratedLevel ?? '-'} /></Card></Col>
</Row>
{difficulty?.anchorText && (
<Card size="small" title="参照锚点">
<Typography.Text>{difficulty.anchorText}</Typography.Text>
<div style={{ marginTop: 8 }}>
<Typography.Text type="secondary">
参照项目:{difficulty.anchorProjectName || '-'} · {projectTypeLabel(difficulty.anchorProjectType)} · {difficulty.anchorLevel || '-'}
</Typography.Text>
</div>
</Card>
)}
<Button icon={<ThunderboltOutlined />} onClick={() => void evaluateDifficulty()}>重新调用 AI 评分</Button>
<Form form={calibrateForm} layout="vertical">
<Form.Item name="newLevel" label="校准后等级" rules={[{ required: true }]}>
<Select options={difficultyOptions} />
</Form.Item>
<Form.Item name="reason" label="校准原因">
<TextArea rows={2} />
</Form.Item>
<Button type="primary" onClick={() => void calibrate()}>提交校准</Button>
</Form>
<Table
size="small"
rowKey="id"
dataSource={difficulty?.calibrationHistory || []}
pagination={false}
columns={[
{ title: '原等级', dataIndex: 'previousLevel', width: 90 },
{ title: '新等级', dataIndex: 'newLevel', width: 90 },
{ title: '原因', dataIndex: 'reason' },
{ title: '操作人', dataIndex: 'calibratedBy', width: 100 },
{
title: '时间',
dataIndex: 'calibratedAt',
width: 180,
render: (value: string) => formatDateTime(value),
},
]}
/>
</Space>
),
},
{
key: 'knowledge',
label: '知识点',
children: (
<Space direction="vertical" style={{ width: '100%' }}>
<Space wrap>
<Button
icon={<ThunderboltOutlined />}
loading={knowledgeExtracting}
onClick={() => void extractKnowledgePoints()}
>
AI 提取知识点
</Button>
<Button icon={<PlusOutlined />} onClick={openCreateKnowledgePoint}>新增知识点</Button>
<Select
allowClear
placeholder="按分类筛选"
style={{ width: 140 }}
options={knowledgeCategoryOptions}
value={knowledgeFilter.category}
onChange={(category) => void loadKnowledgePoints(detail, { ...knowledgeFilter, category })}
/>
<Select
allowClear
placeholder="按难度筛选"
style={{ width: 140 }}
options={knowledgeDifficultyOptions}
value={knowledgeFilter.difficulty}
onChange={(difficultyValue) => void loadKnowledgePoints(detail, {
...knowledgeFilter,
difficulty: difficultyValue,
})}
/>
<Button onClick={() => void loadKnowledgePoints(detail, {})}>重置筛选</Button>
<Button onClick={() => void loadKnowledgePoints(detail, knowledgeFilter)}>刷新</Button>
</Space>
<Table
size="small"
rowKey="id"
loading={knowledgeLoading}
dataSource={knowledgePoints}
pagination={false}
columns={[
{ title: '知识点', dataIndex: 'name', width: 160 },
{ title: '分类', dataIndex: 'category', width: 100 },
{ title: '难度', dataIndex: 'difficulty', width: 100 },
{
title: '预计时长',
dataIndex: 'estimatedHours',
width: 100,
render: (value?: number) => value ? `${value}h` : '-',
},
{
title: '说明',
dataIndex: 'description',
render: (value?: string) => value || '-',
},
{
title: '前置知识',
dataIndex: 'prerequisites',
render: (values?: KnowledgePointRef[]) =>
values?.length ? values.map((item) => <Tag key={item.id}>{item.name}</Tag>) : '-',
},
{
title: '后续知识',
dataIndex: 'dependents',
render: (values?: KnowledgePointRef[]) =>
values?.length ? values.map((item) => <Tag key={item.id}>{item.name}</Tag>) : '-',
},
{
title: '材料',
dataIndex: 'materialUrl',
width: 120,
render: (value?: string) =>
value ? <a href={value} target="_blank" rel="noreferrer">打开材料</a> : '-',
},
{
title: '操作',
width: 140,
render: (_, record: KnowledgePointItem) => (
<Space>
<Button size="small" onClick={() => openEditKnowledgePoint(record)}>编辑</Button>
<Popconfirm title="确认删除该知识点?" onConfirm={() => void deleteKnowledgePoint(record)}>
<Button size="small" danger>删除</Button>
</Popconfirm>
</Space>
),
},
]}
/>
</Space>
),
},
{
key: 'recommendation',
label: 'AI 推荐',
children: (
<Space direction="vertical" style={{ width: '100%' }}>
{detail.projectType !== 'internal' && (
<Typography.Paragraph type="secondary">
当前推荐入口以内部种子项目为基准,请在内部项目详情中发起推荐。
</Typography.Paragraph>
)}
<Space wrap>
<Select
value={recommendationType}
options={[
{ label: 'GitHub 推荐项目', value: 'github' },
{ label: '往届标注项目', value: 'annotation' },
]}
style={{ width: 180 }}
onChange={setRecommendationType}
/>
<Button
type="primary"
icon={<ThunderboltOutlined />}
loading={recommendationLoading}
disabled={detail.projectType !== 'internal'}
onClick={() => void recommendProjects()}
>
生成 Top 5 推荐
</Button>
<Button onClick={() => void loadRecommendationHistory()}>刷新历史</Button>
</Space>
<Table
size="small"
rowKey={(record) => `${record.projectType}-${record.projectId}-${record.recommendationId || 'new'}`}
loading={recommendationLoading}
dataSource={recommendations}
pagination={false}
columns={[
{ title: '推荐项目', dataIndex: 'projectName', width: 180 },
{ title: '类型', dataIndex: 'projectType', width: 100, render: (value: string) => projectTypeLabel(value) },
{ title: '难度', dataIndex: 'difficultyLevel', width: 90, render: (value?: string) => value || '-' },
{ title: '匹配度', dataIndex: 'matchScore', width: 100, render: (value?: number) => formatRecommendationScore(value) },
{ title: '理由', dataIndex: 'matchReason' },
{
title: '操作',
width: 130,
render: (_, record: RecommendationItem) => (
<Space>
<Button size="small" type="primary" onClick={() => void updateRecommendationAction(record, 'choose')}>
选择
</Button>
<Button size="small" onClick={() => void updateRecommendationAction(record, 'ignore')}>
忽略
</Button>
</Space>
),
},
]}
/>
<Divider orientation="left">推荐历史</Divider>
<Table
size="small"
rowKey={(record) => `${record.recommendationId}-${record.createdAt}`}
dataSource={recommendationHistory}
pagination={false}
columns={[
{ title: '种子项目', dataIndex: 'seedProjectName', width: 140 },
{ title: '推荐项目', dataIndex: 'projectName', width: 160 },
{ title: '类型', dataIndex: 'projectType', width: 100, render: (value: string) => projectTypeLabel(value) },
{ title: '匹配度', dataIndex: 'matchScore', width: 100, render: (value?: number) => formatRecommendationScore(value) },
{ title: '状态', dataIndex: 'userAction', width: 90, render: (value?: string) => value || '-' },
{ title: '来源', dataIndex: 'source', width: 90, render: (value?: string) => value || '-' },
{ title: '推荐理由', dataIndex: 'matchReason' },
{
title: '推荐时间',
dataIndex: 'createdAt',
width: 180,
render: (value?: string) => formatDateTime(value),
},
{
title: '操作时间',
dataIndex: 'actionAt',
width: 180,
render: (value?: string) => formatDateTime(value),
},
]}
/>
</Space>
),
},
]}
/>
)}
</Drawer>
</Space>
);
}
import axios from 'axios';
const API_BASE_URL = '/api/v1/auth';
const api = axios.create({
baseURL: API_BASE_URL,
timeout: 10000,
headers: {
'Content-Type': 'application/json',
},
});
// 请求拦截器 - 添加 Token
api.interceptors.request.use(
(config) => {
const token = localStorage.getItem('accessToken');
if (token) {
config.headers.Authorization = `Bearer ${token}`;
}
return config;
},
(error) => Promise.reject(error)
);
// 响应拦截器 - 处理 Token 过期
api.interceptors.response.use(
(response) => response,
async (error) => {
const originalRequest = error.config;
// Token 过期,尝试刷新
if (error.response?.status === 401 && !originalRequest._retry) {
originalRequest._retry = true;
const refreshToken = localStorage.getItem('refreshToken');
if (refreshToken) {
try {
const response = await axios.post(`${API_BASE_URL}/refresh`, {
refreshToken,
});
const { accessToken } = response.data.data;
localStorage.setItem('accessToken', accessToken);
originalRequest.headers.Authorization = `Bearer ${accessToken}`;
return api(originalRequest);
} catch (refreshError) {
// 刷新失败,清除 Token 跳转登录
localStorage.removeItem('accessToken');
localStorage.removeItem('refreshToken');
window.location.href = '/login';
return Promise.reject(refreshError);
}
}
}
return Promise.reject(error);
}
);
// 登录接口
export interface LoginRequest {
username: string;
password: string;
}
// 手机验证码登录接口
export interface PhoneLoginRequest {
phone: string;
smsCode: string;
}
export interface LoginResponse {
accessToken: string;
refreshToken: string;
expiresIn: number;
tokenType: string;
user: {
id: number;
username: string;
realName: string;
roles: string[];
};
}
export const login = async (data: LoginRequest): Promise<LoginResponse> => {
const response = await api.post<{ code: number; message: string; data: LoginResponse }>('/login', data);
return response.data.data;
};
// 手机号+验证码登录
export const phoneLogin = async (data: PhoneLoginRequest): Promise<LoginResponse> => {
const response = await api.post<{ code: number; message: string; data: LoginResponse }>('/login/phone', data);
return response.data.data;
};
// 刷新 Token
export const refreshToken = async (refreshToken: string): Promise<{ accessToken: string; expiresIn: number }> => {
const response = await api.post<{ code: number; message: string; data: { accessToken: string; expiresIn: number } }>('/refresh', { refreshToken });
return response.data.data;
};
// 注册接口
export interface RegisterRequest {
username: string;
phone: string;
password: string;
realName: string;
smsCode: string;
}
export const register = async (data: RegisterRequest): Promise<void> => {
await api.post('/register', data);
};
// 登出接口
export const logout = async (): Promise<void> => {
await api.post('/logout');
};
// 发送验证码
export interface SendSmsCodeRequest {
phone: string;
type: 'login' | 'register' | 'reset';
}
export const sendSmsCode = async (data: SendSmsCodeRequest): Promise<void> => {
await api.post('/sms-code', data);
};
// 找回密码
export interface ResetPasswordRequest {
phone: string;
smsCode: string;
newPassword: string;
}
export const resetPassword = async (data: ResetPasswordRequest): Promise<void> => {
await api.post('/reset-password', data);
};
export default api;
import { create } from 'zustand';
import { persist } from 'zustand/middleware';
import { login as loginApi, logout as logoutApi, phoneLogin as phoneLoginApi, LoginResponse } from '../services/authApi';
interface User {
id: number;
username: string;
realName: string;
roles: string[];
}
interface AuthState {
user: User | null;
accessToken: string | null;
refreshToken: string | null;
isAuthenticated: boolean;
// Actions
setAuth: (data: LoginResponse) => void;
login: (username: string, password: string) => Promise<void>;
phoneLogin: (phone: string, smsCode: string) => Promise<void>;
logout: () => Promise<void>;
clearAuth: () => void;
}
export const useAuthStore = create<AuthState>()(
persist(
(set, get) => ({
user: null,
accessToken: null,
refreshToken: null,
isAuthenticated: false,
setAuth: (data: LoginResponse) => {
localStorage.setItem('accessToken', data.accessToken);
localStorage.setItem('refreshToken', data.refreshToken);
set({
user: data.user,
accessToken: data.accessToken,
refreshToken: data.refreshToken,
isAuthenticated: true,
});
},
login: async (username: string, password: string) => {
const response = await loginApi({ username, password });
get().setAuth(response);
},
phoneLogin: async (phone: string, smsCode: string) => {
const response = await phoneLoginApi({ phone, smsCode });
get().setAuth(response);
},
logout: async () => {
try {
await logoutApi();
} catch (error) {
// 即使 API 调用失败,也清除本地状态
console.error('Logout API error:', error);
} finally {
get().clearAuth();
}
},
clearAuth: () => {
localStorage.removeItem('accessToken');
localStorage.removeItem('refreshToken');
set({
user: null,
accessToken: null,
refreshToken: null,
isAuthenticated: false,
});
},
}),
{
name: 'auth-storage',
partialize: (state) => ({
user: state.user,
accessToken: state.accessToken,
refreshToken: state.refreshToken,
isAuthenticated: state.isAuthenticated,
}),
}
)
);
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论