提交 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; 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.entity.User;
import com.platform.backend.repository.PermissionRepository;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository; import com.platform.backend.repository.UserRepository;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner; import org.springframework.boot.CommandLineRunner;
import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
import java.util.List;
@Slf4j @Slf4j
@Component @Component
...@@ -14,21 +22,70 @@ import org.springframework.stereotype.Component; ...@@ -14,21 +22,70 @@ import org.springframework.stereotype.Component;
public class DataInitializer implements CommandLineRunner { public class DataInitializer implements CommandLineRunner {
private final UserRepository userRepository; private final UserRepository userRepository;
private final RoleRepository roleRepository;
private final PermissionRepository permissionRepository;
private final PasswordEncoder passwordEncoder; private final PasswordEncoder passwordEncoder;
@Override @Override
@Transactional
public void run(String... args) { 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")) { if (!userRepository.existsByUsername("admin")) {
User admin = new User(); User admin = new User();
admin.setUsername("admin"); admin.setUsername("admin");
admin.setPassword(passwordEncoder.encode("admin123")); admin.setPassword(passwordEncoder.encode("admin123"));
admin.setRole("ADMIN");
admin.setRealName("管理员"); admin.setRealName("管理员");
admin.setEmail("admin@example.com"); admin.setEmail("admin@example.com");
admin.setRoleId(adminRole.getId());
admin.setStatus(1);
admin.setIsDeleted(0);
userRepository.save(admin); userRepository.save(admin);
log.info("测试账号已创建: admin / admin123"); log.info("测试账号已创建: admin / admin123 (roleId={})", adminRole.getId());
} else { } else {
log.info("admin 账号已存在,跳过初始化"); 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; package com.platform.backend.config;
import com.platform.backend.auth.JwtProperties;
import com.platform.backend.auth.TraceIdFilter;
import com.platform.backend.security.JwtAuthenticationFilter; import com.platform.backend.security.JwtAuthenticationFilter;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
...@@ -31,7 +33,9 @@ import java.util.List; ...@@ -31,7 +33,9 @@ import java.util.List;
public class SecurityConfig { public class SecurityConfig {
private final JwtAuthenticationFilter jwtAuthFilter; private final JwtAuthenticationFilter jwtAuthFilter;
private final TraceIdFilter traceIdFilter;
private final UserDetailsService userDetailsService; private final UserDetailsService userDetailsService;
private final JwtProperties jwtProperties;
@Bean @Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception { public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
...@@ -40,10 +44,11 @@ public class SecurityConfig { ...@@ -40,10 +44,11 @@ public class SecurityConfig {
.cors(cors -> cors.configurationSource(corsConfigurationSource())) .cors(cors -> cors.configurationSource(corsConfigurationSource()))
.sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.authorizeHttpRequests(auth -> auth .authorizeHttpRequests(auth -> auth
.requestMatchers("/api/auth/**", "/api/health", "/actuator/**").permitAll() .requestMatchers("/api/v1/auth/**", "/api/health", "/actuator/**").permitAll()
.anyRequest().authenticated() .anyRequest().authenticated()
) )
.authenticationProvider(authenticationProvider()) .authenticationProvider(authenticationProvider())
.addFilterBefore(traceIdFilter, UsernamePasswordAuthenticationFilter.class)
.addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class); .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class);
return http.build(); return http.build();
...@@ -75,6 +80,6 @@ public class SecurityConfig { ...@@ -75,6 +80,6 @@ public class SecurityConfig {
@Bean @Bean
public PasswordEncoder passwordEncoder() { public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder(); return new BCryptPasswordEncoder(jwtProperties.getBcrypt().getStrength());
} }
} }
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; package com.platform.backend.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank; import jakarta.validation.constraints.NotBlank;
import lombok.Data; import lombok.Data;
......
package com.platform.backend.dto; package com.platform.backend.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor; import lombok.AllArgsConstructor;
import lombok.Data; import lombok.Data;
import lombok.NoArgsConstructor; import lombok.NoArgsConstructor;
import java.util.List;
@Data @Data
@NoArgsConstructor @NoArgsConstructor
@AllArgsConstructor @AllArgsConstructor
public class LoginResponse { public class LoginResponse {
private String token; @JsonProperty("accessToken")
private String username; private String accessToken;
private String role;
private Long expiresIn; @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;
@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; ...@@ -8,7 +8,13 @@ import lombok.NoArgsConstructor;
import java.time.LocalDateTime; import java.time.LocalDateTime;
@Entity @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 @Data
@NoArgsConstructor @NoArgsConstructor
@AllArgsConstructor @AllArgsConstructor
...@@ -21,29 +27,66 @@ public class User { ...@@ -21,29 +27,66 @@ public class User {
@Column(unique = true, nullable = false, length = 50) @Column(unique = true, nullable = false, length = 50)
private String username; private String username;
@Column(nullable = false) @Column(nullable = false, length = 255)
private String password; private String password;
@Column(name = "real_name", nullable = false, length = 50)
private String realName;
@Column(length = 100) @Column(length = 100)
private String email; private String email;
@Column(length = 20) @Column(length = 20)
private String phone; private String phone;
@Column(length = 50) @Column(name = "role_id")
private String realName; private Long roleId;
@Column(length = 20) @Column(name = "department_id")
private String role = "USER"; 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 @PreUpdate
protected void onUpdate() { 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; ...@@ -4,10 +4,16 @@ import com.platform.backend.entity.User;
import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional; import java.util.Optional;
@Repository @Repository
public interface UserRepository extends JpaRepository<User, Long> { public interface UserRepository extends JpaRepository<User, Long> {
Optional<User> findByUsername(String username); Optional<User> findByUsername(String username);
Optional<User> findByUsernameAndIsDeleted(String username, Integer isDeleted);
Optional<User> findByPhone(String phone);
boolean existsByUsername(String username); 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; package com.platform.backend.security;
import com.platform.backend.entity.Role;
import com.platform.backend.entity.User; import com.platform.backend.entity.User;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository; import com.platform.backend.repository.UserRepository;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.authority.SimpleGrantedAuthority; import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.core.userdetails.UserDetailsService;
...@@ -11,23 +14,46 @@ import org.springframework.stereotype.Service; ...@@ -11,23 +14,46 @@ import org.springframework.stereotype.Service;
import java.util.Collections; import java.util.Collections;
@Slf4j
@Service @Service
@RequiredArgsConstructor @RequiredArgsConstructor
public class CustomUserDetailsService implements UserDetailsService { public class CustomUserDetailsService implements UserDetailsService {
private final UserRepository userRepository; private final UserRepository userRepository;
private final RoleRepository roleRepository;
@Override @Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
User user = userRepository.findByUsername(username) User user = userRepository.findByUsername(username)
.orElseThrow(() -> new UsernameNotFoundException("用户不存在: " + username)); .orElseThrow(() -> new UsernameNotFoundException("用户不存在: " + username));
String authority = resolveAuthority(user);
return new org.springframework.security.core.userdetails.User( return new org.springframework.security.core.userdetails.User(
user.getUsername(), user.getUsername(),
user.getPassword(), user.getPassword(),
user.getEnabled(), user.getEnabled(),
true, true, true, 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; package com.platform.backend.security;
import io.jsonwebtoken.*; import com.platform.backend.auth.JwtTokenService;
import io.jsonwebtoken.security.Keys; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Date;
@Component @Component
@RequiredArgsConstructor
public class JwtUtils { public class JwtUtils {
@Value("${jwt.secret:intern-platform-super-secret-key-2024}") private final JwtTokenService tokenService;
private String jwtSecret;
@Value("${jwt.expiration:86400000}") public String generateToken(String username, String role) {
private long jwtExpiration; return tokenService.generateAccessToken(username, role);
}
private SecretKey getSigningKey() { public String generateAccessToken(String username, String role) {
return Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8)); return tokenService.generateAccessToken(username, role);
} }
public String generateToken(String username, String role) { public String generateRefreshToken(String username, String role) {
return Jwts.builder() return tokenService.generateRefreshToken(username, role);
.subject(username)
.claim("role", role)
.issuedAt(new Date())
.expiration(new Date(System.currentTimeMillis() + jwtExpiration))
.signWith(getSigningKey())
.compact();
} }
public String getUsernameFromToken(String token) { public String getUsernameFromToken(String token) {
return Jwts.parser() return tokenService.getUsernameFromToken(token);
.verifyWith(getSigningKey())
.build()
.parseSignedClaims(token)
.getPayload()
.getSubject();
} }
public boolean validateToken(String token) { public String getRoleFromToken(String token) {
try { return tokenService.getRoleFromToken(token);
Jwts.parser().verifyWith(getSigningKey()).build().parseSignedClaims(token); }
return true;
} catch (JwtException | IllegalArgumentException e) { public String getJtiFromToken(String token) {
return false; return tokenService.getJtiFromToken(token);
}
} }
public long getExpiration() { 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: ...@@ -7,35 +7,97 @@ spring:
name: backend-app name: backend-app
datasource: 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 username: studyweb
password: studyweb123 password: studyweb123
driver-class-name: com.mysql.cj.jdbc.Driver driver-class-name: com.mysql.cj.jdbc.Driver
hikari:
connection-timeout: 5000
initialization-fail-timeout: 60000
jpa: jpa:
hibernate: hibernate:
ddl-auto: update ddl-auto: update
show-sql: true show-sql: false
properties: properties:
hibernate: hibernate:
dialect: org.hibernate.dialect.MySQLDialect dialect: org.hibernate.dialect.MySQLDialect
format_sql: true format_sql: false
data: data:
redis: redis:
host: localhost host: localhost
port: 6379 port: 16379
password: "" password: studyweb123
timeout: 3000ms
lettuce:
pool:
max-active: 16
max-idle: 8
min-idle: 2
logging: logging:
level: level:
root: INFO # 只显示接口日志和错误
com.platform.backend: DEBUG root: WARN
org.springframework.web: INFO com.platform.backend: INFO
org.springframework.security: 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 报告噪音 # 关闭 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: jwt:
secret: intern-platform-super-secret-key-2024-must-be-at-least-32-bytes 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
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<configuration> <configuration>
<include resource="org/springframework/boot/logging/logback/defaults.xml"/> <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"> <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder> <encoder>
<pattern>${CONSOLE_LOG_PATTERN}</pattern> <pattern>%d{HH:mm:ss.SSS} [%level] %logger{36} - %msg%n</pattern>
<charset>UTF-8</charset> <charset>UTF-8</charset>
</encoder> </encoder>
</appender> </appender>
<root level="INFO"> <root level="WARN">
<appender-ref ref="CONSOLE"/> <appender-ref ref="CONSOLE"/>
</root> </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> </configuration>
import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom'; import { BrowserRouter, Routes, Route, Navigate, useLocation, useNavigate } from 'react-router-dom';
import { Layout, Menu } from 'antd'; import { Layout, Menu, Dropdown, Avatar, Button, Space } from 'antd';
import type { MenuProps } from 'antd';
import { import {
DashboardOutlined, DashboardOutlined,
ProjectOutlined, ProjectOutlined,
BookOutlined, BookOutlined,
AuditOutlined, AuditOutlined,
BellOutlined, BellOutlined,
UserOutlined,
LogoutOutlined,
SettingOutlined,
} from '@ant-design/icons'; } from '@ant-design/icons';
import { useState } from 'react'; import { useState, useEffect } from 'react';
import DashboardPage from './pages/DashboardPage'; import DashboardPage from './pages/DashboardPage';
import ProjectPage from './pages/ProjectPage'; import ProjectPage from './pages/ProjectPage';
import TrainingPage from './pages/TrainingPage'; import TrainingPage from './pages/TrainingPage';
import DefensePage from './pages/DefensePage'; import DefensePage from './pages/DefensePage';
import AuditPage from './pages/AuditPage'; import AuditPage from './pages/AuditPage';
import NotificationPage from './pages/NotificationPage'; import NotificationPage from './pages/NotificationPage';
import LoginPage from './pages/LoginPage';
import { useAuthStore } from './stores/useAuthStore';
const { Header, Sider, Content } = Layout; const { Header, Sider, Content } = Layout;
...@@ -26,53 +32,183 @@ const menuItems = [ ...@@ -26,53 +32,183 @@ const menuItems = [
{ key: '/notifications', icon: <BellOutlined />, label: '通知' }, { 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 [collapsed, setCollapsed] = useState(false);
const [selectedKey, setSelectedKey] = useState('/dashboard'); 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 ( return (
<BrowserRouter> <Layout style={{ minHeight: '100vh' }}>
<Layout style={{ minHeight: '100vh' }}> <Sider collapsible collapsed={collapsed} onCollapse={setCollapsed}>
<Sider collapsible collapsed={collapsed} onCollapse={setCollapsed}> <div
<div style={{
style={{ height: 64,
height: 64, margin: 16,
margin: 16, color: '#fff',
color: '#fff', fontSize: 18,
fontSize: 18, fontWeight: 600,
fontWeight: 600, textAlign: 'center',
textAlign: 'center', lineHeight: '32px',
lineHeight: '32px', display: 'flex',
}} alignItems: 'center',
> justifyContent: 'center',
{collapsed ? '实' : '实习生训练平台'} }}
</div> >
<Menu {collapsed ? (
theme="dark" <span style={{ fontSize: 24 }}>实</span>
mode="inline" ) : (
selectedKeys={[selectedKey]} <span>实习生训练平台</span>
items={menuItems} )}
onClick={(e) => setSelectedKey(e.key)} </div>
/> <Menu
</Sider> theme="dark"
<Layout> mode="inline"
<Header style={{ background: '#fff', paddingLeft: 24, fontSize: 20 }}> selectedKeys={[selectedKey]}
实习生训练平台 · MVP items={menuItems}
</Header> onClick={(e) => {
<Content style={{ margin: 16, padding: 24, background: '#fff', borderRadius: 8 }}> setSelectedKey(e.key);
<Routes> navigate(e.key);
<Route path="/" element={<Navigate to="/dashboard" replace />} /> }}
<Route path="/dashboard" element={<DashboardPage />} /> />
<Route path="/projects" element={<ProjectPage />} /> </Sider>
<Route path="/training" element={<TrainingPage />} /> <Layout>
<Route path="/defense" element={<DefensePage />} /> <Header
<Route path="/audit" element={<AuditPage />} /> style={{
<Route path="/notifications" element={<NotificationPage />} /> background: '#fff',
<Route path="*" element={<div>404 Not Found</div>} /> padding: '0 24px',
</Routes> display: 'flex',
</Content> alignItems: 'center',
</Layout> 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,
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>
</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> </BrowserRouter>
); );
} }
...@@ -14,3 +14,64 @@ html, body, #root { ...@@ -14,3 +14,64 @@ html, body, #root {
display: flex; display: flex;
flex-direction: column; 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;
}
差异被折叠。
差异被折叠。
差异被折叠。
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论