登录鉴权

This commit is contained in:
lxp
2026-10-19 17:21:23 +08:00
parent 3a0a3c388c
commit c09dab33f7
65 changed files with 2203 additions and 186 deletions
+3 -2
View File
@@ -15,8 +15,9 @@ OSS_BUCKET=linkerbot
APP_STORAGE_PUBLIC_BASE_URL=http://127.0.0.1:8992/admin-api/component-assets
# At least 32 UTF-8 bytes. Empty uses a random key and invalidates sessions on restart.
APP_UPLOAD_SESSION_SECRET=
APP_ADMIN_OPERATOR_ID=0
APP_ADMIN_OPERATOR_NAME=TEST_OPERATOR
# 管理端验证码与登录态有效期(单实例进程内缓存)
APP_ADMIN_AUTH_CAPTCHA_TTL=PT2M
APP_ADMIN_AUTH_TOKEN_TTL=PT24H
LOG_PATH=logs
# OSS 目录上传签名有效期(不超过会话剩余有效期)
+6 -6
View File
@@ -11,19 +11,19 @@ Java 21 / Spring Boot 3.4.4 / MyBatis-Plus 多模块项目。管理端提供组
| cadworld-bean | 实体、请求和响应 DTO、枚举 |
| cadworld-common | 统一响应、异常、JSON 类型处理、请求编号和操作目标上下文 |
| cadworld-api | 独立用户端 API:组件详情、匹配、需求会话、图文理解、自动选件与装配 |
| cadworld-security | 预留安全子模块 |
| cadworld-security | 用户端及管理端 Spring Security、独立登录态、共用图片验证码与 Token 基础实现 |
当前没有登录和权限接口。上传和审计使用配置操作人,默认 `0 / TEST_OPERATOR`,无需在 `sys_user` 中创建对应记录。上传会话令牌绑定操作人、组件、上传批次和资源目录。
用户端支持[邮箱与图片验证码登录](cadworld-api/docs/auth-api.md),首次自动注册,所有业务接口需要 Bearer Token。管理端支持[管理员邮箱登录](cadworld-adminapi/docs/auth-api.md),仅允许已启用的 ADMIN 账号,全部后台业务接口要求管理端 Bearer Token。上传会话和审计使用实际登录管理员。两端 Token 和验证码不能互用。
## 数据库
管理端访问 `component`、`sys_user`、`sys_operation_log`。用户端组件匹配复用 `component`,需求解析流程另外使用五张独立表;新增表的中文注释建表语句见 [需求流程建表说明](cadworld-api/docs/demand-schema.md),需要部署时手动执行,应用不自动建表。组件旋转轴字段 `rotation_axis` 的迁移 SQL 见 [管理端字段部署说明](cadworld-adminapi/docs/admin-api.md#43-旋转轴字段部署),部署两端新代码前须执行。
管理端访问 `component`、`sys_user`、`sys_operation_log`。用户端登录使用 `sys_user`,组件匹配复用 `component`,需求解析流程另外使用五张独立表;新增表的中文注释建表语句见 [需求流程建表说明](cadworld-api/docs/demand-schema.md),需要部署时手动执行,应用不自动建表。组件旋转轴字段 `rotation_axis` 的迁移 SQL 见 [管理端字段部署说明](cadworld-adminapi/docs/admin-api.md#43-旋转轴字段部署),部署两端新代码前须执行。
组件存储基本信息、自由度、旋转轴、功能、形状、大小描述、扭矩、BOM 清单、URDF 信息、两组自定义字段、STEP 对象键、URDF 目录及实际文件清单、`version`、`deleted` 删除标记和维护时间。旋转轴通过 `rotationAxis` 接收和返回,仅接受 `X`、`Y`、`Z`,未设置时为 null。BOM 和 URDF 信息均为 JSON 对象或数组,创建和修改必填 `urdfInfo`;可选 `bomList` 缺失或为 null 时写入 `[]`。列表返回旋转轴和描述字段,BOM 和 URDF 信息仅在详情及保存结果中返回。通用日志存储模块、动作、目标快照、操作人、请求元信息和结果,不依赖组件专属列。
应用启动不建表、不迁移旧数据。本次未修改 `.sql` 文件;仓库中历史 SQL 不代表当前组件和日志结构,请使用已经建好的表。MySQL 需支持现有建表语句中的 JSON / TEXT 表达式默认值。
用户登录改造发布前需手动执行[用户编码迁移 SQL](cadworld-api/docs/auth-api.md#4-发布前手动执行的迁移-sql)。应用启动不建表、不迁移旧数据。本次未修改 `.sql` 文件;仓库中历史 SQL 不代表当前组件和日志结构,请使用已经建好的表。MySQL 需支持现有建表语句中的 JSON / TEXT 表达式默认值。
组件名称允许重复,编码唯一且不可修改。新增编码为 `CW-` 加 16 位随机数字或大写字母(排除 `I/L/O/U`),总长 19,例如 `CW-7K3M9Q2R6V8X4T5N`;使用 80 位密码学安全随机空间,数据库唯一索引约束重复。旧版 35 字符编码和已有上传会话继续兼容,无需修改表结构或迁移已有编码。组件和用户均逻辑删除;已删除组件的编码和已删除用户的手机号仍被占用。组件替换资源或逻辑删除均不自动删除 OSS 文件。
组件名称允许重复,编码唯一且不可修改。新增编码为 `CW-` 加 16 位随机数字或大写字母(排除 `I/L/O/U`),总长 19,例如 `CW-7K3M9Q2R6V8X4T5N`;使用 80 位密码学安全随机空间,数据库唯一索引约束重复。旧版 35 字符编码和已有上传会话继续兼容,无需修改表结构或迁移已有编码。组件逻辑删除;用户删除入口改为禁用账号,可重新启用,邮箱仍被占用。已删除组件的编码仍被占用。组件替换资源或逻辑删除均不自动删除 OSS 文件。
现有 `component` 表包含 `deleted TINYINT UNSIGNED NOT NULL DEFAULT 0` 字段,中文注释为“删除标记:0-未删除,1-已删除”。运行代码通过 MyBatis-Plus 自动过滤已删除组件,列表、详情、修改和编辑上传签名均只处理未删除记录。
@@ -54,7 +54,7 @@ Spring Boot 不自动读取 `.env`,需要通过 shell 导入。默认 profile
| OSS_UPLOAD_SESSION_TTL | 上传会话有效期,默认 `PT30M`;续签不延长会话 |
| OSS_UPLOAD_SIGNATURE_TTL | OSS 签名有效期,默认 `PT5M`,不超过会话剩余时间 |
| APP_UPLOAD_SESSION_SECRET | 至少 32 个 UTF-8 字节;留空使用进程随机密钥,重启后原会话失效;多实例需配置相同密钥 |
| APP_ADMIN_OPERATOR_ID / APP_ADMIN_OPERATOR_NAME | 当前配置操作人,默认 `0 / TEST_OPERATOR` |
| APP_ADMIN_AUTH_CAPTCHA_TTL / APP_ADMIN_AUTH_TOKEN_TTL | 管理端验证码与登录态有效期,默认 `PT2M / PT24H`;未设置时沿用通用 APP_AUTH_* 配置 |
| LOG_PATH | 运行日志目录,默认 `logs` |
运行时使用已有 OSS 桶,不自动创建桶。前端通过 OSS V4 表单签名直接上传,后端通过 HEAD 检查文件,资源下载仍由后台代理。OSS 需配置前端站点的 CORS,允许表单 POST;上传字段原样使用,`file` 放在表单最后。凭证需有目标目录上传和读取权限。
+14 -7
View File
@@ -6,7 +6,7 @@
## 1. 通用约定
JSON 请求设置 `Content-Type: application/json`。当前没有登录认证,操作人来自 `APP_ADMIN_OPERATOR_ID / APP_ADMIN_OPERATOR_NAME`,默认 `0 / TEST_OPERATOR`。上传令牌与该操作人绑定。
JSON 请求设置 `Content-Type: application/json`。先完成[管理员邮箱与图片验证码登录](auth-api.md),业务接口统一携带 `Authorization: Bearer <token>`。仅允许已启用的 ADMIN 账号,不自动注册;上传会话及审计使用真实登录管理员。
`/admin-api/**` 跨域白名单按 profile 区分:`test` 允许 `https://dev-cadworld-admin.robotquan.com`,`prod` 允许 `https://cadworld-admin.robotquan.com`。可通过 `APP_ADMIN_ALLOWED_ORIGINS` 覆盖,多个完整 origin 用逗号分隔,禁止通配符;显式留空关闭跨域。允许 `GET / HEAD / POST / PUT / DELETE / OPTIONS`,请求头允许 `Content-Type / Authorization / X-Request-Id`,支持凭证,并向前端暴露 `X-Request-Id`;预检缓存 3600 秒。OSS 直传上传的 CORS 仍需在 OSS 单独配置。
@@ -30,6 +30,10 @@ JSON 请求设置 `Content-Type: application/json`。当前没有登录认证,
| 方法 | 路径 | 作用 |
| --- | --- | --- |
| GET | /admin-api/auth/captcha | 获取图片验证码,无需登录 |
| POST | /admin-api/auth/login | 管理员邮箱登录,无需登录 |
| POST | /admin-api/auth/logout | 退出当前管理端登录态 |
| GET | /admin-api/users/me | 当前管理员,不返回主键 |
| POST | /admin-api/storage/upload-signature | 分配编码及上传授权,或续签 |
| GET | /admin-api/components | 组件分页查询 |
| POST | /admin-api/components | 新增组件,校验上传文件后入库 |
@@ -41,7 +45,7 @@ JSON 请求设置 `Content-Type: application/json`。当前没有登录认证,
| POST | /admin-api/users | 创建用户 |
| GET | /admin-api/users/{id} | 用户详情 |
| PUT | /admin-api/users/{id} | 修改用户 |
| DELETE | /admin-api/users/{id} | 逻辑删除用户 |
| DELETE | /admin-api/users/{id} | 禁用用户,可重新启用 |
| GET | /admin-api/operation-logs | 通用操作日志分页查询 |
| GET | /admin-api/operation-logs/{id} | 操作日志详情 |
@@ -335,7 +339,7 @@ ALTER TABLE `component`
已删除组件不出现在列表和详情中,不能修改、申请编辑上传签名或续签绑定该组件的上传会话。组件编码仍保持唯一,不能复用原新增会话重新创建同编码组件。删除标记仅用于数据库内部,不增加到接口响应中。
使用详情中的 `stepUrl`、`urdfUrl` 或依赖文件 URL 直接 GET 下载。下载成功返回原文件流,不包 JSON;对象不存在返回 404。对象键区分大小写且必须属于当前环境根目录。
使用详情中的 `stepUrl`、`urdfUrl` 或依赖文件 URL 下载。若 URL 指向 `/admin-api/component-assets/**`,fetch 或模型加载器须携带管理端 Authorization 头,文件可转 Blob URL 展示或下载;Token 不放在 URL 中。若指向公开 OSS/CDN,则沿用公开资源加载方式。下载成功返回原文件流,不包 JSON;对象不存在返回 404。对象键区分大小写且必须属于当前环境根目录。
## 6. 浏览器完整上传示例
@@ -349,10 +353,11 @@ ALTER TABLE `component`
以下示例使用一次签名完成两类文件上传,授权即将到期时调用同一接口续签,上传全部成功后直接保存。表单取当前页面值;示例按顺序上传以便展示流程,实际页面可使用受控并发。
```javascript
// adminToken 为管理员登录返回的 Token,保存在应用登录状态中。
async function adminApi(path, method, body) {
const response = await fetch(`/admin-api${path}`, {
method,
headers: { 'Content-Type': 'application/json' },
headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${adminToken}` },
...(body === undefined ? {} : { body: JSON.stringify(body) })
});
const result = await response.json();
@@ -441,15 +446,17 @@ const saved = await uploadAndSave({
## 7. 用户管理
保持现有行为和表结构。列表支持 `page`、`size`、`keyword`(手机号或昵称)、`userType`(NORMAL / ADMIN)、`status`(ACTIVE / DISABLED)。详情返回 `id`、`phone`、`nickname`、`status`、`userType`、`createdAt`、`updatedAt`。
用户字段以邮箱版 `sys_user` 为准,发布前执行[用户编码迁移 SQL](../../cadworld-api/docs/auth-api.md#4-发布前手动执行的迁移-sql)。列表支持 `page`、`size`、`keyword`(邮箱或昵称)、`userType`(NORMAL / ADMIN)、`status`(ACTIVE / DISABLED)。详情返回 `id`、`userCode`、`email`、`nickname`、`status`、`userType`、`createdAt`、`updatedAt`;后台路径仍使用 `/{id}`,用户端只返回业务编码。
POST / PUT 请求:
```json
{"phone":"13812345678","nickname":"测试用户","status":"ACTIVE","userType":"NORMAL"}
{"email":"user@example.com","nickname":"测试用户","status":"ACTIVE","userType":"NORMAL"}
```
手机号需符合大陆手机号格式并保持唯一,昵称必填且最多 64 字符。创建省略状态和类型时默认为 ACTIVE / NORMAL;修改省略则保留原值。逻辑删除后列表及详情不再返回该用户,手机号仍被占用。用户管理只记录运行日志。
邮箱去除首尾空格并转小写后校验,最多 254 字符且唯一,重复返回 `409 / USER_EMAIL_DUPLICATE`。昵称必填且最多 64 字符。创建自动生成不可变 `userCode`,省略状态和类型时默认为 ACTIVE / NORMAL;修改省略则保留原值。
`DELETE /admin-api/users/{id}` 将状态设为 DISABLED,不删除记录。禁用用户仍能在列表和详情中查询,邮箱继续占用,可通过 PUT 将状态恢复为 ACTIVE。禁用后用户端登录返回 403,已有登录态的后续请求返回 401。用户管理只记录运行日志。
## 8. 通用操作日志
+105
View File
@@ -0,0 +1,105 @@
# 管理端邮箱与图片验证码登录
服务默认端口 `8992`。仅允许 `sys_user` 中 `status=ACTIVE`、`user_type=ADMIN` 的账号登录;未知邮箱和普通用户返回 `403 / ADMIN_ACCESS_DENIED`,不自动创建账号或提升权限。流程不发送邮件、不验证邮箱归属,与用户端采用相同的图片验证码交互。
## 1. 接口与调用
| 方法 | 路径 | 说明 |
| --- | --- | --- |
| GET | `/admin-api/auth/captcha` | 无需登录,获取一次性图片验证码 |
| POST | `/admin-api/auth/login` | 无需登录,邮箱与图片验证码登录 |
| POST | `/admin-api/auth/logout` | 撤销当前管理员 Token |
| GET | `/admin-api/users/me` | 获取当前管理员,不返回数据库主键 |
除验证码、登录和 OPTIONS 预检外,所有 `/admin-api/**` 业务接口都要求 `Authorization: Bearer <token>`,包含组件、用户、操作日志、上传签名和代理资源下载。Swagger 文档可直接打开,在 Authorize 中填入登录返回的 Token 后调试业务接口。
验证码响应 `data`:
```json
{"captchaCode":"一次性编码","image":"data:image/png;base64,...","expiresIn":120}
```
图片为 180×60 PNG,答案 5 位,不区分大小写,忽略首尾空格。默认有效期 2 分钟,每次通过参数校验的登录提交都会消费验证码,答错后也需重新获取。
登录请求:
```json
{"email":"admin@example.com","captchaCode":"验证码编码","captchaAnswer":"ABCDE"}
```
邮箱去除首尾空格并转小写后校验,最多 254 字符。成功响应沿用 `{code,message,data,requestId}`,`data` 如下:
```json
{
"token":"登录凭证",
"tokenType":"Bearer",
"expiresIn":86400,
"user":{"userCode":"0123456789ABCDEF0123456789ABCDEF","nickname":"管理员","email":"admin@example.com"}
}
```
`GET /admin-api/users/me` 返回同样的 `user` 字段内容。Token 默认有效期 24 小时,不滑动续期;同一管理员可同时保持多个登录态,退出仅撤销当前 Token。验证码和登录响应均设置 `Cache-Control: no-store`。
```javascript
const challenge = (await (await fetch('/admin-api/auth/captcha')).json()).data;
// challenge.image 用于展示图片;answer 为管理员输入的答案。
const response = await fetch('/admin-api/auth/login', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ email, captchaCode: challenge.captchaCode, captchaAnswer: answer })
});
if (!response.ok) throw await response.json();
const { token } = (await response.json()).data;
const current = await fetch('/admin-api/users/me', {
headers: { Authorization: `Bearer ${token}` }
});
```
不要将 Token 放在 URL 中。代理图片、模型或下载文件也需通过带认证头的 fetch 或加载器读取。公开 OSS/CDN 地址按资源服务原有方式访问,OSS 直传表单仍使用签名字段,不向 OSS 发送管理端 Token。
## 2. 权限、上传与审计
- 每次请求从数据库检查状态和角色。禁用或删除用户后已有 Token 返回 `401 / UNAUTHORIZED`;管理员降级为普通用户后返回 `403 / ADMIN_ACCESS_DENIED`。
- 上传会话绑定当前登录管理员的内部用户主键;不同管理员不能续签或使用对方的上传会话。原配置操作人签发的上传会话需要重新申请。
- 组件操作的审计操作人来自当前管理员的主键和昵称;认证失败只记录运行日志,不伪造业务操作人。multipart 等早期业务失败仍记录真实管理员。
- 用户端和管理端共用验证码与 Token 基础代码,但拥有独立进程缓存和独立身份主体;两端 Token 和验证码不能互用。退出某一端不影响另一端。
| HTTP 状态 | code | 处理方式 |
| --- | --- | --- |
| 400 | `CAPTCHA_INVALID` | 验证码错误、过期或已消费,重新获取 |
| 401 | `UNAUTHORIZED` | 未登录、Token 无效或用户已不可用,重新登录 |
| 403 | `ADMIN_ACCESS_DENIED` | 账号没有管理员权限 |
| 403 | `ACCOUNT_DISABLED` | 管理员账号已禁用 |
| 422 | `INVALID_REQUEST` | 邮箱、必填字段或长度不合法 |
| 503 | `DATABASE_UNAVAILABLE` | 数据库暂不可用,稍后重试 |
## 3. 配置和初始管理员
验证码和登录态分别使用最多 10000 条的进程内 Caffeine 缓存,按单实例部署;重启、容量淘汰或过期后凭证失效。缓存不影响数据库中的用户和业务数据。
| 配置 | 默认值与说明 |
| --- | --- |
| `APP_ADMIN_AUTH_CAPTCHA_TTL` | `PT2M`,至少 1 秒;未设置时沿用 `APP_AUTH_CAPTCHA_TTL` |
| `APP_ADMIN_AUTH_TOKEN_TTL` | `PT24H`,至少 1 秒;未设置时沿用 `APP_AUTH_TOKEN_TTL` |
| `APP_ADMIN_ALLOWED_ORIGINS` | 沿用管理端域名白名单,允许 Authorization 请求头;401/403 保留跨域响应头 |
`APP_ADMIN_OPERATOR_ID / APP_ADMIN_OPERATOR_NAME` 已不再使用。此改造无需新增表字段,沿用上次邮箱用户及 `user_code` 迁移后的表结构。
首次管理员由数据库预先授权。选择以下一种方式手动执行,替换为实际邮箱或已有用户编码,应用不会自动执行,也未修改 `.sql` 文件。
新建管理员:
```sql
INSERT INTO `sys_user` (`user_code`, `email`, `nickname`, `status`, `user_type`)
VALUES (UPPER(REPLACE(UUID(), '-', '')), LOWER(TRIM('your-admin@example.com')),
'管理员', 'ACTIVE', 'ADMIN');
```
将已有用户授权为管理员:
```sql
UPDATE `sys_user`
SET `user_type` = 'ADMIN', `status` = 'ACTIVE'
WHERE `user_code` = '替换为已有用户唯一编码';
```
+5
View File
@@ -16,6 +16,11 @@
<name>cadworld-adminapi</name>
<dependencies>
<dependency>
<groupId>com.linkerbot</groupId>
<artifactId>cadworld-security-admin</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.linkerbot</groupId>
<artifactId>cadworld-service</artifactId>
@@ -3,9 +3,10 @@ package com.linkerbot.cadworld;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
@SpringBootApplication
@SpringBootApplication(exclude = UserDetailsServiceAutoConfiguration.class)
@ConfigurationPropertiesScan("com.linkerbot.cadworld.config")
@MapperScan("com.linkerbot.cadworld.mapper")
public class AdminApiApplication {
@@ -9,7 +9,7 @@ import java.io.IOException;
import java.util.Map;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.Ordered;
import org.springframework.boot.autoconfigure.security.SecurityProperties;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
@@ -24,7 +24,7 @@ import org.springframework.web.util.pattern.PathPattern;
/** Multipart size failures can occur before an MVC interceptor is invoked. */
@Slf4j
@Component
@Order(Ordered.HIGHEST_PRECEDENCE + 1)
@Order(SecurityProperties.DEFAULT_FILTER_ORDER + 1)
public class EarlyFailureAuditFilter extends OncePerRequestFilter {
private final RequestMappingHandlerMapping mappings;
private final OperationAuditInterceptor audit;
@@ -0,0 +1,18 @@
package com.linkerbot.cadworld.config;
import io.swagger.v3.oas.models.Components;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.security.SecurityRequirement;
import io.swagger.v3.oas.models.security.SecurityScheme;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration(proxyBeanMethods = false)
public class AdminOpenApiConfiguration {
@Bean
OpenAPI adminOpenApi() {
return new OpenAPI().components(new Components().addSecuritySchemes("adminBearer",
new SecurityScheme().type(SecurityScheme.Type.HTTP).scheme("bearer")))
.addSecurityItem(new SecurityRequirement().addList("adminBearer"));
}
}
@@ -0,0 +1,81 @@
package com.linkerbot.cadworld.controller;
import com.linkerbot.cadworld.common.api.ApiResponse;
import com.linkerbot.cadworld.common.api.RequestIdHolder;
import com.linkerbot.cadworld.dto.auth.CaptchaResponse;
import com.linkerbot.cadworld.dto.auth.LoginRequest;
import com.linkerbot.cadworld.dto.auth.LoginResponse;
import com.linkerbot.cadworld.dto.auth.LoginUserResponse;
import com.linkerbot.cadworld.entity.SysUser;
import com.linkerbot.cadworld.logging.ApiRequestLog;
import com.linkerbot.cadworld.security.admin.CurrentAdmin;
import com.linkerbot.cadworld.security.common.AuthProperties;
import com.linkerbot.cadworld.security.common.CaptchaService;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.auth.AdminLoginService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.security.SecurityRequirements;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;
@Slf4j
@RestController
@RequiredArgsConstructor
@Tag(name = "管理员登录")
public class AdminAuthController {
private final CaptchaService captcha;
private final TokenService tokens;
private final AdminLoginService users;
private final AuthProperties properties;
@ApiRequestLog("获取管理员图片验证码")
@Operation(summary = "获取一次性图片验证码")
@SecurityRequirements
@GetMapping("/admin-api/auth/captcha")
public ApiResponse<CaptchaResponse> captcha(HttpServletResponse response) {
response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store");
return ApiResponse.success(captcha.issue());
}
@ApiRequestLog("管理员邮箱登录")
@Operation(summary = "邮箱与图片验证码登录,仅允许已启用的管理员")
@SecurityRequirements
@PostMapping("/admin-api/auth/login")
public ApiResponse<LoginResponse> login(@Valid @RequestBody LoginRequest input, HttpServletResponse response) {
response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store");
captcha.verify(input.captchaCode(), input.captchaAnswer());
SysUser user = users.login(input.email());
return ApiResponse.success(new LoginResponse(tokens.issue(user.getUserCode()), "Bearer",
properties.tokenTtl().toSeconds(), view(user)));
}
@ApiRequestLog("管理员退出登录")
@Operation(summary = "退出当前管理员登录态")
@PostMapping("/admin-api/auth/logout")
public ApiResponse<Void> logout(@RequestHeader(HttpHeaders.AUTHORIZATION) String authorization) {
String userCode = CurrentAdmin.required().userCode();
tokens.revoke(authorization.substring(7));
log.info("管理员退出登录 userCode={} requestId={}", userCode, RequestIdHolder.get());
return ApiResponse.success(null);
}
@ApiRequestLog("查询当前管理员")
@Operation(summary = "获取当前登录管理员")
@GetMapping("/admin-api/users/me")
public ApiResponse<LoginUserResponse> me() {
return ApiResponse.success(view(users.requireActive(CurrentAdmin.required().userCode())));
}
private LoginUserResponse view(SysUser user) {
return new LoginUserResponse(user.getUserCode(), user.getNickname(), user.getEmail());
}
}
@@ -44,7 +44,7 @@ public class ComponentAssetController {
if (object.contentLength() >= 0) {
response.setContentLengthLong(object.contentLength());
}
response.setHeader(HttpHeaders.CACHE_CONTROL, "public, max-age=3600");
response.setHeader(HttpHeaders.CACHE_CONTROL, "private, max-age=3600");
objectStorageClient.writeObjectTo(objectKey, response.getOutputStream());
}
}
@@ -46,7 +46,7 @@ public class UserManagementController {
@PutMapping("/{id}")
public ApiResponse<UserResponse> update(@PathVariable Long id, @Valid @RequestBody SaveUserRequest request) { return ApiResponse.success(service.update(id, request)); }
@ApiRequestLog("逻辑删除用户")
@ApiRequestLog("禁用用户")
@DeleteMapping("/{id}")
public ApiResponse<SuccessResponse> delete(@PathVariable Long id) {
service.delete(id);
@@ -34,12 +34,12 @@ springdoc:
path: /swagger-ui.html
app:
auth:
captcha-ttl: ${APP_ADMIN_AUTH_CAPTCHA_TTL:${APP_AUTH_CAPTCHA_TTL:PT2M}}
token-ttl: ${APP_ADMIN_AUTH_TOKEN_TTL:${APP_AUTH_TOKEN_TTL:PT24H}}
admin:
cors:
allowed-origins: ${APP_ADMIN_ALLOWED_ORIGINS:}
operator:
id: ${APP_ADMIN_OPERATOR_ID:0}
name: ${APP_ADMIN_OPERATOR_NAME:TEST_OPERATOR}
upload-session:
issuer: cadworld-upload
# Empty means a random, process-local signing key. Set a stable key for restarts/multiple instances.
@@ -6,14 +6,19 @@ import ch.qos.logback.core.read.ListAppender;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linkerbot.cadworld.audit.EarlyFailureAuditFilter;
import com.linkerbot.cadworld.common.api.OperationTargetHolder;
import com.linkerbot.cadworld.common.web.RequestIdFilter;
import com.linkerbot.cadworld.entity.Component;
import com.linkerbot.cadworld.entity.OperationLog;
import com.linkerbot.cadworld.logging.ApiRequestLogCapture;
import com.linkerbot.cadworld.logging.ApiRequestLoggingFilter;
import com.linkerbot.cadworld.mapper.ComponentMapper;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.OperationLogService;
import com.linkerbot.cadworld.service.support.ComponentUploadSessionTokenProvider;
import com.linkerbot.cadworld.service.support.ComponentUploadSessionTokenProvider.UploadSessionClaims;
import com.linkerbot.cadworld.service.support.ComponentUploadSessionTokenProvider;
import jakarta.servlet.Filter;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
@@ -31,6 +36,8 @@ import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.method.HandlerMethod;
import static org.assertj.core.api.Assertions.*;
@@ -47,9 +54,12 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
})
@ActiveProfiles("verification")
@org.springframework.context.annotation.Import(InMemoryObjectStorageConfiguration.class)
@AutoConfigureMockMvc
@AutoConfigureMockMvc(print = org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrint.NONE)
class AdminApiTest {
@Autowired MockMvc mvc;
@Autowired WebApplicationContext webContext;
@Autowired TokenService adminTokens;
private long adminId;
@Autowired ObjectMapper json;
@Autowired JdbcTemplate jdbc;
@Autowired InMemoryObjectStorageConfiguration.InMemoryObjectStorageClient storage;
@@ -64,6 +74,12 @@ class AdminApiTest {
storage.clear();
for (String table : List.of("component", "sys_user", "sys_operation_log")) jdbc.update("DELETE FROM " + table);
OperationTargetHolder.clear();
AdminAuthTestSupport.Session session = AdminAuthTestSupport.create(jdbc, adminTokens);
adminId = session.userId();
mvc = MockMvcBuilders.webAppContextSetup(webContext)
.addFilters(new RequestIdFilter(), webContext.getBean(ApiRequestLoggingFilter.class),
webContext.getBean("springSecurityFilterChain", Filter.class), webContext.getBean(EarlyFailureAuditFilter.class))
.defaultRequest(get("/").header("Authorization", "Bearer " + session.token())).build();
}
@Test
@@ -96,7 +112,7 @@ class AdminApiTest {
String code = "CW-0123456789ABCDEF0123456789ABCDEF";
String batch = "abcdef0123456789abcdef0123456789";
String prefix = "cadworld_dev/components/" + code;
UploadSessionClaims session = new UploadSessionClaims(0L, null, code, batch,
UploadSessionClaims session = new UploadSessionClaims(adminId, null, code, batch,
prefix + "/step/" + batch + "/", prefix + "/urdf/" + batch + "/",
Instant.now().plusSeconds(300));
String token = tokens.generateToken(session);
@@ -660,11 +676,11 @@ class AdminApiTest {
Map<String,Object> body = uploaded();
UploadSessionClaims original = tokens.parseToken(body.get("uploadSessionToken").toString());
for (String token : List.of("forged-token",
tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(99L,null,
tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(adminId + 1000000,null,
original.componentCode(),original.batch(),original.stepPrefix(),original.urdfPrefix(),original.expiresAt())),
tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(0L,null,
tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(adminId,null,
original.componentCode(),original.batch(),original.stepPrefix(),original.urdfPrefix(),Instant.now().minusSeconds(60))),
tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(0L,null,
tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(adminId,null,
original.componentCode(),original.batch(),original.stepPrefix().replace("cadworld_dev/","cadworld/"),
original.urdfPrefix().replace("cadworld_dev/","cadworld/"),original.expiresAt())))) {
body.put("uploadSessionToken",token);
@@ -799,20 +815,31 @@ class AdminApiTest {
}
@Test
void userCrudAndLogicalDeletionRemainUnaudited() throws Exception {
void userCrudAndDisableRemainUnaudited() throws Exception {
JsonNode user = data(mvc.perform(post("/admin-api/users").contentType(MediaType.APPLICATION_JSON)
.content("{\"phone\":\"13812345678\",\"nickname\":\"测试用户\"}")).andExpect(status().isOk()).andReturn());
.content("{\"email\":\" USER@EXAMPLE.TEST \",\"nickname\":\"测试用户\"}")).andExpect(status().isOk()).andReturn());
long id = user.path("id").asLong();
mvc.perform(put("/admin-api/users/{id}",id).contentType(MediaType.APPLICATION_JSON)
.content("{\"phone\":\"13812345678\",\"nickname\":\"管理员\",\"status\":\"DISABLED\",\"userType\":\"ADMIN\"}"))
.content("{\"email\":\" USER@EXAMPLE.TEST \",\"nickname\":\"管理员\",\"status\":\"DISABLED\",\"userType\":\"ADMIN\"}"))
.andExpect(status().isOk());
mvc.perform(get("/admin-api/users").param("userType","ADMIN").param("status","DISABLED"))
.andExpect(jsonPath("$.data.total").value(1));
mvc.perform(delete("/admin-api/users/{id}",id)).andExpect(status().isOk());
mvc.perform(get("/admin-api/users/{id}",id)).andExpect(status().isNotFound());
mvc.perform(get("/admin-api/users/{id}",id)).andExpect(status().isOk())
.andExpect(jsonPath("$.data.status").value("DISABLED"))
.andExpect(jsonPath("$.data.email").value("user@example.test"));
mvc.perform(post("/admin-api/users").contentType(MediaType.APPLICATION_JSON)
.content("{\"phone\":\"13812345678\",\"nickname\":\"再次创建\"}"))
.andExpect(status().isConflict()).andExpect(jsonPath("$.code").value("USER_PHONE_DUPLICATE"));
.content("{\"email\":\"user@example.test\",\"nickname\":\"禁用后再次创建\"}"))
.andExpect(status().isConflict()).andExpect(jsonPath("$.code").value("USER_EMAIL_DUPLICATE"));
mvc.perform(get("/admin-api/users").param("keyword", "user@example.test"))
.andExpect(status().isOk()).andExpect(jsonPath("$.data.total").value(1));
mvc.perform(put("/admin-api/users/{id}",id).contentType(MediaType.APPLICATION_JSON)
.content("{\"email\":\"user@example.test\",\"nickname\":\"重新启用\",\"status\":\"ACTIVE\"}"))
.andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("ACTIVE"))
.andExpect(jsonPath("$.data.userCode").value(user.path("userCode").asText()));
mvc.perform(post("/admin-api/users").contentType(MediaType.APPLICATION_JSON)
.content("{\"email\":\" USER@EXAMPLE.TEST \",\"nickname\":\"再次创建\"}"))
.andExpect(status().isConflict()).andExpect(jsonPath("$.code").value("USER_EMAIL_DUPLICATE"));
assertThat(count("sys_operation_log")).isZero();
}
@@ -839,10 +866,11 @@ class AdminApiTest {
body.put("urdfInfo", "PRIVATE_URDF_VALUE");
expectCreateError(body, 422, "INVALID_COMPONENT_FORM");
mvc.perform(get("/admin-api/users").param("keyword","13800000001"));
mvc.perform(get("/admin-api/users").param("keyword","PRIVATE_EMAIL@example.test"));
String messages = String.join("\n",runtime.messages());
assertThat(messages).contains("description=新增组件","result=SUCCESS","result=FAILURE","durationMs=");
assertThat(messages).doesNotContain("PRIVATE_FIELD_VALUE","PRIVATE_BOM_VALUE","PRIVATE_URDF_VALUE",
"PRIVATE_TOKEN",body.get("stepObjectKey").toString(),"13800000001");
"PRIVATE_TOKEN",body.get("stepObjectKey").toString(),"13800000001","PRIVATE_EMAIL@example.test");
assertThat(capture.list).isEmpty();
assertThat(jdbc.queryForList("SELECT * FROM sys_operation_log").toString())
.doesNotContain("PRIVATE_FIELD_VALUE","PRIVATE_BOM_VALUE","PRIVATE_URDF_VALUE",
@@ -0,0 +1,246 @@
package com.linkerbot.cadworld;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linkerbot.cadworld.security.common.AuthProperties;
import com.linkerbot.cadworld.security.common.CaptchaService;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.auth.AdminLoginService;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Primary;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.bean.override.mockito.MockitoSpyBean;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doThrow;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.options;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@SpringBootTest(classes = AdminApiApplication.class, properties = {
"spring.datasource.url=jdbc:h2:mem:admin-auth;MODE=MySQL;DB_CLOSE_DELAY=-1",
"spring.datasource.driver-class-name=org.h2.Driver", "spring.datasource.username=sa", "spring.datasource.password=",
"app.storage.root-prefix=cadworld_dev", "logging.file.path=target/test-logs",
"logging.level.com.linkerbot.cadworld=DEBUG", "app.admin.cors.allowed-origins=http://localhost:5173"
})
@ActiveProfiles("verification")
@AutoConfigureMockMvc(print = org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrint.NONE)
@Import({InMemoryObjectStorageConfiguration.class, AdminAuthApiTest.CaptchaConfiguration.class})
class AdminAuthApiTest {
private static final String ORIGIN = "http://localhost:5173";
@Autowired private MockMvc mvc;
@Autowired private JdbcTemplate jdbc;
@Autowired private ObjectMapper json;
@Autowired private TokenService tokens;
@Autowired private AuthProperties properties;
@MockitoSpyBean private AdminLoginService users;
private AdminAuthTestSupport.Session admin;
@BeforeEach
void prepare() {
for (String table : List.of("component", "sys_user", "sys_operation_log")) jdbc.update("DELETE FROM " + table);
admin = AdminAuthTestSupport.create(jdbc, tokens);
jdbc.update("UPDATE sys_user SET email=? WHERE user_code=?", "admin@example.test", admin.userCode());
}
@Test
void adminLoginNormalizesEmailAndReturnsCurrentUserWithoutId() throws Exception {
JsonNode login = login(" ADMIN@EXAMPLE.TEST ");
assertThat(login.path("tokenType").asText()).isEqualTo("Bearer");
assertThat(login.path("expiresIn").asLong()).isEqualTo(86400);
assertThat(login.path("user").path("userCode").asText()).isEqualTo(admin.userCode());
assertThat(login.path("user").size()).isEqualTo(3);
mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(login)))
.andExpect(status().isOk()).andExpect(jsonPath("$.data.email").value("admin@example.test"))
.andExpect(jsonPath("$.data.userCode").value(admin.userCode()))
.andExpect(jsonPath("$.data.id").doesNotExist()).andExpect(header().doesNotExist(HttpHeaders.SET_COOKIE));
mvc.perform(get("/admin-api/users/me")).andExpect(status().isUnauthorized());
}
@Test
void unknownAndNormalEmailsAreRejectedWithoutRegistrationOrPrivilegeEscalation() throws Exception {
jdbc.update("INSERT INTO sys_user (user_code,email,nickname,status,user_type) VALUES (?,?,'普通用户','ACTIVE','NORMAL')",
"B".repeat(32), "normal@example.test");
for (String email : List.of("normal@example.test", "unknown@example.test")) {
mvc.perform(post("/admin-api/auth/login").contentType(MediaType.APPLICATION_JSON)
.content(body(email, captcha(), "ABCDE")))
.andExpect(status().isForbidden()).andExpect(jsonPath("$.code").value("ADMIN_ACCESS_DENIED"));
}
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_user", Long.class)).isEqualTo(2);
assertThat(jdbc.queryForObject("SELECT user_type FROM sys_user WHERE email=?", String.class, "normal@example.test")).isEqualTo("NORMAL");
}
@Test
void invalidAndReusedCaptchaCannotLoginAndValidationRejectsBadEmail() throws Exception {
String code = captcha();
mvc.perform(post("/admin-api/auth/login").contentType(MediaType.APPLICATION_JSON)
.content(body("admin@example.test", code, "WRONG")))
.andExpect(status().isBadRequest()).andExpect(jsonPath("$.code").value("CAPTCHA_INVALID"));
mvc.perform(post("/admin-api/auth/login").contentType(MediaType.APPLICATION_JSON)
.content(body("admin@example.test", code, "ABCDE")))
.andExpect(status().isBadRequest());
mvc.perform(post("/admin-api/auth/login").contentType(MediaType.APPLICATION_JSON)
.content(body("invalid-email", captcha(), "ABCDE")))
.andExpect(status().isUnprocessableEntity()).andExpect(jsonPath("$.code").value("INVALID_REQUEST"));
}
@Test
void disabledAndDemotedAdminsLoseAccessOnTheirNextRequest() throws Exception {
JsonNode login = login("admin@example.test");
jdbc.update("UPDATE sys_user SET status='DISABLED' WHERE user_code=?", admin.userCode());
mvc.perform(get("/admin-api/components").header(HttpHeaders.AUTHORIZATION, bearer(login)))
.andExpect(status().isUnauthorized()).andExpect(jsonPath("$.code").value("UNAUTHORIZED"));
mvc.perform(post("/admin-api/auth/login").header(HttpHeaders.ORIGIN, ORIGIN).contentType(MediaType.APPLICATION_JSON)
.content(body("admin@example.test", captcha(), "ABCDE")))
.andExpect(status().isForbidden()).andExpect(jsonPath("$.code").value("ACCOUNT_DISABLED"))
.andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN));
jdbc.update("UPDATE sys_user SET status='ACTIVE', user_type='NORMAL' WHERE user_code=?", admin.userCode());
mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(login)))
.andExpect(status().isForbidden()).andExpect(jsonPath("$.code").value("ADMIN_ACCESS_DENIED"));
}
@Test
void logoutOnlyRevokesCurrentAdminSessionAndOtherTokenStoresAreIndependent() throws Exception {
JsonNode first = login("admin@example.test");
JsonNode second = login("admin@example.test");
mvc.perform(post("/admin-api/auth/logout").header(HttpHeaders.AUTHORIZATION, bearer(first))).andExpect(status().isOk());
mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(first))).andExpect(status().isUnauthorized());
mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(second))).andExpect(status().isOk());
TokenService userSideTokens = new TokenService(properties);
mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, "Bearer " + userSideTokens.issue(admin.userCode())))
.andExpect(status().isUnauthorized());
}
@Test
void everyAdminBusinessRouteRequiresLoginIncludingDownloads() throws Exception {
for (String path : List.of("/admin-api/users/me", "/admin-api/components", "/admin-api/users", "/admin-api/operation-logs",
"/admin-api/component-assets/cadworld_dev/components/model.step")) {
mvc.perform(get(path).header("X-Request-Id", "admin-no-auth"))
.andExpect(status().isUnauthorized()).andExpect(jsonPath("$.code").value("UNAUTHORIZED"))
.andExpect(jsonPath("$.requestId").value("admin-no-auth"));
}
for (String path : List.of("/admin-api/components", "/admin-api/users", "/admin-api/storage/upload-signature", "/admin-api/auth/logout")) {
mvc.perform(post(path)).andExpect(status().isUnauthorized());
}
mvc.perform(put("/admin-api/components/1")).andExpect(status().isUnauthorized());
mvc.perform(delete("/admin-api/components/1")).andExpect(status().isUnauthorized());
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_operation_log", Long.class)).isZero();
mvc.perform(get("/admin-api/auth/captcha").header(HttpHeaders.AUTHORIZATION, "Bearer stale"))
.andExpect(status().isOk()).andExpect(header().string(HttpHeaders.CACHE_CONTROL, "no-store"));
}
@Test
void corsPreflightAndAuthenticationFailuresHaveCorrectHeaders() throws Exception {
mvc.perform(options("/admin-api/components").header(HttpHeaders.ORIGIN, ORIGIN)
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "PUT")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "authorization,content-type,x-request-id"))
.andExpect(status().isOk()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN));
mvc.perform(get("/admin-api/users/me").header(HttpHeaders.ORIGIN, ORIGIN))
.andExpect(status().isUnauthorized()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN));
mvc.perform(get("/admin-api/users/me").header(HttpHeaders.ORIGIN, ORIGIN).header(HttpHeaders.AUTHORIZATION, "Bearer invalid"))
.andExpect(status().isUnauthorized()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN));
mvc.perform(options("/admin-api/components").header(HttpHeaders.ORIGIN, "https://untrusted.example")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "POST"))
.andExpect(status().isForbidden()).andExpect(header().doesNotExist(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN));
}
@Test
void uploadsAndAuditUseActualAdminAndCannotReuseAnotherAdminsUploadSession() throws Exception {
JsonNode upload = data(mvc.perform(post("/admin-api/storage/upload-signature")
.header(HttpHeaders.AUTHORIZATION, "Bearer " + admin.token()).contentType(MediaType.APPLICATION_JSON).content("{}"))
.andExpect(status().isOk()).andReturn());
String renewal = json.writeValueAsString(Map.of("uploadSessionToken", upload.path("uploadSessionToken").asText()));
mvc.perform(post("/admin-api/storage/upload-signature").header(HttpHeaders.AUTHORIZATION, "Bearer " + admin.token())
.contentType(MediaType.APPLICATION_JSON).content(renewal)).andExpect(status().isOk());
AdminAuthTestSupport.Session other = AdminAuthTestSupport.create(jdbc, tokens);
mvc.perform(post("/admin-api/storage/upload-signature").header(HttpHeaders.AUTHORIZATION, "Bearer " + other.token())
.contentType(MediaType.APPLICATION_JSON).content(renewal))
.andExpect(status().isUnprocessableEntity()).andExpect(jsonPath("$.code").value("INVALID_COMPONENT_UPLOAD_SESSION"));
mvc.perform(post("/admin-api/components").header(HttpHeaders.AUTHORIZATION, "Bearer " + admin.token())
.contentType(MediaType.APPLICATION_JSON).content("{}"))
.andExpect(status().isUnprocessableEntity());
assertThat(jdbc.queryForObject("SELECT operator_id FROM sys_operation_log WHERE action='CREATE'", Long.class)).isEqualTo(admin.userId());
assertThat(jdbc.queryForObject("SELECT operator_name FROM sys_operation_log WHERE action='CREATE'", String.class)).isEqualTo("测试管理员");
}
@Test
void databaseFailureDuringAuthenticationUsesExistingErrorEnvelope() throws Exception {
doThrow(new DataAccessResourceFailureException("test unavailable")).when(users).requireActive(admin.userCode());
mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, "Bearer " + admin.token()))
.andExpect(status().isServiceUnavailable()).andExpect(jsonPath("$.code").value("DATABASE_UNAVAILABLE"));
}
@Test
void swaggerDocumentsBearerAuthenticationAndLoginRoutesArePublic() throws Exception {
mvc.perform(get("/api-docs")).andExpect(status().isOk())
.andExpect(jsonPath("$.components.securitySchemes.adminBearer.scheme").value("bearer"));
}
@Test
void adminAuthenticationLogsDoNotExposeTokensCaptchaOrEmail() throws Exception {
Logger logger = (Logger) LoggerFactory.getLogger("com.linkerbot.cadworld");
ListAppender<ILoggingEvent> capture = new ListAppender<>();
capture.start(); logger.addAppender(capture);
try {
JsonNode login = login("admin@example.test");
mvc.perform(post("/admin-api/auth/logout").header(HttpHeaders.AUTHORIZATION, bearer(login))).andExpect(status().isOk());
mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, "Bearer PRIVATE_ADMIN_TOKEN"))
.andExpect(status().isUnauthorized());
String logs = String.join("\n", capture.list.stream().map(ILoggingEvent::getFormattedMessage).toList());
assertThat(logs).contains("管理员登录成功", "管理员退出登录", "UNAUTHORIZED");
assertThat(logs).doesNotContain("admin@example.test", "PRIVATE_ADMIN_TOKEN", "ABCDE", login.path("token").asText(), "data:image/png;base64,");
} finally {
logger.detachAppender(capture); capture.stop();
}
}
private String captcha() throws Exception {
return data(mvc.perform(get("/admin-api/auth/captcha")).andExpect(status().isOk()).andReturn()).path("captchaCode").asText();
}
private JsonNode login(String email) throws Exception {
return data(mvc.perform(post("/admin-api/auth/login").header(HttpHeaders.AUTHORIZATION, "Bearer stale")
.contentType(MediaType.APPLICATION_JSON).content(body(email, captcha(), "abcde")))
.andExpect(status().isOk()).andExpect(header().string(HttpHeaders.CACHE_CONTROL, "no-store")).andReturn());
}
private String body(String email, String code, String answer) throws Exception {
return json.writeValueAsString(Map.of("email", email, "captchaCode", code, "captchaAnswer", answer));
}
private String bearer(JsonNode login) { return "Bearer " + login.path("token").asText(); }
private JsonNode data(MvcResult result) throws Exception { return json.readTree(result.getResponse().getContentAsByteArray()).path("data"); }
@TestConfiguration(proxyBeanMethods = false)
static class CaptchaConfiguration {
@Bean @Primary CaptchaService fixedAdminCaptcha(AuthProperties properties) {
return new CaptchaService(properties) {
@Override protected String generateAnswer() { return "ABCDE"; }
};
}
}
}
@@ -0,0 +1,22 @@
package com.linkerbot.cadworld;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.support.UserCodes;
import java.util.Locale;
import org.springframework.jdbc.core.JdbcTemplate;
final class AdminAuthTestSupport {
private AdminAuthTestSupport() {
}
record Session(long userId, String userCode, String token) {
}
static Session create(JdbcTemplate jdbc, TokenService tokens) {
String code = UserCodes.generate();
jdbc.update("INSERT INTO sys_user (user_code,email,nickname,status,user_type) VALUES (?,?,?,'ACTIVE','ADMIN')",
code, code.toLowerCase(Locale.ROOT) + "@example.test", "测试管理员");
Long id = jdbc.queryForObject("SELECT id FROM sys_user WHERE user_code=?", Long.class, code);
return new Session(id, code, tokens.issue(code));
}
}
@@ -64,11 +64,11 @@ final class TestSchemaSupport {
jdbc.execute("""
CREATE TABLE IF NOT EXISTS sys_user (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
phone VARCHAR(32) NOT NULL UNIQUE,
user_code CHAR(32) NOT NULL UNIQUE,
email VARCHAR(254) NOT NULL UNIQUE,
nickname VARCHAR(64) NOT NULL DEFAULT '',
status VARCHAR(32) NOT NULL DEFAULT 'ACTIVE',
user_type VARCHAR(32) NOT NULL DEFAULT 'NORMAL',
deleted INT NOT NULL DEFAULT 0,
created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
)
@@ -1,6 +1,7 @@
package com.linkerbot.cadworld;
import com.fasterxml.jackson.databind.JsonNode;
import com.linkerbot.cadworld.security.common.TokenService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@@ -22,11 +23,17 @@ import static org.assertj.core.api.Assertions.*;
@org.springframework.context.annotation.Import(InMemoryObjectStorageConfiguration.class)
class UploadHttpTest {
@Autowired TestRestTemplate http;
@Autowired TokenService tokens;
@Autowired JdbcTemplate jdbc;
@Autowired InMemoryObjectStorageConfiguration.InMemoryObjectStorageClient storage;
@Test
void oversizeDirectUploadIsRejectedAtComponentSaveWithoutCreatingRowAndAuditedOnce() {
AdminAuthTestSupport.Session admin = AdminAuthTestSupport.create(jdbc, tokens);
http.getRestTemplate().setInterceptors(List.of((request, body, execution) -> {
request.getHeaders().setBearerAuth(admin.token());
return execution.execute(request, body);
}));
JsonNode session = http.postForObject("/admin-api/storage/upload-signature",Map.of(),JsonNode.class).path("data");
String step = session.path("step").path("keyPrefix").asText()+"model.step";
String main = session.path("urdf").path("keyPrefix").asText()+"robot.urdf";
@@ -40,5 +47,7 @@ class UploadHttpTest {
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM component",Long.class)).isZero();
org.awaitility.Awaitility.await().atMost(java.time.Duration.ofSeconds(5)).untilAsserted(() ->
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_operation_log WHERE action='CREATE' AND success=FALSE",Long.class)).isEqualTo(1));
assertThat(jdbc.queryForObject("SELECT operator_id FROM sys_operation_log WHERE action='CREATE'", Long.class))
.isEqualTo(admin.userId());
}
}
@@ -1,6 +1,5 @@
package com.linkerbot.cadworld.audit;
import com.linkerbot.cadworld.config.AdminOperatorProperties;
import com.linkerbot.cadworld.entity.OperationLog;
import com.linkerbot.cadworld.service.AdminOperatorProvider;
import com.linkerbot.cadworld.service.OperationLogService;
@@ -19,7 +18,7 @@ class OperationAuditInterceptorTest {
@Test
void multipartFailureBeforeMvcIsAuditedOnce() throws Exception {
OperationLogService service = mock(OperationLogService.class);
OperationAuditInterceptor audit = new OperationAuditInterceptor(service, new AdminOperatorProvider(new AdminOperatorProperties(0, "TEST_OPERATOR")));
OperationAuditInterceptor audit = new OperationAuditInterceptor(service, operator());
RequestMappingHandlerMapping mappings = mock(RequestMappingHandlerMapping.class);
MockHttpServletRequest request = new MockHttpServletRequest("POST", "/admin-api/components");
MockHttpServletResponse response = new MockHttpServletResponse();
@@ -41,7 +40,7 @@ class OperationAuditInterceptorTest {
void logFailureDoesNotChangeTheBusinessResponse() throws Exception {
OperationLogService service = mock(OperationLogService.class);
doThrow(new IllegalStateException("database unavailable")).when(service).record(any());
OperationAuditInterceptor audit = new OperationAuditInterceptor(service, new AdminOperatorProvider(new AdminOperatorProperties(0, "TEST_OPERATOR")));
OperationAuditInterceptor audit = new OperationAuditInterceptor(service, operator());
MockHttpServletRequest request = new MockHttpServletRequest("POST", "/admin-api/components");
MockHttpServletResponse response = new MockHttpServletResponse();
HandlerMethod handler = new HandlerMethod(this, getClass().getDeclaredMethod("operation"));
@@ -53,4 +52,11 @@ class OperationAuditInterceptorTest {
@AuditOperation(module = "COMPONENT", action = "CREATE")
void operation() { }
private AdminOperatorProvider operator() {
AdminOperatorProvider operator = mock(AdminOperatorProvider.class);
when(operator.userId()).thenReturn(7L);
when(operator.name()).thenReturn("测试管理员");
return operator;
}
}
+1 -1
View File
@@ -14,7 +14,7 @@
| GET | `/api/components/{componentCode}` | 按组件编码获取详情,包括 BOM、URDF 信息和模型地址 |
| POST | `/api/robot-conversations` | 创建文字/图片需求会话,后续接口见上述联调文档 |
组件匹配和详情无需登录凭证;需求会话使用后端 HttpOnly Cookie 校验访客归属,前端需携带 Cookie。组件使用 `componentCode` 标识,不返回数据库 ID。模型通过响应中的公开 OSS/CDN 地址加载。
所有 `/api/**` 业务接口均需要 Bearer Token,包括组件匹配和详情;先完成[邮箱与图片验证码登录](auth-api.md),请求头携带 `Authorization: Bearer <token>`。需求会话按登录用户隔离。组件使用 `componentCode` 标识,不返回数据库 ID。模型通过响应中的公开 OSS/CDN 地址加载。
新增组件编码格式为 `CW-` 加 16 位随机数字或大写字母(排除 `I/L/O/U`),总长 19,例如 `CW-7K3M9Q2R6V8X4T5N`。旧版 35 字符编码继续有效,以下部分示例保留旧编码。前端将编码视为不透明字符串,直接使用返回值查询和加载,不按固定长度截取或重组。
+147
View File
@@ -0,0 +1,147 @@
# 邮箱与图片验证码登录
用户端默认端口 `8991`。除 `GET /api/auth/captcha`、`POST /api/auth/login` 和跨域预检外,所有 `/api/**` 业务接口都需要 `Authorization: Bearer <token>`,包括组件详情、匹配、需求会话、私有图片和 SSE。JSON 返回统一为 `{code, message, data, requestId}`。
此流程沿用参考项目:邮箱与图片验证码登录,首次自动注册;不发送邮件、不验证邮箱归属。`user_type` 不作为客户端可提交字段。用户端仅返回唯一 `userCode`,不暴露数据库主键。
## 1. 接口
### 获取验证码
`GET /api/auth/captcha`,无需登录,响应设置 `Cache-Control: no-store`。
```json
{
"code": "OK",
"message": "success",
"data": {
"captchaCode": "一次性验证码编码",
"image": "data:image/png;base64,...",
"expiresIn": 120
},
"requestId": "请求编号"
}
```
图片为 180×60 PNG,包含 5 位数字或大写字母。`image` 可直接作为验证码图片的 `src`。有效期默认 120 秒,答案忽略大小写和首尾空格。每次有效参数的登录提交都会消费对应验证码,答错后也必须重新获取。
### 登录
`POST /api/auth/login`,`Content-Type: application/json`,无需登录。
```json
{"email":"user@example.com","captchaCode":"验证码编码","captchaAnswer":"ABCDE"}
```
邮箱去除首尾空格、转小写后校验,最长 254 字符;验证码编码和答案必填,最长分别为 64、32 字符。成功示例:
```json
{
"code": "OK",
"message": "success",
"data": {
"token": "登录凭证",
"tokenType": "Bearer",
"expiresIn": 86400,
"user": {
"userCode": "0123456789ABCDEF0123456789ABCDEF",
"nickname": "用户_01234567",
"email": "user@example.com"
}
},
"requestId": "请求编号"
}
```
首次登录创建 `ACTIVE / NORMAL` 用户,昵称为“用户_用户编码前8位”。同邮箱并发首次登录复用同一用户。用户编码创建后不可修改。
Token 是 32 字节安全随机值的无填充 Base64URL 编码,有效期默认 24 小时;访问不续期。同一用户可持有多个 Token。
### 当前用户与退出
- `GET /api/users/me`:返回 `data={userCode,nickname,email}`。
- `POST /api/auth/logout`:撤销当前 Token,返回 `data=null`,其他登录态继续有效。再次使用已撤销 Token 返回 401。
以上接口均须携带 Bearer Token。用户被后台禁用后,登录返回 403,已有 Token 在下一次业务请求时被拒绝。
| HTTP 状态 | code | 处理方式 |
| --- | --- | --- |
| 400 | `CAPTCHA_INVALID` | 验证码错误、过期或已消费,重新获取图片 |
| 401 | `UNAUTHORIZED` | 未登录、Token 无效或账号已不可用,重新登录 |
| 403 | `ACCOUNT_DISABLED` | 用户已禁用,联系管理员 |
| 422 | `INVALID_REQUEST` | 检查邮箱、必填字段、长度或未知字段 |
| 503 | `DATABASE_UNAVAILABLE` | 数据库暂不可用,稍后重试 |
| 503 | `USER_CODE_EXHAUSTED` | 用户编码分配重试失败,稍后重试 |
## 2. 前端调用与需求归属
```javascript
const challenge = (await (await fetch('/api/auth/captcha')).json()).data;
// 将 challenge.image 展示给用户,answer 为用户输入的图片答案。
const response = await fetch('/api/auth/login', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ email, captchaCode: challenge.captchaCode, captchaAnswer: answer })
});
if (!response.ok) throw await response.json();
const { token } = (await response.json()).data;
const current = await fetch('/api/users/me', {
headers: { Authorization: `Bearer ${token}` }
});
// 私有图片需要认证头,通过 Blob URL 展示,Token 不放在 URL 中。
const imageResponse = await fetch(previewUrl, {
headers: { Authorization: `Bearer ${token}` }
});
if (!imageResponse.ok) throw await imageResponse.json();
const objectUrl = URL.createObjectURL(await imageResponse.blob());
imageElement.src = objectUrl;
// 图片不再使用时执行 URL.revokeObjectURL(objectUrl)。
```
POST SSE 同样在 fetch 的 headers 中携带 `Authorization`,详见 [需求联调文档](robot-demand-api.md)。不再需要访客 Cookie 或 `credentials: 'include'`。
会话归属由服务端认证的 `userCode` 决定,存储为 `SHA-256("user:" + userCode)`。同一用户在不同设备登录后可通过原业务编码访问自己的会话;其他用户访问返回 404。客户端不传 `userId`、`userCode` 或归属摘要来指定所有者。
历史匿名 Cookie 不授予访问权,也不会触发会话认领。历史匿名数据保留至现有过期任务清理。
## 3. 配置与运行
| 环境变量 | 默认值 | 说明 |
| --- | --- | --- |
| `APP_AUTH_CAPTCHA_TTL` | `PT2M` | 验证码有效期,至少 1 秒 |
| `APP_AUTH_TOKEN_TTL` | `PT24H` | 登录态有效期,至少 1 秒 |
| `APP_DEMAND_ALLOWED_ORIGINS` | 沿用各环境配置 | `/api/**` 跨域白名单,允许 Authorization 请求头 |
验证码和登录态分别使用最多 10000 条的 Caffeine 缓存。当前按单实例部署;重启、缓存容量淘汰或有效期结束后凭证失效。用户和会话数据持久化保留;多实例共享登录态需后续切换为共享存储。
用户端和[管理端](../../cadworld-adminapi/docs/auth-api.md)分别引入自己的安全模块,独立保存 Token 和验证码。后台用户管理使用邮箱,删除入口改为禁用账号;上传与审计使用真实登录管理员。
## 4. 发布前手动执行的迁移 SQL
以下 SQL 基于提供的邮箱版 `sys_user`(索引名 `uk_sys_user_phone`,索引列为 `email`),仅执行一次;已有该字段或索引的环境先核对结构。应用不自动迁移,仓库 `.sql` 文件未修改。先执行 SQL,再发布用户端和管理端新代码。
```sql
ALTER TABLE `sys_user`
ADD COLUMN `user_code` char(32)
CHARACTER SET ascii COLLATE ascii_bin
NULL COMMENT '用户唯一编码,对外使用且创建后不可修改'
AFTER `id`;
UPDATE `sys_user`
SET `user_code` = UPPER(REPLACE(UUID(), '-', ''))
WHERE `user_code` IS NULL;
ALTER TABLE `sys_user`
MODIFY COLUMN `user_code` char(32)
CHARACTER SET ascii COLLATE ascii_bin
NOT NULL COMMENT '用户唯一编码,对外使用且创建后不可修改',
ADD UNIQUE KEY `uk_sys_user_code` (`user_code`),
RENAME INDEX `uk_sys_user_phone` TO `uk_sys_user_email`;
ALTER TABLE `robot_demand_conversation`
MODIFY COLUMN `owner_hash` char(64)
CHARACTER SET ascii COLLATE ascii_bin
NOT NULL COMMENT '登录用户归属摘要,历史匿名归属保留至过期';
```
+3 -3
View File
@@ -11,7 +11,7 @@
1. 使用已有 `component` 表,部署前按 [管理端旋转轴字段部署说明](../../cadworld-adminapi/docs/admin-api.md#43-旋转轴字段部署) 添加 `rotation_axis`。在用户端服务使用的数据库中执行 [demand-schema.md](demand-schema.md) 的五张表建表语句。代码不自动建表或迁移,不修改或执行仓库 `.sql` 文件。
2. 配置 MySQL、公开模型域名与 `ARK_API_KEY`。Key 仅提供给后端,缺失时其他组件接口仍可使用,需求解析返回不可用状态。
3. 为需求图片配置私有可写的持久化目录;不能映射为静态资源或挂载到公开模型目录。
4. 前端通过同站点 HTTPS 代理 `/api`;开发跨端口时配置具体前端 origin。生产 Cookie 设置 Secure。
4. 前端通过同站点 HTTPS 代理 `/api`;开发跨端口时配置具体前端 origin。先完成[邮箱登录及用户编码迁移](auth-api.md),全部业务请求携带 Bearer Token。
5. 对接组件实际接口:interfaceType 优先确定现有 category,双方 frames[].child 严格一致才可连接;每个 frames 元素是独立接口。无需填写 urdfInfo.assembly,模型摆放由前端处理。
```bash
@@ -36,7 +36,7 @@ java -jar cadworld-api/target/cadworld-api-0.0.1-SNAPSHOT.jar
| `APP_DEMAND_CONCURRENT_ANALYSES` | `4`,允许 1–16;当前进程并发上限,无等待队列 |
| `APP_DEMAND_ALLOWED_ORIGINS` | `/api/**` 跨域白名单;`test` 默认 `https://dev-cadworld.robotquan.com`,`prod` 默认 `https://cadworld.robotquan.com`;可用逗号分隔的完整 origin 覆盖,显式留空关闭跨域,禁止通配符 |
用户端跨域支持凭证,允许 `GET / POST / DELETE / OPTIONS`,请求头允许 `Content-Type / X-Request-Id`,向前端暴露 `X-Request-Id`,预检缓存 3600 秒。浏览器请求需要携带访客 Cookie 时,使用 `credentials: 'include'`(Axios 使用 `withCredentials: true`)。公开 OSS/CDN 资源的跨域需在对应资源服务单独配置。
用户端跨域支持凭证,允许 `GET / POST / DELETE / OPTIONS`,请求头允许 `Content-Type / X-Request-Id / Authorization`,向前端暴露 `X-Request-Id`,预检缓存 3600 秒。浏览器统一发送 `Authorization: Bearer <token>`,不再依赖匿名 Cookie。公开 OSS/CDN 资源的跨域需在对应资源服务单独配置。
模型调用使用严格 JSON Schema、深度思考、`stream:false`、`store:false`,不启用联网工具。SSE 为后端阶段和已校验业务结果,不透传模型推理内容。接收上游响应最多 2MiB,提取的中间 JSON 最多 150000 字符。
@@ -44,7 +44,7 @@ java -jar cadworld-api/target/cadworld-api-0.0.1-SNAPSHOT.jar
## 持久化与运行方式
五张表分别保存会话归属和版本、私有附件元信息、服务端历史、完整解析结果、自动生成的匹配快照。对外均使用编码;原始访客 Cookie 只在浏览器,数据库保存其 SHA-256。没有账号系统时暂按浏览器访客隔离;以后接入登录,应将归属替换为服务端认证主体,不能改成信任客户端 `userId`。
五张表分别保存会话归属和版本、私有附件元信息、服务端历史、完整解析结果、自动生成的匹配快照。对外均使用编码;会话归属使用服务端认证主体的 `SHA-256("user:" + userCode)`,不信任客户端 `userId` 或用户编码。历史匿名会话不认领,保留至过期任务清理。
新用户消息在事务中锁定会话、递增版本并使旧方案失效;相同消息编号和内容不重复创建版本、调用模型或选件。消息任务在需求规范化后立即执行自动选件和装配校验,需求结果与匹配快照在同一事务内提交,随后才发布 `ready` 和 `analysis.completed`;完成事件及 GET 查询同时返回公开的 `match`,内部 `snapshot` 始终移除。选件在会话锁外执行,提交时再次核对版本和取消状态,防止旧任务覆盖新方案。新流程不写入助手追问。
+3 -3
View File
@@ -4,20 +4,20 @@
自动生成流程复用以下五张表,无需修改表结构或执行新的迁移。新消息完成需求理解、选件和装配校验后,将解析结果与匹配快照一起保存;`ready` 表示方案已生成。`needs_clarification` 仅保留兼容旧记录,新流程不生成该状态。下方已有 DDL 的确认相关注释保留作为旧结构说明。
会话、消息、附件、解析和匹配均使用唯一编码对外访问,数据库主键只在内部使用。`owner_hash` 是匿名访客 Cookie 的 SHA-256,不保存原始 Cookie。完整解析结果只由所属访客访问;模型配置、内部匹配快照和图片磁盘路径不返回前端。
会话、消息、附件、解析和匹配均使用唯一编码对外访问,数据库主键只在内部使用。`owner_hash` 保存服务端认证主体的 `SHA-256("user:" + userCode)`;历史匿名归属保留至过期,已有表的注释调整见[登录迁移 SQL](auth-api.md#4-发布前手动执行的迁移-sql)。完整解析结果只由所属用户访问;模型配置、内部匹配快照和图片磁盘路径不返回前端。
```sql
CREATE TABLE `robot_demand_conversation` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '会话主键ID,仅内部使用',
`conversation_code` varchar(64) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '需求会话唯一编码',
`owner_hash` char(64) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '匿名访客凭证SHA-256,用于归属校验',
`owner_hash` char(64) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '登录用户归属摘要,历史匿名归属保留至过期',
`revision` int unsigned NOT NULL DEFAULT '0' COMMENT '当前需求版本号,每次新用户消息递增',
`created_at` datetime(3) NOT NULL COMMENT '创建时间',
`updated_at` datetime(3) NOT NULL COMMENT '最近更新时间',
`expires_at` datetime(3) NOT NULL COMMENT '会话过期时间,默认最近新消息后七天',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_demand_conversation_code` (`conversation_code`) COMMENT '会话编码唯一索引',
KEY `idx_demand_conversation_owner` (`owner_hash`,`updated_at`) COMMENT '访客会话查询索引',
KEY `idx_demand_conversation_owner` (`owner_hash`,`updated_at`) COMMENT '用户会话查询索引',
KEY `idx_demand_conversation_expiry` (`expires_at`,`id`) COMMENT '过期会话清理索引'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='机器人需求会话表';
+8 -9
View File
@@ -26,7 +26,7 @@
5. 简短展示 `warnings`、缺件及未满足/未验证项;不弹出追问、确认或必须接受降级的页面。`assembly.status=blocked` 或 `status=no_match` 时展示具体原因,不伪造连接位姿。
6. 用户需要调整时,在同一会话发送新消息,例如“改成右臂扭矩至少30N·m”,后端生成新版本并返回新方案。
浏览器需要保留后端设置的 HttpOnly Cookie,所有调用均设置 `credentials:"include"`。不需要读写 Cookie 值,也不传 `userId`、模型 Key 或系统提示词。当前按匿名浏览器访客隔离对话和图片,清除 Cookie 后不能访问之前记录。生产使用 HTTPS;前后端通过同站点 `/api` 代理接入。开发跨端口需后端配置具体允许域名,并使用一致的主机名(不要混用 localhost 与 127.0.0.1)。
先完成[邮箱与图片验证码登录](auth-api.md),所有业务请求头携带 `Authorization: Bearer <token>`,不再依赖匿名 Cookie 或 `credentials:"include"`。会话和图片归属服务端认证的用户,同账号换设备登录后仍可通过原业务编码访问;其他账号访问返回 404。历史匿名会话不自动认领,保留至过期清理。不传 `userId`、用户编码、模型 Key 或系统提示词。生产使用 HTTPS;开发跨端口需配置具体允许域名。
### 接口清单
@@ -34,7 +34,7 @@
| --- | --- | --- | --- |
| POST | `/api/robot-conversations` | 无请求体 | 会话编码、初始版本、有效期 |
| POST | `/api/robot-conversations/{conversationId}/attachments` | multipart `file` | 图片编码、预览地址 |
| GET | `/api/robot-conversations/{conversationId}/attachments/{attachmentId}` | 无 | 私有原图,需要 Cookie |
| GET | `/api/robot-conversations/{conversationId}/attachments/{attachmentId}` | 无 | 私有原图,需要 Bearer Token |
| POST | `/api/robot-conversations/{conversationId}/messages` | 消息 JSON | SSE 生成阶段、完整需求及装配方案 |
| GET | `/api/robot-analyses/{analysisId}` | 无 | 当前生成状态、需求及装配方案 |
| POST | `/api/robot-analyses/{analysisId}/retry` | 无请求体 | SSE,仅重试失败或停止的当前版本 |
@@ -44,7 +44,7 @@ AI 对话拼装仅保留以上 7 个接口。原 `confirm`、`rematch`、按 `ma
正常文字生成只需调用“创建会话 → 发送消息”两个接口;图片生成再增加上传接口。预览、状态查询、重试和停止按实际交互调用。
既有结构化 `POST /api/robot-matches` 和公开组件详情保留,见 [组件接口文档](api.md)。本流程的状态为小写,与既有接口的 `MATCHED/FALLBACK/PARTIAL/NO_MATCH` 分开使用。
既有结构化 `POST /api/robot-matches` 和组件详情保留,均需登录,见 [组件接口文档](api.md)。本流程的状态为小写,与既有接口的 `MATCHED/FALLBACK/PARTIAL/NO_MATCH` 分开使用。
## 2. 创建会话与上传图片
@@ -81,7 +81,7 @@ AI 对话拼装仅保留以上 7 个接口。原 `confirm`、`rematch`、按 `ma
}
```
图片仅能用于所属会话,一个附件只能绑定一条新消息。重复发送同一 `messageId` 无需重复上传;后续图片消息请重新上传附件。原图可用返回的 `previewUrl` 展示,仍需携带 Cookie。
图片仅能用于所属会话,一个附件只能绑定一条新消息。重复发送同一 `messageId` 无需重复上传;后续图片消息请重新上传附件。原图通过返回的 `previewUrl` 用 fetch 携带认证头获取 Blob,再使用 `URL.createObjectURL` 展示,释放时调用 `URL.revokeObjectURL`;示例见[登录文档](auth-api.md#2-前端调用与需求归属)。
## 3. 发送消息并直接生成
@@ -139,11 +139,10 @@ data:{"code":"OK","message":"success","data":{"analysisId":"DN-22222222222222222
使用 fetch 接收 POST SSE(`EventSource` 不支持 POST):
```javascript
async function sendMessage(conversationId, message, onEvent, signal) {
async function sendMessage(token, conversationId, message, onEvent, signal) {
const response = await fetch(`/api/robot-conversations/${conversationId}/messages`, {
method: "POST",
credentials: "include",
headers: { "Content-Type": "application/json", "Accept": "text/event-stream" },
headers: { "Content-Type": "application/json", "Accept": "text/event-stream", "Authorization": `Bearer ${token}` },
body: JSON.stringify(message),
signal
});
@@ -993,7 +992,7 @@ async function sendMessage(conversationId, message, onEvent, signal) {
替代候选组包含目标 `instanceId`;仅替换对应实例,应用该候选返回的完整 `assembly`、`totals` 和校验结果。多个同类型实例分别有替代组,不按 category 整批替换;多个替代预览不能直接叠加。第 4 节提供包含分组外层的完整示例。
加载模型时保留 URDF 相对路径目录;OSS/CDN 须允许前端 CORS。每个实例都独立摆放,资源 URL 可以复用或缓存;用户需求图片继续使用需要 Cookie 的私有预览接口。
加载模型时保留 URDF 相对路径目录;OSS/CDN 须允许前端 CORS。每个实例都独立摆放,资源 URL 可以复用或缓存;用户需求图片继续使用需要 Bearer Token 的私有预览接口。
AI 接口与结构化 `POST /api/robot-matches` 共用选件连接规则,但返回包装不同:AI 使用 `components[].instanceId={matchId}:{category}:{序号}` 和 `assembly.connections[]`;结构化接口使用 `parts[].instanceId={category}:{序号}` 和顶层 `connections[]`,详见 [结构化接口文档](api.md)。
@@ -1017,7 +1016,7 @@ AI 接口与结构化 `POST /api/robot-matches` 共用选件连接规则,但
| HTTP / 错误码 | 前端处理 |
| --- | --- |
| 422 `INVALID_REQUEST` / `DEMAND_INPUT_TOO_LARGE` | 修正输入或新建会话 |
| 404 `DEMAND_NOT_FOUND` | 无记录、已过期或不属于当前访客;新建会话 |
| 404 `DEMAND_NOT_FOUND` | 无记录、已过期或不属于当前用户;新建会话 |
| 409 `DEMAND_REVISION_CONFLICT` | 查询最新生成结果并使用其版本;重复消息编号内容须一致 |
| SSE `COMPONENT_REVISION_CONFLICT` | 生成期间组件已变化,发送新消息重新生成 |
| 409 `DEMAND_ATTACHMENT_MISSING` | 原图已失效,重新上传并发送新消息 |
+10
View File
@@ -16,6 +16,11 @@
<name>cadworld-api</name>
<dependencies>
<dependency>
<groupId>com.linkerbot</groupId>
<artifactId>cadworld-security-api</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.linkerbot</groupId>
<artifactId>cadworld-service</artifactId>
@@ -31,6 +36,11 @@
<artifactId>h2</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
@@ -9,12 +9,14 @@ import com.linkerbot.cadworld.service.impl.ObjectStorageUrlResolver;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Import;
@SpringBootApplication(scanBasePackages = {
@SpringBootApplication(exclude = UserDetailsServiceAutoConfiguration.class, scanBasePackages = {
"com.linkerbot.cadworld.api", "com.linkerbot.cadworld.common",
"com.linkerbot.cadworld.service.matching"
"com.linkerbot.cadworld.service.matching", "com.linkerbot.cadworld.service.auth",
"com.linkerbot.cadworld.security.api"
})
@EnableConfigurationProperties({StorageProperties.class, MatchingProperties.class, DemandProperties.class})
@Import({MybatisPlusConfig.class, ObjectStorageUrlResolver.class})
@@ -58,7 +58,7 @@ public class DemandConfiguration {
if (allowed.length == 0) return;
for (String origin : allowed) if (origin.contains("*")) throw new IllegalArgumentException("需求接口凭证跨域必须配置具体前端域名");
registry.addMapping("/api/**").allowedOrigins(allowed).allowedMethods("GET", "POST", "DELETE", "OPTIONS")
.allowedHeaders("Content-Type", "X-Request-Id").exposedHeaders("X-Request-Id").allowCredentials(true).maxAge(3600);
.allowedHeaders("Content-Type", "X-Request-Id", "Authorization").exposedHeaders("X-Request-Id").allowCredentials(true).maxAge(3600);
log.info("用户接口跨域配置已启用 path=/api/** allowedOrigins={}", List.of(allowed));
}
};
@@ -0,0 +1,62 @@
package com.linkerbot.cadworld.api.controller;
import com.linkerbot.cadworld.common.api.ApiResponse;
import com.linkerbot.cadworld.common.api.RequestIdHolder;
import com.linkerbot.cadworld.dto.auth.CaptchaResponse;
import com.linkerbot.cadworld.dto.auth.LoginRequest;
import com.linkerbot.cadworld.dto.auth.LoginResponse;
import com.linkerbot.cadworld.dto.auth.LoginUserResponse;
import com.linkerbot.cadworld.entity.SysUser;
import com.linkerbot.cadworld.security.api.CurrentUser;
import com.linkerbot.cadworld.security.common.AuthProperties;
import com.linkerbot.cadworld.security.common.CaptchaService;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.auth.LoginUserService;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;
@Slf4j
@RestController
@RequiredArgsConstructor
public class AuthController {
private final CaptchaService captcha;
private final TokenService tokens;
private final LoginUserService users;
private final AuthProperties properties;
@GetMapping("/api/auth/captcha")
public ApiResponse<CaptchaResponse> captcha(HttpServletResponse response) {
response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store");
return ApiResponse.success(captcha.issue());
}
@PostMapping("/api/auth/login")
public ApiResponse<LoginResponse> login(@Valid @RequestBody LoginRequest input, HttpServletResponse response) {
response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store");
captcha.verify(input.captchaCode(), input.captchaAnswer());
SysUser user = users.login(input.email());
return ApiResponse.success(new LoginResponse(tokens.issue(user.getUserCode()), "Bearer",
properties.tokenTtl().toSeconds(), users.view(user)));
}
@PostMapping("/api/auth/logout")
public ApiResponse<Void> logout(@RequestHeader(HttpHeaders.AUTHORIZATION) String authorization) {
String userCode = CurrentUser.required();
tokens.revoke(authorization.substring(7));
log.info("用户退出登录 userCode={} requestId={}", userCode, RequestIdHolder.get());
return ApiResponse.success(null);
}
@GetMapping("/api/users/me")
public ApiResponse<LoginUserResponse> me() {
return ApiResponse.success(users.view(users.requireActive(CurrentUser.required())));
}
}
@@ -1,37 +1,21 @@
package com.linkerbot.cadworld.api.controller;
import com.linkerbot.cadworld.config.DemandProperties;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import com.linkerbot.cadworld.security.api.CurrentUser;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.Base64;
import java.security.NoSuchAlgorithmException;
import java.util.HexFormat;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseCookie;
import org.springframework.stereotype.Component;
/** 当前无账号登录,以高熵 HttpOnly 匿名会话 Cookie 隔离各访客的需求和图片。 */
/** 仅使用服务端认证主体确定归属;历史匿名 Cookie 不参与账号会话访问。 */
@Component
@RequiredArgsConstructor
public class DemandOwner {
private static final SecureRandom RANDOM = new SecureRandom();
private final DemandProperties properties;
public String resolve(HttpServletRequest request, HttpServletResponse response) {
String token = null;
Cookie[] cookies = request.getCookies();
if (cookies != null) for (Cookie cookie : cookies) if ("cadworld_demand_visitor".equals(cookie.getName()) && cookie.getValue().matches("[A-Za-z0-9_-]{43}")) token = cookie.getValue();
if (token == null) {
byte[] bytes = new byte[32]; RANDOM.nextBytes(bytes);
token = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
public String resolve() {
try {
byte[] owner = ("user:" + CurrentUser.required()).getBytes(StandardCharsets.US_ASCII);
return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(owner));
} catch (NoSuchAlgorithmException exception) {
throw new IllegalStateException("SHA-256 unavailable", exception);
}
response.addHeader(HttpHeaders.SET_COOKIE, ResponseCookie.from("cadworld_demand_visitor", token).httpOnly(true)
.secure(properties.secureCookie() || request.isSecure()).sameSite("Lax").path("/api").maxAge(properties.retention()).build().toString());
try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(token.getBytes(StandardCharsets.US_ASCII))); }
catch (Exception exception) { throw new IllegalStateException("SHA-256 unavailable"); }
}
}
@@ -7,7 +7,6 @@ import com.linkerbot.cadworld.dto.demand.DemandMessageRequest;
import com.linkerbot.cadworld.service.demand.DemandAnalysisService;
import com.linkerbot.cadworld.service.demand.DemandAttachmentStore;
import com.linkerbot.cadworld.service.demand.DemandRepository;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
@@ -42,51 +41,49 @@ public class RobotDemandController {
private final DemandAnalysisService analyses;
@PostMapping("/robot-conversations")
public ApiResponse<DemandRepository.Conversation> create(HttpServletRequest request, HttpServletResponse response) {
DemandRepository.Conversation conversation = repository.create(owners.resolve(request, response));
public ApiResponse<DemandRepository.Conversation> create() {
DemandRepository.Conversation conversation = repository.create(owners.resolve());
log.info("需求会话创建 requestId={} conversationId={}", RequestIdHolder.get(), conversation.conversationId());
return ApiResponse.success(conversation);
}
@PostMapping(value = "/robot-conversations/{conversationId}/attachments", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public ApiResponse<AttachmentView> upload(@PathVariable @NotBlank String conversationId, @RequestPart("file") MultipartFile file,
HttpServletRequest request, HttpServletResponse response) throws IOException {
public ApiResponse<AttachmentView> upload(@PathVariable @NotBlank String conversationId, @RequestPart("file") MultipartFile file) throws IOException {
if (file.getSize() > 8 * 1024 * 1024) throw new BizException(422, "INVALID_REQUEST", "每张图片不能超过8MiB");
DemandRepository.Attachment saved = attachments.upload(conversationId, owners.resolve(request, response), file.getBytes(), file.getContentType());
DemandRepository.Attachment saved = attachments.upload(conversationId, owners.resolve(), file.getBytes(), file.getContentType());
log.info("需求图片保存 requestId={} conversationId={} attachmentId={} sizeBytes={}", RequestIdHolder.get(), conversationId, saved.attachmentId(), saved.sizeBytes());
return ApiResponse.success(new AttachmentView(saved.attachmentId(), saved.mimeType(), saved.sizeBytes(), "/api/robot-conversations/" + conversationId + "/attachments/" + saved.attachmentId()));
}
@GetMapping("/robot-conversations/{conversationId}/attachments/{attachmentId}")
public ResponseEntity<byte[]> image(@PathVariable @NotBlank String conversationId, @PathVariable @NotBlank String attachmentId,
HttpServletRequest request, HttpServletResponse response) {
DemandRepository.Attachment file = repository.attachment(conversationId, owners.resolve(request, response), attachmentId);
public ResponseEntity<byte[]> image(@PathVariable @NotBlank String conversationId, @PathVariable @NotBlank String attachmentId) {
DemandRepository.Attachment file = repository.attachment(conversationId, owners.resolve(), attachmentId);
return ResponseEntity.ok().cacheControl(CacheControl.noStore()).contentType(MediaType.parseMediaType(file.mimeType()))
.header("X-Content-Type-Options", "nosniff").body(attachments.read(file));
}
@PostMapping(value = "/robot-conversations/{conversationId}/messages", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public SseEmitter message(@PathVariable @NotBlank String conversationId, @Valid @RequestBody DemandMessageRequest input,
HttpServletRequest request, HttpServletResponse response) {
HttpServletResponse response) {
response.setHeader("Cache-Control", "no-cache"); response.setHeader("X-Accel-Buffering", "no");
return analyses.submit(conversationId, owners.resolve(request, response), input);
return analyses.submit(conversationId, owners.resolve(), input);
}
@GetMapping("/robot-analyses/{analysisId}")
public ApiResponse<DemandAnalysisService.AnalysisView> analysis(@PathVariable @NotBlank String analysisId, HttpServletRequest request, HttpServletResponse response) {
public ApiResponse<DemandAnalysisService.AnalysisView> analysis(@PathVariable @NotBlank String analysisId, HttpServletResponse response) {
response.setHeader("Cache-Control", "no-store");
return ApiResponse.success(analyses.get(analysisId, owners.resolve(request, response)));
return ApiResponse.success(analyses.get(analysisId, owners.resolve()));
}
@PostMapping(value = "/robot-analyses/{analysisId}/retry", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public SseEmitter retry(@PathVariable @NotBlank String analysisId, HttpServletRequest request, HttpServletResponse response) {
public SseEmitter retry(@PathVariable @NotBlank String analysisId, HttpServletResponse response) {
response.setHeader("Cache-Control", "no-cache"); response.setHeader("X-Accel-Buffering", "no");
return analyses.retry(analysisId, owners.resolve(request, response));
return analyses.retry(analysisId, owners.resolve());
}
@DeleteMapping("/robot-analyses/{analysisId}")
public ApiResponse<DemandAnalysisService.AnalysisView> cancel(@PathVariable @NotBlank String analysisId, HttpServletRequest request, HttpServletResponse response) {
return ApiResponse.success(analyses.cancel(analysisId, owners.resolve(request, response)));
public ApiResponse<DemandAnalysisService.AnalysisView> cancel(@PathVariable @NotBlank String analysisId) {
return ApiResponse.success(analyses.cancel(analysisId, owners.resolve()));
}
public record AttachmentView(String attachmentId, String mimeType, long sizeBytes, String previewUrl) { }
@@ -25,6 +25,9 @@ mybatis-plus:
configuration:
map-underscore-to-camel-case: true
app:
auth:
captcha-ttl: ${APP_AUTH_CAPTCHA_TTL:PT2M}
token-ttl: ${APP_AUTH_TOKEN_TTL:PT24H}
demand:
api-key: ${ARK_API_KEY:}
model: ${ARK_MODEL:doubao-seed-2-1-lite-260915}
@@ -0,0 +1,30 @@
package com.linkerbot.cadworld.api;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.auth.LoginUserService;
import java.util.UUID;
import org.springframework.jdbc.core.JdbcTemplate;
final class ApiAuthTestSupport {
private ApiAuthTestSupport() {
}
static void createSchema(JdbcTemplate jdbc) {
jdbc.execute("""
CREATE TABLE IF NOT EXISTS sys_user (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
user_code CHAR(32) NOT NULL UNIQUE,
email VARCHAR(254) NOT NULL UNIQUE,
nickname VARCHAR(64) NOT NULL DEFAULT '',
status VARCHAR(32) NOT NULL DEFAULT 'ACTIVE',
user_type VARCHAR(32) NOT NULL DEFAULT 'NORMAL',
created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP)
""");
jdbc.update("DELETE FROM sys_user");
}
static String token(LoginUserService users, TokenService tokens) {
return tokens.issue(users.login(UUID.randomUUID() + "@example.test").getUserCode());
}
}
@@ -0,0 +1,247 @@
package com.linkerbot.cadworld.api;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linkerbot.cadworld.security.common.AuthProperties;
import com.linkerbot.cadworld.security.common.CaptchaService;
import com.linkerbot.cadworld.service.auth.LoginUserService;
import jakarta.servlet.http.Cookie;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Primary;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.bean.override.mockito.MockitoSpyBean;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doThrow;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.options;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@SpringBootTest(classes = ApiApplication.class, properties = {
"spring.datasource.url=jdbc:h2:mem:auth;MODE=MySQL;DB_CLOSE_DELAY=-1",
"spring.datasource.driver-class-name=org.h2.Driver", "spring.datasource.username=sa", "spring.datasource.password=",
"app.storage.public-base-url=https://models.example.test", "logging.file.path=target/test-logs",
"logging.level.com.linkerbot.cadworld=DEBUG", "app.demand.allowed-origins=http://localhost:5173"
})
@AutoConfigureMockMvc(print = org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrint.NONE)
@Import(AuthApiTest.CaptchaConfiguration.class)
class AuthApiTest {
private static final String ORIGIN = "http://localhost:5173";
@Autowired private MockMvc mvc;
@Autowired private JdbcTemplate jdbc;
@Autowired private ObjectMapper json;
@MockitoSpyBean private LoginUserService users;
@BeforeEach
void prepare() {
assertThat(jdbc.execute((org.springframework.jdbc.core.ConnectionCallback<String>) connection ->
connection.getMetaData().getDatabaseProductName())).isEqualTo("H2");
ApiAuthTestSupport.createSchema(jdbc);
}
@Test
void firstLoginNormalizesEmailAndMeDoesNotExposeDatabaseId() throws Exception {
JsonNode first = login(" USER@EXAMPLE.TEST ");
JsonNode second = login("user@example.test");
assertThat(first.path("tokenType").asText()).isEqualTo("Bearer");
assertThat(first.path("expiresIn").asLong()).isEqualTo(86400);
assertThat(first.path("user").path("userCode").asText()).matches("[A-F0-9]{32}");
assertThat(first.path("user").path("email").asText()).isEqualTo("user@example.test");
assertThat(first.path("user").size()).isEqualTo(3);
assertThat(first.path("user")).isEqualTo(second.path("user"));
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_user", Long.class)).isEqualTo(1);
mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(first)))
.andExpect(status().isOk()).andExpect(jsonPath("$.data.id").doesNotExist())
.andExpect(jsonPath("$.data.email").value("user@example.test"))
.andExpect(jsonPath("$.data.userCode").value(first.path("user").path("userCode").asText()))
.andExpect(header().doesNotExist(HttpHeaders.SET_COOKIE));
mvc.perform(get("/api/users/me")).andExpect(status().isUnauthorized());
}
@Test
void wrongCaptchaIsConsumedAndInvalidInputCannotCreateUsers() throws Exception {
String code = captcha();
mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON)
.content(body("user@example.test", code, "WRONG")))
.andExpect(status().isBadRequest()).andExpect(jsonPath("$.code").value("CAPTCHA_INVALID"));
mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON)
.content(body("user@example.test", code, "ABCDE")))
.andExpect(status().isBadRequest());
for (String email : List.of("", "not-an-email", "a".repeat(255) + "@example.test")) {
mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON)
.content(body(email, captcha(), "ABCDE")))
.andExpect(status().isUnprocessableEntity()).andExpect(jsonPath("$.code").value("INVALID_REQUEST"));
}
mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON)
.content("{\"email\":\"user@example.test\",\"captchaCode\":\"x\",\"captchaAnswer\":\"ABCDE\",\"userType\":\"ADMIN\"}"))
.andExpect(status().isUnprocessableEntity());
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_user", Long.class)).isZero();
}
@Test
void logoutRevokesOnlyCurrentSession() throws Exception {
JsonNode first = login("user@example.test");
JsonNode second = login("user@example.test");
mvc.perform(post("/api/auth/logout").header(HttpHeaders.AUTHORIZATION, bearer(first))).andExpect(status().isOk());
mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(first)))
.andExpect(status().isUnauthorized()).andExpect(jsonPath("$.code").value("UNAUTHORIZED"));
mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(second))).andExpect(status().isOk());
mvc.perform(post("/api/auth/logout").header(HttpHeaders.AUTHORIZATION, bearer(first))).andExpect(status().isUnauthorized());
}
@Test
void disablingUserRejectsLoginAndExistingTokensImmediately() throws Exception {
JsonNode user = login("user@example.test");
jdbc.update("UPDATE sys_user SET status='DISABLED'");
mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(user)))
.andExpect(status().isUnauthorized()).andExpect(jsonPath("$.code").value("UNAUTHORIZED"));
mvc.perform(post("/api/auth/login").header(HttpHeaders.ORIGIN, ORIGIN).contentType(MediaType.APPLICATION_JSON)
.content(body("user@example.test", captcha(), "ABCDE")))
.andExpect(status().isForbidden()).andExpect(jsonPath("$.code").value("ACCOUNT_DISABLED"))
.andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN));
}
@Test
void allBusinessRoutesRequireAuthenticationAndAnonymousCookieHasNoAuthority() throws Exception {
for (String path : List.of("/api/users/me", "/api/components/CW-A", "/api/robot-analyses/test",
"/api/robot-conversations/test/attachments/test")) {
mvc.perform(get(path).cookie(new Cookie("cadworld_demand_visitor", "A".repeat(43))))
.andExpect(status().isUnauthorized()).andExpect(jsonPath("$.code").value("UNAUTHORIZED"));
}
for (String path : List.of("/api/robot-matches", "/api/robot-conversations", "/api/auth/logout",
"/api/robot-conversations/test/attachments", "/api/robot-conversations/test/messages", "/api/robot-analyses/test/retry")) {
mvc.perform(post(path)).andExpect(status().isUnauthorized());
}
mvc.perform(delete("/api/robot-analyses/test")).andExpect(status().isUnauthorized());
for (String value : List.of("Bearer invalid", "Basic invalid", "Bearer ")) {
mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, value).header("X-Request-Id", "auth-invalid"))
.andExpect(status().isUnauthorized()).andExpect(jsonPath("$.requestId").value("auth-invalid"));
}
mvc.perform(get("/api/auth/captcha").header(HttpHeaders.AUTHORIZATION, "Bearer stale"))
.andExpect(status().isOk()).andExpect(header().string(HttpHeaders.CACHE_CONTROL, "no-store"));
}
@Test
void corsPreflightAndAuthenticationErrorsKeepCorsHeaders() throws Exception {
mvc.perform(options("/api/robot-matches").header(HttpHeaders.ORIGIN, ORIGIN)
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "POST")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "authorization,content-type,x-request-id"))
.andExpect(status().isOk()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN));
mvc.perform(get("/api/users/me").header(HttpHeaders.ORIGIN, ORIGIN))
.andExpect(status().isUnauthorized()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN));
mvc.perform(get("/api/users/me").header(HttpHeaders.ORIGIN, ORIGIN).header(HttpHeaders.AUTHORIZATION, "Bearer invalid"))
.andExpect(status().isUnauthorized()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN));
mvc.perform(options("/api/robot-matches").header(HttpHeaders.ORIGIN, "https://untrusted.example")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "POST"))
.andExpect(status().isForbidden()).andExpect(header().doesNotExist(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN));
}
@Test
void authenticationDatabaseFailureUsesExistingErrorEnvelope() throws Exception {
JsonNode login = login("user@example.test");
doThrow(new DataAccessResourceFailureException("test unavailable")).when(users)
.requireActive(login.path("user").path("userCode").asText());
mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(login)).header("X-Request-Id", "auth-database"))
.andExpect(status().isServiceUnavailable()).andExpect(jsonPath("$.code").value("DATABASE_UNAVAILABLE"))
.andExpect(jsonPath("$.requestId").value("auth-database"));
}
@Test
void concurrentFirstLoginsCreateExactlyOneUser() throws Exception {
CountDownLatch start = new CountDownLatch(1);
List<Future<String>> results = new ArrayList<>();
Set<String> codes = new HashSet<>();
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int index = 0; index < 10; index++) results.add(executor.submit(() -> {
start.await();
return users.login(" RACE@EXAMPLE.TEST ").getUserCode();
}));
start.countDown();
for (Future<String> result : results) codes.add(result.get(10, TimeUnit.SECONDS));
}
assertThat(codes).hasSize(1);
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_user", Long.class)).isEqualTo(1);
}
@Test
void authenticationLogsDoNotContainCredentialsOrEmail() throws Exception {
Logger logger = (Logger) LoggerFactory.getLogger("com.linkerbot.cadworld");
ListAppender<ILoggingEvent> capture = new ListAppender<>();
capture.start();
logger.addAppender(capture);
try {
String code = captcha();
JsonNode login = data(mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON)
.content(body("private.email@example.test", code, "ABCDE"))).andExpect(status().isOk()).andReturn());
mvc.perform(post("/api/auth/logout").header(HttpHeaders.AUTHORIZATION, bearer(login))).andExpect(status().isOk());
mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, "Bearer PRIVATE_TOKEN")).andExpect(status().isUnauthorized());
mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON)
.content(body("private.email@example.test", captcha(), "PRIVATE_ANSWER"))).andExpect(status().isBadRequest());
String logs = String.join("\n", capture.list.stream().map(ILoggingEvent::getFormattedMessage).toList());
assertThat(logs).contains("用户登录成功", "用户退出登录", "CAPTCHA_INVALID", "UNAUTHORIZED");
assertThat(logs).doesNotContain("private.email@example.test", "PRIVATE_TOKEN", "PRIVATE_ANSWER", "ABCDE",
code, login.path("token").asText(), "data:image/png;base64,");
} finally {
logger.detachAppender(capture);
capture.stop();
}
}
private String captcha() throws Exception {
return data(mvc.perform(get("/api/auth/captcha")).andExpect(status().isOk()).andReturn()).path("captchaCode").asText();
}
private JsonNode login(String email) throws Exception {
return data(mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON)
.content(body(email, captcha(), "abcde"))).andExpect(status().isOk())
.andExpect(header().string(HttpHeaders.CACHE_CONTROL, "no-store")).andReturn());
}
private String body(String email, String code, String answer) throws Exception {
return json.writeValueAsString(Map.of("email", email, "captchaCode", code, "captchaAnswer", answer));
}
private String bearer(JsonNode login) { return "Bearer " + login.path("token").asText(); }
private JsonNode data(MvcResult result) throws Exception { return json.readTree(result.getResponse().getContentAsByteArray()).path("data"); }
@TestConfiguration(proxyBeanMethods = false)
static class CaptchaConfiguration {
@Bean
@Primary
CaptchaService fixedAnswerCaptcha(AuthProperties properties) {
return new CaptchaService(properties) {
@Override protected String generateAnswer() { return "ABCDE"; }
};
}
}
}
@@ -3,10 +3,12 @@ package com.linkerbot.cadworld.api;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.linkerbot.cadworld.common.web.RequestIdFilter;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.auth.LoginUserService;
import com.linkerbot.cadworld.service.demand.DemandMatchService;
import com.linkerbot.cadworld.service.demand.DemandMessage;
import com.linkerbot.cadworld.service.demand.DemandModelClient;
import com.linkerbot.cadworld.service.demand.DemandMatchService;
import jakarta.servlet.http.Cookie;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
@@ -34,12 +36,15 @@ import org.springframework.test.context.bean.override.mockito.MockitoBean;
import org.springframework.test.context.bean.override.mockito.MockitoSpyBean;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.doAnswer;
@@ -62,6 +67,9 @@ class DemandFlowApiTest {
private static final String TEXT = "我要机器人躯干和右臂,整体4自由度,质量不超过4kg,右臂扭矩至少20N·m";
private static final Path DIRECTORY = directory();
@Autowired private MockMvc mvc;
@Autowired private WebApplicationContext webContext;
@Autowired private LoginUserService loginUsers;
@Autowired private TokenService tokens;
@Autowired private ObjectMapper json;
@Autowired private JdbcTemplate jdbc;
@Autowired private com.linkerbot.cadworld.service.demand.DemandRepository repository;
@@ -97,6 +105,10 @@ class DemandFlowApiTest {
""");
for (String table : List.of("robot_demand_match", "robot_demand_analysis", "robot_demand_message", "robot_demand_attachment", "robot_demand_conversation", "component")) jdbc.update("DELETE FROM " + table);
when(model.analyze(anyList())).thenAnswer(invocation -> raw(invocation.getArgument(0)));
ApiAuthTestSupport.createSchema(jdbc);
mvc = MockMvcBuilders.webAppContextSetup(webContext).apply(springSecurity())
.addFilters(new RequestIdFilter())
.defaultRequest(get("/").header("Authorization", "Bearer " + ApiAuthTestSupport.token(loginUsers, tokens))).build();
}
@Test void demandControllerExposesExactlySevenRoutesAndRemovedEndpointsReturn404() throws Exception {
@@ -120,12 +132,12 @@ class DemandFlowApiTest {
String analysisId = generated.path("analysisId").asText();
String matchId = generated.path("match").path("matchId").asText();
for (String action : List.of("confirm", "rematch")) {
mvc.perform(post("/api/robot-analyses/" + analysisId + "/" + action).cookie(session.cookie())
mvc.perform(post("/api/robot-analyses/" + analysisId + "/" + action).header("Authorization", "Bearer " + session.token())
.contentType(MediaType.APPLICATION_JSON).content("{\"revision\":1,\"confirmed\":true}"))
.andExpect(status().isNotFound());
}
mvc.perform(get("/api/robot-demand-matches/" + matchId).cookie(session.cookie())).andExpect(status().isNotFound());
mvc.perform(post("/api/robot-demand-matches/" + matchId + "/accept-degradation").cookie(session.cookie())
mvc.perform(get("/api/robot-demand-matches/" + matchId).header("Authorization", "Bearer " + session.token())).andExpect(status().isNotFound());
mvc.perform(post("/api/robot-demand-matches/" + matchId + "/accept-degradation").header("Authorization", "Bearer " + session.token())
.contentType(MediaType.APPLICATION_JSON).content("{\"revision\":1,\"accepted\":true}"))
.andExpect(status().isNotFound());
}
@@ -170,11 +182,11 @@ class DemandFlowApiTest {
assertThat(alternate.path("component").path("urdfInfo").path("rootLink").asText()).isEqualTo("ARM_V2_ROOT");
assertThat(alternate.path("assembly").path("connections").get(0).path("childRootLink").asText()).isEqualTo("ARM_V2_ROOT");
assertThat(generatedMatch(session, analysis, 1).path("matchId").asText()).isEqualTo(match.path("matchId").asText());
JsonNode queried = data(mvc.perform(get("/api/robot-analyses/" + analysis).cookie(session.cookie())).andExpect(status().isOk()).andReturn());
JsonNode queried = data(mvc.perform(get("/api/robot-analyses/" + analysis).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()).andReturn());
assertThat(queried.path("match")).isEqualTo(match);
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM robot_demand_match", Integer.class)).isEqualTo(1);
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM robot_demand_message WHERE message_role='assistant'", Integer.class)).isZero();
mvc.perform(get("/api/robot-analyses/" + analysis).cookie(session.cookie())).andExpect(status().isOk())
mvc.perform(get("/api/robot-analyses/" + analysis).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk())
.andExpect(jsonPath("$.data.match.snapshot").doesNotExist());
}
@@ -425,7 +437,7 @@ class DemandFlowApiTest {
try {
assertThat(selecting.await(5, TimeUnit.SECONDS)).isTrue();
String id = jdbc.queryForObject("SELECT analysis_code FROM robot_demand_analysis", String.class);
mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk())
mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk())
.andExpect(jsonPath("$.data.status").value("processing"))
.andExpect(jsonPath("$.data.result").isEmpty()).andExpect(jsonPath("$.data.match").isEmpty());
assertThat(jdbc.queryForObject("SELECT result_json FROM robot_demand_analysis", String.class)).isEqualTo("{}");
@@ -445,7 +457,7 @@ class DemandFlowApiTest {
mvc.perform(asyncDispatch(pending)).andExpect(status().isOk());
assertThat(pending.getResponse().getContentAsString()).contains("event:analysis.failed").doesNotContain("event:analysis.completed");
String id = jdbc.queryForObject("SELECT analysis_code FROM robot_demand_analysis", String.class);
mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk())
mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk())
.andExpect(jsonPath("$.data.status").value("failed"))
.andExpect(jsonPath("$.data.result").isEmpty()).andExpect(jsonPath("$.data.match").isEmpty());
assertThat(jdbc.queryForObject("SELECT result_json FROM robot_demand_analysis", String.class)).isEqualTo("{}");
@@ -469,7 +481,7 @@ class DemandFlowApiTest {
String id = jdbc.queryForObject("SELECT analysis_code FROM robot_demand_analysis", String.class);
assertThat(jdbc.queryForObject("SELECT result_json FROM robot_demand_analysis", String.class)).isEqualTo("{}");
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM robot_demand_match WHERE analysis_code=?", Integer.class, id)).isZero();
mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk())
mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk())
.andExpect(jsonPath("$.data.status").value("failed")).andExpect(jsonPath("$.data.match").isEmpty());
}
@@ -492,11 +504,11 @@ class DemandFlowApiTest {
for (jakarta.servlet.AsyncListener listener : context.getListeners()) {
listener.onError(new jakarta.servlet.AsyncEvent(context, pending.getRequest(), pending.getResponse(), new IOException("Stream disconnected")));
}
mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk())
mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk())
.andExpect(jsonPath("$.data.status").value("processing"));
} finally { release.countDown(); }
org.awaitility.Awaitility.await().atMost(5, TimeUnit.SECONDS).untilAsserted(() ->
mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk())
mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk())
.andExpect(jsonPath("$.data.status").value("ready"))
.andExpect(jsonPath("$.data.match.components.length()").value(2)));
org.mockito.Mockito.verify(model, org.mockito.Mockito.times(1)).analyze(anyList());
@@ -523,7 +535,7 @@ class DemandFlowApiTest {
assertThat(current.path("revision").asInt()).isEqualTo(2);
assertThat(current.path("match").path("assembly").path("status").asText()).isEqualTo("ready");
first.getAsyncResult(5000);
mvc.perform(get("/api/robot-analyses/" + old).cookie(session.cookie())).andExpect(status().isOk())
mvc.perform(get("/api/robot-analyses/" + old).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk())
.andExpect(jsonPath("$.data.status").value("superseded")).andExpect(jsonPath("$.data.match").isEmpty());
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM robot_demand_match", Integer.class)).isEqualTo(1);
assertThat(jdbc.queryForObject("SELECT revision FROM robot_demand_match", Integer.class)).isEqualTo(2);
@@ -723,7 +735,7 @@ class DemandFlowApiTest {
@Test void expiredConversationsCleanOnlyOwnedDemandRowsAndPrivateFiles() throws Exception {
Session expired = create(); Session active = create();
JsonNode file = data(mvc.perform(multipart("/api/robot-conversations/" + expired.id() + "/attachments").file(image()).cookie(expired.cookie())).andExpect(status().isOk()).andReturn());
JsonNode file = data(mvc.perform(multipart("/api/robot-conversations/" + expired.id() + "/attachments").file(image()).header("Authorization", "Bearer " + expired.token())).andExpect(status().isOk()).andReturn());
Path saved = DIRECTORY.resolve(file.path("attachmentId").asText() + ".bin");
assertThat(saved).exists();
submit(expired, "m1", TEXT, List.of());
@@ -740,7 +752,7 @@ class DemandFlowApiTest {
result.getAsyncResult(10000); mvc.perform(asyncDispatch(result)).andExpect(status().isOk());
assertThat(result.getResponse().getContentAsString()).contains("event:analysis.failed", "DEMAND_INVALID_OUTPUT").doesNotContain("伪造用户证据");
String analysis = jdbc.queryForObject("SELECT analysis_code FROM robot_demand_analysis WHERE conversation_code=?", String.class, session.id());
mvc.perform(get("/api/robot-analyses/" + analysis).cookie(session.cookie())).andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("failed")).andExpect(jsonPath("$.data.result").isEmpty());
mvc.perform(get("/api/robot-analyses/" + analysis).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("failed")).andExpect(jsonPath("$.data.result").isEmpty());
}
@Test void newMessageInvalidatesOldRobotAndMessageReplayDoesNotCreateRevision() throws Exception {
@@ -753,26 +765,62 @@ class DemandFlowApiTest {
org.mockito.Mockito.verify(matches, org.mockito.Mockito.times(1)).match(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any());
assertThat(jdbc.queryForObject("SELECT revision FROM robot_demand_conversation WHERE conversation_code=?", Integer.class, session.id())).isEqualTo(1);
submit(session, "m2", TEXT, List.of());
mvc.perform(get("/api/robot-analyses/" + first.path("analysisId").asText()).cookie(session.cookie()))
mvc.perform(get("/api/robot-analyses/" + first.path("analysisId").asText()).header("Authorization", "Bearer " + session.token()))
.andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("superseded")).andExpect(jsonPath("$.data.canSubmit").value(false))
.andExpect(jsonPath("$.data.result").isEmpty()).andExpect(jsonPath("$.data.match").isEmpty());
}
@Test void anonymousOwnersCannotAccessOtherVisitorsTasksOrAttachments() throws Exception {
@Test void accountsCannotAccessOtherUsersTasksOrAttachments() throws Exception {
Session first = create(); Session other = create();
JsonNode analysis = submit(first, "m1", TEXT, List.of());
mvc.perform(get("/api/robot-analyses/" + analysis.path("analysisId").asText()).cookie(other.cookie())).andExpect(status().isNotFound());
mvc.perform(post("/api/robot-analyses/" + analysis.path("analysisId").asText() + "/retry").cookie(other.cookie()))
mvc.perform(get("/api/robot-analyses/" + analysis.path("analysisId").asText()).header("Authorization", "Bearer " + other.token())).andExpect(status().isNotFound());
mvc.perform(post("/api/robot-analyses/" + analysis.path("analysisId").asText() + "/retry").header("Authorization", "Bearer " + other.token()))
.andExpect(status().isNotFound());
mvc.perform(delete("/api/robot-analyses/" + analysis.path("analysisId").asText()).cookie(other.cookie()))
mvc.perform(delete("/api/robot-analyses/" + analysis.path("analysisId").asText()).header("Authorization", "Bearer " + other.token()))
.andExpect(status().isNotFound());
mvc.perform(multipart("/api/robot-conversations/" + first.id() + "/attachments").file(image()).cookie(other.cookie())).andExpect(status().isNotFound());
mvc.perform(multipart("/api/robot-conversations/" + first.id() + "/attachments").file(image()).header("Authorization", "Bearer " + other.token())).andExpect(status().isNotFound());
}
@Test void sameAccountCanAccessConversationAndImagesWithAnotherToken() throws Exception {
Session first = create();
JsonNode file = data(mvc.perform(multipart("/api/robot-conversations/" + first.id() + "/attachments")
.file(image()).header("Authorization", "Bearer " + first.token())).andExpect(status().isOk()).andReturn());
JsonNode analysis = submit(first, "m1", TEXT, List.of());
String secondToken = tokens.issue(tokens.resolve(first.token()));
tokens.revoke(first.token());
mvc.perform(get("/api/robot-analyses/" + analysis.path("analysisId").asText())
.header("Authorization", "Bearer " + secondToken))
.andExpect(status().isOk()).andExpect(jsonPath("$.data.analysisId").value(analysis.path("analysisId").asText()));
mvc.perform(get(file.path("previewUrl").asText()).header("Authorization", "Bearer " + secondToken)).andExpect(status().isOk());
String owner = java.util.HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256")
.digest(("user:" + tokens.resolve(secondToken)).getBytes(java.nio.charset.StandardCharsets.US_ASCII)));
assertThat(jdbc.queryForObject("SELECT owner_hash FROM robot_demand_conversation WHERE conversation_code=?",
String.class, first.id())).isEqualTo(owner);
}
@Test void legacyAnonymousCookieDoesNotClaimHistoricalConversation() throws Exception {
String visitor = "A".repeat(43);
String owner = java.util.HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256")
.digest(visitor.getBytes(java.nio.charset.StandardCharsets.US_ASCII)));
String conversation = repository.create(owner).conversationId();
Session user = create();
mvc.perform(get("/api/robot-conversations/" + conversation + "/attachments/DA-MISSING")
.cookie(new jakarta.servlet.http.Cookie("cadworld_demand_visitor", visitor))
.header("Authorization", "Bearer " + user.token()))
.andExpect(status().isNotFound());
mvc.perform(post("/api/robot-conversations/" + conversation + "/messages")
.cookie(new jakarta.servlet.http.Cookie("cadworld_demand_visitor", visitor))
.header("Authorization", "Bearer " + user.token()).contentType(MediaType.APPLICATION_JSON)
.content(json.writeValueAsBytes(Map.of("messageId", "m1", "text", TEXT, "attachmentIds", List.of()))))
.andExpect(status().isNotFound());
assertThat(jdbc.queryForObject("SELECT owner_hash FROM robot_demand_conversation WHERE conversation_code=?",
String.class, conversation)).isEqualTo(owner);
}
@Test void imageOnlyMessagesUseOwnedPrivateAttachmentsAndPreserveOcrSources() throws Exception {
components(true, 20);
Session session = create();
MvcResult uploaded = mvc.perform(multipart("/api/robot-conversations/" + session.id() + "/attachments").file(image()).cookie(session.cookie())).andExpect(status().isOk()).andReturn();
MvcResult uploaded = mvc.perform(multipart("/api/robot-conversations/" + session.id() + "/attachments").file(image()).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()).andReturn();
JsonNode file = data(uploaded);
String id = file.path("attachmentId").asText();
doAnswer(invocation -> {
@@ -790,8 +838,8 @@ class DemandFlowApiTest {
assertThat(completed.path("match").path("assembly").path("status").asText()).isEqualTo("ready");
assertThat(completed.path("result").path("request").path("userInput").asText()).isEqualTo("[图片:" + id + "]");
assertThat(completed.path("result").path("analysis").path("observations").get(0).path("kind").asText()).isEqualTo("image_text");
mvc.perform(get(file.path("previewUrl").asText()).cookie(session.cookie())).andExpect(status().isOk());
mvc.perform(get(file.path("previewUrl").asText()).cookie(create().cookie())).andExpect(status().isNotFound());
mvc.perform(get(file.path("previewUrl").asText()).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk());
mvc.perform(get(file.path("previewUrl").asText()).header("Authorization", "Bearer " + create().token())).andExpect(status().isNotFound());
}
@Test void missingUnitsGeneratePartialAssemblyAndLaterUserEditsApplyWithoutQuestions() throws Exception {
@@ -839,11 +887,11 @@ class DemandFlowApiTest {
MvcResult pending = message(session, "m1", TEXT, List.of());
assertThat(entered.await(5, TimeUnit.SECONDS)).isTrue();
String id = jdbc.queryForObject("SELECT analysis_code FROM robot_demand_analysis WHERE conversation_code=?", String.class, session.id());
mvc.perform(delete("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("cancelled")).andExpect(jsonPath("$.data.canSubmit").value(false));
mvc.perform(delete("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("cancelled")).andExpect(jsonPath("$.data.canSubmit").value(false));
assertThat(exited.await(5, TimeUnit.SECONDS)).isTrue();
pending.getAsyncResult(5000);
doAnswer(invocation -> raw(invocation.getArgument(0))).when(model).analyze(anyList());
MvcResult retry = mvc.perform(post("/api/robot-analyses/" + id + "/retry").cookie(session.cookie())).andExpect(status().isOk()).andReturn();
MvcResult retry = mvc.perform(post("/api/robot-analyses/" + id + "/retry").header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()).andReturn();
JsonNode result = completed(retry);
assertThat(result.path("analysisId").asText()).isEqualTo(id);
assertThat(result.path("status").asText()).isEqualTo("ready");
@@ -880,31 +928,31 @@ class DemandFlowApiTest {
JsonNode refreshed = regenerated.path("match");
assertThat(refreshed.path("matchId").asText()).isNotEqualTo(original.path("matchId").asText());
assertThat(refreshed.path("components").get(1).path("component").path("version").asInt()).isEqualTo(2);
mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk())
mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk())
.andExpect(jsonPath("$.data.status").value("superseded")).andExpect(jsonPath("$.data.match").isEmpty());
org.mockito.Mockito.verify(model, org.mockito.Mockito.times(2)).analyze(anyList());
}
@Test void invalidPayloadsImagesAndPublicRuleDownloadsAreRejected() throws Exception {
Session session = create();
mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").cookie(session.cookie()).contentType(MediaType.APPLICATION_JSON).content("{\"messageId\":\"m1\",\"text\":\"abc\",\"role\":\"system\"}"))
mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").header("Authorization", "Bearer " + session.token()).contentType(MediaType.APPLICATION_JSON).content("{\"messageId\":\"m1\",\"text\":\"abc\",\"role\":\"system\"}"))
.andExpect(status().isUnprocessableEntity());
mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").cookie(session.cookie()).contentType(MediaType.APPLICATION_JSON).content("{\"messageId\":\"m1\",\"text\":\"\",\"attachmentIds\":[]}"))
mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").header("Authorization", "Bearer " + session.token()).contentType(MediaType.APPLICATION_JSON).content("{\"messageId\":\"m1\",\"text\":\"\",\"attachmentIds\":[]}"))
.andExpect(status().isUnprocessableEntity());
mvc.perform(multipart("/api/robot-conversations/" + session.id() + "/attachments").file(new MockMultipartFile("file", "fake.png", "image/png", "invalid".getBytes(java.nio.charset.StandardCharsets.UTF_8))).cookie(session.cookie()))
mvc.perform(multipart("/api/robot-conversations/" + session.id() + "/attachments").file(new MockMultipartFile("file", "fake.png", "image/png", "invalid".getBytes(java.nio.charset.StandardCharsets.UTF_8))).header("Authorization", "Bearer " + session.token()))
.andExpect(status().isUnprocessableEntity());
for (String path : List.of("/robot-demand/system-prompt.txt", "/robot-demand/model-output.schema.json", "/robot-demand/part-catalog.json")) mvc.perform(get(path)).andExpect(status().isNotFound());
}
private Session create() throws Exception {
MvcResult result = mvc.perform(post("/api/robot-conversations")).andExpect(status().isOk()).andReturn();
String header = result.getResponse().getHeader("Set-Cookie");
assertThat(header).contains("HttpOnly", "SameSite=Lax");
String[] pair = header.substring(0, header.indexOf(';')).split("=", 2);
return new Session(data(result).path("conversationId").asText(), new Cookie(pair[0], pair[1]));
String token = ApiAuthTestSupport.token(loginUsers, tokens);
MvcResult result = mvc.perform(post("/api/robot-conversations").header("Authorization", "Bearer " + token))
.andExpect(status().isOk()).andReturn();
assertThat(result.getResponse().getHeader("Set-Cookie")).isNull();
return new Session(data(result).path("conversationId").asText(), token);
}
private MvcResult message(Session session, String id, String text, List<String> images) throws Exception {
return mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").cookie(session.cookie()).contentType(MediaType.APPLICATION_JSON)
return mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").header("Authorization", "Bearer " + session.token()).contentType(MediaType.APPLICATION_JSON)
.content(json.writeValueAsBytes(Map.of("messageId", id, "text", text, "attachmentIds", images)))).andExpect(status().isOk()).andReturn();
}
private JsonNode submit(Session session, String id, String text, List<String> images) throws Exception { return completed(message(session, id, text, images)); }
@@ -919,7 +967,7 @@ class DemandFlowApiTest {
throw new AssertionError("No completed event: " + events);
}
private JsonNode generatedMatch(Session session, String id, int revision) throws Exception {
JsonNode generated = data(mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie()))
JsonNode generated = data(mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token()))
.andExpect(status().isOk()).andReturn());
assertThat(generated.path("revision").asInt()).isEqualTo(revision);
return generated.path("match");
@@ -1021,5 +1069,5 @@ class DemandFlowApiTest {
try (java.util.stream.Stream<Path> paths = Files.list(DIRECTORY)) { for (Path path : paths.toList()) Files.deleteIfExists(path); }
Files.deleteIfExists(DIRECTORY);
}
private record Session(String id, Cookie cookie) { }
private record Session(String id, String token) { }
}
@@ -5,10 +5,13 @@ import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linkerbot.cadworld.common.web.RequestIdFilter;
import com.linkerbot.cadworld.config.MatchingProperties;
import com.linkerbot.cadworld.dto.matching.RobotMatchRequest;
import com.linkerbot.cadworld.dto.matching.RobotMatchResponse;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.AdminOperatorProvider;
import com.linkerbot.cadworld.service.auth.LoginUserService;
import com.linkerbot.cadworld.service.client.ObjectStorageClient;
import com.linkerbot.cadworld.service.matching.AssemblySearchEngine;
import com.linkerbot.cadworld.service.matching.PublicComponentQueryService;
@@ -33,8 +36,11 @@ import org.springframework.http.MediaType;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
@@ -46,9 +52,12 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
"spring.datasource.password=", "spring.sql.init.mode=never",
"app.storage.public-base-url=https://models.example.test", "logging.file.path=target/test-logs"
})
@AutoConfigureMockMvc
@AutoConfigureMockMvc(print = org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrint.NONE)
class MatchingApiTest {
@Autowired private MockMvc mvc;
@Autowired private WebApplicationContext webContext;
@Autowired private LoginUserService loginUsers;
@Autowired private TokenService tokens;
@Autowired private ObjectMapper json;
@Autowired private JdbcTemplate jdbc;
@Autowired private ApplicationContext context;
@@ -79,6 +88,10 @@ class MatchingApiTest {
updated_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP)
""");
jdbc.update("DELETE FROM component");
ApiAuthTestSupport.createSchema(jdbc);
mvc = MockMvcBuilders.webAppContextSetup(webContext).apply(springSecurity())
.addFilters(new RequestIdFilter())
.defaultRequest(get("/").header("Authorization", "Bearer " + ApiAuthTestSupport.token(loginUsers, tokens))).build();
}
@Test
@@ -47,7 +47,7 @@ class ApiCorsConfigurationTest {
for (String method : List.of("GET", "POST", "DELETE")) {
mvc.perform(options("/api/cors-probe").header(HttpHeaders.ORIGIN, allowedOrigin)
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, method)
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "content-type,x-request-id"))
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "content-type,x-request-id,authorization"))
.andExpect(status().isOk())
.andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, allowedOrigin))
.andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true"))
@@ -0,0 +1,8 @@
package com.linkerbot.cadworld.dto.auth;
public record CaptchaResponse(String captchaCode, String image, long expiresIn) {
@Override
public String toString() {
return "CaptchaResponse[expiresIn=" + expiresIn + "]";
}
}
@@ -0,0 +1,20 @@
package com.linkerbot.cadworld.dto.auth;
import com.linkerbot.cadworld.common.util.EmailAddresses;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
public record LoginRequest(
@NotBlank @Email(message = "邮箱格式不正确") @Size(max = 254) String email,
@NotBlank @Size(max = 64) String captchaCode,
@NotBlank @Size(max = 32) String captchaAnswer) {
public LoginRequest {
email = EmailAddresses.normalize(email);
}
@Override
public String toString() {
return "LoginRequest[redacted]";
}
}
@@ -0,0 +1,8 @@
package com.linkerbot.cadworld.dto.auth;
public record LoginResponse(String token, String tokenType, long expiresIn, LoginUserResponse user) {
@Override
public String toString() {
return "LoginResponse[tokenType=" + tokenType + ", expiresIn=" + expiresIn + "]";
}
}
@@ -0,0 +1,4 @@
package com.linkerbot.cadworld.dto.auth;
public record LoginUserResponse(String userCode, String nickname, String email) {
}
@@ -1,15 +1,19 @@
package com.linkerbot.cadworld.dto.user;
import com.linkerbot.cadworld.common.util.EmailAddresses;
import com.linkerbot.cadworld.enums.UserStatus;
import com.linkerbot.cadworld.enums.UserType;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;
public record SaveUserRequest(
@NotBlank @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确") String phone,
@NotBlank @Email(message = "邮箱格式不正确") @Size(max = 254) String email,
@NotBlank @Size(max = 64) String nickname,
UserStatus status,
UserType userType
) {
public SaveUserRequest {
email = EmailAddresses.normalize(email);
}
}
@@ -4,6 +4,6 @@ import com.linkerbot.cadworld.enums.UserStatus;
import com.linkerbot.cadworld.enums.UserType;
import java.time.LocalDateTime;
public record UserResponse(Long id, String phone, String nickname, UserStatus status, UserType userType,
public record UserResponse(Long id, String userCode, String email, String nickname, UserStatus status, UserType userType,
LocalDateTime createdAt, LocalDateTime updatedAt) {
}
@@ -1,6 +1,8 @@
package com.linkerbot.cadworld.entity;
import com.baomidou.mybatisplus.annotation.FieldStrategy;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.linkerbot.cadworld.enums.UserStatus;
@@ -16,7 +18,10 @@ public class SysUser extends BaseEntity {
@TableId(type = IdType.AUTO)
private Long id;
private String phone;
@TableField(updateStrategy = FieldStrategy.NEVER)
private String userCode;
private String email;
private String nickname;
@@ -24,6 +29,4 @@ public class SysUser extends BaseEntity {
private UserType userType;
@com.baomidou.mybatisplus.annotation.TableLogic
private Integer deleted;
}
@@ -0,0 +1,12 @@
package com.linkerbot.cadworld.common.util;
import java.util.Locale;
public final class EmailAddresses {
private EmailAddresses() {
}
public static String normalize(String email) {
return email == null ? null : email.trim().toLowerCase(Locale.ROOT);
}
}
@@ -14,4 +14,16 @@
<artifactId>cadworld-security-admin</artifactId>
<packaging>jar</packaging>
<name>cadworld-security-admin</name>
<dependencies>
<dependency>
<groupId>com.linkerbot</groupId>
<artifactId>cadworld-service</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.linkerbot</groupId>
<artifactId>cadworld-security-common</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
</project>
@@ -0,0 +1,67 @@
package com.linkerbot.cadworld.security.admin;
import com.linkerbot.cadworld.common.api.RequestIdHolder;
import com.linkerbot.cadworld.common.exception.BizException;
import com.linkerbot.cadworld.entity.SysUser;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.auth.AdminLoginService;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.context.SecurityContextRepository;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.web.servlet.HandlerExceptionResolver;
@Slf4j
@RequiredArgsConstructor
public class AdminBearerTokenFilter extends OncePerRequestFilter {
private final TokenService tokens;
private final AdminLoginService users;
private final SecurityContextRepository contexts;
private final HandlerExceptionResolver exceptions;
@Override
protected boolean shouldNotFilter(HttpServletRequest request) {
String path = request.getRequestURI().substring(request.getContextPath().length());
return "OPTIONS".equals(request.getMethod())
|| ("GET".equals(request.getMethod()) && "/admin-api/auth/captcha".equals(path))
|| ("POST".equals(request.getMethod()) && "/admin-api/auth/login".equals(path));
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
throws ServletException, IOException {
String header = request.getHeader(HttpHeaders.AUTHORIZATION);
if (header != null) {
try {
String token = header.startsWith("Bearer ") ? header.substring(7) : null;
String userCode = tokens.resolve(token);
if (userCode == null) throw new BizException(401, "UNAUTHORIZED", "登录已失效,请重新登录");
SysUser user = users.requireActive(userCode);
SecurityContext context = SecurityContextHolder.createEmptyContext();
context.setAuthentication(new UsernamePasswordAuthenticationToken(
new CurrentAdmin.Principal(user.getId(), user.getUserCode(), user.getNickname()), null,
List.of(new SimpleGrantedAuthority("ROLE_ADMIN"))));
SecurityContextHolder.setContext(context);
contexts.saveContext(context, request, response);
} catch (RuntimeException exception) {
SecurityContextHolder.clearContext();
String reason = exception instanceof BizException business ? business.getCode() : exception.getClass().getSimpleName();
log.warn("管理员认证失败 method={} reason={} requestId={}", request.getMethod(), reason, RequestIdHolder.get());
if (exceptions.resolveException(request, response, null, exception) == null) throw exception;
return;
}
}
chain.doFilter(request, response);
}
}
@@ -0,0 +1,80 @@
package com.linkerbot.cadworld.security.admin;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linkerbot.cadworld.common.api.ApiResponse;
import com.linkerbot.cadworld.common.api.RequestIdHolder;
import com.linkerbot.cadworld.security.common.AuthProperties;
import com.linkerbot.cadworld.security.common.CaptchaService;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.auth.AdminLoginService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.context.RequestAttributeSecurityContextRepository;
import org.springframework.security.web.context.SecurityContextRepository;
import org.springframework.web.servlet.HandlerExceptionResolver;
@Slf4j
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(AuthProperties.class)
public class AdminSecurityConfiguration {
@Bean CaptchaService captchaService(AuthProperties properties) { return new CaptchaService(properties); }
@Bean TokenService tokenService(AuthProperties properties) { return new TokenService(properties); }
@Bean SecurityContextRepository securityContextRepository() { return new RequestAttributeSecurityContextRepository(); }
@Bean
AdminBearerTokenFilter adminBearerTokenFilter(TokenService tokens, AdminLoginService users, SecurityContextRepository contexts,
@Qualifier("handlerExceptionResolver") HandlerExceptionResolver exceptions) {
return new AdminBearerTokenFilter(tokens, users, contexts, exceptions);
}
@Bean
FilterRegistrationBean<AdminBearerTokenFilter> disableAdminServletRegistration(AdminBearerTokenFilter filter) {
FilterRegistrationBean<AdminBearerTokenFilter> registration = new FilterRegistrationBean<>(filter);
registration.setEnabled(false);
return registration;
}
@Bean
SecurityFilterChain adminSecurityFilterChain(HttpSecurity http, AdminBearerTokenFilter filter, ObjectMapper json,
SecurityContextRepository contexts) throws Exception {
http.securityMatcher("/admin-api/**")
.cors(Customizer.withDefaults())
.csrf(csrf -> csrf.disable())
.sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.securityContext(context -> context.securityContextRepository(contexts))
.requestCache(cache -> cache.disable())
.formLogin(form -> form.disable()).httpBasic(basic -> basic.disable()).logout(logout -> logout.disable())
.authorizeHttpRequests(auth -> auth
.requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
.requestMatchers(HttpMethod.GET, "/admin-api/auth/captcha").permitAll()
.requestMatchers(HttpMethod.POST, "/admin-api/auth/login").permitAll()
.anyRequest().hasRole("ADMIN"))
.exceptionHandling(errors -> errors
.authenticationEntryPoint((request, response, exception) -> {
log.warn("管理员认证失败 method={} reason=UNAUTHORIZED requestId={}", request.getMethod(), RequestIdHolder.get());
response.setStatus(401);
response.setContentType("application/json;charset=UTF-8");
request.setAttribute("cadworld.runtimeLogResultCode", "UNAUTHORIZED");
json.writeValue(response.getOutputStream(), ApiResponse.failure("UNAUTHORIZED", "请先登录管理端"));
})
.accessDeniedHandler((request, response, exception) -> {
log.warn("管理员访问拒绝 method={} reason=FORBIDDEN requestId={}", request.getMethod(), RequestIdHolder.get());
response.setStatus(403);
response.setContentType("application/json;charset=UTF-8");
request.setAttribute("cadworld.runtimeLogResultCode", "FORBIDDEN");
json.writeValue(response.getOutputStream(), ApiResponse.failure("FORBIDDEN", "无管理端访问权限"));
}))
.addFilterBefore(filter, UsernamePasswordAuthenticationFilter.class);
return http.build();
}
}
@@ -0,0 +1,13 @@
package com.linkerbot.cadworld.security.admin;
import com.linkerbot.cadworld.service.AdminOperatorProvider;
import org.springframework.stereotype.Component;
@Component
public class AuthenticatedAdminOperatorProvider implements AdminOperatorProvider {
@Override
public Long userId() { return CurrentAdmin.required().userId(); }
@Override
public String name() { return CurrentAdmin.required().nickname(); }
}
@@ -0,0 +1,21 @@
package com.linkerbot.cadworld.security.admin;
import com.linkerbot.cadworld.common.exception.BizException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
public final class CurrentAdmin {
private CurrentAdmin() {
}
/** 主键仅用于服务端上传会话和审计,不作为接口响应。 */
public record Principal(Long userId, String userCode, String nickname) {
}
public static Principal required() {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
if (authentication != null && authentication.isAuthenticated()
&& authentication.getPrincipal() instanceof Principal principal) return principal;
throw new BizException(401, "UNAUTHORIZED", "请先登录管理端");
}
}
@@ -14,4 +14,16 @@
<artifactId>cadworld-security-api</artifactId>
<packaging>jar</packaging>
<name>cadworld-security-api</name>
<dependencies>
<dependency>
<groupId>com.linkerbot</groupId>
<artifactId>cadworld-service</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.linkerbot</groupId>
<artifactId>cadworld-security-common</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
</project>
@@ -0,0 +1,77 @@
package com.linkerbot.cadworld.security.api;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linkerbot.cadworld.common.api.ApiResponse;
import com.linkerbot.cadworld.common.api.RequestIdHolder;
import com.linkerbot.cadworld.security.common.AuthProperties;
import com.linkerbot.cadworld.security.common.CaptchaService;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.auth.LoginUserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.context.RequestAttributeSecurityContextRepository;
import org.springframework.security.web.context.SecurityContextRepository;
import org.springframework.web.servlet.HandlerExceptionResolver;
@Slf4j
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(AuthProperties.class)
public class ApiSecurityConfiguration {
@Bean CaptchaService captchaService(AuthProperties properties) { return new CaptchaService(properties); }
@Bean TokenService tokenService(AuthProperties properties) { return new TokenService(properties); }
@Bean SecurityContextRepository securityContextRepository() { return new RequestAttributeSecurityContextRepository(); }
@Bean
BearerTokenFilter bearerTokenFilter(TokenService tokens, LoginUserService users, SecurityContextRepository contexts,
@Qualifier("handlerExceptionResolver") HandlerExceptionResolver exceptions) {
return new BearerTokenFilter(tokens, users, contexts, exceptions);
}
@Bean
FilterRegistrationBean<BearerTokenFilter> disableServletRegistration(BearerTokenFilter filter) {
FilterRegistrationBean<BearerTokenFilter> registration = new FilterRegistrationBean<>(filter);
registration.setEnabled(false);
return registration;
}
@Bean
SecurityFilterChain apiSecurityFilterChain(HttpSecurity http, BearerTokenFilter filter, ObjectMapper json,
SecurityContextRepository contexts) throws Exception {
http.securityMatcher("/api/**")
.cors(cors -> { })
.csrf(csrf -> csrf.disable())
.sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.securityContext(context -> context.securityContextRepository(contexts))
.requestCache(cache -> cache.disable())
.formLogin(form -> form.disable()).httpBasic(basic -> basic.disable()).logout(logout -> logout.disable())
.authorizeHttpRequests(auth -> auth
.requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
.requestMatchers(HttpMethod.GET, "/api/auth/captcha").permitAll()
.requestMatchers(HttpMethod.POST, "/api/auth/login").permitAll()
.anyRequest().authenticated())
.exceptionHandling(errors -> errors
.authenticationEntryPoint((request, response, exception) -> {
log.warn("用户认证失败 method={} reason=UNAUTHORIZED requestId={}", request.getMethod(), RequestIdHolder.get());
response.setStatus(401);
response.setContentType("application/json;charset=UTF-8");
json.writeValue(response.getOutputStream(), ApiResponse.failure("UNAUTHORIZED", "请先登录"));
})
.accessDeniedHandler((request, response, exception) -> {
log.warn("用户访问拒绝 method={} reason=FORBIDDEN requestId={}", request.getMethod(), RequestIdHolder.get());
response.setStatus(403);
response.setContentType("application/json;charset=UTF-8");
json.writeValue(response.getOutputStream(), ApiResponse.failure("FORBIDDEN", "无权访问"));
}))
.addFilterBefore(filter, UsernamePasswordAuthenticationFilter.class);
return http.build();
}
}
@@ -0,0 +1,65 @@
package com.linkerbot.cadworld.security.api;
import com.linkerbot.cadworld.common.api.RequestIdHolder;
import com.linkerbot.cadworld.common.exception.BizException;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.auth.LoginUserService;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.context.SecurityContextRepository;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.web.servlet.HandlerExceptionResolver;
@Slf4j
@RequiredArgsConstructor
public class BearerTokenFilter extends OncePerRequestFilter {
private final TokenService tokens;
private final LoginUserService users;
private final SecurityContextRepository contexts;
private final HandlerExceptionResolver exceptions;
@Override
protected boolean shouldNotFilter(HttpServletRequest request) {
String path = request.getRequestURI().substring(request.getContextPath().length());
return "OPTIONS".equals(request.getMethod())
|| ("GET".equals(request.getMethod()) && "/api/auth/captcha".equals(path))
|| ("POST".equals(request.getMethod()) && "/api/auth/login".equals(path));
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
throws ServletException, IOException {
String header = request.getHeader(HttpHeaders.AUTHORIZATION);
if (header != null) {
try {
String token = header.startsWith("Bearer ") ? header.substring(7) : null;
String userCode = tokens.resolve(token);
if (userCode == null) throw new BizException(401, "UNAUTHORIZED", "登录已失效,请重新登录");
users.requireActive(userCode);
SecurityContext context = SecurityContextHolder.createEmptyContext();
context.setAuthentication(new UsernamePasswordAuthenticationToken(new CurrentUser.Principal(userCode), null,
List.of(new SimpleGrantedAuthority("ROLE_USER"))));
SecurityContextHolder.setContext(context);
contexts.saveContext(context, request, response);
} catch (RuntimeException exception) {
SecurityContextHolder.clearContext();
String reason = exception instanceof BizException business ? business.getCode() : exception.getClass().getSimpleName();
log.warn("用户认证失败 method={} reason={} requestId={}", request.getMethod(), reason, RequestIdHolder.get());
if (exceptions.resolveException(request, response, null, exception) == null) throw exception;
return;
}
}
chain.doFilter(request, response);
}
}
@@ -0,0 +1,20 @@
package com.linkerbot.cadworld.security.api;
import com.linkerbot.cadworld.common.exception.BizException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
public final class CurrentUser {
private CurrentUser() {
}
public record Principal(String userCode) {
}
public static String required() {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
if (authentication != null && authentication.isAuthenticated()
&& authentication.getPrincipal() instanceof Principal principal) return principal.userCode();
throw new BizException(401, "UNAUTHORIZED", "请先登录");
}
}
@@ -14,4 +14,19 @@
<artifactId>cadworld-security-common</artifactId>
<packaging>jar</packaging>
<name>cadworld-security-common</name>
<dependencies>
<dependency>
<groupId>com.linkerbot</groupId>
<artifactId>cadworld-bean</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
</dependency>
</dependencies>
</project>
@@ -0,0 +1,19 @@
package com.linkerbot.cadworld.security.common;
import jakarta.validation.constraints.AssertTrue;
import java.time.Duration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.bind.DefaultValue;
import org.springframework.validation.annotation.Validated;
@Validated
@ConfigurationProperties(prefix = "app.auth")
public record AuthProperties(
@DefaultValue("PT2M") Duration captchaTtl,
@DefaultValue("PT24H") Duration tokenTtl) {
@AssertTrue(message = "验证码和登录态有效期必须至少为1秒")
public boolean isDurationValid() {
return captchaTtl != null && captchaTtl.compareTo(Duration.ofSeconds(1)) >= 0
&& tokenTtl != null && tokenTtl.compareTo(Duration.ofSeconds(1)) >= 0;
}
}
@@ -0,0 +1,87 @@
package com.linkerbot.cadworld.security.common;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.Ticker;
import com.linkerbot.cadworld.common.api.RequestIdHolder;
import com.linkerbot.cadworld.common.exception.BizException;
import com.linkerbot.cadworld.dto.auth.CaptchaResponse;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.Locale;
import java.util.UUID;
import javax.imageio.ImageIO;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class CaptchaService {
private static final String ALPHABET = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
private final SecureRandom random = new SecureRandom();
private final Cache<String, String> challenges;
private final AuthProperties properties;
public CaptchaService(AuthProperties properties) {
this(properties, Ticker.systemTicker());
}
CaptchaService(AuthProperties properties, Ticker ticker) {
this.properties = properties;
challenges = Caffeine.newBuilder().maximumSize(10000)
.expireAfterWrite(properties.captchaTtl()).ticker(ticker).build();
}
protected String generateAnswer() {
StringBuilder answer = new StringBuilder(5);
for (int index = 0; index < 5; index++) answer.append(ALPHABET.charAt(random.nextInt(ALPHABET.length())));
return answer.toString();
}
public CaptchaResponse issue() {
String answer = generateAnswer();
BufferedImage image = new BufferedImage(180, 60, BufferedImage.TYPE_INT_RGB);
Graphics2D graphics = image.createGraphics();
try {
graphics.setColor(new Color(245, 247, 250));
graphics.fillRect(0, 0, 180, 60);
for (int index = 0; index < 10; index++) {
graphics.setColor(new Color(random.nextInt(160), random.nextInt(160), random.nextInt(160)));
graphics.drawLine(random.nextInt(180), random.nextInt(60), random.nextInt(180), random.nextInt(60));
}
graphics.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 30));
for (int index = 0; index < answer.length(); index++) {
graphics.setColor(new Color(random.nextInt(100), random.nextInt(100), random.nextInt(100)));
graphics.drawString(String.valueOf(answer.charAt(index)), 15 + index * 30, 38 + random.nextInt(8));
}
} finally {
graphics.dispose();
}
try (ByteArrayOutputStream bytes = new ByteArrayOutputStream()) {
if (!ImageIO.write(image, "png", bytes)) throw new IOException("PNG writer unavailable");
String code = UUID.randomUUID().toString().replace("-", "");
challenges.put(code, answer);
log.debug("图片验证码生成成功 requestId={}", RequestIdHolder.get());
return new CaptchaResponse(code, "data:image/png;base64," + Base64.getEncoder().encodeToString(bytes.toByteArray()),
properties.captchaTtl().toSeconds());
} catch (IOException exception) {
log.error("图片验证码生成失败 requestId={}", RequestIdHolder.get(), exception);
throw new BizException(500, "CAPTCHA_ERROR", "验证码生成失败");
}
}
public void verify(String code, String answer) {
String expected = code == null ? null : challenges.asMap().remove(code);
String actual = answer == null ? "" : answer.trim().toUpperCase(Locale.ROOT);
if (expected == null || !MessageDigest.isEqual(expected.getBytes(StandardCharsets.US_ASCII), actual.getBytes(StandardCharsets.UTF_8))) {
log.warn("图片验证码校验失败 reason=CAPTCHA_INVALID requestId={}", RequestIdHolder.get());
throw new BizException(400, "CAPTCHA_INVALID", "图片验证码错误、已使用或已过期");
}
}
}
@@ -0,0 +1,36 @@
package com.linkerbot.cadworld.security.common;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.Ticker;
import java.security.SecureRandom;
import java.util.Base64;
public class TokenService {
private final SecureRandom random = new SecureRandom();
private final Cache<String, String> sessions;
public TokenService(AuthProperties properties) {
this(properties, Ticker.systemTicker());
}
TokenService(AuthProperties properties, Ticker ticker) {
sessions = Caffeine.newBuilder().maximumSize(10000).expireAfterWrite(properties.tokenTtl()).ticker(ticker).build();
}
public String issue(String userCode) {
byte[] bytes = new byte[32];
random.nextBytes(bytes);
String token = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
sessions.put(token, userCode);
return token;
}
public String resolve(String token) {
return token == null ? null : sessions.getIfPresent(token);
}
public void revoke(String token) {
if (token != null) sessions.invalidate(token);
}
}
@@ -0,0 +1,37 @@
package com.linkerbot.cadworld.security.common;
import java.time.Duration;
import org.junit.jupiter.api.Test;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.context.annotation.Configuration;
import static org.assertj.core.api.Assertions.assertThat;
class AuthPropertiesTest {
private final ApplicationContextRunner runner = new ApplicationContextRunner().withUserConfiguration(ConfigurationUnderTest.class);
@Test
void defaultsAndOverridesBind() {
runner.run(context -> {
assertThat(context).hasNotFailed();
assertThat(context.getBean(AuthProperties.class).captchaTtl()).isEqualTo(Duration.ofMinutes(2));
assertThat(context.getBean(AuthProperties.class).tokenTtl()).isEqualTo(Duration.ofHours(24));
});
runner.withPropertyValues("app.auth.captcha-ttl=PT30S", "app.auth.token-ttl=PT2H").run(context -> {
assertThat(context).hasNotFailed();
assertThat(context.getBean(AuthProperties.class).tokenTtl()).isEqualTo(Duration.ofHours(2));
});
}
@Test
void invalidTtlFailsStartup() {
runner.withPropertyValues("app.auth.captcha-ttl=PT0S").run(context -> assertThat(context).hasFailed());
runner.withPropertyValues("app.auth.token-ttl=-PT1S").run(context -> assertThat(context).hasFailed());
}
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(AuthProperties.class)
static class ConfigurationUnderTest {
}
}
@@ -0,0 +1,104 @@
package com.linkerbot.cadworld.security.common;
import com.linkerbot.cadworld.common.exception.BizException;
import com.linkerbot.cadworld.dto.auth.CaptchaResponse;
import java.io.ByteArrayInputStream;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import javax.imageio.ImageIO;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
class SessionTest {
private final AuthProperties properties = new AuthProperties(Duration.ofMinutes(2), Duration.ofHours(24));
private final AtomicLong time = new AtomicLong();
private CaptchaService captcha() {
return new CaptchaService(properties, time::get) {
@Override protected String generateAnswer() { return "ABCDE"; }
};
}
@Test
void captchaIsDecodablePngAndCanOnlyBeConsumedOnce() throws Exception {
CaptchaService captcha = captcha();
CaptchaResponse response = captcha.issue();
assertThat(response.expiresIn()).isEqualTo(120);
assertThat(response.image()).startsWith("data:image/png;base64,");
byte[] png = Base64.getDecoder().decode(response.image().substring(response.image().indexOf(',') + 1));
assertThat(ImageIO.read(new ByteArrayInputStream(png)).getWidth()).isEqualTo(180);
captcha.verify(response.captchaCode(), " abcde ");
invalid(captcha, response.captchaCode(), "ABCDE");
invalid(captcha, "missing", "ABCDE");
invalid(captcha, null, null);
}
@Test
void wrongAnswerConsumesChallengeAndExpiredChallengeIsRejected() {
CaptchaService captcha = captcha();
String wrong = captcha.issue().captchaCode();
invalid(captcha, wrong, "WRONG");
invalid(captcha, wrong, "ABCDE");
String expired = captcha.issue().captchaCode();
time.addAndGet(Duration.ofMinutes(2).toNanos());
invalid(captcha, expired, "ABCDE");
}
@Test
void concurrentCaptchaVerificationHasExactlyOneWinner() throws Exception {
CaptchaService captcha = captcha();
String code = captcha.issue().captchaCode();
CountDownLatch start = new CountDownLatch(1);
List<Future<Boolean>> results = new ArrayList<>();
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int index = 0; index < 12; index++) results.add(executor.submit(() -> {
start.await();
try {
captcha.verify(code, "ABCDE");
return true;
} catch (BizException exception) {
assertThat(exception.getCode()).isEqualTo("CAPTCHA_INVALID");
return false;
}
}));
start.countDown();
int winners = 0;
for (Future<Boolean> result : results) if (result.get(5, TimeUnit.SECONDS)) winners++;
assertThat(winners).isEqualTo(1);
}
}
@Test
void tokensAreIndependentRandomAndExpireWithoutSlidingRenewal() {
TokenService tokens = new TokenService(properties, time::get);
String first = tokens.issue("USER");
String second = tokens.issue("USER");
assertThat(first).isNotEqualTo(second);
assertThat(Base64.getUrlDecoder().decode(first)).hasSize(32);
tokens.revoke(first);
assertThat(tokens.resolve(first)).isNull();
assertThat(tokens.resolve(second)).isEqualTo("USER");
time.addAndGet(Duration.ofHours(23).toNanos());
assertThat(tokens.resolve(second)).isEqualTo("USER");
time.addAndGet(Duration.ofHours(1).toNanos());
assertThat(tokens.resolve(second)).isNull();
assertThat(tokens.resolve(null)).isNull();
}
private void invalid(CaptchaService captcha, String code, String answer) {
assertThatThrownBy(() -> captcha.verify(code, answer)).isInstanceOfSatisfying(BizException.class, exception -> {
assertThat(exception.getHttpStatus()).isEqualTo(400);
assertThat(exception.getCode()).isEqualTo("CAPTCHA_INVALID");
});
}
}
@@ -1,12 +0,0 @@
package com.linkerbot.cadworld.config;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.validation.annotation.Validated;
@Validated
@ConfigurationProperties(prefix = "app.admin.operator")
public record AdminOperatorProperties(@Min(0) long id, @NotBlank @Size(max = 64) String name) {
}
@@ -1,15 +1,7 @@
package com.linkerbot.cadworld.service;
import com.linkerbot.cadworld.config.AdminOperatorProperties;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
/** A configured test identity, to be replaced when account authentication is enabled. */
@Component
@RequiredArgsConstructor
public class AdminOperatorProvider {
private final AdminOperatorProperties properties;
public Long userId() { return properties.id(); }
public String name() { return properties.name(); }
/** 管理端认证模块提供当前操作人,业务服务不依赖具体认证实现。 */
public interface AdminOperatorProvider {
Long userId();
String name();
}
@@ -0,0 +1,49 @@
package com.linkerbot.cadworld.service.auth;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.linkerbot.cadworld.common.api.RequestIdHolder;
import com.linkerbot.cadworld.common.exception.BizException;
import com.linkerbot.cadworld.common.util.EmailAddresses;
import com.linkerbot.cadworld.entity.SysUser;
import com.linkerbot.cadworld.enums.UserStatus;
import com.linkerbot.cadworld.enums.UserType;
import com.linkerbot.cadworld.mapper.SysUserMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@Slf4j
@Service
@RequiredArgsConstructor
public class AdminLoginService {
private final SysUserMapper users;
/** 管理端只接受预先授权的管理员,禁止通过登录入口注册或提升权限。 */
public SysUser login(String email) {
SysUser user = users.selectOne(new LambdaQueryWrapper<SysUser>()
.eq(SysUser::getEmail, EmailAddresses.normalize(email)));
if (user == null || user.getUserType() != UserType.ADMIN) {
log.warn("管理员登录拒绝 reason=ADMIN_ACCESS_DENIED requestId={}", RequestIdHolder.get());
throw forbidden();
}
if (user.getStatus() != UserStatus.ACTIVE) {
log.warn("管理员登录拒绝 userCode={} reason=ACCOUNT_DISABLED requestId={}", user.getUserCode(), RequestIdHolder.get());
throw new BizException(403, "ACCOUNT_DISABLED", "账号已禁用");
}
log.info("管理员登录成功 userCode={} requestId={}", user.getUserCode(), RequestIdHolder.get());
return user;
}
public SysUser requireActive(String userCode) {
SysUser user = users.selectOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUserCode, userCode));
if (user == null || user.getStatus() != UserStatus.ACTIVE) {
throw new BizException(401, "UNAUTHORIZED", "登录已失效,请重新登录");
}
if (user.getUserType() != UserType.ADMIN) throw forbidden();
return user;
}
private BizException forbidden() {
return new BizException(403, "ADMIN_ACCESS_DENIED", "该账号无管理端访问权限");
}
}
@@ -0,0 +1,77 @@
package com.linkerbot.cadworld.service.auth;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.linkerbot.cadworld.common.api.RequestIdHolder;
import com.linkerbot.cadworld.common.exception.BizException;
import com.linkerbot.cadworld.common.util.EmailAddresses;
import com.linkerbot.cadworld.dto.auth.LoginUserResponse;
import com.linkerbot.cadworld.entity.SysUser;
import com.linkerbot.cadworld.enums.UserStatus;
import com.linkerbot.cadworld.enums.UserType;
import com.linkerbot.cadworld.mapper.SysUserMapper;
import com.linkerbot.cadworld.service.support.UserCodes;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
@Slf4j
@Service
@RequiredArgsConstructor
public class LoginUserService {
private static final int MAX_CODE_ATTEMPTS = 5;
private final SysUserMapper users;
// 不开启外层事务:唯一索引冲突后的查询必须能看到并发请求已提交的用户。
public SysUser login(String email) {
String normalized = EmailAddresses.normalize(email);
SysUser user = findByEmail(normalized);
if (user == null) user = create(normalized);
if (user.getStatus() != UserStatus.ACTIVE) {
log.warn("用户登录拒绝 userCode={} reason=ACCOUNT_DISABLED requestId={}", user.getUserCode(), RequestIdHolder.get());
throw new BizException(403, "ACCOUNT_DISABLED", "账号已禁用");
}
log.info("用户登录成功 userCode={} requestId={}", user.getUserCode(), RequestIdHolder.get());
return user;
}
public SysUser requireActive(String userCode) {
SysUser user = users.selectOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUserCode, userCode));
if (user == null || user.getStatus() != UserStatus.ACTIVE) {
throw new BizException(401, "UNAUTHORIZED", "登录已失效,请重新登录");
}
return user;
}
public LoginUserResponse view(SysUser user) {
return new LoginUserResponse(user.getUserCode(), user.getNickname(), user.getEmail());
}
private SysUser create(String email) {
for (int attempt = 1; attempt <= MAX_CODE_ATTEMPTS; attempt++) {
SysUser candidate = new SysUser();
candidate.setUserCode(UserCodes.generate());
candidate.setEmail(email);
candidate.setNickname("用户_" + candidate.getUserCode().substring(0, 8));
candidate.setStatus(UserStatus.ACTIVE);
candidate.setUserType(UserType.NORMAL);
try {
users.insert(candidate);
log.info("首次登录创建用户 userCode={} requestId={}", candidate.getUserCode(), RequestIdHolder.get());
return candidate;
} catch (DuplicateKeyException exception) {
SysUser existing = findByEmail(email);
if (existing != null) return existing;
Long conflicts = users.selectCount(new LambdaQueryWrapper<SysUser>()
.eq(SysUser::getUserCode, candidate.getUserCode()));
if (conflicts == 0) throw exception;
log.warn("用户编码冲突 userCode={} attempt={} requestId={}", candidate.getUserCode(), attempt, RequestIdHolder.get());
}
}
throw new BizException(503, "USER_CODE_EXHAUSTED", "用户编码分配失败,请稍后重试");
}
private SysUser findByEmail(String email) {
return users.selectOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getEmail, email));
}
}
@@ -3,6 +3,7 @@ package com.linkerbot.cadworld.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.linkerbot.cadworld.common.api.PageResponse;
import com.linkerbot.cadworld.common.api.RequestIdHolder;
import com.linkerbot.cadworld.common.exception.BizException;
import com.linkerbot.cadworld.dto.user.SaveUserRequest;
import com.linkerbot.cadworld.dto.user.UserResponse;
@@ -11,7 +12,9 @@ import com.linkerbot.cadworld.enums.UserStatus;
import com.linkerbot.cadworld.enums.UserType;
import com.linkerbot.cadworld.mapper.SysUserMapper;
import com.linkerbot.cadworld.service.UserManagementService;
import com.linkerbot.cadworld.service.support.UserCodes;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -19,7 +22,9 @@ import org.springframework.util.StringUtils;
@Service
@RequiredArgsConstructor
@Slf4j
public class UserManagementServiceImpl implements UserManagementService {
private static final int MAX_CODE_ATTEMPTS = 5;
private final SysUserMapper mapper;
@Override
@@ -28,7 +33,7 @@ public class UserManagementServiceImpl implements UserManagementService {
.eq(type != null, SysUser::getUserType, type).eq(status != null, SysUser::getStatus, status);
if (StringUtils.hasText(keyword)) {
String term = keyword.trim();
query.and(q -> q.like(SysUser::getPhone, term).or().like(SysUser::getNickname, term));
query.and(q -> q.like(SysUser::getEmail, term).or().like(SysUser::getNickname, term));
}
Page<SysUser> result = mapper.selectPage(new Page<>(page, size),
query.orderByDesc(SysUser::getUpdatedAt).orderByDesc(SysUser::getId));
@@ -39,17 +44,27 @@ public class UserManagementServiceImpl implements UserManagementService {
public UserResponse get(Long id) { return response(require(id)); }
@Override
@Transactional
public UserResponse create(SaveUserRequest request) {
SysUser user = new SysUser();
user.setDeleted(0);
apply(user, request);
try {
mapper.insert(user);
} catch (DuplicateKeyException exception) {
throw duplicatePhone();
for (int attempt = 1; attempt <= MAX_CODE_ATTEMPTS; attempt++) {
user.setUserCode(UserCodes.generate());
try {
mapper.insert(user);
log.info("后台创建用户 userCode={} requestId={}", user.getUserCode(), RequestIdHolder.get());
return response(require(user.getId()));
} catch (DuplicateKeyException exception) {
if (mapper.selectCount(new LambdaQueryWrapper<SysUser>().eq(SysUser::getEmail, user.getEmail())) > 0) {
throw duplicateEmail();
}
if (mapper.selectCount(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUserCode, user.getUserCode())) == 0) {
throw exception;
}
user.setId(null);
log.warn("后台创建用户编码冲突 userCode={} attempt={} requestId={}", user.getUserCode(), attempt, RequestIdHolder.get());
}
}
return response(require(user.getId()));
throw new BizException(503, "USER_CODE_EXHAUSTED", "用户编码分配失败,请稍后重试");
}
@Override
@@ -60,20 +75,26 @@ public class UserManagementServiceImpl implements UserManagementService {
try {
if (mapper.updateById(user) == 0) throw notFound();
} catch (DuplicateKeyException exception) {
throw duplicatePhone();
throw duplicateEmail();
}
log.info("后台更新用户 userCode={} status={} requestId={}", user.getUserCode(), user.getStatus(), RequestIdHolder.get());
return response(require(id));
}
@Override
@Transactional
public void delete(Long id) {
require(id);
if (mapper.deleteById(id) == 0) throw notFound();
SysUser user = require(id);
// 删除入口仅禁用账号,保留唯一邮箱和历史业务归属。
SysUser disabled = new SysUser();
disabled.setId(id);
disabled.setStatus(UserStatus.DISABLED);
if (mapper.updateById(disabled) == 0) throw notFound();
log.info("后台禁用用户 userCode={} requestId={}", user.getUserCode(), RequestIdHolder.get());
}
private void apply(SysUser user, SaveUserRequest request) {
user.setPhone(request.phone().trim());
user.setEmail(request.email());
user.setNickname(request.nickname().trim());
user.setStatus(request.status() == null ? (user.getStatus() == null ? UserStatus.ACTIVE : user.getStatus()) : request.status());
user.setUserType(request.userType() == null ? (user.getUserType() == null ? UserType.NORMAL : user.getUserType()) : request.userType());
@@ -86,8 +107,8 @@ public class UserManagementServiceImpl implements UserManagementService {
}
private BizException notFound() { return new BizException(404, "USER_NOT_FOUND", "用户不存在"); }
private BizException duplicatePhone() { return new BizException(409, "USER_PHONE_DUPLICATE", "手机号已存在,包括已删除的用户"); }
private BizException duplicateEmail() { return new BizException(409, "USER_EMAIL_DUPLICATE", "邮箱已存在"); }
private UserResponse response(SysUser user) {
return new UserResponse(user.getId(), user.getPhone(), user.getNickname(), user.getStatus(), user.getUserType(), user.getCreatedAt(), user.getUpdatedAt());
return new UserResponse(user.getId(), user.getUserCode(), user.getEmail(), user.getNickname(), user.getStatus(), user.getUserType(), user.getCreatedAt(), user.getUpdatedAt());
}
}
@@ -0,0 +1,13 @@
package com.linkerbot.cadworld.service.support;
import java.util.Locale;
import java.util.UUID;
public final class UserCodes {
private UserCodes() {
}
public static String generate() {
return UUID.randomUUID().toString().replace("-", "").toUpperCase(Locale.ROOT);
}
}
@@ -0,0 +1,82 @@
package com.linkerbot.cadworld.service.auth;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.linkerbot.cadworld.common.exception.BizException;
import com.linkerbot.cadworld.entity.SysUser;
import com.linkerbot.cadworld.enums.UserStatus;
import com.linkerbot.cadworld.enums.UserType;
import com.linkerbot.cadworld.mapper.SysUserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.dao.DuplicateKeyException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
class LoginUserServiceTest {
private final SysUserMapper mapper = mock(SysUserMapper.class);
private final LoginUserService service = new LoginUserService(mapper);
@Test
void firstLoginCreatesNormalUserWithNormalizedEmailAndOpaqueCode() {
SysUser user = service.login(" USER@EXAMPLE.TEST ");
assertThat(user.getEmail()).isEqualTo("user@example.test");
assertThat(user.getUserCode()).matches("[A-F0-9]{32}");
assertThat(user.getStatus()).isEqualTo(UserStatus.ACTIVE);
assertThat(user.getUserType()).isEqualTo(UserType.NORMAL);
assertThat(user.getNickname()).isEqualTo("用户_" + user.getUserCode().substring(0, 8));
}
@Test
void concurrentEmailInsertReusesCommittedUser() {
SysUser existing = existing(UserStatus.ACTIVE);
when(mapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(null, existing);
when(mapper.insert(any(SysUser.class))).thenThrow(new DuplicateKeyException("test duplicate"));
assertThat(service.login("user@example.test")).isSameAs(existing);
verify(mapper, times(1)).insert(any(SysUser.class));
}
@Test
void concurrentInsertStillChecksDisabledStatus() {
when(mapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(null, existing(UserStatus.DISABLED));
when(mapper.insert(any(SysUser.class))).thenThrow(new DuplicateKeyException("test duplicate"));
assertThatThrownBy(() -> service.login("user@example.test")).isInstanceOfSatisfying(BizException.class,
exception -> assertThat(exception.getCode()).isEqualTo("ACCOUNT_DISABLED"));
}
@Test
void codeCollisionRetriesAndIsBounded() {
when(mapper.insert(any(SysUser.class))).thenThrow(new DuplicateKeyException("test duplicate"));
when(mapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(1L);
assertThatThrownBy(() -> service.login("user@example.test")).isInstanceOfSatisfying(BizException.class,
exception -> assertThat(exception.getCode()).isEqualTo("USER_CODE_EXHAUSTED"));
verify(mapper, times(5)).insert(any(SysUser.class));
}
@Test
void codeCollisionCanRecover() {
when(mapper.insert(any(SysUser.class))).thenThrow(new DuplicateKeyException("test duplicate")).thenReturn(1);
when(mapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(1L);
assertThat(service.login("user@example.test").getUserCode()).matches("[A-F0-9]{32}");
verify(mapper, times(2)).insert(any(SysUser.class));
}
@Test
void unexpectedDuplicatePropagates() {
when(mapper.insert(any(SysUser.class))).thenThrow(new DuplicateKeyException("test duplicate"));
when(mapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(0L);
assertThatThrownBy(() -> service.login("user@example.test")).isInstanceOf(DuplicateKeyException.class);
verify(mapper, times(1)).insert(any(SysUser.class));
}
private SysUser existing(UserStatus status) {
SysUser user = new SysUser();
user.setUserCode("A".repeat(32));
user.setStatus(status);
return user;
}
}