提交 44c60fc9 authored 作者: caifuming's avatar caifuming

cfm_7/16/完成用户模块第二版文档所有功能已实现并通过验收

上级 a3abd226
......@@ -2,6 +2,7 @@
from __future__ import annotations
import json
import re
from app.llm.base import LLMProvider, ProviderRequest, ProviderResult
......@@ -17,24 +18,57 @@ class MockProvider(LLMProvider):
content = f"[mock:{request.model}] {user_message[:400]}".strip()
structured = None
if request.response_format == "json":
structured = {
"summary": "Mock structured output for local verification.",
"knowledge_points": [
{
"name": "Tensor basics",
"description": "Understand tensors, shapes, and simple operations.",
"difficulty": "beginner",
"estimated_minutes": 30,
"prerequisites": ["Python basics"],
}
],
"prerequisites": ["Python basics"],
"study_order": ["Tensor basics", "Autograd", "Training loop"],
"common_mistakes": ["Shape mismatch", "Device mismatch"],
}
structured = self._structured_response(user_message)
content = json.dumps(structured, ensure_ascii=True)
return ProviderResult(
content=content,
structured=structured,
raw={"provider": self.name, "model": request.model},
)
def _structured_response(self, user_message: str) -> dict:
candidate_match = re.search(
r"<CANDIDATES_JSON>\s*(.*?)\s*</CANDIDATES_JSON>",
user_message,
flags=re.DOTALL,
)
if candidate_match:
try:
candidates = json.loads(candidate_match.group(1))
except json.JSONDecodeError:
candidates = []
recommendations = []
for candidate in candidates if isinstance(candidates, list) else []:
if not isinstance(candidate, dict):
continue
project_id = candidate.get("project_id")
project_name = str(candidate.get("project_name") or "候选项目")
if not isinstance(project_id, int):
continue
recommendations.append(
{
"project_id": project_id,
"match_reason": (
f"候选项目“{project_name}”与种子项目在技术方向、主题标签和工程实践上具有关联,"
"可以用于继续训练相近能力并对比不同实现方式;建议结合 README、核心目录和"
"实际运行结果确认学习成本与适用范围。"
),
}
)
return {"recommendations": recommendations}
return {
"summary": "Mock structured output for local verification.",
"knowledge_points": [
{
"name": "Tensor basics",
"description": "Understand tensors, shapes, and simple operations.",
"difficulty": "beginner",
"estimated_minutes": 30,
"prerequisites": ["Python basics"],
}
],
"prerequisites": ["Python basics"],
"study_order": ["Tensor basics", "Autograd", "Training loop"],
"common_mistakes": ["Shape mismatch", "Device mismatch"],
}
......@@ -31,6 +31,12 @@
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring WebClient for backend-app -> ai-service calls -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<!-- Spring Boot Data JPA -->
<dependency>
<groupId>org.springframework.boot</groupId>
......@@ -49,12 +55,39 @@
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- Spring Boot AOP (用于 @PreAuthorize 自定义注解 + @DataScope) -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!-- Alibaba EasyExcel(用于批量导入) -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel</artifactId>
<version>3.3.4</version>
</dependency>
<!-- Spring Boot Redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- Resilience4j for AI service timeout/circuit-breaker protection -->
<dependency>
<groupId>io.github.resilience4j</groupId>
<artifactId>resilience4j-spring-boot3</artifactId>
<version>2.2.0</version>
</dependency>
<!-- MinIO file storage client -->
<dependency>
<groupId>io.minio</groupId>
<artifactId>minio</artifactId>
<version>8.5.12</version>
</dependency>
<!-- MySQL Connector -->
<dependency>
<groupId>com.mysql</groupId>
......
......@@ -10,4 +10,6 @@ public final class AuthConstants {
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:";
public static final String REDIS_ACCESS_BLACKLIST_PREFIX = "auth:access:blacklist:";
public static final String REDIS_TOKEN_VERSION_PREFIX = "auth:token:version:";
}
......@@ -3,6 +3,7 @@ package com.platform.backend.auth;
import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
......@@ -12,6 +13,7 @@ import java.util.Date;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
@Slf4j
@Service
@RequiredArgsConstructor
public class JwtTokenService {
......@@ -27,11 +29,13 @@ public class JwtTokenService {
public String generateAccessToken(String username, String role) {
long now = System.currentTimeMillis();
int tokenVersion = getTokenVersion(username);
return Jwts.builder()
.id(UUID.randomUUID().toString())
.subject(username)
.claim("role", role)
.claim("type", "access")
.claim("tokenVersion", tokenVersion)
.issuedAt(new Date(now))
.expiration(new Date(now + props.getAccess().getExpirationMs()))
.signWith(signingKey())
......@@ -132,20 +136,99 @@ public class JwtTokenService {
// ===== logout =====
public void logout(String refreshToken) {
/**
* 登出:同时拉黑 access token 和 refresh token,实现立即失效。
*
* @param accessToken 当前 access token(用于提取 jti 并拉黑)
* @param refreshToken 当前 refresh token(用于提取 jti 并拉黑)
*/
public void logout(String accessToken, String refreshToken) {
// 1. 拉黑 access token
if (accessToken != null && !accessToken.isBlank()) {
try {
String accessJti = parseClaims(accessToken).getId();
long accessTtlMs = parseClaims(accessToken).getExpiration().getTime()
- System.currentTimeMillis();
if (accessTtlMs > 0) {
redis.opsForValue().set(
AuthConstants.REDIS_ACCESS_BLACKLIST_PREFIX + accessJti,
"1",
accessTtlMs,
TimeUnit.MILLISECONDS);
}
} catch (JwtException | IllegalArgumentException e) {
// access token 解析失败不影响 refresh 拉黑
}
}
// 2. 拉黑 refresh token
if (refreshToken != null && !refreshToken.isBlank()) {
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);
redis.delete(AuthConstants.REDIS_REFRESH_ACTIVE_PREFIX + claims.getSubject());
} catch (JwtException | IllegalArgumentException ignored) {
// 已过期/已失效也允许清理
}
}
}
// ===== Token 版本控制:密码修改 / 角色分配后使旧 Token 失效 =====
/**
* 获取用户当前 Token 版本号(Redis 中存的版本)。
*/
public int getTokenVersion(String username) {
String v = redis.opsForValue().get(AuthConstants.REDIS_TOKEN_VERSION_PREFIX + username);
return v == null ? 0 : Integer.parseInt(v);
}
/**
* 递增用户 Token 版本号(+1)。
* 递增后,所有旧 access token 的 jti 将不在新版本中有效,实现强制下线。
*/
public void incrementTokenVersion(String username) {
redis.opsForValue().increment(AuthConstants.REDIS_TOKEN_VERSION_PREFIX + username);
log.info("[Token] 用户 {} Token 版本递增,当前所有旧 Token 已失效", username);
}
/**
* 检查 access token 的 jti 是否在黑名单中(已失效)。
*
* @param token access token
* @param username 用户名(从 token 中提取或外部传入)
* @return true = 已失效,false = 有效
*/
public boolean isAccessTokenInvalid(String token, String username) {
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 也允许前端清理
String jti = parseClaims(token).getId();
String blacklistKey = AuthConstants.REDIS_ACCESS_BLACKLIST_PREFIX + jti;
if (Boolean.TRUE.equals(redis.hasKey(blacklistKey))) {
return true;
}
// Token 版本校验:用户 Token 版本号变化后,旧 jti 失效
int currentVersion = getTokenVersion(username);
Object tokenVersionObj = parseClaims(token).get("tokenVersion");
if (tokenVersionObj != null) {
int tokenVersion;
if (tokenVersionObj instanceof Number) {
tokenVersion = ((Number) tokenVersionObj).intValue();
} else {
tokenVersion = Integer.parseInt(tokenVersionObj.toString());
}
if (tokenVersion < currentVersion) {
return true;
}
}
return false;
} catch (Exception e) {
return true; // 解析失败视为无效
}
}
}
package com.platform.backend.auth;
import com.platform.backend.entity.SmsCode;
import com.platform.backend.repository.SmsCodeRepository;
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.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.Random;
import java.util.concurrent.TimeUnit;
/**
* 短信验证码服务(对应文档 4.3 验证码模块)。
*
* <p>验证码同时写入 Redis(快速校验)和 user_sms_code 表(持久化日志)。
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class SmsCodeService {
private final StringRedisTemplate redis;
private final SmsCodeRepository smsCodeRepository;
@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 生成的验证码(模拟发送,实际项目中应调用短信网关)
* 生成并存储验证码。
* 同时写入 Redis(快速校验)和 user_sms_code 表(持久化)。
*/
public String generateCode(String phone, String type, String ip) {
String key = SMS_KEY_PREFIX + phone + ":" + type;
// 检查发送频率
String sendKey = key + ":send";
// 1. 发送频率检查
String sendKey = SMS_KEY_PREFIX + phone + ":" + type + ":send";
Long lastSend = redis.opsForValue().increment(sendKey);
if (lastSend != null && lastSend > 1) {
Long ttl = redis.getExpire(sendKey);
......@@ -45,8 +53,8 @@ public class SmsCodeService {
}
}
redis.expire(sendKey, sendIntervalSeconds, TimeUnit.SECONDS);
// 检查IP频率
// 2. IP 频率检查
String ipKey = IP_LIMIT_KEY_PREFIX + ip;
Long ipCount = redis.opsForValue().increment(ipKey);
if (ipCount != null && ipCount > MAX_IP_PER_HOUR) {
......@@ -56,35 +64,74 @@ public class SmsCodeService {
if (ipCount != null && ipCount == 1) {
redis.expire(ipKey, 3600, TimeUnit.SECONDS);
}
// 生成6位验证码
// 3. 生成 6 位验证码
String code = String.format("%06d", random.nextInt(1000000));
// 存储到Redis
redis.opsForValue().set(key, code, expireMinutes * 60L, TimeUnit.SECONDS);
// 4. 写入 Redis(快速校验用,TTL = 5 分钟)
String cacheKey = SMS_KEY_PREFIX + phone + ":" + type;
redis.opsForValue().set(cacheKey, code, expireMinutes * 60L, TimeUnit.SECONDS);
// 5. 持久化到 user_sms_code 表
saveSmsCodeToDb(phone, code, type, ip);
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)) {
if (storedCode == null || !storedCode.equals(code)) {
return false;
}
// 验证通过,删除验证码(一次性使用)
// 验证通过,删除 Redis 中的验证码(一次性)
redis.delete(key);
// 标记数据库中对应记录为已使用
markCodeAsUsed(phone, type, code);
return true;
}
/**
* 持久化验证码到数据库(异步)。
*/
@Async
public void saveSmsCodeToDb(String phone, String code, String type, String ip) {
try {
SmsCode smsCode = new SmsCode();
smsCode.setPhone(phone);
smsCode.setCode(code);
smsCode.setType(type);
smsCode.setIp(ip);
smsCode.setExpireTime(LocalDateTime.now().plusMinutes(expireMinutes));
smsCode.setIsUsed(0);
smsCodeRepository.save(smsCode);
} catch (Exception e) {
log.warn("[SMS] 保存验证码到数据库失败 phone={} type={}: {}", phone, type, e.getMessage());
}
}
/**
* 标记验证码为已使用(异步)。
*/
@Async
public void markCodeAsUsed(String phone, String type, String code) {
try {
smsCodeRepository.findTopByPhoneAndTypeOrderByCreatedAtDesc(phone, type)
.filter(s -> s.getCode().equals(code) && s.getIsUsed() == 0)
.ifPresent(s -> {
s.setIsUsed(1);
smsCodeRepository.save(s);
});
} catch (Exception e) {
log.warn("[SMS] 标记验证码已使用失败 phone={} type={}: {}", phone, type, e.getMessage());
}
}
}
package com.platform.backend.common;
import com.platform.backend.dto.ApiResponse;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
/**
* 统一将 {@link ApiResponse} 包装为 {@link ResponseEntity},确保每个 controller 都显式声明 HTTP 状态码。
*
* <p>使用示例:
* <pre>
* return ApiResponseEnvelope.ok(buildUserDetail(user));
* return ApiResponseEnvelope.created(data);
* return ApiResponseEnvelope.noContent();
* </pre>
*
* <p>HTTP 状态码与业务码分离:
* <ul>
* <li>HTTP 200 + 业务码 200 = 操作成功</li>
* <li>HTTP 201 + 业务码 200 = 创建成功</li>
* <li>HTTP 204 + 无 body = 删除成功</li>
* </ul>
*/
public final class ApiResponseEnvelope {
private ApiResponseEnvelope() {}
/** HTTP 200 */
public static <T> ResponseEntity<ApiResponse<T>> ok(ApiResponse<T> body) {
return ResponseEntity.status(HttpStatus.OK).body(body);
}
public static <T> ResponseEntity<ApiResponse<T>> ok(T data, String traceId) {
return ok(ApiResponse.ok(data, traceId));
}
public static <T> ResponseEntity<ApiResponse<T>> ok(T data, String message, String traceId) {
return ok(ApiResponse.ok(data, message, traceId));
}
/** HTTP 201 Created */
public static <T> ResponseEntity<ApiResponse<T>> created(ApiResponse<T> body) {
return ResponseEntity.status(HttpStatus.CREATED).body(body);
}
public static <T> ResponseEntity<ApiResponse<T>> created(T data, String message, String traceId) {
return created(ApiResponse.ok(data, message, traceId));
}
/** HTTP 204 No Content(无 body) */
public static ResponseEntity<Void> noContent() {
return ResponseEntity.noContent().build();
}
}
\ No newline at end of file
package com.platform.backend.common;
/**
* 业务码枚举(与平台文档 user-module-任务文档.md 3.1.3 一致)。
*
* <p>响应体中 {@code code} 字段取自本枚举;HTTP 状态码由 GlobalExceptionHandler 按 {@link #getDefaultHttpStatus()} 映射。
*/
public enum BizCode {
SUCCESS(200, "操作成功"),
PARAM_INVALID(1001, "参数错误"),
UNAUTHORIZED(1002, "认证失败,请重新登录"),
FORBIDDEN(1003, "无权限访问"),
RESOURCE_NOT_FOUND(1004, "资源不存在"),
TOO_MANY_REQUESTS(1005, "请求过于频繁,请稍后再试"),
USER_NOT_FOUND(2001, "用户不存在"),
USER_ALREADY_EXISTS(2002, "用户已存在"),
BAD_CREDENTIALS(2003, "账号或密码错误"),
ACCOUNT_LOCKED(2010, "账号已被锁定,请稍后再试"),
SMS_CODE_INVALID(2020, "验证码错误或已过期"),
OLD_PASSWORD_WRONG(2021, "旧密码错误"),
PASSWORD_REUSED(2022, "不可与最近 3 次密码相同"),
CANNOT_DELETE_SELF(2023, "不能删除自己"),
CANNOT_DELETE_ADMIN(2027, "不能删除管理员账号"),
USER_HAS_PENDING(2024, "用户存在未结业务,无法删除"),
REFRESH_TOKEN_INVALID(2025, "Refresh token 已使用或已过期"),
ACCOUNT_DISABLED(2026, "账户已被禁用"),
ROLE_NAME_DUPLICATE(2030, "角色名称已存在"),
ROLE_HAS_USERS(2031, "该角色下存在用户,无法删除"),
ROLE_PRESET(2032, "预置角色不可修改/删除"),
MENU_HAS_CHILDREN(2040, "存在子菜单,无法删除"),
MENU_NAME_DUPLICATE(2041, "菜单名称已存在"),
SYSTEM_ERROR(9999, "系统繁忙,请稍后再试");
private final int code;
private final String defaultMessage;
BizCode(int code, String defaultMessage) {
this.code = code;
this.defaultMessage = defaultMessage;
}
public int getCode() {
return code;
}
public String getDefaultMessage() {
return defaultMessage;
}
public static BizCode of(int code) {
for (BizCode b : values()) {
if (b.code == code) return b;
}
return SYSTEM_ERROR;
}
}
package com.platform.backend.common;
import org.springframework.http.HttpStatus;
/**
* 业务异常:抛出后由 {@link GlobalExceptionHandler} 统一处理为对应 HTTP 状态码的 JSON 响应。
*
* <p>业务异常按 BizCode 自动映射到 HTTP 状态码:
* <ul>
* <li>1001 → 400</li>
* <li>1002 → 401</li>
* <li>1003 → 403</li>
* <li>1004 → 404</li>
* <li>1005 → 429</li>
* <li>2xxx 中的冲突类 → 409</li>
* <li>2010 → 423</li>
* <li>9999 → 500</li>
* </ul>
*/
public class BizException extends RuntimeException {
private final BizCode bizCode;
public BizException(BizCode bizCode) {
super(bizCode.getDefaultMessage());
this.bizCode = bizCode;
}
public BizException(BizCode bizCode, String message) {
super(message);
this.bizCode = bizCode;
}
public BizCode getBizCode() {
return bizCode;
}
public int getCode() {
return bizCode.getCode();
}
/** 根据业务码得到对应的 HTTP 状态码。 */
public HttpStatus getHttpStatus() {
return HttpStatusMapper.map(bizCode);
}
}
package com.platform.backend.common;
import java.lang.annotation.*;
/**
* 资源级数据权限注解(文档 4.10)。
*
* <p>配合 {@link DataScopeAspect} 使用,切面自动解析当前用户的角色 data_scope,
* 注入对应 SQL 条件到 {@link DataScopeContext},由 {@code JpaSpecificationExecutor}
* 读取并拼接 WHERE 子句。
*
* <p>使用示例:
* <pre>
* {@code @DataScope(tableAlias = "u")}
* {@code @PreAuthorize("hasAuthority('user:read')")}
* {@code public Page<User> listUsers(...) { ... }}
* </pre>
*
* @see DataScopeAspect
* @see DataScopeContext
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataScope {
/**
* 主表别名(与 JPA Specification root.get(alias) 对应)。
* 例如查询用户时表别名为 "u",则自动注入 "u.department_id = ?" 等条件。
*/
String tableAlias() default "u";
/**
* 部门 ID 列名(不含表别名),默认 "department_id"。
* 用于生成 {@code tableAlias.department_id = ?} 类型的条件。
*/
String deptIdColumn() default "department_id";
/**
* 用户 ID 列名(不含表别名),默认 "id"。
* 用于生成 {@code tableAlias.id = ?}(仅本人)类型的条件。
*/
String userIdColumn() default "id";
}
package com.platform.backend.common;
import com.platform.backend.entity.User;
import com.platform.backend.repository.DepartmentRepository;
import com.platform.backend.repository.RoleCustomDeptRepository;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* 数据权限 AOP 切面(文档 4.10)。
*
* <p>拦截所有带 {@link DataScope} 注解的方法:
* <ol>
* <li>从 SecurityContext 获取当前登录用户</li>
* <li>查询用户角色的 data_scope</li>
* <li>根据权限范围填充 {@link DataScopeContext}</li>
* <li>执行业务方法</li>
* <li>清理 ThreadLocal</li>
* </ol>
*
* <p>数据权限范围(user_role.data_scope):
* <ul>
* <li>1 = 全部(ALL)—— 无附加条件</li>
* <li>2 = 本部门(DEPARTMENT)—— 附加 department_id = #{user.deptId}</li>
* <li>3 = 本部门及下级(DEPARTMENT_AND_SUB)—— 本期简化为"本部门"</li>
* <li>4 = 仅本人(SELF)—— 附加 id = #{userId}</li>
* <li>5 = 自定义(CUSTOM)—— 附加 department_id IN (#{customDeptIds})</li>
* </ul>
*
* @see DataScope
* @see DataScopeContext
*/
@Slf4j
@Aspect
@Component
@RequiredArgsConstructor
public class DataScopeAspect {
private final UserRepository userRepository;
private final RoleRepository roleRepository;
private final RoleCustomDeptRepository roleCustomDeptRepository;
private final DepartmentRepository departmentRepository;
@Around("@annotation(dataScope)")
public Object around(ProceedingJoinPoint joinPoint, DataScope dataScope) throws Throwable {
DataScopeContext.DataScopeInfo info = buildDataScopeInfo();
DataScopeContext.set(info);
try {
return joinPoint.proceed();
} finally {
DataScopeContext.clear();
}
}
private DataScopeContext.DataScopeInfo buildDataScopeInfo() {
DataScopeContext.DataScopeInfo info = new DataScopeContext.DataScopeInfo();
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
if (auth == null || auth.getName() == null || "anonymousUser".equals(auth.getName())) {
info.setDataScope(4); // 未认证只能看自己
return info;
}
String username = auth.getName();
User user = userRepository.findByUsername(username).orElse(null);
if (user == null) {
info.setDataScope(4);
return info;
}
info.setUserId(user.getId());
info.setDepartmentId(user.getDepartmentId());
info.setRoleId(user.getRoleId());
// 查询角色 data_scope(默认 4=仅本人)
if (user.getRoleId() != null) {
roleRepository.findById(user.getRoleId())
.ifPresent(role -> {
int scope = role.getDataScope() != null ? role.getDataScope() : 4;
info.setDataScope(scope);
// data_scope=5 自定义部门
if (scope == 5) {
try {
List<Long> customDepts = roleCustomDeptRepository.findByRoleId(user.getRoleId())
.stream()
.map(rcd -> rcd.getDepartmentId())
.toList();
info.setCustomDeptIds(customDepts);
} catch (Exception e) {
log.warn("[DataScope] 查询自定义部门失败: {}", e.getMessage());
}
}
// data_scope=3 本部门及下级 → 注入子部门列表
if (scope == 3 && user.getDepartmentId() != null) {
try {
List<Long> childDepts = departmentRepository.findAllChildIds(user.getDepartmentId());
info.setChildDeptIds(childDepts);
} catch (Exception e) {
log.warn("[DataScope] 查询子部门失败: {}", e.getMessage());
}
}
});
} else {
info.setDataScope(4);
}
return info;
}
}
package com.platform.backend.common;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;
import lombok.Getter;
import lombok.Setter;
import java.util.ArrayList;
import java.util.List;
/**
* 数据权限上下文(ThreadLocal),由 {@link DataScopeAspect} 填充,
* {@code JpaSpecificationExecutor} 读取并拼接到 JPA 查询条件中。
*
* <p>线程隔离,异步场景安全。
*
* @see DataScope
* @see DataScopeAspect
*/
public class DataScopeContext {
private static final ThreadLocal<DataScopeInfo> CONTEXT = new ThreadLocal<>();
private DataScopeContext() {}
/**
* 当前线程的数据权限信息。
*/
@Getter
@Setter
public static class DataScopeInfo {
/** data_scope 值:1=全部 2=本部门 3=本部门及下级 4=仅本人 5=自定义 */
private int dataScope;
/** 当前用户 ID */
private Long userId;
/** 当前用户所属部门 ID */
private Long departmentId;
/** 当前用户角色 ID */
private Long roleId;
/** 自定义可访问部门列表(data_scope=5 时填充) */
private List<Long> customDeptIds = new ArrayList<>();
/** 本部门及子部门列表(data_scope=3 时填充) */
private List<Long> childDeptIds = new ArrayList<>();
public boolean isAdmin() {
return dataScope == 1;
}
}
/** 写入上下文 */
public static void set(DataScopeInfo info) {
CONTEXT.set(info);
}
/** 读取上下文 */
public static DataScopeInfo get() {
return CONTEXT.get();
}
/** 清除上下文(finally 块调用) */
public static void clear() {
CONTEXT.remove();
}
/**
* 根据 data_scope 构建部门相关过滤条件,返回 Predicate 列表。
* 调用方将其加入 Specification 的 predicates 列表。
*
* @param root JPA Root(对应查询主表)
* @param cb CriteriaBuilder
* @param deptCol 部门 ID 列名(不含表别名,如 "departmentId")
* @param userCol 用户 ID 列名(不含表别名,如 "id")
* @return 权限过滤条件列表(ADMIN 返回空列表)
*/
public static List<Predicate> buildPredicates(Root<?> root, CriteriaBuilder cb,
String deptCol, String userCol) {
List<Predicate> predicates = new ArrayList<>();
DataScopeInfo info = get();
if (info == null || info.isAdmin()) {
return predicates; // 无数据或 ADMIN 不限制
}
switch (info.getDataScope()) {
case 2 -> {
// 本部门
if (info.getDepartmentId() != null) {
predicates.add(cb.equal(root.get(deptCol), info.getDepartmentId()));
}
}
case 3 -> {
// 本部门及下级(DEPARTMENT_AND_SUB)→ 用子部门列表(包含自己)
List<Long> childDepts = info.getChildDeptIds();
if (childDepts != null && !childDepts.isEmpty()) {
predicates.add(root.get(deptCol).in(childDepts));
} else if (info.getDepartmentId() != null) {
predicates.add(cb.equal(root.get(deptCol), info.getDepartmentId()));
}
}
case 4 -> {
// 仅本人
if (info.getUserId() != null) {
predicates.add(cb.equal(root.get(userCol), info.getUserId()));
}
}
case 5 -> {
// 自定义部门集合
if (info.getCustomDeptIds() != null && !info.getCustomDeptIds().isEmpty()) {
predicates.add(root.get(deptCol).in(info.getCustomDeptIds()));
}
}
default -> {
// 未配置,视为仅本人
if (info.getUserId() != null) {
predicates.add(cb.equal(root.get(userCol), info.getUserId()));
}
}
}
return predicates;
}
}
package com.platform.backend.common;
import com.platform.backend.auth.AuthConstants;
import com.platform.backend.dto.ApiResponse;
import com.platform.backend.project.common.ProjectBusinessException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.ConstraintViolationException;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.MDC;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.core.AuthenticationException;
import org.springframework.validation.BindException;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.NoHandlerFoundException;
import java.util.stream.Collectors;
/**
* 全局异常处理器。
*
* <p>统一返回结构:HTTP 状态码 = 业务语义(401/403/404/409/423/429/500);
* 响应体 code 字段 = BizCode 业务码;message = 具体错误信息。
*
* <p>对应平台文档 4.14 节统一异常处理。
*/
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
/** 业务异常(带 BizCode) */
@ExceptionHandler(BizException.class)
public ResponseEntity<ApiResponse<Void>> handleBiz(BizException ex, HttpServletRequest req) {
log.warn("[BIZ] traceId={} bizCode={} msg={}", tid(req), ex.getCode(), ex.getMessage());
return ResponseEntity.status(ex.getHttpStatus())
.body(ApiResponse.fail(ex.getCode(), ex.getMessage(), tid(req)));
}
/** Spring Security 权限不足 → 403 */
@ExceptionHandler(AccessDeniedException.class)
public ResponseEntity<ApiResponse<Void>> handleAccessDenied(AccessDeniedException ex, HttpServletRequest req) {
log.warn("[ACCESS_DENIED] traceId={} msg={}", tid(req), ex.getMessage());
return ResponseEntity.status(HttpStatusMapper.map(BizCode.FORBIDDEN))
.body(ApiResponse.fail(BizCode.FORBIDDEN.getCode(), BizCode.FORBIDDEN.getDefaultMessage(), tid(req)));
}
/** Spring Security 认证失败 → 401 */
@ExceptionHandler(AuthenticationException.class)
public ResponseEntity<ApiResponse<Void>> handleAuth(AuthenticationException ex, HttpServletRequest req) {
log.warn("[AUTH_FAIL] traceId={} msg={}", tid(req), ex.getMessage());
return ResponseEntity.status(HttpStatusMapper.map(BizCode.UNAUTHORIZED))
.body(ApiResponse.fail(BizCode.UNAUTHORIZED.getCode(), BizCode.UNAUTHORIZED.getDefaultMessage(), tid(req)));
}
/** @RequestBody 参数校验失败 → 400 */
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<ApiResponse<Void>> handleValid(MethodArgumentNotValidException ex, HttpServletRequest req) {
String msg = ex.getBindingResult().getFieldErrors().stream()
.map(this::formatFieldError)
.collect(Collectors.joining("; "));
return ResponseEntity.status(HttpStatusMapper.map(BizCode.PARAM_INVALID))
.body(ApiResponse.fail(BizCode.PARAM_INVALID.getCode(), msg, tid(req)));
}
/** @ModelAttribute 参数校验失败 → 400 */
@ExceptionHandler(BindException.class)
public ResponseEntity<ApiResponse<Void>> handleBind(BindException ex, HttpServletRequest req) {
String msg = ex.getBindingResult().getFieldErrors().stream()
.map(this::formatFieldError)
.collect(Collectors.joining("; "));
return ResponseEntity.status(HttpStatusMapper.map(BizCode.PARAM_INVALID))
.body(ApiResponse.fail(BizCode.PARAM_INVALID.getCode(), msg, tid(req)));
}
/** @RequestParam / @PathVariable 上的 @Validated 校验失败 → 400 */
@ExceptionHandler(ConstraintViolationException.class)
public ResponseEntity<ApiResponse<Void>> handleConstraint(ConstraintViolationException ex, HttpServletRequest req) {
String msg = ex.getConstraintViolations().stream()
.map(v -> v.getPropertyPath() + " " + v.getMessage())
.collect(Collectors.joining("; "));
return ResponseEntity.status(HttpStatusMapper.map(BizCode.PARAM_INVALID))
.body(ApiResponse.fail(BizCode.PARAM_INVALID.getCode(), msg, tid(req)));
}
/** 404 路由不存在 */
@ExceptionHandler(NoHandlerFoundException.class)
public ResponseEntity<ApiResponse<Void>> handleNoHandler(NoHandlerFoundException ex, HttpServletRequest req) {
return ResponseEntity.status(HttpStatusMapper.map(BizCode.RESOURCE_NOT_FOUND))
.body(ApiResponse.fail(BizCode.RESOURCE_NOT_FOUND.getCode(), "接口不存在", tid(req)));
}
/** 数据库唯一约束冲突 → 409 */
@ExceptionHandler(DataIntegrityViolationException.class)
public ResponseEntity<ApiResponse<Void>> handleDataIntegrity(DataIntegrityViolationException ex, HttpServletRequest req) {
log.warn("[DB_INTEGRITY] traceId={} msg={}", tid(req), ex.getMostSpecificCause().getMessage());
return ResponseEntity.status(HttpStatusMapper.map(BizCode.USER_ALREADY_EXISTS))
.body(ApiResponse.fail(BizCode.USER_ALREADY_EXISTS.getCode(), "数据冲突,记录已存在", tid(req)));
}
/** 项目模块业务异常:避免可预期业务错误落入 500。 */
@ExceptionHandler(ProjectBusinessException.class)
public ResponseEntity<ApiResponse<Void>> handleProjectBusiness(ProjectBusinessException ex, HttpServletRequest req) {
BizCode bizCode = mapProjectBusinessCode(ex.getMessage());
log.warn("[PROJECT_BIZ] traceId={} bizCode={} msg={}", tid(req), bizCode, ex.getMessage());
return ResponseEntity.status(HttpStatusMapper.map(bizCode))
.body(ApiResponse.fail(bizCode.getCode(), ex.getMessage(), tid(req)));
}
/** 兜底异常 → 500 */
@ExceptionHandler(Exception.class)
public ResponseEntity<ApiResponse<Void>> handleUnknown(Exception ex, HttpServletRequest req) {
log.error("[SYS_ERR] traceId={} msg={}", tid(req), ex.getMessage(), ex);
return ResponseEntity.status(HttpStatusMapper.map(BizCode.SYSTEM_ERROR))
.body(ApiResponse.fail(BizCode.SYSTEM_ERROR.getCode(), BizCode.SYSTEM_ERROR.getDefaultMessage(), tid(req)));
}
private String formatFieldError(FieldError f) {
return f.getField() + ": " + f.getDefaultMessage();
}
private BizCode mapProjectBusinessCode(String message) {
if (message == null) {
return BizCode.PARAM_INVALID;
}
if (message.contains("不存在")) {
return BizCode.RESOURCE_NOT_FOUND;
}
if (message.contains("无权限")) {
return BizCode.FORBIDDEN;
}
if (message.contains("已存在")) {
return BizCode.USER_ALREADY_EXISTS;
}
if (message.contains("无法删除") || message.contains("已被使用")) {
return BizCode.USER_HAS_PENDING;
}
return BizCode.PARAM_INVALID;
}
private String tid(HttpServletRequest req) {
Object t = req == null ? null : req.getAttribute(AuthConstants.MDC_TRACE_ID);
if (t == null) t = MDC.get(AuthConstants.MDC_TRACE_ID);
return t == null ? "" : t.toString();
}
}
package com.platform.backend.common;
import org.springframework.http.HttpStatus;
import java.util.Map;
/**
* 业务码 → HTTP 状态码映射。集中维护,避免散落 magic number。
*
* <p>对应平台文档 4.14 节异常码定义表 + 3.1.3 HTTP 状态码总表。
*/
public final class HttpStatusMapper {
private static final Map<BizCode, HttpStatus> MAP = Map.ofEntries(
Map.entry(BizCode.SUCCESS, HttpStatus.OK),
Map.entry(BizCode.PARAM_INVALID, HttpStatus.BAD_REQUEST),
Map.entry(BizCode.UNAUTHORIZED, HttpStatus.UNAUTHORIZED),
Map.entry(BizCode.FORBIDDEN, HttpStatus.FORBIDDEN),
Map.entry(BizCode.RESOURCE_NOT_FOUND, HttpStatus.NOT_FOUND),
Map.entry(BizCode.TOO_MANY_REQUESTS, HttpStatus.TOO_MANY_REQUESTS),
Map.entry(BizCode.USER_NOT_FOUND, HttpStatus.NOT_FOUND),
Map.entry(BizCode.USER_ALREADY_EXISTS, HttpStatus.CONFLICT),
Map.entry(BizCode.BAD_CREDENTIALS, HttpStatus.UNAUTHORIZED),
Map.entry(BizCode.ACCOUNT_LOCKED, HttpStatus.LOCKED),
Map.entry(BizCode.SMS_CODE_INVALID, HttpStatus.BAD_REQUEST),
Map.entry(BizCode.OLD_PASSWORD_WRONG, HttpStatus.BAD_REQUEST),
Map.entry(BizCode.PASSWORD_REUSED, HttpStatus.BAD_REQUEST),
Map.entry(BizCode.CANNOT_DELETE_SELF, HttpStatus.BAD_REQUEST),
Map.entry(BizCode.CANNOT_DELETE_ADMIN, HttpStatus.FORBIDDEN),
Map.entry(BizCode.USER_HAS_PENDING, HttpStatus.CONFLICT),
Map.entry(BizCode.REFRESH_TOKEN_INVALID, HttpStatus.UNAUTHORIZED),
Map.entry(BizCode.ACCOUNT_DISABLED, HttpStatus.FORBIDDEN),
Map.entry(BizCode.ROLE_NAME_DUPLICATE, HttpStatus.CONFLICT),
Map.entry(BizCode.ROLE_HAS_USERS, HttpStatus.CONFLICT),
Map.entry(BizCode.ROLE_PRESET, HttpStatus.FORBIDDEN),
Map.entry(BizCode.MENU_HAS_CHILDREN, HttpStatus.CONFLICT),
Map.entry(BizCode.MENU_NAME_DUPLICATE, HttpStatus.CONFLICT),
Map.entry(BizCode.SYSTEM_ERROR, HttpStatus.INTERNAL_SERVER_ERROR)
);
private HttpStatusMapper() {}
public static HttpStatus map(BizCode bizCode) {
return MAP.getOrDefault(bizCode, HttpStatus.INTERNAL_SERVER_ERROR);
}
public static HttpStatus map(int bizCode) {
return map(BizCode.of(bizCode));
}
}
package com.platform.backend.common;
import java.util.regex.Pattern;
/**
* 密码强度校验器(文档 4.12)。
*
* <p>规则:8-20 位,必须包含大小写字母 + 数字;可包含常见特殊字符。
*
* <p>正则:^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d!@#$%^&*()_+\-=]{8,20}$
*/
public final class PasswordValidator {
private static final Pattern PATTERN = Pattern.compile(
"^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)[A-Za-z\\d!@#$%^&*()_+\\-=]{8,20}$"
);
private PasswordValidator() {}
public static boolean isValid(String password) {
return password != null && PATTERN.matcher(password).matches();
}
}
\ No newline at end of file
......@@ -9,6 +9,7 @@ import com.platform.backend.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
......@@ -25,10 +26,20 @@ public class DataInitializer implements CommandLineRunner {
private final RoleRepository roleRepository;
private final PermissionRepository permissionRepository;
private final PasswordEncoder passwordEncoder;
private final JdbcTemplate jdbcTemplate;
@Override
@Transactional
public void run(String... args) {
// 数据库列修正(防止旧表 device 为 VARCHAR(500) 导致插入失败;DDL 自动提交,无需事务)
migrateLoginLogColumns();
migrateProjectSoftDeleteUniqueIndexes();
// 以下操作在事务内执行
initRolesAndPermissions();
}
@Transactional
public void initRolesAndPermissions() {
// 创建预设角色
Role adminRole = ensureRole("管理员", "ROLE_ADMIN", "全系统配置、用户管理", 1);
ensureRole("主管", "ROLE_SUPERVISOR", "审核学员、内容终审", 1);
......@@ -61,10 +72,27 @@ public class DataInitializer implements CommandLineRunner {
admin.setRoleId(adminRole.getId());
admin.setStatus(1);
admin.setIsDeleted(0);
admin.setMustChangePassword(0);
userRepository.save(admin);
log.info("测试账号已创建: admin / admin123 (roleId={})", adminRole.getId());
} else {
log.info("admin 账号已存在,跳过初始化");
// admin 已存在:确保密码正确(schema-init.sql 的 INSERT IGNORE 用的是旧哈希)
User admin = userRepository.findByUsername("admin").orElse(null);
if (admin != null) {
String expectedHash = passwordEncoder.encode("admin123");
// 如果密码哈希不匹配(schema-init 插入了错误哈希),强制更新
if (!passwordEncoder.matches("admin123", admin.getPassword())) {
admin.setPassword(expectedHash);
admin.setRoleId(adminRole.getId());
admin.setStatus(1);
admin.setIsDeleted(0);
admin.setMustChangePassword(0);
userRepository.save(admin);
log.info("admin 账号密码已修正为 admin123(schema-init 旧哈希已替换)");
} else {
log.info("admin 账号已存在且密码正确,跳过");
}
}
}
}
......@@ -88,4 +116,69 @@ public class DataInitializer implements CommandLineRunner {
return permissionRepository.save(p);
});
}
}
\ No newline at end of file
/**
* 修正 user_login_log 表的列类型,防止 device 列超长导致整条日志插入失败。
* <ul>
* <li>device VARCHAR(500) → TEXT</li>
* <li>fail_reason VARCHAR(100) → VARCHAR(255)</li>
* </ul>
*/
private void migrateLoginLogColumns() {
try {
// 修正 device 字段(User-Agent 通常远超 500 字符)
jdbcTemplate.execute(
"ALTER TABLE user_login_log MODIFY COLUMN device TEXT");
log.info("[migrate] user_login_log.device → TEXT OK");
// 修正 fail_reason 字段(避免较长的失败原因被截断)
jdbcTemplate.execute(
"ALTER TABLE user_login_log MODIFY COLUMN fail_reason VARCHAR(255)");
log.info("[migrate] user_login_log.fail_reason → VARCHAR(255) OK");
} catch (Exception e) {
log.warn("[migrate] user_login_log 列修正失败(可能已是最优类型或表不存在): {}", e.getMessage());
}
}
/**
* 项目删除按文档要求是软删除。旧库里 name 单列唯一会让已软删项目继续占用名称,
* 因此删除单列唯一索引,保留服务层的“未删除项目名称不可重复”校验。
*/
private void migrateProjectSoftDeleteUniqueIndexes() {
dropSingleColumnUniqueIndexIfExists("proj_internal_project", "name");
dropSingleColumnUniqueIndexIfExists("proj_annotation_project", "name");
}
private void dropSingleColumnUniqueIndexIfExists(String tableName, String columnName) {
try {
List<String> indexNames = jdbcTemplate.queryForList("""
SELECT s.INDEX_NAME
FROM INFORMATION_SCHEMA.STATISTICS s
JOIN (
SELECT INDEX_NAME, COUNT(*) AS column_count
FROM INFORMATION_SCHEMA.STATISTICS
WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
GROUP BY INDEX_NAME
) c ON c.INDEX_NAME = s.INDEX_NAME
WHERE s.TABLE_SCHEMA = DATABASE()
AND s.TABLE_NAME = ?
AND s.COLUMN_NAME = ?
AND s.NON_UNIQUE = 0
AND s.INDEX_NAME <> 'PRIMARY'
AND c.column_count = 1
""",
String.class,
tableName,
tableName,
columnName);
for (String indexName : indexNames) {
jdbcTemplate.execute("ALTER TABLE `" + tableName + "` DROP INDEX `" + indexName + "`");
log.info("[migrate] {}.{} 单列唯一索引 {} 已删除,软删除项目名称可复用",
tableName, columnName, indexName);
}
} catch (Exception e) {
log.warn("[migrate] {}.{} 单列唯一索引修正失败(可能已修正或表不存在): {}",
tableName, columnName, e.getMessage());
}
}
}
package com.platform.backend.config;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.platform.backend.auth.AuthConstants;
import com.platform.backend.auth.JwtProperties;
import com.platform.backend.auth.TraceIdFilter;
import com.platform.backend.common.BizCode;
import com.platform.backend.dto.ApiResponse;
import com.platform.backend.security.JwtAuthenticationFilter;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
......@@ -32,10 +38,22 @@ import java.util.List;
@RequiredArgsConstructor
public class SecurityConfig {
private static final String[] WHITELIST = {
"/api/v1/auth/login",
"/api/v1/auth/login/phone",
"/api/v1/auth/register",
"/api/v1/auth/refresh",
"/api/v1/auth/sms-code",
"/api/v1/auth/reset-password",
"/api/health",
"/actuator/**"
};
private final JwtAuthenticationFilter jwtAuthFilter;
private final TraceIdFilter traceIdFilter;
private final UserDetailsService userDetailsService;
private final JwtProperties jwtProperties;
private final ObjectMapper objectMapper;
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
......@@ -44,9 +62,13 @@ public class SecurityConfig {
.cors(cors -> cors.configurationSource(corsConfigurationSource()))
.sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.authorizeHttpRequests(auth -> auth
.requestMatchers("/api/v1/auth/**", "/api/health", "/actuator/**").permitAll()
.requestMatchers(WHITELIST).permitAll()
.anyRequest().authenticated()
)
.exceptionHandling(ex -> ex
.authenticationEntryPoint(this::onUnauthorized)
.accessDeniedHandler(this::onAccessDenied)
)
.authenticationProvider(authenticationProvider())
.addFilterBefore(traceIdFilter, UsernamePasswordAuthenticationFilter.class)
.addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class);
......@@ -54,6 +76,41 @@ public class SecurityConfig {
return http.build();
}
/** 401 JSON 响应 */
private void onUnauthorized(jakarta.servlet.http.HttpServletRequest req,
HttpServletResponse resp,
org.springframework.security.core.AuthenticationException ex) throws java.io.IOException {
writeJson(resp, HttpServletResponse.SC_UNAUTHORIZED,
BizCode.UNAUTHORIZED.getCode(),
BizCode.UNAUTHORIZED.getDefaultMessage(),
req);
}
/** 403 JSON 响应 */
private void onAccessDenied(jakarta.servlet.http.HttpServletRequest req,
HttpServletResponse resp,
org.springframework.security.access.AccessDeniedException ex) throws java.io.IOException {
writeJson(resp, HttpServletResponse.SC_FORBIDDEN,
BizCode.FORBIDDEN.getCode(),
BizCode.FORBIDDEN.getDefaultMessage(),
req);
}
private void writeJson(HttpServletResponse resp,
int httpStatus,
int bizCode,
String message,
jakarta.servlet.http.HttpServletRequest req) throws java.io.IOException {
resp.setStatus(httpStatus);
resp.setContentType(MediaType.APPLICATION_JSON_VALUE);
resp.setCharacterEncoding("UTF-8");
String traceId = (String) req.getAttribute(AuthConstants.MDC_TRACE_ID);
if (traceId == null) traceId = org.slf4j.MDC.get(AuthConstants.MDC_TRACE_ID);
if (traceId == null) traceId = "";
resp.getWriter().write(objectMapper.writeValueAsString(
ApiResponse.fail(bizCode, message, traceId)));
}
@Bean
public CorsConfigurationSource corsConfigurationSource() {
CorsConfiguration configuration = new CorsConfiguration();
......
......@@ -5,24 +5,30 @@ 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.common.ApiResponseEnvelope;
import com.platform.backend.common.BizCode;
import com.platform.backend.common.BizException;
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.service.PasswordService;
import org.springframework.security.crypto.password.PasswordEncoder;
import io.jsonwebtoken.Claims;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
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.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.Collections;
......@@ -41,8 +47,12 @@ public class AuthController {
private final LoginAttemptService loginAttempt;
private final LoginLogService loginLogService;
private final SmsCodeService smsCodeService;
private final PasswordService passwordService;
private final PasswordEncoder passwordEncoder;
@Value("${login.lock-minutes:10}")
private int lockMinutes;
private String tid(HttpServletRequest req) {
Object t = req.getAttribute(AuthConstants.MDC_TRACE_ID);
return t == null ? "" : t.toString();
......@@ -78,45 +88,53 @@ public class AuthController {
}
@PostMapping("/sms-code")
public ApiResponse<Void> sendSmsCode(@Valid @RequestBody SmsCodeRequest request,
public ResponseEntity<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);
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "验证码已发送", traceId));
} catch (BizException e) {
throw e;
} catch (Exception e) {
return ApiResponse.fail(1001, e.getMessage(), traceId);
throw new BizException(BizCode.PARAM_INVALID, e.getMessage());
}
}
@PostMapping("/register")
public ApiResponse<LoginResponse> register(@Valid @RequestBody RegisterRequest request,
public ResponseEntity<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);
throw new BizException(BizCode.SMS_CODE_INVALID);
}
// 2. 检查用户名唯一
if (userRepository.findByUsername(request.getUsername()).isPresent()) {
return ApiResponse.fail(2001, "用户名已存在", traceId);
throw new BizException(BizCode.USER_ALREADY_EXISTS, "用户名已存在");
}
// 3. 检查手机号唯一
if (userRepository.findByPhone(request.getPhone()).isPresent()) {
return ApiResponse.fail(2002, "该手机号已注册", traceId);
throw new BizException(BizCode.USER_ALREADY_EXISTS, "该手机号已注册");
}
// 4. 查询学员角色
Role studentRole = roleRepository.findByRoleCode("ROLE_STUDENT")
.orElseThrow(() -> new RuntimeException("系统未配置学员角色"));
.orElseThrow(() -> new BizException(BizCode.SYSTEM_ERROR, "系统未配置学员角色"));
// 5. 创建用户
// 5. 密码强度校验
if (!com.platform.backend.common.PasswordValidator.isValid(request.getPassword())) {
throw new BizException(BizCode.PARAM_INVALID,
"密码长度 8-20 位,必须包含大小写字母 + 数字");
}
// 6. 创建用户
User user = new User();
user.setUsername(request.getUsername());
user.setPassword(passwordEncoder.encode(request.getPassword()));
......@@ -127,7 +145,7 @@ public class AuthController {
user.setIsDeleted(0);
user = userRepository.save(user);
// 6. 签发双Token
// 7. 签发双Token
String access = tokenService.generateAccessToken(user.getUsername(), "STUDENT");
String refresh = tokenService.generateRefreshToken(user.getUsername(), "STUDENT");
......@@ -135,7 +153,8 @@ public class AuthController {
user.getId(),
user.getUsername(),
user.getRealName(),
resolveRoles(user)
resolveRoles(user),
user.isMustChangePassword()
);
LoginResponse loginResponse = new LoginResponse(
access,
......@@ -145,182 +164,239 @@ public class AuthController {
userInfo
);
return ApiResponse.ok(loginResponse, "注册成功", traceId);
// 注册成功日志
loginLogService.logSuccess(user.getId(), user.getUsername(), httpReq);
return ApiResponseEnvelope.created(loginResponse, "注册成功", traceId);
}
@PostMapping("/login")
public ApiResponse<LoginResponse> login(@Valid @RequestBody LoginRequest request,
public ResponseEntity<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. 锁定检查
// 0. 锁定检查 → HTTP 423
if (loginAttempt.isLocked(username)) {
loginLogService.logFail(username, "账户已锁定", httpReq);
return ApiResponse.fail(2004, "账户已锁定,请稍后再试", traceId);
throw new BizException(BizCode.ACCOUNT_LOCKED,
"账号已被锁定,请 " + lockMinutes + " 分钟后再试");
}
try {
// 1. 校验密码
authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(username, request.getPassword()));
} catch (BadCredentialsException e) {
} catch (UsernameNotFoundException e) {
loginAttempt.loginFailed(username);
loginLogService.logFail(username, "用户不存在", httpReq);
int remaining = loginAttempt.getRemainingAttempts(username);
if (remaining <= 0) {
loginAttempt.lockAccount(username);
throw new BizException(BizCode.ACCOUNT_LOCKED,
"连续失败次数过多,账号已锁定 " + lockMinutes + " 分钟");
}
throw new BizException(BizCode.BAD_CREDENTIALS,
"账号或密码错误,剩余尝试次数: " + remaining);
} catch (BadCredentialsException e) {
loginAttempt.loginFailed(username);
loginLogService.logFail(username, "密码错误", httpReq);
int remaining = loginAttempt.getRemainingAttempts(username);
if (remaining <= 0) {
loginAttempt.lockAccount(username);
return ApiResponse.fail(2004, "连续失败次数过多,账户已锁定30分钟", traceId);
throw new BizException(BizCode.ACCOUNT_LOCKED,
"连续失败次数过多,账号已锁定 " + lockMinutes + " 分钟");
}
return ApiResponse.fail(2003, "账号或密码错误,剩余尝试次数: " + remaining, traceId);
throw new BizException(BizCode.BAD_CREDENTIALS,
"账号或密码错误,剩余尝试次数: " + remaining);
} catch (Exception e) {
loginAttempt.loginFailed(username);
int remaining = loginAttempt.getRemainingAttempts(username);
loginLogService.logFail(username, e.getMessage(), httpReq);
int remaining = loginAttempt.getRemainingAttempts(username);
if (remaining <= 0) {
loginAttempt.lockAccount(username);
return ApiResponse.fail(2004, "连续失败次数过多,账户已锁定30分钟", traceId);
throw new BizException(BizCode.ACCOUNT_LOCKED,
"连续失败次数过多,账号已锁定 " + lockMinutes + " 分钟");
}
return ApiResponse.fail(2003, "账号或密码错误,剩余尝试次数: " + remaining, traceId);
throw new BizException(BizCode.BAD_CREDENTIALS,
"账号或密码错误,剩余尝试次数: " + remaining);
}
// 2. 登录成功 - 清理失败计数
// 登录成功 - 清理失败计数
loginAttempt.loginSucceeded(username);
// 3. 查询用户
// 查询用户
User user = userRepository.findByUsername(username)
.orElseThrow(() -> new UsernameNotFoundException("用户不存在"));
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND));
if (Boolean.FALSE.equals(user.getEnabled())) {
loginLogService.logFail(username, "账户已禁用", httpReq);
return ApiResponse.fail(2002, "账户已被禁用", traceId);
throw new BizException(BizCode.ACCOUNT_DISABLED);
}
// 4. 签发双 Token
// 签发双 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)
resolveRoles(user),
user.isMustChangePassword()
);
LoginResponse loginResponse = new LoginResponse(
access,
refresh,
"Bearer",
access, refresh, "Bearer",
(int) (tokenService.getAccessExpirationMs() / 1000),
userInfo
);
return ApiResponse.ok(loginResponse, "登录成功", traceId);
return ApiResponseEnvelope.ok(loginResponse, "登录成功", traceId);
}
/**
* 手机号 + 验证码登录
*/
@PostMapping("/login/phone")
public ApiResponse<LoginResponse> loginByPhone(@Valid @RequestBody PhoneLoginRequest request,
public ResponseEntity<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);
// 1. 验证验证码
// 0. 锁定检查
if (loginAttempt.isLocked(phone)) {
loginLogService.logFail(phone, "账户已锁定", httpReq);
throw new BizException(BizCode.ACCOUNT_LOCKED,
"账号已被锁定,请 " + lockMinutes + " 分钟后再试");
}
if (!smsCodeService.verifyCode(phone, "login", request.getSmsCode())) {
loginAttempt.loginFailed(phone);
loginLogService.logFail(phone, "验证码错误", httpReq);
return ApiResponse.fail(1001, "验证码错误或已过期", traceId);
int remaining = loginAttempt.getRemainingAttempts(phone);
if (remaining <= 0) {
loginAttempt.lockAccount(phone);
throw new BizException(BizCode.ACCOUNT_LOCKED,
"连续失败次数过多,账号已锁定 " + lockMinutes + " 分钟");
}
throw new BizException(BizCode.SMS_CODE_INVALID);
}
// 2. 根据手机号查询用户
User user = userRepository.findByPhone(phone)
.orElseThrow(() -> new UsernameNotFoundException("该手机号未注册"));
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND, "该手机号未注册"));
// 3. 检查账户状态
if (Boolean.FALSE.equals(user.getEnabled())) {
loginLogService.logFail(phone, "账户已禁用", httpReq);
return ApiResponse.fail(2002, "账户已被禁用", traceId);
throw new BizException(BizCode.ACCOUNT_DISABLED);
}
// 4. 签发双 Token
// 清除失败计数
loginAttempt.loginSucceeded(phone);
String role = resolveRoleCode(user);
String access = tokenService.generateAccessToken(user.getUsername(), role);
String refresh = tokenService.generateRefreshToken(user.getUsername(), role);
// 5. 记录登录日志
loginLogService.logSuccess(user.getId(), user.getUsername(), httpReq);
// 6. 返回
LoginResponse.User userInfo = new LoginResponse.User(
user.getId(),
user.getUsername(),
user.getRealName(),
resolveRoles(user)
user.getId(), user.getUsername(), user.getRealName(),
resolveRoles(user), user.isMustChangePassword()
);
LoginResponse loginResponse = new LoginResponse(
access,
refresh,
"Bearer",
access, refresh, "Bearer",
(int) (tokenService.getAccessExpirationMs() / 1000),
userInfo
);
return ApiResponse.ok(loginResponse, "登录成功", traceId);
return ApiResponseEnvelope.ok(loginResponse, "登录成功", traceId);
}
@PostMapping("/refresh")
public ApiResponse<RefreshTokenResponse> refresh(@Valid @RequestBody RefreshRequest body,
public ResponseEntity<ApiResponse<RefreshTokenResponse>> refresh(@Valid @RequestBody RefreshRequest body,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] POST /api/v1/auth/refresh");
try {
// validateAndConsumeRefreshToken 会将旧 refresh token 加入黑名单(一次性消费)
Claims claims = tokenService.validateAndConsumeRefreshToken(body.getRefreshToken());
String username = claims.getSubject();
String role = String.valueOf(claims.get("role"));
// 只返回新的 accessToken
// 颁发新 access + 新 refresh(refresh 也一次性)
String newAccess = tokenService.generateAccessToken(username, role);
String newRefresh = tokenService.generateRefreshToken(username, role);
RefreshTokenResponse resp = new RefreshTokenResponse(
newAccess,
newRefresh,
tokenService.getAccessExpirationMs() / 1000
);
return ApiResponse.ok(resp, "刷新成功", traceId);
return ApiResponseEnvelope.ok(resp, "刷新成功", traceId);
} catch (Exception e) {
log.warn("[API] refresh failed: {}", e.getMessage());
return ApiResponse.fail(2005, "Refresh token 已使用或已过期", traceId);
throw new BizException(BizCode.REFRESH_TOKEN_INVALID);
}
}
@PostMapping("/logout")
public ApiResponse<Void> logout(@Valid @RequestBody LogoutRequest body,
// ========== 3.2.6 找回密码(手机号 + 验证码) ==========
@PostMapping("/reset-password")
public ResponseEntity<ApiResponse<Void>> resetPassword(@Valid @RequestBody ResetPwdRequest request,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] POST /api/v1/auth/reset-password phone={}", request.getPhone());
// 1. 校验验证码
if (!smsCodeService.verifyCode(request.getPhone(), "reset", request.getSmsCode())) {
throw new BizException(BizCode.SMS_CODE_INVALID);
}
// 2. 校验密码强度
if (!com.platform.backend.common.PasswordValidator.isValid(request.getNewPassword())) {
throw new BizException(BizCode.PARAM_INVALID,
"密码长度 8-20 位,必须包含大小写字母 + 数字");
}
// 3. 按手机号重置密码
passwordService.resetPasswordByPhone(request.getPhone(), request.getNewPassword());
log.info("[API] reset-password success phone={}", request.getPhone());
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "密码重置成功,请使用新密码登录", traceId));
}
// ========== 3.2.4 登出 ==========
@PostMapping("/logout")
public ResponseEntity<ApiResponse<Void>> logout(
@RequestParam(required = false) String accessToken,
@RequestParam(required = false) String refreshToken,
@RequestBody(required = false) LogoutRequest body,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] POST /api/v1/auth/logout");
tokenService.logout(body.getRefreshToken());
String at = accessToken != null ? accessToken : (body != null ? body.getAccessToken() : null);
String rt = refreshToken != null ? refreshToken : (body != null ? body.getRefreshToken() : null);
tokenService.logout(at, rt);
SecurityContextHolder.clearContext();
return ApiResponse.ok(null, "注销成功", traceId);
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "注销成功", traceId));
}
@GetMapping("/me")
public ApiResponse<LoginResponse.User> me(HttpServletRequest httpReq) {
public ResponseEntity<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);
if (auth == null || auth.getName() == null || "anonymousUser".equals(auth.getName())) {
throw new BizException(BizCode.UNAUTHORIZED);
}
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);
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND));
return ApiResponseEnvelope.ok(
new LoginResponse.User(u.getId(), u.getUsername(), u.getRealName(),
Collections.singletonList(resolveRoleCode(u)), u.isMustChangePassword()),
traceId);
}
}
package com.platform.backend.controller;
import com.platform.backend.auth.AuthConstants;
import com.platform.backend.common.ApiResponseEnvelope;
import com.platform.backend.common.BizCode;
import com.platform.backend.common.BizException;
import com.platform.backend.dto.ApiResponse;
import com.platform.backend.entity.Department;
import com.platform.backend.repository.DepartmentRepository;
import jakarta.servlet.http.HttpServletRequest;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
/**
* 部门管理 Controller(基础接口,对应文档 2.2.6)。
*
* <p>仅 ADMIN 可写入;登录用户可查询。
*/
@Slf4j
@RestController
@RequestMapping("/api/v1/departments")
@RequiredArgsConstructor
public class DepartmentController {
private final DepartmentRepository departmentRepository;
private String tid(HttpServletRequest req) {
Object t = req.getAttribute(AuthConstants.MDC_TRACE_ID);
return t == null ? "" : t.toString();
}
@GetMapping
public ResponseEntity<ApiResponse<List<Department>>> list(@RequestParam(required = false) Integer status,
HttpServletRequest httpReq) {
log.info("[API] GET /api/v1/departments status={}", status);
List<Department> list = status == null
? departmentRepository.findAll()
: departmentRepository.findByStatus(status);
return ApiResponseEnvelope.ok(list, tid(httpReq));
}
@GetMapping("/{id}")
public ResponseEntity<ApiResponse<Department>> getById(@PathVariable Long id, HttpServletRequest httpReq) {
log.info("[API] GET /api/v1/departments/{}", id);
Department dept = departmentRepository.findById(id)
.orElseThrow(() -> new BizException(BizCode.RESOURCE_NOT_FOUND, "部门不存在"));
return ApiResponseEnvelope.ok(dept, tid(httpReq));
}
@PostMapping
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Department>> create(@RequestBody Department dept,
HttpServletRequest httpReq) {
log.info("[API] POST /api/v1/departments name={}", dept.getName());
if (dept.getStatus() == null) dept.setStatus(1);
Department saved = departmentRepository.save(dept);
return ApiResponseEnvelope.created(saved, "创建成功", tid(httpReq));
}
@PutMapping("/{id}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Department>> update(@PathVariable Long id,
@RequestBody Department dept,
HttpServletRequest httpReq) {
log.info("[API] PUT /api/v1/departments/{}", id);
Department exist = departmentRepository.findById(id)
.orElseThrow(() -> new BizException(BizCode.RESOURCE_NOT_FOUND, "部门不存在"));
if (dept.getName() != null) exist.setName(dept.getName());
if (dept.getCode() != null) exist.setCode(dept.getCode());
if (dept.getDescription() != null) exist.setDescription(dept.getDescription());
if (dept.getParentId() != null) exist.setParentId(dept.getParentId());
if (dept.getStatus() != null) exist.setStatus(dept.getStatus());
return ApiResponseEnvelope.ok(departmentRepository.save(exist), "更新成功", tid(httpReq));
}
@DeleteMapping("/{id}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<Void> delete(@PathVariable Long id, HttpServletRequest httpReq) {
log.info("[API] DELETE /api/v1/departments/{}", id);
departmentRepository.findById(id)
.orElseThrow(() -> new BizException(BizCode.RESOURCE_NOT_FOUND, "部门不存在"));
departmentRepository.deleteById(id);
return ApiResponseEnvelope.noContent();
}
// ========== 部门树形结构 ==========
@GetMapping("/tree")
public ResponseEntity<ApiResponse<List<Map<String, Object>>>> getTree(
@RequestParam(required = false) Integer status,
HttpServletRequest httpReq) {
log.info("[API] GET /api/v1/departments/tree status={}", status);
List<Department> all = status == null
? departmentRepository.findAll()
: departmentRepository.findByStatus(status);
return ApiResponseEnvelope.ok(buildTree(all, 0L), tid(httpReq));
}
private List<Map<String, Object>> buildTree(List<Department> all, Long parentId) {
List<Map<String, Object>> result = new java.util.ArrayList<>();
for (Department d : all) {
if (java.util.Objects.equals(d.getParentId(), parentId)) {
Map<String, Object> node = new java.util.LinkedHashMap<>();
node.put("id", d.getId());
node.put("parentId", d.getParentId());
node.put("name", d.getName());
node.put("code", d.getCode());
node.put("description", d.getDescription());
node.put("status", d.getStatus());
List<Map<String, Object>> children = buildTree(all, d.getId());
if (!children.isEmpty()) node.put("children", children);
result.add(node);
}
}
return result;
}
}
\ No newline at end of file
package com.platform.backend.controller;
import com.platform.backend.auth.AuthConstants;
import com.platform.backend.common.ApiResponseEnvelope;
import com.platform.backend.common.BizCode;
import com.platform.backend.common.BizException;
import com.platform.backend.dto.ApiResponse;
import com.platform.backend.entity.Menu;
import com.platform.backend.entity.User;
import com.platform.backend.service.MenuService;
import com.platform.backend.service.UserService;
import jakarta.servlet.http.HttpServletRequest;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.*;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* 菜单管理 Controller(文档 3.5 节)。
*/
@Slf4j
@RestController
@RequestMapping("/api/v1/menus")
@RequiredArgsConstructor
public class MenuController {
private final MenuService menuService;
private final UserService userService;
private String tid(HttpServletRequest req) {
Object t = req.getAttribute(AuthConstants.MDC_TRACE_ID);
return t == null ? "" : t.toString();
}
private Long currentUserId() {
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
if (auth == null || auth.getName() == null || "anonymousUser".equals(auth.getName())) {
throw new BizException(BizCode.UNAUTHORIZED);
}
User u = userService.getByUsername(auth.getName());
return u.getId();
}
// ========== 3.5.1 用户菜单 ==========
@GetMapping
public ResponseEntity<ApiResponse<List<Map<String, Object>>>> getUserMenuTree(HttpServletRequest httpReq) {
Long userId = currentUserId();
log.info("[API] GET /api/v1/menus userId={}", userId);
return ApiResponseEnvelope.ok(menuService.getUserMenuTree(userId), tid(httpReq));
}
// ========== 3.5.2 完整菜单树 ==========
@GetMapping("/tree")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<List<Map<String, Object>>>> getTree(
@RequestParam(required = false) Integer status,
HttpServletRequest httpReq) {
log.info("[API] GET /api/v1/menus/tree status={}", status);
return ApiResponseEnvelope.ok(menuService.getTree(status), tid(httpReq));
}
// ========== 3.5.3 菜单详情 ==========
@GetMapping("/{id}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Map<String, Object>>> getMenuById(@PathVariable Long id,
HttpServletRequest httpReq) {
log.info("[API] GET /api/v1/menus/{}", id);
Menu menu = menuService.getById(id);
Map<String, Object> map = new LinkedHashMap<>();
map.put("id", menu.getId());
map.put("parentId", menu.getParentId());
map.put("name", menu.getName());
map.put("title", menu.getTitle());
map.put("icon", menu.getIcon());
map.put("path", menu.getPath());
map.put("component", menu.getComponent());
map.put("permissionCode", menu.getPermissionCode());
map.put("type", menu.getType());
map.put("sort", menu.getSort());
map.put("visible", menu.getVisible());
map.put("status", menu.getStatus());
map.put("createdAt", menu.getCreatedAt());
map.put("updatedAt", menu.getUpdatedAt());
return ApiResponseEnvelope.ok(map, tid(httpReq));
}
// ========== 3.5.4 创建菜单 ==========
@PostMapping
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Map<String, Object>>> createMenu(
@RequestBody MenuRequest request, HttpServletRequest httpReq) {
log.info("[API] POST /api/v1/menus name={}", request.getName());
Menu menu = menuService.create(request.getParentId(), request.getName(),
request.getTitle(), request.getIcon(), request.getPath(),
request.getComponent(), request.getPermissionCode(),
request.getType(), request.getSort(), request.getVisible(),
request.getStatus());
return ApiResponseEnvelope.created(Map.of("id", menu.getId()), "创建成功", tid(httpReq));
}
// ========== 3.5.5 更新菜单 ==========
@PutMapping("/{id}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Void>> updateMenu(@PathVariable Long id,
@RequestBody MenuUpdateRequest request,
HttpServletRequest httpReq) {
log.info("[API] PUT /api/v1/menus/{}", id);
menuService.update(id, request.getTitle(), request.getIcon(),
request.getPath(), request.getComponent(), request.getType(),
request.getSort(), request.getVisible(), request.getStatus());
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "更新成功", tid(httpReq)));
}
// ========== 3.5.6 删除菜单 ==========
@DeleteMapping("/{id}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<Void> deleteMenu(@PathVariable Long id, HttpServletRequest httpReq) {
log.info("[API] DELETE /api/v1/menus/{}", id);
menuService.delete(id);
return ApiResponseEnvelope.noContent();
}
@Data
public static class MenuRequest {
private Long parentId;
private String name;
private String title;
private String icon;
private String path;
private String component;
private String permissionCode;
private Integer type;
private Integer sort;
private Integer visible;
private Integer status;
}
@Data
public static class MenuUpdateRequest {
private String title;
private String icon;
private String path;
private String component;
private Integer type;
private Integer sort;
private Integer visible;
private Integer status;
}
}
\ No newline at end of file
package com.platform.backend.controller;
import com.platform.backend.auth.AuthConstants;
import com.platform.backend.common.ApiResponseEnvelope;
import com.platform.backend.common.BizCode;
import com.platform.backend.common.BizException;
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 com.platform.backend.service.RoleService;
import jakarta.servlet.http.HttpServletRequest;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
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.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* 角色权限 Controller(文档 3.4 节 / 3.5.7 节)。
*/
@Slf4j
@RestController
@RequestMapping("/api/v1/roles")
@RequiredArgsConstructor
public class RoleController {
private final RoleRepository roleRepository;
private final RoleService roleService;
private final RolePermissionRepository rolePermissionRepository;
private final PermissionRepository permissionRepository;
private final UserRoleRepository userRoleRepository;
......@@ -41,193 +48,111 @@ public class RoleController {
private boolean isAdmin() {
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
return auth.getAuthorities().stream()
.anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"));
return auth != null && auth.getAuthorities().stream()
.anyMatch(a -> "ROLE_ADMIN".equals(a.getAuthority()));
}
/**
* 获取角色列表
*/
// ========== 3.4.1 角色列表 ==========
@GetMapping
public ApiResponse<?> listRoles(HttpServletRequest httpReq) {
String traceId = tid(httpReq);
public ResponseEntity<ApiResponse<List<Map<String, Object>>>> listRoles(HttpServletRequest 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>();
List<Role> roles = roleService.list();
List<Map<String, Object>> items = roles.stream().map(r -> {
Map<String, Object> map = new LinkedHashMap<>();
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("isPreset", r.getIsPreset() != null && r.getIsPreset() == 1);
map.put("dataScope", r.getDataScope());
map.put("sort", r.getSort());
map.put("status", r.getStatus());
map.put("userCount", userRoleRepository.countByRoleId(r.getId()));
return map;
}).toList();
return ApiResponse.ok(items, traceId);
return ApiResponseEnvelope.ok(items, tid(httpReq));
}
/**
* 获取角色详情(含权限列表)
*/
// ========== 3.4.2 角色详情 ==========
@GetMapping("/{id}")
public ApiResponse<?> getRoleById(@PathVariable Long id, HttpServletRequest httpReq) {
String traceId = tid(httpReq);
public ResponseEntity<ApiResponse<Map<String, Object>>> getRoleById(@PathVariable Long id,
HttpServletRequest 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>();
Role role = roleService.getById(id);
Map<String, Object> map = new LinkedHashMap<>();
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);
// 获取权限列表
map.put("isPreset", role.getIsPreset() != null && role.getIsPreset() == 1);
map.put("dataScope", role.getDataScope());
map.put("sort", role.getSort());
map.put("status", role.getStatus());
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>();
map.put("permissions", perms.stream().map(p -> {
Map<String, Object> pm = new LinkedHashMap<>();
pm.put("id", p.getId());
pm.put("permissionCode", p.getPermissionCode());
pm.put("permissionName", p.getPermissionName());
pm.put("module", p.getModule());
return pm;
}).toList();
map.put("permissions", permissions);
return ApiResponse.ok(map, traceId);
}).toList());
return ApiResponseEnvelope.ok(map, tid(httpReq));
}
/**
* 创建角色
*/
// ========== 3.4.3 创建角色 ==========
@PostMapping
public ApiResponse<?> createRole(@RequestBody CreateRoleRequest request, HttpServletRequest httpReq) {
String traceId = tid(httpReq);
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Map<String, Object>>> createRole(
@RequestBody CreateRoleRequest request, HttpServletRequest 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);
if (!isAdmin()) throw new BizException(BizCode.FORBIDDEN);
Role role = roleService.create(request.getRoleName(), request.getRoleCode(),
request.getDescription(), request.getDataScope(), request.getSort(),
request.getStatus(), request.getPermissionIds());
Map<String, Object> data = new LinkedHashMap<>();
data.put("id", role.getId());
data.put("roleName", role.getRoleName());
data.put("roleCode", role.getRoleCode());
return ApiResponseEnvelope.created(data, "创建成功", tid(httpReq));
}
/**
* 更新角色
*/
// ========== 3.4.4 更新角色 ==========
@PutMapping("/{id}")
public ApiResponse<?> updateRole(@PathVariable Long id,
@RequestBody UpdateRoleRequest request,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Void>> updateRole(@PathVariable Long id,
@RequestBody UpdateRoleRequest request,
HttpServletRequest 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);
if (!isAdmin()) throw new BizException(BizCode.FORBIDDEN);
roleService.update(id, request.getRoleName(), request.getDescription(),
request.getDataScope(), request.getSort(), request.getStatus(),
request.getPermissionIds());
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "更新成功", tid(httpReq)));
}
/**
* 删除角色
*/
// ========== 3.4.5 删除角色 ==========
@DeleteMapping("/{id}")
public ApiResponse<?> deleteRole(@PathVariable Long id, HttpServletRequest httpReq) {
String traceId = tid(httpReq);
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<Void> deleteRole(@PathVariable Long id, HttpServletRequest 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);
if (!isAdmin()) throw new BizException(BizCode.FORBIDDEN);
roleService.delete(id);
return ApiResponseEnvelope.noContent();
}
/**
* 获取权限列表
*/
// ========== 权限列表 ==========
@GetMapping("/permissions")
public ApiResponse<?> listPermissions(HttpServletRequest httpReq) {
String traceId = tid(httpReq);
public ResponseEntity<ApiResponse<List<Map<String, Object>>>> listPermissions(HttpServletRequest 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>();
List<Map<String, Object>> items = permissions.stream().map(p -> {
Map<String, Object> map = new LinkedHashMap<>();
map.put("id", p.getId());
map.put("permissionCode", p.getPermissionCode());
map.put("permissionName", p.getPermissionName());
......@@ -235,14 +160,51 @@ public class RoleController {
map.put("description", p.getDescription());
return map;
}).toList();
return ApiResponse.ok(items, traceId);
return ApiResponseEnvelope.ok(items, tid(httpReq));
}
// ========== 3.5.7 角色分配菜单 ==========
@PutMapping("/{roleId}/menus")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Void>> assignMenus(@PathVariable Long roleId,
@RequestBody AssignMenusRequest request,
HttpServletRequest httpReq) {
log.info("[API] PUT /api/v1/roles/{}/menus", roleId);
if (!isAdmin()) throw new BizException(BizCode.FORBIDDEN);
roleService.assignMenus(roleId, request.getMenuIds());
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "分配成功", tid(httpReq)));
}
// ========== 4.10 角色分配自定义数据权限部门 ==========
@PutMapping("/{roleId}/custom-depts")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Void>> assignCustomDepts(@PathVariable Long roleId,
@RequestBody AssignCustomDeptsRequest request,
HttpServletRequest httpReq) {
log.info("[API] PUT /api/v1/roles/{}/custom-depts", roleId);
if (!isAdmin()) throw new BizException(BizCode.FORBIDDEN);
roleService.assignCustomDepts(roleId, request.getDepartmentIds());
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "自定义部门分配成功", tid(httpReq)));
}
// ========== 查询角色自定义数据权限部门 ==========
@GetMapping("/{roleId}/custom-depts")
public ResponseEntity<ApiResponse<List<Long>>> getCustomDepts(@PathVariable Long roleId,
HttpServletRequest httpReq) {
log.info("[API] GET /api/v1/roles/{}/custom-depts", roleId);
List<Long> deptIds = roleService.getCustomDepts(roleId);
return ApiResponseEnvelope.ok(deptIds, tid(httpReq));
}
// ========== DTOs ==========
@Data
public static class CreateRoleRequest {
private String roleName;
private String roleCode;
private String description;
private Integer dataScope;
private Integer sort;
private Integer status;
private List<Long> permissionIds;
}
......@@ -250,6 +212,19 @@ public class RoleController {
public static class UpdateRoleRequest {
private String roleName;
private String description;
private Integer dataScope;
private Integer sort;
private Integer status;
private List<Long> permissionIds;
}
@Data
public static class AssignMenusRequest {
private List<Long> menuIds;
}
@Data
public static class AssignCustomDeptsRequest {
private List<Long> departmentIds;
}
}
package com.platform.backend.controller;
import com.platform.backend.auth.AuthConstants;
import com.platform.backend.auth.LoginAttemptService;
import com.platform.backend.auth.SmsCodeService;
import com.platform.backend.common.ApiResponseEnvelope;
import com.platform.backend.common.BizCode;
import com.platform.backend.common.BizException;
import com.platform.backend.common.DataScope;
import com.platform.backend.dto.ApiResponse;
import com.platform.backend.dto.UpdatePhoneRequest;
import com.platform.backend.entity.User;
import com.platform.backend.repository.UserRepository;
import com.platform.backend.service.AsyncImportService;
import com.platform.backend.service.PasswordService;
import com.platform.backend.service.UnlockLogService;
import com.platform.backend.service.UserService;
import jakarta.servlet.http.HttpServletRequest;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
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.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* 用户管理 Controller(文档 3.3 节)。
*
* <p>业务异常(用户不存在、权限不足等)由 {@link com.platform.backend.common.GlobalExceptionHandler}
* 统一捕获并返回对应 HTTP 状态码的 JSON 响应。
*/
@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 final UserService userService;
private final PasswordService passwordService;
private final LoginAttemptService loginAttempt;
private final AsyncImportService asyncImportService;
private final UnlockLogService unlockLogService;
private final SmsCodeService smsCodeService;
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);
private boolean isAdmin() {
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);
return auth != null && auth.getAuthorities().stream()
.anyMatch(a -> "ROLE_ADMIN".equals(a.getAuthority()));
}
/**
* 创建用户(管理员功能)
*/
@PostMapping
public ApiResponse<?> createUser(@RequestBody CreateUserRequest request, HttpServletRequest httpReq) {
String traceId = tid(httpReq);
log.info("[API] POST /api/v1/users username={}", request.getUsername());
private String currentUsername() {
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);
return auth == null ? null : auth.getName();
}
// ========== 3.3.1 当前用户 ==========
@GetMapping("/me")
public ResponseEntity<ApiResponse<Map<String, Object>>> getCurrentUser(HttpServletRequest httpReq) {
String username = currentUsername();
if (username == null || "anonymousUser".equals(username)) {
throw new BizException(BizCode.UNAUTHORIZED);
}
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);
}
/**
* 获取用户详情
*/
log.info("[API] GET /api/v1/users/me username={}", username);
User user = userService.getByUsername(username);
return ApiResponseEnvelope.ok(buildUserDetail(user), tid(httpReq));
}
// ========== 3.3.2 用户详情 ==========
@GetMapping("/{id}")
public ApiResponse<?> getUserById(@PathVariable Long id, HttpServletRequest httpReq) {
String traceId = tid(httpReq);
@PreAuthorize("hasRole('ADMIN') or #id == authentication.principal.id")
public ResponseEntity<ApiResponse<Map<String, Object>>> getUserById(@PathVariable Long id,
HttpServletRequest 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);
User user = userService.getById(id);
if (user.getIsDeleted() != null && user.getIsDeleted() == 1) {
throw new BizException(BizCode.USER_NOT_FOUND);
}
return ApiResponse.ok(buildUserDetail(user), traceId);
return ApiResponseEnvelope.ok(buildUserDetail(user), tid(httpReq));
}
/**
* 更新用户信息
*/
// ========== 3.3.3 更新用户信息 ==========
@PutMapping("/{id}")
public ApiResponse<?> updateUser(@PathVariable Long id,
@RequestBody UpdateUserRequest request,
HttpServletRequest httpReq) {
String traceId = tid(httpReq);
@PreAuthorize("hasRole('ADMIN') or #id == authentication.principal.id")
public ResponseEntity<ApiResponse<Map<String, Object>>> updateUser(@PathVariable Long id,
@RequestBody UpdateUserRequest request,
HttpServletRequest 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);
User user = userService.update(id,
request.getRealName(), request.getAvatar(),
request.getEmail(), request.getPhone(), request.getStatus());
return ApiResponseEnvelope.ok(buildUserDetail(user), "更新成功", tid(httpReq));
}
/**
* 删除用户(软删除)
*/
@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);
// ========== 更新手机号(需验证码) ==========
@PutMapping("/{id}/phone")
@PreAuthorize("hasRole('ADMIN') or #id == authentication.principal.id")
public ResponseEntity<ApiResponse<Void>> updatePhone(@PathVariable Long id,
@RequestBody UpdatePhoneRequest request,
HttpServletRequest httpReq) {
log.info("[API] PUT /api/v1/users/{}/phone", id);
// 验证码校验(type=update_phone)
if (!smsCodeService.verifyCode(request.getPhone(), "update_phone", request.getSmsCode())) {
throw new BizException(BizCode.SMS_CODE_INVALID);
}
user.setIsDeleted(1);
userRepository.save(user);
return ApiResponse.ok(null, "删除成功", traceId);
userService.updatePhone(id, request.getPhone());
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "手机号更新成功", tid(httpReq)));
}
/**
* 用户列表(分页)
*/
// ========== 3.3.4 修改密码 ==========
@PutMapping("/{id}/password")
@PreAuthorize("hasRole('ADMIN') or #id == authentication.principal.id")
public ResponseEntity<ApiResponse<Void>> changePassword(@PathVariable Long id,
@RequestBody ChangePasswordRequest request,
HttpServletRequest httpReq) {
log.info("[API] PUT /api/v1/users/{}/password", id);
passwordService.changePassword(currentUsername(), id, isAdmin(),
request.getOldPassword(), request.getNewPassword());
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "修改成功", tid(httpReq)));
}
// ========== 3.3.5 用户列表(带数据权限) ==========
@GetMapping
public ApiResponse<?> listUsers(
@PreAuthorize("hasRole('ADMIN')")
@DataScope(tableAlias = "root", deptIdColumn = "departmentId", userIdColumn = "id")
public ResponseEntity<ApiResponse<Map<String, Object>>> listUsers(
@RequestParam(defaultValue = "1") int page,
@RequestParam(defaultValue = "10") int size,
@RequestParam(required = false) String keyword,
@RequestParam(required = false) Long roleId,
@RequestParam(required = false) Long departmentId,
@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>();
Page<User> result = userService.list(keyword, roleId, departmentId, status, page, size);
Map<String, Object> data = new LinkedHashMap<>();
data.put("total", result.getTotalElements());
data.put("page", page);
data.put("size", size);
data.put("pages", result.getTotalPages());
data.put("items", result.getContent().stream().map(this::buildUserDetail).toList());
return ApiResponseEnvelope.ok(data, tid(httpReq));
}
// ========== 3.3.6 创建用户 ==========
@PostMapping
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Map<String, Object>>> createUser(
@RequestBody CreateUserRequest request,
HttpServletRequest httpReq) {
log.info("[API] POST /api/v1/users username={}", request.getUsername());
User user = userService.create(
request.getUsername(), request.getPassword(),
request.getRealName(), request.getEmail(),
request.getPhone(), request.getRoleIds());
return ApiResponseEnvelope.created(buildUserDetail(user), "创建成功", tid(httpReq));
}
// ========== 3.3.7 删除用户(软删除) ==========
@DeleteMapping("/{id}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<Void> deleteUser(@PathVariable Long id, HttpServletRequest httpReq) {
log.info("[API] DELETE /api/v1/users/{}", id);
userService.softDelete(id, currentUsername());
return ApiResponseEnvelope.noContent();
}
// ========== 3.3.8 重置用户密码(管理员) ==========
@PutMapping("/{id}/password/reset")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Void>> resetPassword(@PathVariable Long id,
@RequestBody ResetPasswordRequest request,
HttpServletRequest httpReq) {
log.info("[API] PUT /api/v1/users/{}/password/reset", id);
passwordService.resetPassword(id, request.getNewPassword());
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "重置成功", tid(httpReq)));
}
// ========== 4.11 用户角色分配 ==========
@PutMapping("/{id}/roles")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Void>> assignRoles(@PathVariable Long id,
@RequestBody AssignRolesRequest request,
HttpServletRequest httpReq) {
log.info("[API] PUT /api/v1/users/{}/roles", id);
userService.assignRoles(id, request.getRoleIds());
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "分配成功", tid(httpReq)));
}
// ========== 4.13 手动解锁 ==========
@PutMapping("/{id}/unlock")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Void>> unlockAccount(@PathVariable Long id, HttpServletRequest httpReq) {
String operator = currentUsername();
log.info("[API] PUT /api/v1/users/{}/unlock operator={}", id, operator);
User user = userService.getById(id);
loginAttempt.loginSucceeded(user.getUsername());
unlockLogService.log(operator, id, "管理员手动解锁");
return ApiResponseEnvelope.ok(ApiResponse.ok(null, "解锁成功", tid(httpReq)));
}
// ========== 3.3.9 批量导入用户(异步) ==========
@PostMapping("/batch-import")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Map<String, Object>>> batchImport(
@RequestParam("file") org.springframework.web.multipart.MultipartFile file,
HttpServletRequest httpReq) {
log.info("[API] POST /api/v1/users/batch-import filename={} size={}",
file.getOriginalFilename(), file.getSize());
if (file == null || file.isEmpty()) {
throw new BizException(BizCode.PARAM_INVALID, "上传文件不能为空");
}
String filename = file.getOriginalFilename();
if (filename == null ||
(!filename.endsWith(".xlsx") && !filename.endsWith(".xls"))) {
throw new BizException(BizCode.PARAM_INVALID, "仅支持 .xlsx / .xls 格式");
}
// 提交异步任务,立即返回 taskId
String taskId = asyncImportService.submitTask(0);
asyncImportService.executeImport(taskId, file);
Map<String, Object> data = new LinkedHashMap<>();
data.put("taskId", taskId);
return ApiResponseEnvelope.ok(data, "导入任务已提交", tid(httpReq));
}
// ========== 3.3.10 查询导入进度 ==========
@GetMapping("/batch-import/{taskId}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<ApiResponse<Map<String, Object>>> getImportProgress(
@PathVariable String taskId, HttpServletRequest httpReq) {
log.info("[API] GET /api/v1/users/batch-import/{}", taskId);
Map<String, Object> data = asyncImportService.getTaskDetail(taskId);
return ApiResponseEnvelope.ok(data, tid(httpReq));
}
// ========== DTOs ==========
@Data
public static class CreateUserRequest {
private String username;
private String password;
private String realName;
private String email;
private String phone;
private List<Long> roleIds;
}
@Data
public static class UpdateUserRequest {
private String realName;
private String avatar;
private String email;
private String phone;
private Integer status;
}
@Data
public static class ChangePasswordRequest {
private String oldPassword;
private String newPassword;
}
@Data
public static class ResetPasswordRequest {
private String newPassword;
}
@Data
public static class AssignRolesRequest {
private List<Long> roleIds;
}
// ========== 通用:构造用户详情(脱敏) ==========
private Map<String, Object> buildUserDetail(User user) {
Map<String, Object> map = new LinkedHashMap<>();
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("roleId", user.getRoleId());
map.put("departmentId", user.getDepartmentId());
map.put("status", user.getStatus());
map.put("createdAt", user.getCreatedAt());
map.put("updatedAt", user.getUpdatedAt());
return map;
}
......@@ -244,11 +313,4 @@ public class UserController {
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;
}
}
}
\ No newline at end of file
......@@ -16,18 +16,27 @@ public class ApiResponse<T> {
private int code;
private String message;
private String traceId;
private Long timestamp;
private T data;
public ApiResponse(int code, String message, String traceId, T data) {
this.code = code;
this.message = message;
this.traceId = traceId;
this.timestamp = System.currentTimeMillis();
this.data = data;
}
public static <T> ApiResponse<T> ok(T data) {
return new ApiResponse<>(0, "操作成功", UUID.randomUUID().toString(), data);
return new ApiResponse<>(200, "操作成功", UUID.randomUUID().toString(), data);
}
public static <T> ApiResponse<T> ok(T data, String traceId) {
return new ApiResponse<>(0, "操作成功", traceId, data);
return new ApiResponse<>(200, "操作成功", traceId, data);
}
public static <T> ApiResponse<T> ok(T data, String message, String traceId) {
return new ApiResponse<>(0, message, traceId, data);
return new ApiResponse<>(200, message, traceId, data);
}
public static <T> ApiResponse<T> fail(int code, String message) {
......
......@@ -34,5 +34,6 @@ public class LoginResponse {
@JsonProperty("realName")
private String realName;
private List<String> roles;
private boolean mustChangePassword;
}
}
package com.platform.backend.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
/**
* 登出请求。
*
* <p>支持两种传参方式:
* <ol>
* <li>Query 参数(推荐,前端不传 body 也可调用)</li>
* <li>JSON body(兼容旧客户端)</li>
* </ol>
*/
@Data
public class LogoutRequest {
@NotBlank(message = "refreshToken不能为空")
@JsonProperty("accessToken")
private String accessToken;
@JsonProperty("refreshToken")
private String refreshToken;
}
......@@ -12,6 +12,9 @@ public class RefreshTokenResponse {
@JsonProperty("accessToken")
private String accessToken;
@JsonProperty("refreshToken")
private String refreshToken;
@JsonProperty("expiresIn")
private long expiresIn;
}
package com.platform.backend.dto;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.Data;
/**
* 找回密码请求(对应文档 3.2.6)。
*/
@Data
public class ResetPwdRequest {
@NotBlank(message = "手机号不能为空")
@Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式错误")
private String phone;
@NotBlank(message = "验证码不能为空")
private String smsCode;
@NotBlank(message = "新密码不能为空")
private String newPassword;
}
package com.platform.backend.dto;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.Data;
/**
* 更新手机号请求(对应文档 3.3.3 更新用户信息中"更新手机号需验证码")。
*/
@Data
public class UpdatePhoneRequest {
@NotBlank(message = "新手机号不能为空")
@Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式错误")
private String phone;
@NotBlank(message = "验证码不能为空")
private String smsCode;
}
package com.platform.backend.dto;
import com.alibaba.excel.annotation.ExcelProperty;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;
import lombok.Data;
/**
* 批量导入用户 Excel 行模型(对应文档 3.3.9)。
*
* <p>Excel 表头必须与以下字段一一对应。
* 错误行将在导入结果中返回具体错误原因。
*/
@Data
public class UserImportModel {
@ExcelProperty("用户名")
@NotBlank(message = "用户名不能为空")
@Size(min = 3, max = 50, message = "用户名长度 3-50 位")
private String username;
@ExcelProperty("真实姓名")
@NotBlank(message = "真实姓名不能为空")
@Size(max = 50, message = "真实姓名最多 50 字符")
private String realName;
@ExcelProperty("手机号")
@NotBlank(message = "手机号不能为空")
@Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式错误")
private String phone;
@ExcelProperty("邮箱")
@Pattern(regexp = "^(|[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,})$",
message = "邮箱格式错误")
private String email;
@ExcelProperty("角色编码")
@NotBlank(message = "角色编码不能为空")
private String roleCode;
@ExcelProperty("初始密码")
@Size(min = 8, max = 20, message = "初始密码长度 8-20 位")
private String password;
@ExcelProperty("部门ID")
private Long departmentId;
@ExcelProperty("备注")
@Size(max = 200, message = "备注最多 200 字符")
private String remark;
}
package com.platform.backend.entity;
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
/** 部门表(user_department) — 文档 2.2.6 */
@Entity
@Table(name = "user_department")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Department {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, length = 100)
private String name;
@Column(length = 50, unique = true)
private String code;
@Column(length = 500)
private String description;
@Column(name = "parent_id")
private Long parentId;
@Column(nullable = false)
private Integer status = 1;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@Column(name = "updated_at")
private LocalDateTime updatedAt;
@PrePersist
protected void onCreate() { this.createdAt = LocalDateTime.now(); }
@PreUpdate
protected void onUpdate() { this.updatedAt = LocalDateTime.now(); }
}
\ No newline at end of file
......@@ -30,7 +30,7 @@ public class LoginLog {
@Column(length = 50)
private String ip;
@Column(length = 500)
@Column(columnDefinition = "TEXT")
private String device;
@Column(length = 100)
......@@ -39,7 +39,7 @@ public class LoginLog {
@Column(nullable = false)
private Integer status;
@Column(name = "fail_reason", length = 100)
@Column(name = "fail_reason", length = 255)
private String failReason;
@Column(name = "created_at", nullable = false, updatable = false)
......
package com.platform.backend.entity;
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
/** 菜单表(user_menu) — 文档 2.2.9 */
@Entity
@Table(
name = "user_menu",
indexes = {
@Index(name = "idx_menu_parent", columnList = "parent_id"),
@Index(name = "idx_menu_permission", columnList = "permission_code")
}
)
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Menu {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "parent_id", nullable = false)
private Long parentId = 0L;
@Column(nullable = false, length = 50)
private String name;
@Column(nullable = false, length = 50)
private String title;
@Column(length = 50)
private String icon;
@Column(length = 200)
private String path;
@Column(length = 200)
private String component;
@Column(name = "permission_code", length = 50)
private String permissionCode;
/** 1=目录 2=菜单 3=按钮 */
@Column(nullable = false)
private Integer type = 1;
@Column(nullable = false)
private Integer sort = 0;
@Column(nullable = false)
private Integer visible = 1;
@Column(nullable = false)
private Integer status = 1;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@Column(name = "updated_at")
private LocalDateTime updatedAt;
@PrePersist
protected void onCreate() {
this.createdAt = LocalDateTime.now();
if (this.parentId == null) this.parentId = 0L;
if (this.type == null) this.type = 1;
}
@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;
/** 密码历史表(user_password_history) — 文档 2.2.11 */
@Entity
@Table(
name = "user_password_history",
indexes = {
@Index(name = "idx_pwd_history_user", columnList = "user_id, created_at")
}
)
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PasswordHistory {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "user_id", nullable = false)
private Long userId;
@Column(name = "password_hash", nullable = false, length = 255)
private String passwordHash;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@PrePersist
protected void onCreate() { this.createdAt = LocalDateTime.now(); }
}
\ No newline at end of file
......@@ -30,6 +30,16 @@ public class Role {
@Column(name = "is_preset", nullable = false)
private Integer isPreset = 0;
/** 数据权限范围(文档 4.10):1=全部 2=本部门 3=本部门及下级 4=仅本人 5=自定义 */
@Column(name = "data_scope", nullable = false)
private Integer dataScope = 4;
@Column(nullable = false)
private Integer sort = 0;
@Column(nullable = false)
private Integer status = 1;
@Column(name = "updated_at")
private LocalDateTime updatedAt;
......@@ -39,6 +49,8 @@ public class Role {
@PrePersist
protected void onCreate() {
this.createdAt = LocalDateTime.now();
if (this.dataScope == null) this.dataScope = 4;
if (this.status == null) this.status = 1;
}
@PreUpdate
......
package com.platform.backend.entity;
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
/** 角色自定义数据权限表(user_role_custom_dept) — 文档 2.2.12 */
@Entity
@Table(
name = "user_role_custom_dept",
uniqueConstraints = @UniqueConstraint(columnNames = {"role_id", "department_id"})
)
@Data
@NoArgsConstructor
@AllArgsConstructor
public class RoleCustomDept {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "role_id", nullable = false)
private Long roleId;
@Column(name = "department_id", nullable = false)
private Long departmentId;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@PrePersist
protected void onCreate() { this.createdAt = 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;
/** 角色-菜单关联表(user_role_menu) — 文档 2.2.10 */
@Entity
@Table(
name = "user_role_menu",
uniqueConstraints = @UniqueConstraint(columnNames = {"role_id", "menu_id"})
)
@Data
@NoArgsConstructor
@AllArgsConstructor
public class RoleMenu {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "role_id", nullable = false)
private Long roleId;
@Column(name = "menu_id", nullable = false)
private Long menuId;
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;
@PrePersist
protected void onCreate() { this.createdAt = LocalDateTime.now(); }
}
\ No newline at end of file
......@@ -54,6 +54,9 @@ public class User {
@Column(name = "is_deleted", nullable = false)
private Integer isDeleted = 0;
@Column(name = "must_change_password", nullable = false)
private Integer mustChangePassword = 1;
@Column(name = "updated_at")
private LocalDateTime updatedAt;
......@@ -80,6 +83,11 @@ public class User {
this.status = (enabled != null && enabled) ? 1 : 0;
}
/** 首次登录必须改密标识:true = 需要改密 */
public boolean isMustChangePassword() {
return mustChangePassword != null && mustChangePassword == 1;
}
/** 兼容旧代码:单角色字符串读取 */
public String getRole() {
return roleId == null ? "USER" : String.valueOf(roleId);
......
package com.platform.backend.repository;
import com.platform.backend.entity.Department;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
@Repository
public interface DepartmentRepository extends JpaRepository<Department, Long> {
Optional<Department> findByCode(String code);
List<Department> findByStatus(Integer status);
List<Department> findByParentId(Long parentId);
/**
* 递归查询部门及其所有子部门 ID。
* 对应 data_scope=3(本部门及下级)场景。
*/
@Query(value = """
WITH RECURSIVE dept_tree AS (
SELECT id, parent_id FROM user_department WHERE id = :deptId
UNION ALL
SELECT d.id, d.parent_id FROM user_department d
INNER JOIN dept_tree dt ON d.parent_id = dt.id
)
SELECT id FROM dept_tree
""", nativeQuery = true)
List<Long> findAllChildIds(@Param("deptId") Long deptId);
/**
* 递归查询部门及其所有子部门。
*/
@Query(value = """
WITH RECURSIVE dept_tree AS (
SELECT id, parent_id, name, code, description, status, created_at, updated_at
FROM user_department WHERE id = :deptId
UNION ALL
SELECT d.id, d.parent_id, d.name, d.code, d.description, d.status, d.created_at, d.updated_at
FROM user_department d
INNER JOIN dept_tree dt ON d.parent_id = dt.id
)
SELECT * FROM dept_tree
""", nativeQuery = true)
List<Department> findAllChildren(@Param("deptId") Long deptId);
}
\ No newline at end of file
package com.platform.backend.repository;
import com.platform.backend.entity.Menu;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface MenuRepository extends JpaRepository<Menu, Long> {
List<Menu> findByStatus(Integer status);
List<Menu> findByParentId(Long parentId);
List<Menu> findByParentIdAndStatus(Long parentId, Integer status);
long countByParentId(Long parentId);
}
\ No newline at end of file
package com.platform.backend.repository;
import com.platform.backend.entity.PasswordHistory;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface PasswordHistoryRepository extends JpaRepository<PasswordHistory, Long> {
@Query("SELECT p.passwordHash FROM PasswordHistory p WHERE p.userId = :userId ORDER BY p.createdAt DESC")
List<String> findRecentHashes(@Param("userId") Long userId, Pageable pageable);
}
\ No newline at end of file
package com.platform.backend.repository;
import com.platform.backend.entity.RoleCustomDept;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface RoleCustomDeptRepository extends JpaRepository<RoleCustomDept, Long> {
List<RoleCustomDept> findByRoleId(Long roleId);
}
\ No newline at end of file
package com.platform.backend.repository;
import com.platform.backend.entity.RoleMenu;
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.util.List;
@Repository
public interface RoleMenuRepository extends JpaRepository<RoleMenu, Long> {
List<RoleMenu> findByRoleId(Long roleId);
List<RoleMenu> findByMenuId(Long menuId);
@Modifying
@Query("DELETE FROM RoleMenu rm WHERE rm.roleId = :roleId")
void deleteByRoleId(@Param("roleId") Long roleId);
@Query("SELECT rm.menuId FROM RoleMenu rm WHERE rm.roleId IN :roleIds")
List<Long> findMenuIdsByRoleIds(@Param("roleIds") List<Long> roleIds);
}
\ No newline at end of file
......@@ -2,18 +2,21 @@ package com.platform.backend.repository;
import com.platform.backend.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {
Optional<User> findByUsername(String username);
Optional<User> findByUsernameAndIsDeleted(String username, Integer isDeleted);
Optional<User> findByPhone(String phone);
boolean existsByUsername(String username);
boolean existsByPhone(String phone);
long countByIsDeletedAndRoleId(Integer isDeleted, Long roleId);
// 分页查询
List<User> findByIsDeleted(Integer isDeleted);
}
......@@ -2,6 +2,9 @@ package com.platform.backend.repository;
import com.platform.backend.entity.UserRole;
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.util.List;
......@@ -9,6 +12,14 @@ import java.util.List;
@Repository
public interface UserRoleRepository extends JpaRepository<UserRole, Long> {
List<UserRole> findByUserId(Long userId);
void deleteByUserId(Long userId);
List<UserRole> findByRoleId(Long roleId);
@Modifying
@Query("DELETE FROM UserRole ur WHERE ur.userId = :userId")
void deleteByUserId(@Param("userId") Long userId);
@Query("SELECT ur.roleId FROM UserRole ur WHERE ur.userId = :userId")
List<Long> findRoleIdsByUserId(@Param("userId") Long userId);
long countByRoleId(Long roleId);
}
package com.platform.backend.security;
import com.platform.backend.auth.AuthConstants;
import com.platform.backend.auth.JwtTokenService;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
......@@ -19,8 +22,9 @@ import java.io.IOException;
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {
private final JwtUtils jwtUtils;
private final JwtTokenService tokenService;
private final CustomUserDetailsService userDetailsService;
private final StringRedisTemplate redisTemplate;
@Override
protected void doFilterInternal(HttpServletRequest request,
......@@ -28,8 +32,15 @@ public class JwtAuthenticationFilter extends OncePerRequestFilter {
FilterChain filterChain) throws ServletException, IOException {
String token = parseJwt(request);
if (token != null && jwtUtils.validateToken(token)) {
String username = jwtUtils.getUsernameFromToken(token);
if (token != null && tokenService.validateAccessToken(token)) {
String username = tokenService.getUsernameFromToken(token);
// 检查 access token 黑名单(登出失效)或 Token 版本号变化(强制下线)
if (tokenService.isAccessTokenInvalid(token, username)) {
filterChain.doFilter(request, response);
return;
}
UserDetails userDetails = userDetailsService.loadUserByUsername(username);
UsernamePasswordAuthenticationToken authentication =
......
package com.platform.backend.service;
import com.alibaba.excel.EasyExcel;
import com.platform.backend.common.BizCode;
import com.platform.backend.common.BizException;
import com.platform.backend.dto.UserImportModel;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository;
import com.platform.backend.repository.UserRoleRepository;
import com.platform.backend.service.listener.UserImportListener;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.List;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
* 异步批量导入服务(对应文档 3.3.9 批量导入异步化)。
*
* <p>POST /batch-import → 返回 taskId,立即提交异步任务
* GET /batch-import/{taskId} → 查询进度
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class AsyncImportService {
private static final String TASK_KEY_PREFIX = "import:task:";
private final UserRepository userRepository;
private final RoleRepository roleRepository;
private final UserRoleRepository userRoleRepository;
private final PasswordEncoder passwordEncoder;
private final StringRedisTemplate redis;
/**
* 提交导入任务,立即返回 taskId。
*
* @return taskId
*/
public String submitTask(int total) {
String taskId = UUID.randomUUID().toString().replace("-", "");
saveTask(taskId, "PROCESSING", total, 0, 0, 0, null);
return taskId;
}
/**
* 异步执行导入任务(由 Spring @Async 调用)。
*/
@Async
public void executeImport(String taskId, MultipartFile file) {
log.info("[AsyncImport] 开始执行 taskId={}", taskId);
try {
UserImportListener listener = new UserImportListener(
userRepository, roleRepository, userRoleRepository, passwordEncoder);
EasyExcel.read(file.getInputStream(), UserImportModel.class, listener)
.sheet()
.headRowNumber(1)
.doRead();
saveTask(taskId, "SUCCESS",
listener.getTotal(),
listener.getTotal(),
listener.getSuccess(),
listener.getFailed(),
listener.getErrors());
log.info("[AsyncImport] 完成 taskId={} success={} failed={}",
taskId, listener.getSuccess(), listener.getFailed());
} catch (Exception e) {
log.error("[AsyncImport] 执行失败 taskId={}: {}", taskId, e.getMessage(), e);
saveTask(taskId, "FAILED", 0, 0, 0, 0, null);
redis.opsForHash().put(TASK_KEY_PREFIX + taskId, "error", e.getMessage());
}
}
/**
* 查询导入任务状态。
*/
public java.util.Map<String, Object> getTaskStatus(String taskId) {
String key = TASK_KEY_PREFIX + taskId;
if (!Boolean.TRUE.equals(redis.hasKey(key))) {
throw new BizException(BizCode.RESOURCE_NOT_FOUND, "任务不存在");
}
java.util.Map<Object, Object> raw = redis.opsForHash().entries(key);
java.util.Map<String, Object> result = new java.util.LinkedHashMap<>();
result.put("taskId", taskId);
result.put("status", raw.get("status"));
result.put("total", parseInt(raw.get("total")));
result.put("processed", parseInt(raw.get("processed")));
result.put("successCount", parseInt(raw.get("successCount")));
result.put("failCount", parseInt(raw.get("failCount")));
result.put("progress", calcProgress(raw));
Object error = raw.get("error");
if (error != null) {
result.put("error", error.toString());
}
return result;
}
/**
* 轮询进度时返回 failDetails(用于详情页)。
*/
public java.util.Map<String, Object> getTaskDetail(String taskId) {
java.util.Map<String, Object> base = getTaskStatus(taskId);
String key = TASK_KEY_PREFIX + taskId;
Object detailsRaw = redis.opsForHash().get(key, "failDetails");
if (detailsRaw != null) {
try {
ObjectMapper mapper = new ObjectMapper();
List<String> details = mapper.readValue(
detailsRaw.toString(),
new TypeReference<List<String>>() {});
base.put("failDetails", details);
} catch (Exception ignored) {
}
}
return base;
}
private void saveTask(String taskId, String status, int total, int processed,
int success, int failed, java.util.List<String> errors) {
String key = TASK_KEY_PREFIX + taskId;
redis.opsForHash().put(key, "status", status);
redis.opsForHash().put(key, "total", String.valueOf(total));
redis.opsForHash().put(key, "processed", String.valueOf(processed));
redis.opsForHash().put(key, "successCount", String.valueOf(success));
redis.opsForHash().put(key, "failCount", String.valueOf(failed));
if (errors != null && !errors.isEmpty()) {
try {
String json = new com.fasterxml.jackson.databind.ObjectMapper().writeValueAsString(errors);
redis.opsForHash().put(key, "failDetails", json);
} catch (Exception ignored) {
}
}
// 任务完成后保留 24 小时
redis.expire(key, 24, TimeUnit.HOURS);
}
private int parseInt(Object val) {
if (val == null) return 0;
try { return Integer.parseInt(val.toString()); } catch (Exception e) { return 0; }
}
private int calcProgress(java.util.Map<Object, Object> raw) {
int total = parseInt(raw.get("total"));
int processed = parseInt(raw.get("processed"));
if (total == 0) return 0;
return (int) (processed * 100L / total);
}
}
package com.platform.backend.service;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.platform.backend.auth.AuthConstants;
import com.platform.backend.common.BizCode;
import com.platform.backend.common.BizException;
import com.platform.backend.entity.Menu;
import com.platform.backend.entity.User;
import com.platform.backend.entity.UserRole;
import com.platform.backend.repository.MenuRepository;
import com.platform.backend.repository.RoleMenuRepository;
import com.platform.backend.repository.UserRepository;
import com.platform.backend.repository.UserRoleRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
/**
* 菜单服务:CRUD + 用户菜单查询 + 角色菜单分配 + Redis 缓存。
*
* <p>对应文档 3.5 节 / 4.8 节。
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class MenuService {
private final MenuRepository menuRepository;
private final RoleMenuRepository roleMenuRepository;
private final UserRoleRepository userRoleRepository;
private final UserRepository userRepository;
private final StringRedisTemplate redis;
private final ObjectMapper objectMapper;
private static final long MENU_TTL_HOURS = 1;
private static final String MENU_CACHE_KEY_PREFIX = "menu:";
private static final String MENU_CACHE_VERSION_KEY = "menu:cache:version";
private static final String MENU_CACHE_KEY_SUFFIX = ":tree";
/** 完整菜单树(管理后台用,文档 3.5.2)。 */
public List<Map<String, Object>> getTree(Integer status) {
List<Menu> all = status == null
? menuRepository.findAll()
: menuRepository.findByStatus(status);
return buildTree(all, 0L);
}
/** 用户可见菜单(按角色,文档 3.5.1)。支持 Redis JSON 缓存 + 版本号失效。 */
@SuppressWarnings("unchecked")
public List<Map<String, Object>> getUserMenuTree(Long userId) {
String cacheKey = cacheKey(userId);
String cached = redis.opsForValue().get(cacheKey);
if (cached != null) {
try {
return objectMapper.readValue(cached,
objectMapper.getTypeFactory().constructCollectionType(List.class, Map.class));
} catch (JsonProcessingException e) {
log.warn("[Menu] 解析菜单缓存失败 userId={},重新查询", userId);
}
}
List<Map<String, Object>> tree = queryUserMenuTree(userId);
try {
String json = objectMapper.writeValueAsString(tree);
redis.opsForValue().set(cacheKey, json, MENU_TTL_HOURS, TimeUnit.HOURS);
} catch (JsonProcessingException e) {
log.warn("[Menu] 序列化菜单缓存失败 userId={}", userId);
}
return tree;
}
private String cacheKey(Long userId) {
return MENU_CACHE_KEY_PREFIX + userId + MENU_CACHE_KEY_SUFFIX;
}
private List<Map<String, Object>> queryUserMenuTree(Long userId) {
List<Long> roleIds = userRoleRepository.findRoleIdsByUserId(userId);
if (roleIds.isEmpty()) return Collections.emptyList();
List<Long> menuIds = roleMenuRepository.findMenuIdsByRoleIds(roleIds);
if (menuIds.isEmpty()) return Collections.emptyList();
List<Menu> all = menuRepository.findAllById(menuIds).stream()
.filter(m -> m.getStatus() != null && m.getStatus() == 1)
.filter(m -> m.getVisible() != null && m.getVisible() == 1)
.sorted(Comparator.comparing(Menu::getSort).thenComparing(Menu::getId))
.collect(Collectors.toList());
return buildTree(all, 0L);
}
public Menu getById(Long id) {
return menuRepository.findById(id)
.orElseThrow(() -> new BizException(BizCode.RESOURCE_NOT_FOUND, "菜单不存在"));
}
@Transactional
public Menu create(Long parentId, String name, String title, String icon, String path,
String component, String permissionCode, Integer type,
Integer sort, Integer visible, Integer status) {
if (parentId != null && parentId != 0L) {
menuRepository.findById(parentId).orElseThrow(
() -> new BizException(BizCode.RESOURCE_NOT_FOUND, "父菜单不存在"));
}
// 同级 name 唯一(粗校验:parentId 相同 + name 相同 不可重复)
List<Menu> siblings = menuRepository.findByParentId(parentId == null ? 0L : parentId);
if (siblings.stream().anyMatch(m -> name.equals(m.getName()))) {
throw new BizException(BizCode.MENU_NAME_DUPLICATE);
}
Menu menu = new Menu();
menu.setParentId(parentId == null ? 0L : parentId);
menu.setName(name);
menu.setTitle(title);
menu.setIcon(icon);
menu.setPath(path);
menu.setComponent(component);
menu.setPermissionCode(permissionCode);
menu.setType(type == null ? 1 : type);
menu.setSort(sort == null ? 0 : sort);
menu.setVisible(visible == null ? 1 : visible);
menu.setStatus(status == null ? 1 : status);
menu = menuRepository.save(menu);
refreshAllMenuCache();
return menu;
}
@Transactional
public Menu update(Long id, String title, String icon, String path, String component,
Integer type, Integer sort, Integer visible, Integer status) {
Menu menu = menuRepository.findById(id)
.orElseThrow(() -> new BizException(BizCode.RESOURCE_NOT_FOUND, "菜单不存在"));
// 不允许修改 name(前端路由名)
if (title != null) menu.setTitle(title);
if (icon != null) menu.setIcon(icon);
if (path != null) menu.setPath(path);
if (component != null) menu.setComponent(component);
if (type != null) menu.setType(type);
if (sort != null) menu.setSort(sort);
if (visible != null) menu.setVisible(visible);
if (status != null) menu.setStatus(status);
menu = menuRepository.save(menu);
refreshAllMenuCache();
return menu;
}
@Transactional
public void delete(Long id) {
Menu menu = menuRepository.findById(id)
.orElseThrow(() -> new BizException(BizCode.RESOURCE_NOT_FOUND, "菜单不存在"));
if (menuRepository.countByParentId(id) > 0) {
throw new BizException(BizCode.MENU_HAS_CHILDREN);
}
roleMenuRepository.findByMenuId(id).forEach(roleMenuRepository::delete);
menuRepository.delete(menu);
refreshAllMenuCache();
}
@Transactional
public void assignToRole(Long roleId, List<Long> menuIds) {
roleMenuRepository.deleteByRoleId(roleId);
if (menuIds != null) {
for (Long menuId : menuIds) {
var rm = new com.platform.backend.entity.RoleMenu();
rm.setRoleId(roleId);
rm.setMenuId(menuId);
roleMenuRepository.save(rm);
}
}
// 找到该角色下的所有用户,清除他们的菜单缓存
List<UserRole> userRoles = userRoleRepository.findByRoleId(roleId);
for (UserRole ur : userRoles) {
redis.delete(cacheKey(ur.getUserId()));
}
incrementMenuCacheVersion();
}
/**
* 递增菜单缓存版本号,使所有用户缓存失效。
* 使用版本号替代 KEYS 命令,避免生产环境性能问题。
*/
private void incrementMenuCacheVersion() {
Long version = redis.opsForValue().increment(MENU_CACHE_VERSION_KEY);
log.info("[Menu] 菜单缓存版本递增 → {}", version);
}
private void refreshAllMenuCache() {
incrementMenuCacheVersion();
}
private List<Map<String, Object>> buildTree(List<Menu> all, Long parentId) {
List<Map<String, Object>> result = new ArrayList<>();
for (Menu m : all) {
if (Objects.equals(m.getParentId(), parentId)) {
Map<String, Object> node = new LinkedHashMap<>();
node.put("id", m.getId());
node.put("parentId", m.getParentId());
node.put("name", m.getName());
node.put("title", m.getTitle());
node.put("icon", m.getIcon());
node.put("path", m.getPath());
node.put("component", m.getComponent());
node.put("permissionCode", m.getPermissionCode());
node.put("type", m.getType());
node.put("sort", m.getSort());
node.put("visible", m.getVisible());
node.put("status", m.getStatus());
List<Map<String, Object>> children = buildTree(all, m.getId());
if (!children.isEmpty()) node.put("children", children);
result.add(node);
}
}
return result;
}
}
\ No newline at end of file
package com.platform.backend.service;
import com.platform.backend.auth.JwtTokenService;
import com.platform.backend.common.BizCode;
import com.platform.backend.common.BizException;
import com.platform.backend.entity.PasswordHistory;
import com.platform.backend.entity.User;
import com.platform.backend.repository.PasswordHistoryRepository;
import com.platform.backend.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* 密码相关服务:密码历史校验、修改密码、记录密码历史。
*
* <p>对应文档 4.12 密码安全。
*/
@Service
@RequiredArgsConstructor
public class PasswordService {
private final UserRepository userRepository;
private final PasswordHistoryRepository passwordHistoryRepository;
private final PasswordEncoder passwordEncoder;
private final JwtTokenService tokenService;
@Value("${login-policy.password-history-limit:3}")
private int historyLimit;
/**
* 修改密码(含旧密码校验、密码强度校验、密码历史校验)。
*
* @param operatorUsername 当前操作用户(用于权限判断:本人或 ADMIN)
* @param targetUserId 被修改密码的用户 ID
* @param isAdmin 当前操作用户是否是 ADMIN
* @param oldPassword 旧密码(管理员重置时可为 null)
* @param newPassword 新密码
*/
@Transactional
public void changePassword(String operatorUsername,
Long targetUserId,
boolean isAdmin,
String oldPassword,
String newPassword) {
User user = userRepository.findById(targetUserId)
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND));
// 权限校验:本人或 ADMIN 才能修改
if (!isAdmin && !user.getUsername().equals(operatorUsername)) {
throw new BizException(BizCode.FORBIDDEN);
}
// 校验旧密码(非管理员场景)
if (oldPassword != null && !passwordEncoder.matches(oldPassword, user.getPassword())) {
throw new BizException(BizCode.OLD_PASSWORD_WRONG);
}
// 密码强度
if (!com.platform.backend.common.PasswordValidator.isValid(newPassword)) {
throw new BizException(BizCode.PARAM_INVALID,
"密码长度 8-20 位,必须包含大小写字母 + 数字");
}
// 历史密码校验:不可与最近 N 次相同
Pageable pageable = PageRequest.of(0, historyLimit);
List<String> recentHashes = passwordHistoryRepository.findRecentHashes(targetUserId, pageable);
if (recentHashes.stream().anyMatch(h -> passwordEncoder.matches(newPassword, h))) {
throw new BizException(BizCode.PASSWORD_REUSED,
"新密码不可与最近 " + historyLimit + " 次密码相同");
}
// 更新密码
user.setPassword(passwordEncoder.encode(newPassword));
userRepository.save(user);
// 写入历史
PasswordHistory history = new PasswordHistory();
history.setUserId(targetUserId);
history.setPasswordHash(user.getPassword());
passwordHistoryRepository.save(history);
// 密码变更后使该用户所有旧 Token 失效
if (user.getUsername() != null) {
tokenService.incrementTokenVersion(user.getUsername());
}
}
/**
* 管理员重置密码(不校验旧密码)。
*/
@Transactional
public void resetPassword(Long targetUserId, String newPassword) {
User user = userRepository.findById(targetUserId)
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND));
doResetPassword(user, newPassword);
}
/**
* 短信验证码找回密码:按手机号重置(对应文档 3.2.6)。
*
* @param phone 手机号
* @param newPassword 新密码
*/
@Transactional
public void resetPasswordByPhone(String phone, String newPassword) {
User user = userRepository.findByPhone(phone)
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND, "该手机号未注册"));
doResetPassword(user, newPassword);
// 重置后使该用户所有旧 Token 失效(下次需重新登录)
if (user.getUsername() != null) {
tokenService.incrementTokenVersion(user.getUsername());
}
}
private void doResetPassword(User user, String newPassword) {
if (!com.platform.backend.common.PasswordValidator.isValid(newPassword)) {
throw new BizException(BizCode.PARAM_INVALID,
"密码长度 8-20 位,必须包含大小写字母 + 数字");
}
Pageable pageable = PageRequest.of(0, historyLimit);
List<String> recentHashes = passwordHistoryRepository.findRecentHashes(user.getId(), pageable);
if (recentHashes.stream().anyMatch(h -> passwordEncoder.matches(newPassword, h))) {
throw new BizException(BizCode.PASSWORD_REUSED,
"新密码不可与最近 " + historyLimit + " 次密码相同");
}
user.setPassword(passwordEncoder.encode(newPassword));
user.setMustChangePassword(0);
userRepository.save(user);
PasswordHistory history = new PasswordHistory();
history.setUserId(user.getId());
history.setPasswordHash(user.getPassword());
passwordHistoryRepository.save(history);
}
}
\ No newline at end of file
package com.platform.backend.service;
import com.platform.backend.common.BizCode;
import com.platform.backend.common.BizException;
import com.platform.backend.entity.Role;
import com.platform.backend.entity.RoleCustomDept;
import com.platform.backend.entity.RoleMenu;
import com.platform.backend.entity.RolePermission;
import com.platform.backend.entity.UserRole;
import com.platform.backend.repository.RoleCustomDeptRepository;
import com.platform.backend.repository.RoleMenuRepository;
import com.platform.backend.repository.RolePermissionRepository;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRoleRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* 角色业务服务:CRUD、权限分配、菜单分配。
*
* <p>对应文档 3.4 节 / 4.6 节 / 4.7 节。
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class RoleService {
private final RoleRepository roleRepository;
private final RolePermissionRepository rolePermissionRepository;
private final RoleMenuRepository roleMenuRepository;
private final UserRoleRepository userRoleRepository;
private final RoleCustomDeptRepository roleCustomDeptRepository;
private final StringRedisTemplate redis;
public List<Role> list() {
return roleRepository.findAll();
}
public Role getById(Long id) {
return roleRepository.findById(id)
.orElseThrow(() -> new BizException(BizCode.RESOURCE_NOT_FOUND, "角色不存在"));
}
@Transactional
public Role create(String roleName, String roleCode, String description,
Integer dataScope, Integer sort, Integer status,
List<Long> permissionIds) {
if (roleRepository.findByRoleCode(roleCode).isPresent()) {
throw new BizException(BizCode.ROLE_NAME_DUPLICATE, "角色编码已存在");
}
Role role = new Role();
role.setRoleName(roleName);
role.setRoleCode(roleCode);
role.setDescription(description);
role.setIsPreset(0);
role.setDataScope(dataScope == null ? 4 : dataScope);
role.setSort(sort == null ? 0 : sort);
role.setStatus(status == null ? 1 : status);
role = roleRepository.save(role);
if (permissionIds != null) {
for (Long permId : permissionIds) {
RolePermission rp = new RolePermission();
rp.setRoleId(role.getId());
rp.setPermissionId(permId);
rolePermissionRepository.save(rp);
}
}
return role;
}
@Transactional
public Role update(Long id, String roleName, String description,
Integer dataScope, Integer sort, Integer status,
List<Long> permissionIds) {
Role role = getById(id);
if (role.getIsPreset() != null && role.getIsPreset() == 1) {
throw new BizException(BizCode.ROLE_PRESET);
}
if (roleName != null) role.setRoleName(roleName);
if (description != null) role.setDescription(description);
if (dataScope != null) role.setDataScope(dataScope);
if (sort != null) role.setSort(sort);
if (status != null) role.setStatus(status);
role = roleRepository.save(role);
if (permissionIds != null) {
rolePermissionRepository.deleteByRoleId(id);
for (Long permId : permissionIds) {
RolePermission rp = new RolePermission();
rp.setRoleId(id);
rp.setPermissionId(permId);
rolePermissionRepository.save(rp);
}
}
return role;
}
@Transactional
public void delete(Long id) {
Role role = getById(id);
if (role.getIsPreset() != null && role.getIsPreset() == 1) {
throw new BizException(BizCode.ROLE_PRESET, "预置角色不可删除");
}
if (userRoleRepository.countByRoleId(id) > 0) {
throw new BizException(BizCode.ROLE_HAS_USERS);
}
rolePermissionRepository.deleteByRoleId(id);
roleMenuRepository.deleteByRoleId(id);
roleRepository.delete(role);
}
@Transactional
public void assignMenus(Long roleId, List<Long> menuIds) {
Role role = getById(roleId);
roleMenuRepository.deleteByRoleId(roleId);
if (menuIds != null) {
for (Long menuId : menuIds) {
RoleMenu rm = new RoleMenu();
rm.setRoleId(roleId);
rm.setMenuId(menuId);
roleMenuRepository.save(rm);
}
}
// 清除该角色下所有用户的菜单缓存
List<UserRole> userRoles = userRoleRepository.findByRoleId(roleId);
for (UserRole ur : userRoles) {
redis.delete("menu:" + ur.getUserId());
}
log.info("[ROLE] 分配菜单 roleId={} menuIds={} 菜单缓存已清除", roleId, menuIds);
}
/**
* 角色分配自定义数据权限部门(对应 data_scope=5,文档 4.10)。
* 替换式更新(先删后插)。
*/
@Transactional
public void assignCustomDepts(Long roleId, List<Long> departmentIds) {
getById(roleId);
// 先删旧关联
List<RoleCustomDept> existing = roleCustomDeptRepository.findByRoleId(roleId);
roleCustomDeptRepository.deleteAll(existing);
// 再插新关联
if (departmentIds != null) {
for (Long deptId : departmentIds) {
RoleCustomDept rcd = new RoleCustomDept();
rcd.setRoleId(roleId);
rcd.setDepartmentId(deptId);
roleCustomDeptRepository.save(rcd);
}
}
log.info("[ROLE] 分配自定义部门 roleId={} deptIds={}", roleId, departmentIds);
}
/**
* 查询角色已分配的自定义部门。
*/
public List<Long> getCustomDepts(Long roleId) {
return roleCustomDeptRepository.findByRoleId(roleId).stream()
.map(RoleCustomDept::getDepartmentId)
.toList();
}
}
package com.platform.backend.service;
import com.platform.backend.entity.User;
import com.platform.backend.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
/**
* 解锁操作日志服务(对应文档 4.13 手动解锁验收标准)。
*
* <p>记录管理员解锁用户账号的操作日志,供审计追溯。
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class UnlockLogService {
private final UserRepository userRepository;
/**
* 记录解锁操作日志。
*
* @param operatorUsername 操作人(管理员)用户名
* @param targetUserId 被解锁的用户 ID
* @param reason 解锁原因
*/
public void log(String operatorUsername, Long targetUserId, String reason) {
String targetUsername = userRepository.findById(targetUserId)
.map(User::getUsername)
.orElse("unknown");
log.info("[UNLOCK_LOG] operator={} target={}({}) reason={} time={}",
operatorUsername,
targetUsername,
targetUserId,
reason != null ? reason : "管理员手动解锁",
LocalDateTime.now());
}
}
package com.platform.backend.service;
import com.platform.backend.auth.JwtTokenService;
import com.platform.backend.common.BizCode;
import com.platform.backend.common.BizException;
import com.platform.backend.common.DataScopeContext;
import com.platform.backend.entity.Role;
import com.platform.backend.entity.User;
import com.platform.backend.entity.UserRole;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository;
import com.platform.backend.repository.UserRoleRepository;
import jakarta.persistence.criteria.Predicate;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
/**
* 用户业务服务:CRUD、关键词筛选、角色分配。
*
* <p>对应文档 3.3 节 / 4.5 节 / 4.11 节。
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class UserService {
private final UserRepository userRepository;
private final UserRoleRepository userRoleRepository;
private final RoleRepository roleRepository;
private final PasswordEncoder passwordEncoder;
private final StringRedisTemplate redis;
private final JwtTokenService tokenService;
@Transactional
public User create(String username,
String password,
String realName,
String email,
String phone,
List<Long> roleIds) {
if (userRepository.existsByUsername(username)) {
throw new BizException(BizCode.USER_ALREADY_EXISTS, "用户名已存在");
}
if (phone != null && !phone.isBlank() && userRepository.existsByPhone(phone)) {
throw new BizException(BizCode.USER_ALREADY_EXISTS, "该手机号已注册");
}
if (!com.platform.backend.common.PasswordValidator.isValid(password)) {
throw new BizException(BizCode.PARAM_INVALID,
"密码长度 8-20 位,必须包含大小写字母 + 数字");
}
User user = new User();
user.setUsername(username);
user.setPassword(passwordEncoder.encode(password));
user.setRealName(realName);
user.setEmail(email);
user.setPhone(phone);
user.setStatus(1);
user.setIsDeleted(0);
// 注册用户首次登录不需要强制改密(注册时已自行设置密码)
user.setMustChangePassword(0);
// 单角色快速查询字段兼容
if (roleIds != null && !roleIds.isEmpty()) {
user.setRoleId(roleIds.get(0));
}
user = userRepository.save(user);
// 多角色关联
if (roleIds != null && !roleIds.isEmpty()) {
for (Long roleId : roleIds) {
UserRole ur = new UserRole();
ur.setUserId(user.getId());
ur.setRoleId(roleId);
userRoleRepository.save(ur);
}
}
return user;
}
@Transactional
public User update(Long id, String realName, String avatar, String email, String phone, Integer status) {
User user = userRepository.findById(id)
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND));
if (user.getIsDeleted() != null && user.getIsDeleted() == 1) {
throw new BizException(BizCode.USER_NOT_FOUND);
}
if (realName != null) user.setRealName(realName);
if (avatar != null) user.setAvatarUrl(avatar);
if (email != null) user.setEmail(email);
if (phone != null) user.setPhone(phone);
if (status != null) user.setStatus(status);
return userRepository.save(user);
}
@Transactional
public void softDelete(Long id, String operatorUsername) {
User user = userRepository.findById(id)
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND));
if (user.getIsDeleted() != null && user.getIsDeleted() == 1) {
throw new BizException(BizCode.USER_NOT_FOUND);
}
// 不能删除自己
if (user.getUsername().equals(operatorUsername)) {
throw new BizException(BizCode.CANNOT_DELETE_SELF);
}
// 不能删除 ADMIN 角色的用户
if (user.getRoleId() != null) {
roleRepository.findById(user.getRoleId()).ifPresent(role -> {
if ("ROLE_ADMIN".equals(role.getRoleCode())) {
throw new BizException(BizCode.CANNOT_DELETE_ADMIN);
}
});
}
user.setIsDeleted(1);
userRepository.save(user);
}
public User getById(Long id) {
return userRepository.findById(id)
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND));
}
public User getByUsername(String username) {
return userRepository.findByUsernameAndIsDeleted(username, 0)
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND));
}
/**
* 更新手机号(仅更新字段,由 Controller 层验证验证码)。
*/
@Transactional
public void updatePhone(Long id, String phone) {
User user = userRepository.findById(id)
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND));
if (user.getIsDeleted() != null && user.getIsDeleted() == 1) {
throw new BizException(BizCode.USER_NOT_FOUND);
}
if (phone != null && !phone.isBlank() && userRepository.existsByPhone(phone)) {
throw new BizException(BizCode.USER_ALREADY_EXISTS, "该手机号已被使用");
}
user.setPhone(phone);
userRepository.save(user);
}
/**
* 分页 + 关键词 + 多条件筛选(文档 3.3.5)。
*
* @param keyword 模糊匹配 username / realName / phone
* @param roleId 角色 ID(精确匹配)
* @param departmentId 部门 ID(精确匹配)
* @param status 状态
* @param page 页码(1-based)
* @param size 每页大小
*/
public Page<User> list(String keyword,
Long roleId,
Long departmentId,
Integer status,
int page,
int size) {
Specification<User> spec = (root, query, cb) -> {
List<Predicate> predicates = new ArrayList<>();
// 默认仅查未删除
predicates.add(cb.equal(root.get("isDeleted"), 0));
if (keyword != null && !keyword.isBlank()) {
String like = "%" + keyword.trim() + "%";
Predicate userLike = cb.like(root.get("username"), like);
Predicate nameLike = cb.like(root.get("realName"), like);
Predicate phoneLike = cb.like(root.get("phone"), like);
predicates.add(cb.or(userLike, nameLike, phoneLike));
}
if (roleId != null) {
predicates.add(cb.equal(root.get("roleId"), roleId));
}
if (departmentId != null) {
predicates.add(cb.equal(root.get("departmentId"), departmentId));
}
if (status != null) {
predicates.add(cb.equal(root.get("status"), status));
}
// 数据权限过滤条件(@DataScope 切面已在 controller 层注入到 ThreadLocal)
predicates.addAll(DataScopeContext.buildPredicates(root, cb, "departmentId", "id"));
return cb.and(predicates.toArray(new Predicate[0]));
};
Pageable pageable = PageRequest.of(Math.max(page - 1, 0), Math.min(Math.max(size, 1), 100),
Sort.by(Sort.Direction.DESC, "createdAt"));
return userRepository.findAll(spec, pageable);
}
/**
* 用户角色分配(替换式,文档 4.11)。
*/
@Transactional
public void assignRoles(Long userId, List<Long> roleIds) {
User user = userRepository.findById(userId)
.orElseThrow(() -> new BizException(BizCode.USER_NOT_FOUND));
// 清旧关联
userRoleRepository.deleteByUserId(userId);
// 写新关联
if (roleIds != null) {
for (Long roleId : roleIds) {
UserRole ur = new UserRole();
ur.setUserId(userId);
ur.setRoleId(roleId);
userRoleRepository.save(ur);
}
}
// 同步快速查询字段(取第一个)
if (roleIds != null && !roleIds.isEmpty()) {
user.setRoleId(roleIds.get(0));
} else {
user.setRoleId(null);
}
userRepository.save(user);
// 分配后清该用户的菜单和权限缓存
redis.delete("menu:" + userId);
// 分配角色后使该用户所有旧 Token 失效(强制重新登录)
tokenService.incrementTokenVersion(user.getUsername());
log.info("[USER] 分配角色 userId={} roleIds={} 缓存已清除,Token 已失效", userId, roleIds);
}
/** 获取用户的角色 ID 列表(用于角色判断和角色菜单查询)。 */
public List<Long> getRoleIds(Long userId) {
return userRoleRepository.findRoleIdsByUserId(userId);
}
}
\ No newline at end of file
package com.platform.backend.service.listener;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.platform.backend.common.BizCode;
import com.platform.backend.common.BizException;
import com.platform.backend.dto.UserImportModel;
import com.platform.backend.entity.Role;
import com.platform.backend.entity.User;
import com.platform.backend.entity.UserRole;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository;
import com.platform.backend.repository.UserRoleRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.crypto.password.PasswordEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* EasyExcel 批量导入监听器。
*
* <p>每读满 {@link #BATCH_SIZE} 行或读完后,触发一次批量持久化。
* 失败行记录错误信息,继续处理后续行,最终返回完整错误报告。
*
* <p><strong>注意</strong>:此类由 {@link com.platform.backend.service.AsyncImportService}
* 每次导入时手动 {@code new} 创建实例,请勿添加 {@code @Component} 等 Spring 生命周期注解。
*/
@Slf4j
@RequiredArgsConstructor
public class UserImportListener implements ReadListener<UserImportModel> {
private static final int BATCH_SIZE = 100;
private final UserRepository userRepository;
private final RoleRepository roleRepository;
private final UserRoleRepository userRoleRepository;
private final PasswordEncoder passwordEncoder;
/** 批次缓冲 */
private final List<User> batch = new ArrayList<>();
/** 批次角色关联 */
private final Map<String, Role> roleCache = new HashMap<>();
/** 导入结果 */
private int total = 0;
private int success = 0;
private int failed = 0;
private final List<String> errors = new ArrayList<>();
@Override
public void invoke(UserImportModel row, AnalysisContext context) {
total++;
try {
validateAndBuild(row);
batch.add(buildUser(row));
if (batch.size() >= BATCH_SIZE) {
flushBatch();
}
} catch (Exception e) {
failed++;
errors.add("行 " + total + " [" + safeStr(row.getUsername()) + "]: " + e.getMessage());
}
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
try {
flushBatch();
} catch (Exception e) {
log.error("[UserImport] 最终批次 flush 失败: {}", e.getMessage());
}
}
/** 校验行数据并缓存角色 */
private void validateAndBuild(UserImportModel row) {
if (row.getUsername() == null || row.getUsername().isBlank()) {
throw new BizException(BizCode.PARAM_INVALID, "用户名不能为空");
}
if (userRepository.existsByUsername(row.getUsername().trim())) {
throw new BizException(BizCode.USER_ALREADY_EXISTS, "用户名已存在: " + row.getUsername());
}
if (row.getPhone() != null && !row.getPhone().isBlank()) {
if (userRepository.existsByPhone(row.getPhone())) {
throw new BizException(BizCode.USER_ALREADY_EXISTS, "手机号已注册: " + row.getPhone());
}
}
if (row.getRoleCode() == null || row.getRoleCode().isBlank()) {
throw new BizException(BizCode.PARAM_INVALID, "角色编码不能为空");
}
Role role = roleCache.computeIfAbsent(row.getRoleCode().trim(), code ->
roleRepository.findByRoleCode(code)
.orElseThrow(() -> new BizException(BizCode.RESOURCE_NOT_FOUND,
"角色不存在: " + code)));
}
private User buildUser(UserImportModel row) {
User user = new User();
user.setUsername(row.getUsername().trim());
String pwd = row.getPassword() != null && !row.getPassword().isBlank()
? row.getPassword() : "Temp" + (int) ((Math.random() * 9000) + 1000);
user.setPassword(passwordEncoder.encode(pwd));
user.setRealName(row.getRealName().trim());
user.setPhone(row.getPhone());
user.setEmail(row.getEmail());
user.setDepartmentId(row.getDepartmentId());
user.setStatus(1);
user.setIsDeleted(0);
user.setMustChangePassword(0);
Role role = roleCache.get(row.getRoleCode().trim());
user.setRoleId(role.getId());
return user;
}
/**
* 流式 flush:供外部(AsyncImportService)在事务内调用。
*/
public void flushBatch() {
if (batch.isEmpty()) return;
List<User> saved = userRepository.saveAll(batch);
for (User u : saved) {
if (u.getRoleId() != null) {
UserRole ur = new UserRole();
ur.setUserId(u.getId());
ur.setRoleId(u.getRoleId());
userRoleRepository.save(ur);
}
}
success += saved.size();
batch.clear();
}
private String safeStr(String s) {
return s == null ? "" : s;
}
public int getTotal() { return total; }
public int getSuccess() { return success; }
public int getFailed() { return failed; }
public List<String> getErrors() { return errors; }
}
......@@ -17,13 +17,20 @@ spring:
jpa:
hibernate:
ddl-auto: update
ddl-auto: none
show-sql: false
properties:
hibernate:
dialect: org.hibernate.dialect.MySQLDialect
format_sql: false
sql:
init:
mode: always
continue-on-error: true
encoding: UTF-8
schema-locations: classpath:db/user-module-schema.sql
data:
redis:
host: localhost
......@@ -72,11 +79,18 @@ jwt:
login:
max-failures: 5
lock-minutes: 30 # 锁定 30 分钟
lock-minutes: 10 # 锁定 10 分钟(文档 4.13 节约定)
sms:
send-interval: 30 # 30秒内同一手机只能发一次
send-interval: 60 # 60秒内同一手机只能发一次(文档 4.3 节约定)
expire-minutes: 5 # 验证码5分钟有效
ip-hourly-max: 10 # 单 IP 1 小时最多 10 次
verify-max-errors: 3 # 验证码错误 3 次后失效
login-policy:
password-min-length: 8 # 密码最小长度
password-max-length: 20 # 密码最大长度
password-history-limit: 3 # 不可与最近 3 次密码相同
ai-service:
base-url: ${AI_SERVICE_BASE_URL:http://localhost:7083}
......
-- 从 sql/user-module-schema.sql 复制到此,由 Spring classpath 自动加载
-- 路径:src/main/resources/db/user-module-schema.sql
-- ============================================================
-- 用户模块数据库表设计
-- 根据 user-module-任务文档.md 设计
-- 数据库: studyweb
-- 创建时间: 2026-07-15
-- ============================================================
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- 1. 部门表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_department (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL COMMENT '部门名称',
code VARCHAR(50) UNIQUE COMMENT '部门编码:tech/annotation',
description VARCHAR(500) COMMENT '说明',
parent_id BIGINT COMMENT '父部门ID',
status TINYINT DEFAULT 1 COMMENT '状态:1=启用 0=禁用',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='部门表';
-- ----------------------------
-- 2. 用户表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_user (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(50) NOT NULL UNIQUE COMMENT '用户名',
password VARCHAR(255) NOT NULL COMMENT 'bcrypt加密密码',
real_name VARCHAR(50) NOT NULL COMMENT '真实姓名',
email VARCHAR(100) COMMENT '邮箱',
phone VARCHAR(20) COMMENT '手机号',
role_id BIGINT COMMENT '主角色ID(单角色快速查询字段)',
department_id BIGINT COMMENT '所属部门',
avatar_url VARCHAR(500) COMMENT '头像',
status TINYINT DEFAULT 1 COMMENT '0=禁用 1=启用',
is_deleted TINYINT DEFAULT 0 COMMENT '软删除标记',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
INDEX idx_role_id (role_id),
INDEX idx_department_id (department_id),
INDEX idx_status (status),
INDEX idx_phone (phone)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='用户表';
-- ----------------------------
-- 3. 角色表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_role (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
role_name VARCHAR(50) NOT NULL UNIQUE COMMENT '角色名称',
role_code VARCHAR(50) UNIQUE COMMENT '角色编码,用于 Spring Security(如 ROLE_ADMIN)',
description VARCHAR(200) COMMENT '角色描述',
is_preset TINYINT DEFAULT 0 COMMENT '是否预置角色:0=否 1=是',
data_scope TINYINT DEFAULT 4 COMMENT '数据权限:1=全部 2=本部门 3=本部门及下级 4=仅本人 5=自定义',
sort INT DEFAULT 0 COMMENT '排序号',
status TINYINT DEFAULT 1 COMMENT '状态:1=启用 0=禁用',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='角色表';
-- ----------------------------
-- 4. 权限点表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_permission (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
permission_code VARCHAR(50) NOT NULL UNIQUE COMMENT '权限编码',
permission_name VARCHAR(100) NOT NULL COMMENT '权限名称',
module VARCHAR(50) NOT NULL COMMENT '所属模块:project/training/defense/audit/user',
description VARCHAR(200) COMMENT '权限说明',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
INDEX idx_module (module)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='权限点表';
-- ----------------------------
-- 5. 用户角色关联表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_user_role (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
user_id BIGINT NOT NULL COMMENT '用户ID',
role_id BIGINT NOT NULL COMMENT '角色ID',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
UNIQUE KEY uk_user_role (user_id, role_id),
INDEX idx_user_id (user_id),
INDEX idx_role_id (role_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='用户角色关联表';
-- ----------------------------
-- 6. 角色权限关联表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_role_permission (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
role_id BIGINT NOT NULL COMMENT '角色ID',
permission_id BIGINT NOT NULL COMMENT '权限ID',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
UNIQUE KEY uk_role_permission (role_id, permission_id),
INDEX idx_role_id (role_id),
INDEX idx_permission_id (permission_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='角色权限关联表';
-- ----------------------------
-- 7. 角色菜单关联表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_role_menu (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
role_id BIGINT NOT NULL COMMENT '角色ID',
menu_id BIGINT NOT NULL COMMENT '菜单ID',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
UNIQUE KEY uk_role_menu (role_id, menu_id),
INDEX idx_role_id (role_id),
INDEX idx_menu_id (menu_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='角色菜单关联表';
-- ----------------------------
-- 8. 菜单表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_menu (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
parent_id BIGINT DEFAULT 0 COMMENT '父菜单ID:0=顶级',
name VARCHAR(50) NOT NULL COMMENT '菜单标识(英文,唯一)',
title VARCHAR(50) NOT NULL COMMENT '菜单标题(中文)',
icon VARCHAR(100) COMMENT '图标',
path VARCHAR(255) COMMENT '路由路径',
component VARCHAR(255) COMMENT '前端组件路径',
permission_code VARCHAR(50) COMMENT '权限标识(按钮级)',
type TINYINT DEFAULT 1 COMMENT '类型:1=菜单 2=按钮',
sort INT DEFAULT 0 COMMENT '排序号',
visible TINYINT DEFAULT 1 COMMENT '是否显示:1=显示 0=隐藏',
status TINYINT DEFAULT 1 COMMENT '状态:1=启用 0=禁用',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
INDEX idx_parent_id (parent_id),
INDEX idx_status (status)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='菜单表';
-- ----------------------------
-- 9. 登录日志表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_login_log (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
user_id BIGINT COMMENT '用户ID',
username VARCHAR(50) NOT NULL COMMENT '登录账号',
ip VARCHAR(50) COMMENT 'IP地址',
device TEXT COMMENT '设备信息(User-Agent)',
location VARCHAR(100) COMMENT '登录地点',
status TINYINT NOT NULL COMMENT '1=成功 2=失败',
fail_reason VARCHAR(255) COMMENT '失败原因',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
INDEX idx_user_id (user_id),
INDEX idx_created_at (created_at),
INDEX idx_username (username)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='登录日志表';
-- ----------------------------
-- 10. 短信验证码表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_sms_code (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
phone VARCHAR(20) NOT NULL COMMENT '手机号',
code VARCHAR(10) NOT NULL COMMENT '验证码',
type VARCHAR(20) NOT NULL COMMENT '用途:login/register/reset',
ip VARCHAR(50) NOT NULL COMMENT '请求IP',
expire_time DATETIME NOT NULL COMMENT '过期时间',
is_used TINYINT DEFAULT 0 COMMENT '是否已使用',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
INDEX idx_phone_type (phone, type),
INDEX idx_created_at (created_at),
INDEX idx_expire_time (expire_time)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='短信验证码表';
-- ----------------------------
-- 11. 密码历史表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_password_history (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
user_id BIGINT NOT NULL COMMENT '用户ID',
password_hash VARCHAR(255) NOT NULL COMMENT '历史密码哈希',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
INDEX idx_pwd_history_user (user_id, created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='密码历史表';
-- ----------------------------
-- 12. 角色自定义数据权限表
-- ----------------------------
CREATE TABLE IF NOT EXISTS user_role_custom_dept (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
role_id BIGINT NOT NULL COMMENT '角色ID',
department_id BIGINT NOT NULL COMMENT '部门ID',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
UNIQUE KEY uk_role_dept (role_id, department_id),
INDEX idx_department_id (department_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='角色自定义数据权限表';
-- ============================================================
-- ALTER TABLE:修正已有表的字段(兼容旧表,不影响数据)
-- ============================================================
-- 修正 user_login_log.device 类型(User-Agent 远超 100 字符)
ALTER TABLE user_login_log MODIFY COLUMN device TEXT COMMENT '设备信息(User-Agent)';
-- 修正 user_login_log.fail_reason 长度(支持更长的错误原因描述)
ALTER TABLE user_login_log MODIFY COLUMN fail_reason VARCHAR(255) COMMENT '失败原因';
-- 已有 user_role 表补 data_scope/sort/status 字段(不影响已存在的列)
ALTER TABLE user_role ADD COLUMN IF NOT EXISTS data_scope TINYINT DEFAULT 4 COMMENT '数据权限:1=全部 2=本部门 3=本部门及下级 4=仅本人 5=自定义' AFTER is_preset;
ALTER TABLE user_role ADD COLUMN IF NOT EXISTS sort INT DEFAULT 0 COMMENT '排序号' AFTER data_scope;
ALTER TABLE user_role ADD COLUMN IF NOT EXISTS status TINYINT DEFAULT 1 COMMENT '状态:1=启用 0=禁用' AFTER sort;
-- 已有 user_sms_code 表补 created_at 索引
ALTER TABLE user_sms_code ADD INDEX IF NOT EXISTS idx_created_at (created_at);
-- ============================================================
-- 插入预置角色数据
-- ============================================================
INSERT IGNORE INTO user_role (role_name, role_code, description, is_preset, data_scope, sort, status) VALUES
('ADMIN', 'ROLE_ADMIN', '管理员:全系统配置、用户管理', 1, 1, 0, 1),
('SUPERVISOR', 'ROLE_SUPERVISOR', '主管:审核学员、内容终审', 1, 3, 1, 1),
('MENTOR', 'ROLE_MENTOR', '导师:答辩评审、学员指导', 1, 4, 2, 1),
('STUDENT', 'ROLE_STUDENT', '学员:参与实训、提交产物', 1, 4, 3, 1);
-- ============================================================
-- 插入预置权限数据
-- ============================================================
INSERT IGNORE INTO user_permission (permission_code, permission_name, module, description) VALUES
-- 项目权限
('project:read', '查看项目', 'project', '查看项目列表和详情'),
('project:create', '创建项目', 'project', '创建新项目'),
('project:update', '更新项目', 'project', '修改项目信息'),
('project:delete', '删除项目', 'project', '删除项目'),
-- 实训权限
('training:read', '查看实训', 'training', '查看实训内容'),
('training:submit', '提交实训', 'training', '提交实训产物'),
('training:review', '审核实训', 'training', '审核学员实训'),
-- 答辩权限
('defense:review', '答辩评审', 'defense', '参与答辩评审'),
-- 审核权限
('audit:review', '主管审核', 'audit', '主管审核权限'),
-- 用户管理权限
('user:read', '查看用户', 'user', '查看用户列表和详情'),
('user:create', '创建用户', 'user', '创建新用户'),
('user:update', '更新用户', 'user', '修改用户信息'),
('user:delete', '删除用户', 'user', '删除用户'),
('user:assign-role', '分配角色', 'user', '分配用户角色');
-- ============================================================
-- 为预置角色分配权限
-- ============================================================
-- ADMIN: 所有权限
INSERT IGNORE INTO user_role_permission (role_id, permission_id)
SELECT 1, id FROM user_permission;
-- SUPERVISOR: 审核相关权限
INSERT IGNORE INTO user_role_permission (role_id, permission_id)
SELECT 2, id FROM user_permission WHERE permission_code IN ('project:read', 'training:read', 'training:review', 'defense:review', 'audit:review');
-- MENTOR: 导师相关权限
INSERT IGNORE INTO user_role_permission (role_id, permission_id)
SELECT 3, id FROM user_permission WHERE permission_code IN ('project:read', 'project:update', 'training:read', 'defense:review');
-- STUDENT: 学员权限
INSERT IGNORE INTO user_role_permission (role_id, permission_id)
SELECT 4, id FROM user_permission WHERE permission_code IN ('project:read', 'training:read', 'training:submit');
-- ============================================================
-- 插入默认管理员账户 (密码: Admin123)
-- bcrypt加密后的密码
-- ============================================================
INSERT IGNORE INTO user_user (username, password, real_name, email, role_id, status, is_deleted) VALUES
('admin', '$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG', '系统管理员', 'admin@example.com', 1, 1, 0);
-- 为管理员分配ADMIN角色
INSERT IGNORE INTO user_user_role (user_id, role_id) VALUES (1, 1);
-- ============================================================
-- 插入默认部门数据
-- ============================================================
INSERT IGNORE INTO user_department (name, code, description) VALUES
('技术部', 'tech', '负责系统研发和技术支持'),
('标注部', 'annotation', '负责数据标注和质量管理');
SET FOREIGN_KEY_CHECKS = 1;
......@@ -2,19 +2,45 @@
<configuration>
<include resource="org/springframework/boot/logging/logback/defaults.xml"/>
<!-- 禁止 Spring 默认的异常堆栈全量打印,仅保留 ERROR 日志行 -->
<springProperty name="DISABLE_STACKTRACE" source="spring.mvc.throwExceptionIfNoHandlerFound" defaultValue="false"/>
<property name="CONSOLE_PATTERN" value="%d{HH:mm:ss.SSS} [%level] %logger{36} - %msg%n"/>
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss.SSS} [%level] %logger{36} - %msg%n</pattern>
<pattern>${CONSOLE_PATTERN}</pattern>
<charset>UTF-8</charset>
</encoder>
</appender>
<!-- 仅输出 ERROR 级别,屏蔽 Tomcat/Spring 的长堆栈噪声 -->
<appender name="SIMPLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss.SSS} [%level] %logger{20} - %msg%n</pattern>
<charset>UTF-8</charset>
</encoder>
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>ERROR</level>
</filter>
</appender>
<root level="WARN">
<appender-ref ref="CONSOLE"/>
<appender-ref ref="SIMPLE"/>
</root>
<logger name="com.platform.backend" level="INFO"/>
<!-- 应用业务日志 -->
<logger name="com.platform.backend" level="INFO" additivity="false">
<appender-ref ref="CONSOLE"/>
</logger>
<!-- 关闭 Hibernate SQL 打印 -->
<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"/>
<!-- 屏蔽 Tomcat / Spring Web 无效堆栈 -->
<logger name="org.apache.catalina" level="OFF"/>
<logger name="org.apache.tomcat" level="OFF"/>
<logger name="org.springframework.web" level="INFO"/>
<logger name="org.springframework.security" level="INFO"/>
</configuration>
auth_enabled: false
server:
http_listen_port: 3100
grpc_listen_port: 9096
common:
instance_addr: 127.0.0.1
path_prefix: /tmp/loki
storage:
filesystem:
chunks_directory: /tmp/loki/chunks
rules_directory: /tmp/loki/rules
replication_factor: 1
ring:
instance_addr: 127.0.0.1
kvstore:
store: inmemory
query_range:
results_cache:
cache:
embedded_cache:
enabled: true
max_size_mb: 100
schema_config:
configs:
- from: 2024-01-01
store: tsdb
object_store: filesystem
schema: v13
index:
prefix: index_
period: 24h
limits_config:
allow_structured_metadata: false
ruler:
alertmanager_url: http://localhost:9093
[mysqld]
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
default-time-zone='+08:00'
max_connections=500
server:
http_listen_port: 9080
grpc_listen_port: 0
positions:
filename: /tmp/positions.yaml
clients:
- url: http://loki:3100/loki/api/v1/push
scrape_configs:
- job_name: app-logs
static_configs:
- targets:
- localhost
labels:
job: app-logs
__path__: /var/log/app/**/*.log
bind 0.0.0.0
protected-mode no
appendonly yes
requirepass studyweb123
......@@ -39,8 +39,12 @@ api.interceptors.response.use(
refreshToken,
});
const { accessToken } = response.data.data;
const { accessToken, refreshToken: nextRefreshToken } = response.data.data;
localStorage.setItem('accessToken', accessToken);
// 后端 refresh token 是一次性消费,刷新成功后必须同步保存新的 refreshToken。
if (nextRefreshToken) {
localStorage.setItem('refreshToken', nextRefreshToken);
}
originalRequest.headers.Authorization = `Bearer ${accessToken}`;
return api(originalRequest);
......@@ -95,8 +99,8 @@ export const phoneLogin = async (data: PhoneLoginRequest): Promise<LoginResponse
};
// 刷新 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 });
export const refreshToken = async (refreshToken: string): Promise<{ accessToken: string; refreshToken: string; expiresIn: number }> => {
const response = await api.post<{ code: number; message: string; data: { accessToken: string; refreshToken: string; expiresIn: number } }>('/refresh', { refreshToken });
return response.data.data;
};
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论