个人工作空间和广场,支持发布到广场和fork

This commit is contained in:
lxp
2026-10-20 11:30:19 +08:00
parent 2ddf750e5b
commit 0631bd5ecc
19 changed files with 1364 additions and 3 deletions
+145
View File
@@ -0,0 +1,145 @@
# 个人项目、广场与封面接口
先执行[项目建表 SQL](project-schema.md),再部署服务。接口继续使用 `{code,message,data,requestId}`;`projectCode`、`ownerUserCode` 等均为业务编码,不返回数据库主键。
## 1. 前端调用顺序与权限
1. 完成[需求生成](robot-demand-api.md),获取状态为 `ready` 的 `analysisId`。
2. 调用 `POST /api/projects`,将该值作为 `analysisCode`,保存为当前用户的私有项目。
3. 需要封面时,用户选择图片或前端对装配预览截图,通过专用封面接口上传。
4. 发布前必须存在有效封面;有缺件但可预览的方案也可发布,前端保留缺件和校验提示。
5. 广场列表和详情无需登录;登录后可以 fork 到自己的工作空间,副本默认私有。
除两个广场 GET 接口外,所有项目接口都需要 `Authorization: Bearer <token>`。用户归属从认证主体获取,不传用户编码。无 Token 可匿名浏览广场;主动携带无效 Token 时沿用现有鉴权规则返回 401。
`GET /api/projects` 即“我的工作空间”。项目装配内容保存后固定,只能修改名称、简介、封面和发布状态;重新拼装后另存一个项目。不提供任意模型文件上传、替换或文件编辑接口。
| 方法 | 路径 | 请求 | 用途 |
| --- | --- | --- | --- |
| POST | `/api/projects` | 创建 JSON | 保存生成结果 |
| GET | `/api/projects` | `page`、`size` | 当前用户项目列表 |
| GET | `/api/projects/{projectCode}` | 无 | 当前用户项目详情 |
| PATCH | `/api/projects/{projectCode}` | 修改 JSON | 修改名称、简介 |
| DELETE | `/api/projects/{projectCode}` | 无 | 软删除,返回 `{success:true}` |
| POST | `/api/projects/{projectCode}/cover` | multipart `file` | 上传或替换封面 |
| POST | `/api/projects/{projectCode}/publish` | 无 | 发布到广场 |
| POST | `/api/projects/{projectCode}/unpublish` | 无 | 取消发布 |
| GET | `/api/plaza/projects` | `page`、`size` | 匿名浏览广场 |
| GET | `/api/plaza/projects/{projectCode}` | 无 | 匿名查看公开详情 |
| POST | `/api/plaza/projects/{projectCode}/fork` | 无 | fork 为自己的私有项目 |
所有者详情及写操作只能操作自己的项目,即使目标项目公开也不能直接修改。其他用户查看公开项目应使用广场详情接口。无权访问、不存在或已删除的项目返回 404;取消发布后的广场详情及 fork 也返回 404。项目响应设置 `Cache-Control: no-store`。
## 2. 保存、修改与响应
创建请求示例:
```json
{
"analysisCode": "DN-22222222222222222222222222222222",
"projectName": "我的机器人",
"description": "躯干与右臂装配方案"
}
```
`analysisCode`、`projectName` 必填,分别最多 64、128 字符;名称不能全为空白。简介可省略或为 null,保存为空字符串,最多 2000 字符。重复保存同一方案会创建独立的新项目。
来源必须是当前用户未过期会话的当前已完成版本,且有可预览组件;处理中、失败、被新消息替代、无匹配或 `assembly.status=blocked` 的结果不能保存。服务端读取自己的生成快照,不接受客户端上传自定义装配 JSON。
PATCH 请求只接受 `projectName` 和 `description`。字段省略或为 null 时保持原值;简介传 `""` 表示清空,名称不能清空。客户端提交 `snapshot`、`visibility`、`coverRelativePath`、`ownerUserCode` 等额外字段返回 422。
创建、详情、修改、上传、发布、取消发布和 fork 返回同一项目结构:
```json
{
"code": "OK",
"message": "success",
"data": {
"projectCode": "RP-11111111111111111111111111111111",
"ownerUserCode": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
"projectName": "我的机器人",
"description": "躯干与右臂装配方案",
"coverRelativePath": null,
"coverUrl": null,
"schemaVersion": "project-v1",
"matchStatus": "partial",
"assemblyStatus": "ready",
"sourceProjectCode": null,
"visibility": "PRIVATE",
"publishedAt": null,
"createdAt": "2026-10-20T02:00:00Z",
"updatedAt": "2026-10-20T02:00:00Z",
"snapshot": {
"status": "partial",
"rootCategory": "TORSO_0",
"searchLimited": false,
"totals": {},
"unmetRequirements": [],
"missingParts": [],
"missingPartGroups": [],
"requirementChecks": [],
"assembly": {},
"components": []
}
},
"requestId": "project-save-001"
}
```
示例中的 `snapshot` 子数组和对象作结构占位,真实成功项目一定包含非空组件和可预览装配。其 `components`、`assembly`、汇总、缺件及校验字段沿用生成响应 `match` 中的展示结构,可复用现有预览器。快照去除原始对话、需求图片、来源解析/会话信息、内部字段和替代方案列表,不返回 `sourceAnalysisCode`。
列表返回 `{items,page,size,total}`;`items` 与项目结构相同,但省略 `snapshot`。`page` 默认 1,`size` 默认 20、范围 1–100。个人列表按 `updatedAt` 倒序,广场按 `publishedAt` 倒序,时间相同按项目编码倒序。
## 3. OSS 封面
```javascript
async function uploadProjectCover(token, projectCode, fileOrScreenshotBlob) {
const form = new FormData();
form.append("file", fileOrScreenshotBlob, "cover.png");
const response = await fetch(`/api/projects/${projectCode}/cover`, {
method: "POST",
headers: { Authorization: `Bearer ${token}` },
body: form
});
const result = await response.json();
if (!response.ok) throw result;
return result.data;
}
```
不要手动设置 multipart 的 Content-Type。支持 PNG、JPEG、WebP,每张不超过 8MiB,文件内容须与 MIME 一致;文件名由服务端生成,忽略客户端文件名,不接受对象路径或 URL。
```text
数据库 cover_relative_path:
projects/RP-xxx/covers/uuid.png
OSS 对象键(示例测试环境):
cadworld_dev/projects/RP-xxx/covers/uuid.png
响应 coverUrl:
https://你的OSS或CDN域名/cadworld_dev/projects/RP-xxx/covers/uuid.png
```
配置 `OSS_ACCESS_KEY_ID`、`OSS_ACCESS_KEY_SECRET`、`OSS_REGION`、`OSS_BUCKET`、`OSS_ROOT_PREFIX` 和 `APP_STORAGE_PUBLIC_BASE_URL`。公开访问基址只填写 OSS/CDN 域名或统一基址,不重复附加环境根目录,不能使用管理端下载代理地址。浏览器通过返回的 URL 直接加载图片。
后端接收图片并上传 OSS,成功后才更新项目路径;失败保留原封面。数据库关联失败会尝试清理本次新对象,失败日志带项目编码及 requestId,供排查补偿。每次替换都产生新路径,不覆盖旧图片。
## 4. 发布、fork 与错误
发布成功后 `visibility=PUBLIC`、`publishedAt` 有值;重复发布保留原时间。取消发布后改为 `PRIVATE` 且清空发布时间,再次发布生成新时间。发布时校验快照可预览以及封面对象确实存在。
fork 不需要请求体,沿用来源名称和简介,复制独立装配快照,记录 `sourceProjectCode`,新项目归当前用户并默认为私有。封面共享同一不可覆盖的 OSS 对象,替换或删除原项目不影响副本;来源重新发布、修改简介或更换封面也不会自动同步到副本。
| HTTP | 业务码 | 含义 |
| --- | --- | --- |
| 401 | `UNAUTHORIZED` | 写操作未登录或 Token 失效 |
| 404 | `PROJECT_NOT_FOUND` | 项目不存在、已删除、无权访问或来源不再公开 |
| 404 | `DEMAND_NOT_FOUND` | 来源解析不存在、不属于当前用户或会话过期 |
| 409 | `PROJECT_RESULT_UNAVAILABLE` | 来源未完成、版本已更新或装配结果不可预览 |
| 409 | `PROJECT_COVER_REQUIRED` | 发布前缺少封面或 OSS 对象已不存在 |
| 413 | `UPLOAD_TOO_LARGE` / `INVALID_REQUEST` | 封面超过限制;后者由 multipart 请求限制返回 |
| 422 | `INVALID_PROJECT_COVER` | 空图片、不支持的格式或 MIME 与文件头不一致 |
| 422 | `INVALID_REQUEST` | JSON 字段、长度或分页参数非法 |
| 502 | `OSS_*_FAILED` | OSS 上传或对象校验失败 |
部署顺序:执行建表 SQL → 配置 OSS 和访问域名 → 部署服务 → 验证保存、封面上传、匿名广场及跨账号 fork。替换封面和软删除项目不立即删除旧 OSS 对象,一期不提供自动垃圾回收。
+55
View File
@@ -0,0 +1,55 @@
# 机器人项目建表 SQL
部署项目功能前,在用户端使用的 MySQL 数据库中手动执行以下 SQL。只新增一张 `robot_project` 表,不自动迁移,不修改仓库 `.sql` 文件。每个用户的工作空间直接通过 `owner_user_code` 查询。
```sql
CREATE TABLE `robot_project` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '项目主键ID,仅内部使用',
`project_code` varchar(64) COLLATE utf8mb4_bin NOT NULL COMMENT '项目唯一编码',
`owner_user_code` char(32) COLLATE utf8mb4_bin NOT NULL COMMENT '所属用户唯一编码',
`project_name` varchar(128) NOT NULL COMMENT '项目名称',
`description` varchar(2000) NOT NULL DEFAULT '' COMMENT '项目简介',
`cover_relative_path` varchar(512) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '封面相对路径,不含域名和环境根目录',
`snapshot_json` json NOT NULL COMMENT '独立保存的装配展示快照,不含原始对话和需求图片',
`schema_version` varchar(32) COLLATE utf8mb4_bin NOT NULL COMMENT '项目快照格式版本,首版为project-v1',
`match_status` varchar(16) COLLATE utf8mb4_bin NOT NULL COMMENT '方案完整度:complete或partial',
`assembly_status` varchar(16) COLLATE utf8mb4_bin NOT NULL COMMENT '装配状态:ready或partial',
`source_analysis_code` varchar(64) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '原始需求解析编码,仅用于溯源',
`source_project_code` varchar(64) COLLATE utf8mb4_bin DEFAULT NULL COMMENT 'fork来源项目编码,原创项目为空',
`visibility` varchar(16) COLLATE utf8mb4_bin NOT NULL DEFAULT 'PRIVATE' COMMENT '可见性:PRIVATE私有,PUBLIC公开',
`published_at` datetime(3) DEFAULT NULL COMMENT '最近一次从私有转为公开的时间,私有时为空',
`deleted` tinyint unsigned NOT NULL DEFAULT '0' COMMENT '删除标记:0未删除,1已删除',
`created_at` datetime(3) NOT NULL COMMENT '创建时间',
`updated_at` datetime(3) NOT NULL COMMENT '最近更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_robot_project_code` (`project_code`) COMMENT '项目编码唯一索引',
KEY `idx_robot_project_owner`
(`owner_user_code`, `deleted`, `updated_at`, `project_code`) COMMENT '个人项目列表索引',
KEY `idx_robot_project_plaza`
(`visibility`, `deleted`, `published_at`, `project_code`) COMMENT '广场项目列表索引'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
COLLATE=utf8mb4_general_ci COMMENT='机器人装配项目表';
```
所有字符字段统一使用表级 `utf8mb4` 字符集。编码、路径、版本和状态字段指定 `utf8mb4_bin`,保留区分大小写的比较规则;名称和简介使用表级 `utf8mb4_general_ci`。
如果已经执行了此前的建表 SQL,手动执行以下语句,将原先单独使用 ASCII 的字段转换为 `utf8mb4`,保留原有类型、默认值及中文注释。新建表无需执行这段转换 SQL。
```sql
ALTER TABLE `robot_project`
MODIFY COLUMN `project_code` varchar(64) COLLATE utf8mb4_bin NOT NULL COMMENT '项目唯一编码',
MODIFY COLUMN `owner_user_code` char(32) COLLATE utf8mb4_bin NOT NULL COMMENT '所属用户唯一编码',
MODIFY COLUMN `cover_relative_path` varchar(512) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '封面相对路径,不含域名和环境根目录',
MODIFY COLUMN `schema_version` varchar(32) COLLATE utf8mb4_bin NOT NULL COMMENT '项目快照格式版本,首版为project-v1',
MODIFY COLUMN `match_status` varchar(16) COLLATE utf8mb4_bin NOT NULL COMMENT '方案完整度:complete或partial',
MODIFY COLUMN `assembly_status` varchar(16) COLLATE utf8mb4_bin NOT NULL COMMENT '装配状态:ready或partial',
MODIFY COLUMN `source_analysis_code` varchar(64) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '原始需求解析编码,仅用于溯源',
MODIFY COLUMN `source_project_code` varchar(64) COLLATE utf8mb4_bin DEFAULT NULL COMMENT 'fork来源项目编码,原创项目为空',
MODIFY COLUMN `visibility` varchar(16) COLLATE utf8mb4_bin NOT NULL DEFAULT 'PRIVATE' COMMENT '可见性:PRIVATE私有,PUBLIC公开';
```
来源编码不设置级联删除约束。保存项目后,原需求会话过期清理不影响项目;fork 后,来源项目取消发布或删除也不影响副本。
封面数据库路径示例为 `projects/RP-xxx/covers/xxx.png`。实际 OSS 对象键由当前 `OSS_ROOT_PREFIX` 加上此路径生成,域名由 `APP_STORAGE_PUBLIC_BASE_URL` 配置。切换环境只改变路径解析配置;若跨环境迁移数据,仍需将实际图片同步到目标桶的对应环境目录。
项目删除采用软删除。封面替换、项目软删除暂不物理清理 OSS 对象,因为已有 fork 可能共享这些对象;后续清理必须先确认没有项目引用。
+1
View File
@@ -25,6 +25,7 @@
4. 收到 `analysis.completed`,直接读取 `data.match`。当 `match.assembly.status=ready` 时,按 `instanceId` 加载 `match.components` 的资源,再根据 `match.assembly.connections` 定位双方接口并由前端摆放;`partial` 也可直接显示有效的已有组合。
5. 简短展示 `warnings`、缺件及未满足/未验证项;不弹出追问、确认或必须接受降级的页面。`assembly.status=blocked` 或 `status=no_match` 时展示具体原因,不伪造连接位姿。
6. 用户需要调整时,在同一会话发送新消息,例如“改成右臂扭矩至少30N·m”,后端生成新版本并返回新方案。
7. 需要长期保留时,将当前 `analysisId` 作为 `analysisCode` 调用[保存为我的项目](project-api.md)。项目可上传 OSS 封面、发布到广场或被其他用户 fork;保存后不随需求会话过期清理。
先完成[邮箱与图片验证码登录](auth-api.md),所有业务请求头携带 `Authorization: Bearer <token>`,不再依赖匿名 Cookie 或 `credentials:"include"`。会话和图片归属服务端认证的用户,同账号换设备登录后仍可通过原业务编码访问;其他账号访问返回 404。历史匿名会话不自动认领,保留至过期清理。不传 `userId`、用户编码、模型 Key 或系统提示词。生产使用 HTTPS;开发跨端口需配置具体允许域名。
@@ -57,7 +57,7 @@ public class DemandConfiguration {
String[] allowed = origins.stream().filter((String origin) -> !origin.isBlank()).toArray(String[]::new);
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")
registry.addMapping("/api/**").allowedOrigins(allowed).allowedMethods("GET", "POST", "PATCH", "DELETE", "OPTIONS")
.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,46 @@
package com.linkerbot.cadworld.api.config;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linkerbot.cadworld.config.OssClientConfiguration;
import com.linkerbot.cadworld.config.OssProperties;
import com.linkerbot.cadworld.service.client.ObjectStorageClient;
import com.linkerbot.cadworld.service.client.OssObjectStorageClient;
import com.linkerbot.cadworld.service.demand.DemandRepository;
import com.linkerbot.cadworld.service.impl.ObjectStorageUrlResolver;
import com.linkerbot.cadworld.service.project.ProjectCoverStore;
import com.linkerbot.cadworld.service.project.ProjectRepository;
import com.linkerbot.cadworld.service.project.ProjectService;
import com.linkerbot.cadworld.service.project.ProjectSnapshots;
import com.linkerbot.cadworld.service.support.StorageObjectKeys;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.PlatformTransactionManager;
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(OssProperties.class)
@Import({OssClientConfiguration.class, OssObjectStorageClient.class, StorageObjectKeys.class})
public class ProjectConfiguration {
@Bean
ProjectRepository projectRepository(JdbcTemplate jdbc, ObjectMapper json) {
return new ProjectRepository(jdbc, json);
}
@Bean
ProjectSnapshots projectSnapshots(ObjectMapper json) {
return new ProjectSnapshots(json);
}
@Bean
ProjectCoverStore projectCoverStore(ObjectStorageClient storage, StorageObjectKeys keys, ObjectStorageUrlResolver urls) {
return new ProjectCoverStore(storage, keys, urls);
}
@Bean
ProjectService projectService(ProjectRepository projects, DemandRepository demands, ProjectSnapshots snapshots,
ProjectCoverStore covers, PlatformTransactionManager manager) {
return new ProjectService(projects, demands, snapshots, covers, manager);
}
}
@@ -0,0 +1,110 @@
package com.linkerbot.cadworld.api.controller;
import com.linkerbot.cadworld.common.api.ApiResponse;
import com.linkerbot.cadworld.common.api.PageResponse;
import com.linkerbot.cadworld.common.exception.BizException;
import com.linkerbot.cadworld.dto.common.SuccessResponse;
import com.linkerbot.cadworld.dto.project.CreateProjectRequest;
import com.linkerbot.cadworld.dto.project.ProjectResponse;
import com.linkerbot.cadworld.dto.project.UpdateProjectRequest;
import com.linkerbot.cadworld.security.api.CurrentUser;
import com.linkerbot.cadworld.service.project.ProjectCoverStore;
import com.linkerbot.cadworld.service.project.ProjectService;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
import java.io.IOException;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PatchMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
@RestController
@RequestMapping("/api")
@Validated
@RequiredArgsConstructor
public class RobotProjectController {
private final ProjectService projects;
private final DemandOwner demandOwners;
@ModelAttribute
public void disableCaching(HttpServletResponse response) {
response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store");
}
@PostMapping("/projects")
public ApiResponse<ProjectResponse> create(@Valid @RequestBody CreateProjectRequest request) {
return ApiResponse.success(projects.create(CurrentUser.required(), demandOwners.resolve(), request));
}
@GetMapping("/projects")
public ApiResponse<PageResponse<ProjectResponse>> mine(@RequestParam(defaultValue = "1") long page,
@RequestParam(defaultValue = "20") long size) {
return ApiResponse.success(projects.list(CurrentUser.required(), page, size));
}
@GetMapping("/projects/{projectCode}")
public ApiResponse<ProjectResponse> detail(@PathVariable @NotBlank @Size(max = 64) String projectCode) {
return ApiResponse.success(projects.owned(projectCode, CurrentUser.required()));
}
@PatchMapping("/projects/{projectCode}")
public ApiResponse<ProjectResponse> update(@PathVariable @NotBlank @Size(max = 64) String projectCode,
@Valid @RequestBody UpdateProjectRequest request) {
return ApiResponse.success(projects.update(projectCode, CurrentUser.required(), request));
}
@DeleteMapping("/projects/{projectCode}")
public ApiResponse<SuccessResponse> delete(@PathVariable @NotBlank @Size(max = 64) String projectCode) {
projects.delete(projectCode, CurrentUser.required());
return ApiResponse.success(SuccessResponse.ok());
}
@PostMapping(value = "/projects/{projectCode}/cover", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public ApiResponse<ProjectResponse> cover(@PathVariable @NotBlank @Size(max = 64) String projectCode,
@RequestPart("file") MultipartFile file) throws IOException {
if (file.getSize() > ProjectCoverStore.MAX_BYTES) {
throw new BizException(413, "UPLOAD_TOO_LARGE", "封面图片不能超过8MiB");
}
return ApiResponse.success(projects.uploadCover(projectCode, CurrentUser.required(), file.getBytes(), file.getContentType()));
}
@PostMapping("/projects/{projectCode}/publish")
public ApiResponse<ProjectResponse> publish(@PathVariable @NotBlank @Size(max = 64) String projectCode) {
return ApiResponse.success(projects.visibility(projectCode, CurrentUser.required(), true));
}
@PostMapping("/projects/{projectCode}/unpublish")
public ApiResponse<ProjectResponse> unpublish(@PathVariable @NotBlank @Size(max = 64) String projectCode) {
return ApiResponse.success(projects.visibility(projectCode, CurrentUser.required(), false));
}
@GetMapping("/plaza/projects")
public ApiResponse<PageResponse<ProjectResponse>> plaza(@RequestParam(defaultValue = "1") long page,
@RequestParam(defaultValue = "20") long size) {
return ApiResponse.success(projects.list(null, page, size));
}
@GetMapping("/plaza/projects/{projectCode}")
public ApiResponse<ProjectResponse> published(@PathVariable @NotBlank @Size(max = 64) String projectCode) {
return ApiResponse.success(projects.published(projectCode));
}
@PostMapping("/plaza/projects/{projectCode}/fork")
public ApiResponse<ProjectResponse> fork(@PathVariable @NotBlank @Size(max = 64) String projectCode) {
return ApiResponse.success(projects.fork(projectCode, CurrentUser.required()));
}
}
@@ -40,6 +40,11 @@ app:
storage:
# 配置公开 OSS/CDN 域名,不能填管理端下载代理地址;对象键已包含环境根目录。
public-base-url: ${APP_STORAGE_PUBLIC_BASE_URL:}
oss:
access-key-id: ${OSS_ACCESS_KEY_ID:}
access-key-secret: ${OSS_ACCESS_KEY_SECRET:}
region: ${OSS_REGION:oss-cn-beijing}
bucket: ${OSS_BUCKET:linkerbot}
matching:
candidates-per-role: 50
preferred-candidates-per-role: 30
@@ -0,0 +1,455 @@
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.exception.BizException;
import com.linkerbot.cadworld.dto.project.ProjectResponse;
import com.linkerbot.cadworld.entity.SysUser;
import com.linkerbot.cadworld.security.common.TokenService;
import com.linkerbot.cadworld.service.auth.LoginUserService;
import com.linkerbot.cadworld.service.client.ObjectStorageClient;
import com.linkerbot.cadworld.service.demand.DemandModelClient;
import com.linkerbot.cadworld.service.demand.DemandRepository;
import com.linkerbot.cadworld.service.project.ProjectCoverStore;
import com.linkerbot.cadworld.service.project.ProjectRepository;
import com.linkerbot.cadworld.service.project.ProjectService;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.sql.Timestamp;
import java.time.Instant;
import java.util.Base64;
import java.util.HexFormat;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
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.TimeoutException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
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.dao.DataAccessResourceFailureException;
import org.springframework.http.MediaType;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.mock.web.MockMultipartFile;
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 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.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
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.multipart;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch;
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:projects;MODE=MySQL;DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=5000",
"spring.datasource.driver-class-name=org.h2.Driver", "spring.datasource.username=sa", "spring.datasource.password=",
"app.storage.root-prefix=cadworld_dev", "app.storage.public-base-url=https://assets.example.test",
"logging.file.path=target/test-logs"
})
@AutoConfigureMockMvc(print = org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrint.NONE)
class ProjectApiTest {
private static final byte[] PNG = Base64.getDecoder().decode("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+j2ioAAAAASUVORK5CYII=");
@Autowired private MockMvc mvc;
@Autowired private JdbcTemplate jdbc;
@Autowired private ObjectMapper json;
@Autowired private LoginUserService users;
@Autowired private TokenService tokens;
@Autowired private DemandRepository demands;
@Autowired private ProjectService service;
@MockitoBean private DemandModelClient model;
@MockitoBean private ObjectStorageClient storage;
@MockitoSpyBean private ProjectRepository projects;
private final Map<String, byte[]> objects = new ConcurrentHashMap<>();
private String owner;
private String token;
private String other;
private String otherToken;
@BeforeEach
void prepare() throws Exception {
assertThat(jdbc.execute((org.springframework.jdbc.core.ConnectionCallback<String>) connection -> connection.getMetaData().getDatabaseProductName())).isEqualTo("H2");
ApiAuthTestSupport.createSchema(jdbc);
jdbc.execute("""
CREATE TABLE IF NOT EXISTS robot_project (
id BIGINT AUTO_INCREMENT PRIMARY KEY,project_code VARCHAR(64) NOT NULL UNIQUE,
owner_user_code CHAR(32) NOT NULL,project_name VARCHAR(128) NOT NULL,description VARCHAR(2000) NOT NULL,
cover_relative_path VARCHAR(512),snapshot_json CLOB NOT NULL,schema_version VARCHAR(32) NOT NULL,
match_status VARCHAR(16) NOT NULL,assembly_status VARCHAR(16) NOT NULL,source_analysis_code VARCHAR(64),
source_project_code VARCHAR(64),visibility VARCHAR(16) NOT NULL,published_at TIMESTAMP(3),
deleted INT NOT NULL DEFAULT 0,created_at TIMESTAMP(3) NOT NULL,updated_at TIMESTAMP(3) NOT NULL)
""");
jdbc.execute("CREATE TABLE IF NOT EXISTS robot_demand_conversation (id BIGINT AUTO_INCREMENT PRIMARY KEY,conversation_code VARCHAR(64) NOT NULL UNIQUE,owner_hash VARCHAR(64) NOT NULL,revision INT NOT NULL,created_at TIMESTAMP NOT NULL,updated_at TIMESTAMP NOT NULL,expires_at TIMESTAMP NOT NULL)");
jdbc.execute("CREATE TABLE IF NOT EXISTS robot_demand_analysis (id BIGINT AUTO_INCREMENT PRIMARY KEY,analysis_code VARCHAR(64) NOT NULL UNIQUE,conversation_code VARCHAR(64) NOT NULL,source_message_code VARCHAR(80) NOT NULL,revision INT NOT NULL,status VARCHAR(32) NOT NULL,result_json CLOB NOT NULL,model_version VARCHAR(128) NOT NULL,failure_code VARCHAR(64) NOT NULL,created_at TIMESTAMP NOT NULL,updated_at TIMESTAMP NOT NULL)");
jdbc.execute("CREATE TABLE IF NOT EXISTS robot_demand_match (id BIGINT AUTO_INCREMENT PRIMARY KEY,match_code VARCHAR(64) NOT NULL UNIQUE,analysis_code VARCHAR(64) NOT NULL UNIQUE,revision INT NOT NULL,result_json CLOB NOT NULL,degradation_accepted INT NOT NULL,created_at TIMESTAMP NOT NULL,updated_at TIMESTAMP NOT NULL)");
jdbc.execute("CREATE TABLE IF NOT EXISTS robot_demand_attachment (attachment_code VARCHAR(64),conversation_code VARCHAR(64))");
jdbc.execute("CREATE TABLE IF NOT EXISTS robot_demand_message (conversation_code VARCHAR(64))");
for (String table : List.of("robot_project", "robot_demand_match", "robot_demand_analysis", "robot_demand_attachment", "robot_demand_message", "robot_demand_conversation")) {
jdbc.update("DELETE FROM " + table);
}
SysUser first = users.login("project-owner@example.test");
SysUser second = users.login("project-other@example.test");
owner = first.getUserCode();
other = second.getUserCode();
token = tokens.issue(owner);
otherToken = tokens.issue(other);
objects.clear();
mockUploads();
when(storage.objectExists(anyString())).thenAnswer(invocation -> objects.containsKey(invocation.getArgument(0, String.class)));
doAnswer(invocation -> { objects.remove(invocation.getArgument(0, String.class)); return null; }).when(storage).deleteObject(anyString());
}
@Test
void savesIndependentSanitizedSnapshotAndDoesNotLoadSnapshotsForLists() throws Exception {
String analysis = source(false);
JsonNode created = create(analysis);
String code = created.path("projectCode").asText();
assertThat(created.path("visibility").asText()).isEqualTo("PRIVATE");
assertThat(created.path("schemaVersion").asText()).isEqualTo("project-v1");
assertThat(created.path("ownerUserCode").asText()).isEqualTo(owner);
assertThat(created.path("snapshot").path("components").get(0).path("component").path("version").asInt()).isEqualTo(3);
assertThat(created.path("snapshot").path("assembly").path("connections").isArray()).isTrue();
assertThat(created.findValues("id")).isEmpty();
assertThat(created.toString()).doesNotContain("PRIVATE_PROMPT", "PRIVATE_KEY", "analysisId", "conversationId", "alternatives", "sourceAnalysisCode");
assertThat(jdbc.queryForObject("SELECT source_analysis_code FROM robot_project WHERE project_code=?", String.class, code)).isEqualTo(analysis);
JsonNode listed = data(mvc.perform(get("/api/projects").header("Authorization", bearer(token)))
.andExpect(status().isOk()).andExpect(header().string("Cache-Control", "no-store"))
.andExpect(jsonPath("$.data.total").value(1)).andExpect(jsonPath("$.data.size").value(20))
.andExpect(jsonPath("$.data.items[0].snapshot").doesNotExist()).andReturn());
assertThat(listed.path("items").get(0).has("id")).isFalse();
jdbc.update("UPDATE robot_demand_conversation SET expires_at=?", Timestamp.from(Instant.now().minusSeconds(10)));
assertThat(demands.purgeExpired(attachment -> { })).isEqualTo(1);
JsonNode detail = data(mvc.perform(get("/api/projects/" + code).header("Authorization", bearer(token))).andExpect(status().isOk()).andReturn());
assertThat(detail.path("snapshot")).isEqualTo(created.path("snapshot"));
}
@Test
void privateOperationsRequireLoginAndOwnership() throws Exception {
String code = create(source(false)).path("projectCode").asText();
mvc.perform(get("/api/projects")).andExpect(status().isUnauthorized());
mvc.perform(post("/api/projects").contentType(MediaType.APPLICATION_JSON).content("{}" )).andExpect(status().isUnauthorized());
mvc.perform(get("/api/projects/" + code)).andExpect(status().isUnauthorized());
mvc.perform(patch("/api/projects/" + code).contentType(MediaType.APPLICATION_JSON).content("{}" )).andExpect(status().isUnauthorized());
mvc.perform(delete("/api/projects/" + code)).andExpect(status().isUnauthorized());
mvc.perform(multipart("/api/projects/" + code + "/cover").file(image(PNG, "image/png"))).andExpect(status().isUnauthorized());
for (String action : List.of("publish", "unpublish")) {
mvc.perform(post("/api/projects/" + code + "/" + action)).andExpect(status().isUnauthorized());
mvc.perform(post("/api/projects/" + code + "/" + action).header("Authorization", bearer(otherToken))).andExpect(status().isNotFound());
}
mvc.perform(post("/api/plaza/projects/" + code + "/fork")).andExpect(status().isUnauthorized());
mvc.perform(get("/api/projects/" + code).header("Authorization", bearer(otherToken))).andExpect(status().isNotFound());
mvc.perform(patch("/api/projects/" + code).header("Authorization", bearer(otherToken)).contentType(MediaType.APPLICATION_JSON).content("{\"description\":\"改\"}" )).andExpect(status().isNotFound());
mvc.perform(delete("/api/projects/" + code).header("Authorization", bearer(otherToken))).andExpect(status().isNotFound());
mvc.perform(multipart("/api/projects/" + code + "/cover").file(image(PNG, "image/png")).header("Authorization", bearer(otherToken))).andExpect(status().isNotFound());
mvc.perform(get("/api/plaza/projects/" + code)).andExpect(status().isNotFound());
mvc.perform(post("/api/plaza/projects/" + code + "/fork").header("Authorization", bearer(otherToken))).andExpect(status().isNotFound());
mvc.perform(get("/api/projects").header("Authorization", bearer(otherToken))).andExpect(jsonPath("$.data.total").value(0));
mvc.perform(get("/api/plaza/projects")).andExpect(status().isOk()).andExpect(jsonPath("$.data.total").value(0));
verify(storage, never()).putObject(anyString(), anyString(), any(), anyLong());
}
@Test
void publishesPartialProjectsAndForkKeepsSnapshotAndOriginalCover() throws Exception {
String code = create(source(true)).path("projectCode").asText();
mvc.perform(post("/api/projects/" + code + "/publish").header("Authorization", bearer(token)))
.andExpect(status().isConflict()).andExpect(jsonPath("$.code").value("PROJECT_COVER_REQUIRED"));
JsonNode cover = upload(code, PNG, "image/png");
String relative = cover.path("coverRelativePath").asText();
assertThat(relative).matches("projects/RP-[a-f0-9]{32}/covers/[a-f0-9]{32}\\.png");
assertThat(relative).doesNotContain("cadworld_dev", "https:");
assertThat(cover.path("coverUrl").asText()).isEqualTo("https://assets.example.test/cadworld_dev/" + relative);
assertThat(objects).containsKey("cadworld_dev/" + relative);
JsonNode published = publish(code);
assertThat(published.path("matchStatus").asText()).isEqualTo("partial");
assertThat(published.path("snapshot").path("missingParts").size()).isEqualTo(1);
assertThat(publish(code).path("publishedAt")).isEqualTo(published.path("publishedAt"));
mvc.perform(get("/api/plaza/projects")).andExpect(status().isOk()).andExpect(header().string("Cache-Control", "no-store"))
.andExpect(jsonPath("$.data.items[0].projectCode").value(code)).andExpect(jsonPath("$.data.items[0].snapshot").doesNotExist());
mvc.perform(get("/api/plaza/projects/" + code)).andExpect(status().isOk()).andExpect(header().string("Cache-Control", "no-store"));
JsonNode fork = data(mvc.perform(post("/api/plaza/projects/" + code + "/fork").header("Authorization", bearer(otherToken)))
.andExpect(status().isOk()).andReturn());
String forkCode = fork.path("projectCode").asText();
assertThat(forkCode).isNotEqualTo(code);
assertThat(fork.path("ownerUserCode").asText()).isEqualTo(other);
assertThat(fork.path("sourceProjectCode").asText()).isEqualTo(code);
assertThat(fork.path("snapshot")).isEqualTo(published.path("snapshot"));
assertThat(fork.path("coverRelativePath").asText()).isEqualTo(relative);
assertThat(fork.path("visibility").asText()).isEqualTo("PRIVATE");
assertThat(upload(code, PNG, "image/png").path("coverRelativePath").asText()).isNotEqualTo(relative);
mvc.perform(post("/api/projects/" + code + "/unpublish").header("Authorization", bearer(token))).andExpect(status().isOk()).andExpect(jsonPath("$.data.publishedAt").isEmpty());
mvc.perform(get("/api/plaza/projects/" + code)).andExpect(status().isNotFound());
mvc.perform(post("/api/plaza/projects/" + code + "/fork").header("Authorization", bearer(otherToken))).andExpect(status().isNotFound());
mvc.perform(delete("/api/projects/" + code).header("Authorization", bearer(token))).andExpect(status().isOk());
mvc.perform(get("/api/projects/" + code).header("Authorization", bearer(token))).andExpect(status().isNotFound());
mvc.perform(post("/api/projects/" + forkCode + "/publish").header("Authorization", bearer(otherToken))).andExpect(status().isOk());
JsonNode independent = data(mvc.perform(get("/api/projects/" + forkCode).header("Authorization", bearer(otherToken))).andExpect(status().isOk()).andReturn());
assertThat(independent.path("snapshot")).isEqualTo(fork.path("snapshot"));
assertThat(independent.path("coverRelativePath").asText()).isEqualTo(relative);
assertThat(objects).hasSize(2);
verify(storage, never()).deleteObject(anyString());
}
@Test
void validatesMetadataRejectsSnapshotEditingAndSortsPagesStably() throws Exception {
String analysis = source(false);
for (int index = 0; index < 3; index++) create(analysis);
List<String> codes = jdbc.queryForList("SELECT project_code FROM robot_project ORDER BY project_code DESC", String.class);
jdbc.update("UPDATE robot_project SET updated_at=?", Timestamp.from(Instant.parse("2026-01-01T00:00:00Z")));
mvc.perform(get("/api/projects").param("page", "2").param("size", "1").header("Authorization", bearer(token)))
.andExpect(status().isOk()).andExpect(jsonPath("$.data.total").value(3)).andExpect(jsonPath("$.data.items[0].projectCode").value(codes.get(1)));
String code = codes.get(0);
mvc.perform(patch("/api/projects/" + code).header("Authorization", bearer(token)).contentType(MediaType.APPLICATION_JSON).content("{\"description\":\"新简介\"}"))
.andExpect(status().isOk()).andExpect(jsonPath("$.data.projectName").value("我的机器人")).andExpect(jsonPath("$.data.description").value("新简介"));
mvc.perform(patch("/api/projects/" + code).header("Authorization", bearer(token)).contentType(MediaType.APPLICATION_JSON).content("{\"projectName\":\"新名称\",\"description\":\"\"}"))
.andExpect(status().isOk()).andExpect(jsonPath("$.data.projectName").value("新名称")).andExpect(jsonPath("$.data.description").value(""));
for (String content : List.of("{\"projectName\":\" \"}", "{\"snapshot\":{}}", "{\"coverRelativePath\":\"projects/other.png\"}", "{\"visibility\":\"PUBLIC\"}", "{\"ownerUserCode\":\"other\"}", "{\"description\":\"" + "a".repeat(2001) + "\"}")) {
mvc.perform(patch("/api/projects/" + code).header("Authorization", bearer(token)).contentType(MediaType.APPLICATION_JSON).content(content)).andExpect(status().isUnprocessableEntity());
}
mvc.perform(post("/api/projects").header("Authorization", bearer(token)).contentType(MediaType.APPLICATION_JSON)
.content(json.writeValueAsString(Map.of("analysisCode", analysis, "projectName", "a".repeat(129))))).andExpect(status().isUnprocessableEntity());
for (String page : List.of("0", "-1", String.valueOf(Long.MAX_VALUE))) {
mvc.perform(get("/api/plaza/projects").param("page", page)).andExpect(status().isUnprocessableEntity());
}
for (String size : List.of("0", "101", "-1")) {
mvc.perform(get("/api/plaza/projects").param("size", size)).andExpect(status().isUnprocessableEntity());
}
}
@Test
void rejectsUnfinishedExpiredForeignSupersededAndUnpreviewableSources() throws Exception {
String analysis = source(false);
mvc.perform(createRequest(analysis, otherToken)).andExpect(status().isNotFound());
mvc.perform(createRequest("DN-missing", token)).andExpect(status().isNotFound());
for (String state : List.of("processing", "failed", "cancelled", "superseded", "needs_clarification")) {
jdbc.update("UPDATE robot_demand_analysis SET status=? WHERE analysis_code=?", state, analysis);
mvc.perform(createRequest(analysis, token)).andExpect(status().isConflict());
}
jdbc.update("UPDATE robot_demand_analysis SET status='ready' WHERE analysis_code=?", analysis);
jdbc.update("UPDATE robot_demand_conversation SET revision=2");
mvc.perform(createRequest(analysis, token)).andExpect(status().isConflict());
jdbc.update("UPDATE robot_demand_conversation SET revision=1");
for (String invalid : List.of("no_match", "blocked", "empty")) {
ObjectNode snapshot = match(false);
if ("no_match".equals(invalid)) snapshot.put("status", "no_match");
if ("blocked".equals(invalid)) ((ObjectNode) snapshot.path("assembly")).put("status", "blocked");
if ("empty".equals(invalid)) snapshot.putArray("components");
jdbc.update("UPDATE robot_demand_match SET result_json=? WHERE analysis_code=?", json.writeValueAsString(snapshot), analysis);
mvc.perform(createRequest(analysis, token)).andExpect(status().isConflict());
}
jdbc.update("DELETE FROM robot_demand_match");
mvc.perform(createRequest(analysis, token)).andExpect(status().isConflict());
jdbc.update("UPDATE robot_demand_conversation SET expires_at=?", Timestamp.from(Instant.now().minusSeconds(10)));
mvc.perform(createRequest(analysis, token)).andExpect(status().isNotFound());
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM robot_project", Integer.class)).isZero();
}
@Test
void coverAcceptsOnlyBoundedImagesAndUsesServerGeneratedPaths() throws Exception {
String code = create(source(false)).path("projectCode").asText();
upload(code, PNG, "image/png");
assertThat(upload(code, new byte[] {(byte) 255, (byte) 216, (byte) 255, 0}, "image/jpeg").path("coverRelativePath").asText()).endsWith(".jpg");
String previous = upload(code, "RIFF0000WEBP".getBytes(StandardCharsets.US_ASCII), "image/webp").path("coverRelativePath").asText();
for (MockMultipartFile file : List.of(image(new byte[0], "image/png"), image("invalid".getBytes(StandardCharsets.US_ASCII), "image/png"), image(PNG, "image/jpeg"), image(PNG, "image/svg+xml"))) {
mvc.perform(multipart("/api/projects/" + code + "/cover").file(file).header("Authorization", bearer(token))).andExpect(status().isUnprocessableEntity());
}
mvc.perform(multipart("/api/projects/" + code + "/cover").file(image(new byte[(int) ProjectCoverStore.MAX_BYTES + 1], "image/png"))
.header("Authorization", bearer(token))).andExpect(status().isPayloadTooLarge());
assertThat(coverPath(code)).isEqualTo(previous);
assertThat(objects).hasSize(3);
for (String key : objects.keySet()) assertThat(key).startsWith("cadworld_dev/projects/" + code + "/covers/").doesNotContain("client-name");
}
@Test
void failedOssUploadPreservesOldCoverAndDatabaseFailureRollsBackAndCompensates() throws Exception {
String code = create(source(false)).path("projectCode").asText();
String previous = upload(code, PNG, "image/png").path("coverRelativePath").asText();
doThrow(new BizException(502, "OSS_UPLOAD_FAILED", "上传失败")).when(storage).putObject(anyString(), anyString(), any(), anyLong());
mvc.perform(multipart("/api/projects/" + code + "/cover").file(image(PNG, "image/png")).header("Authorization", bearer(token))).andExpect(status().isBadGateway());
assertThat(coverPath(code)).isEqualTo(previous);
mockUploads();
doAnswer(invocation -> {
invocation.callRealMethod();
throw new DataAccessResourceFailureException("simulated failure after update");
}).when(projects).updateCover(eq(code), eq(owner), anyString(), any(Instant.class));
mvc.perform(multipart("/api/projects/" + code + "/cover").file(image(PNG, "image/png")).header("Authorization", bearer(token))).andExpect(status().isServiceUnavailable());
assertThat(coverPath(code)).isEqualTo(previous);
assertThat(objects.keySet()).containsExactly("cadworld_dev/" + previous);
verify(storage).deleteObject(anyString());
}
@Test
void deletionDuringUploadCompensatesOnlyTheNewObject() throws Exception {
String code = create(source(false)).path("projectCode").asText();
String previous = upload(code, PNG, "image/png").path("coverRelativePath").asText();
doAnswer(invocation -> {
objects.put(invocation.getArgument(0, String.class), PNG);
jdbc.update("UPDATE robot_project SET deleted=1 WHERE project_code=?", code);
return null;
}).when(storage).putObject(anyString(), anyString(), any(), anyLong());
mvc.perform(multipart("/api/projects/" + code + "/cover").file(image(PNG, "image/png")).header("Authorization", bearer(token))).andExpect(status().isNotFound());
assertThat(objects.keySet()).containsExactly("cadworld_dev/" + previous);
}
@Test
void compensationFailurePreservesOriginalDatabaseErrorAndPreviousCover() throws Exception {
String code = create(source(false)).path("projectCode").asText();
String previous = upload(code, PNG, "image/png").path("coverRelativePath").asText();
doThrow(new DataAccessResourceFailureException("simulated update failure"))
.when(projects).updateCover(eq(code), eq(owner), anyString(), any(Instant.class));
doThrow(new BizException(502, "OSS_DELETE_FAILED", "清理失败")).when(storage).deleteObject(anyString());
mvc.perform(multipart("/api/projects/" + code + "/cover").file(image(PNG, "image/png")).header("Authorization", bearer(token)))
.andExpect(status().isServiceUnavailable()).andExpect(jsonPath("$.code").value("DATABASE_UNAVAILABLE"));
assertThat(coverPath(code)).isEqualTo(previous);
assertThat(objects).hasSize(2);
verify(storage).deleteObject(anyString());
}
@Test
void publishingRequiresExistingCoverAndRepublishingAssignsNewTime() throws Exception {
String code = create(source(false)).path("projectCode").asText();
String path = upload(code, PNG, "image/png").path("coverRelativePath").asText();
objects.clear();
mvc.perform(post("/api/projects/" + code + "/publish").header("Authorization", bearer(token))).andExpect(status().isConflict());
objects.put("cadworld_dev/" + path, PNG);
publish(code);
jdbc.update("UPDATE robot_project SET published_at=? WHERE project_code=?", Timestamp.from(Instant.parse("2020-01-01T00:00:00Z")), code);
assertThat(publish(code).path("publishedAt").asText()).startsWith("2020-01-01");
mvc.perform(post("/api/projects/" + code + "/unpublish").header("Authorization", bearer(token))).andExpect(status().isOk());
assertThat(publish(code).path("publishedAt").asText()).doesNotStartWith("2020-01-01");
jdbc.update("UPDATE robot_project SET snapshot_json=? WHERE project_code=?", "{}", code);
mvc.perform(post("/api/projects/" + code + "/publish").header("Authorization", bearer(token))).andExpect(status().isConflict());
}
@Test
void forkAndUnpublishSerializeOnSourceProjectLock() throws Exception {
String code = create(source(false)).path("projectCode").asText();
upload(code, PNG, "image/png");
publish(code);
CountDownLatch sourceLocked = new CountDownLatch(1);
CountDownLatch releaseFork = new CountDownLatch(1);
CountDownLatch unpublishAttempted = new CountDownLatch(1);
doAnswer(invocation -> {
ProjectRepository.Project project = (ProjectRepository.Project) invocation.callRealMethod();
sourceLocked.countDown();
if (!releaseFork.await(5, TimeUnit.SECONDS)) throw new IllegalStateException("fork barrier timeout");
return project;
}).when(projects).published(code, true);
doAnswer(invocation -> {
unpublishAttempted.countDown();
return invocation.callRealMethod();
}).when(projects).owned(code, owner, true);
try (ExecutorService executor = Executors.newFixedThreadPool(2)) {
Future<ProjectResponse> fork = executor.submit(() -> service.fork(code, other));
try {
assertThat(sourceLocked.await(5, TimeUnit.SECONDS)).isTrue();
Future<ProjectResponse> unpublish = executor.submit(() -> service.visibility(code, owner, false));
assertThat(unpublishAttempted.await(5, TimeUnit.SECONDS)).isTrue();
assertThatThrownBy(() -> unpublish.get(150, TimeUnit.MILLISECONDS)).isInstanceOf(TimeoutException.class);
releaseFork.countDown();
assertThat(fork.get(5, TimeUnit.SECONDS).visibility()).isEqualTo("PRIVATE");
assertThat(unpublish.get(5, TimeUnit.SECONDS).visibility()).isEqualTo("PRIVATE");
} finally {
releaseFork.countDown();
}
}
mvc.perform(post("/api/plaza/projects/" + code + "/fork").header("Authorization", bearer(otherToken))).andExpect(status().isNotFound());
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM robot_project WHERE owner_user_code=?", Integer.class, other)).isEqualTo(1);
}
private void mockUploads() {
doAnswer(invocation -> {
java.io.InputStream input = invocation.getArgument(2, java.io.InputStream.class);
objects.put(invocation.getArgument(0, String.class), input.readAllBytes());
return null;
}).when(storage).putObject(anyString(), anyString(), any(), anyLong());
}
private String source(boolean partial) throws Exception {
String conversation = "DC-" + UUID.randomUUID().toString().replace("-", "");
String analysis = "DN-" + UUID.randomUUID().toString().replace("-", "");
Timestamp now = Timestamp.from(Instant.now());
String hash = HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(("user:" + owner).getBytes(StandardCharsets.US_ASCII)));
jdbc.update("INSERT INTO robot_demand_conversation(conversation_code,owner_hash,revision,created_at,updated_at,expires_at) VALUES (?,?,1,?,?,?)", conversation, hash, now, now, Timestamp.from(Instant.now().plusSeconds(3600)));
jdbc.update("INSERT INTO robot_demand_analysis(analysis_code,conversation_code,source_message_code,revision,status,result_json,model_version,failure_code,created_at,updated_at) VALUES (?,?,'m1',1,'ready',?,'test','',?,?)", analysis, conversation, "{\"request\":{\"userInput\":\"PRIVATE_PROMPT\"}}", now, now);
jdbc.update("INSERT INTO robot_demand_match(match_code,analysis_code,revision,result_json,degradation_accepted,created_at,updated_at) VALUES (?,?,1,?,0,?,?)", "DM-" + UUID.randomUUID(), analysis, json.writeValueAsString(match(partial)), now, now);
return analysis;
}
private ObjectNode match(boolean partial) throws Exception {
ObjectNode result = (ObjectNode) json.readTree("""
{"analysisId":"DN-private","conversationId":"DC-private","snapshot":{"id":9000,"secret":"PRIVATE_KEY"},
"request":{"userInput":"PRIVATE_PROMPT"},"alternatives":[{"secret":"PRIVATE_KEY"}],
"status":"complete","rootCategory":"TORSO_0","searchLimited":false,"totals":{"massKg":1},
"components":[{"instanceId":"DM-test:TORSO_0","id":12,"snapshot":{"secret":"PRIVATE_KEY"},
"component":{"componentCode":"C-TORSO","componentName":"躯干","version":3,"id":9001,
"internalObjectKey":"PRIVATE_KEY","urdfInfo":{"rootLink":"BASE","frames":[],"id":9002}},
"urdfMainPath":"robot.urdf","resourceIssues":[],
"resources":[{"relativePath":"robot.urdf","url":"https://assets.example.test/cadworld_dev/components/robot.urdf","version":3,"expiresAt":null,"id":9003}]}],
"assembly":{"status":"ready","rootInstanceId":"DM-test:TORSO_0","connections":[],"issues":[]},
"unmetRequirements":[],"missingParts":[],"missingPartGroups":[],"requirementChecks":[]}
""");
if (partial) {
result.put("status", "partial");
result.withArray("missingParts").addObject().put("category", "ARM_R").put("missingQuantity", 1).put("reason", "NO_CANDIDATE");
}
return result;
}
private org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder createRequest(String analysis, String accessToken) throws Exception {
return post("/api/projects").header("Authorization", bearer(accessToken)).contentType(MediaType.APPLICATION_JSON)
.content(json.writeValueAsString(Map.of("analysisCode", analysis, "projectName", "我的机器人", "description", "项目简介")));
}
private JsonNode create(String analysis) throws Exception {
return data(mvc.perform(createRequest(analysis, token)).andExpect(status().isOk()).andReturn());
}
private JsonNode upload(String code, byte[] bytes, String mime) throws Exception {
return data(mvc.perform(multipart("/api/projects/" + code + "/cover").file(image(bytes, mime)).header("Authorization", bearer(token)))
.andExpect(status().isOk()).andReturn());
}
private JsonNode publish(String code) throws Exception {
return data(mvc.perform(post("/api/projects/" + code + "/publish").header("Authorization", bearer(token)))
.andExpect(status().isOk()).andReturn());
}
private JsonNode data(MvcResult result) throws Exception {
return json.readTree(result.getResponse().getContentAsString()).path("data");
}
private MockMultipartFile image(byte[] bytes, String mime) {
return new MockMultipartFile("file", "../client-name.svg", mime, bytes);
}
private String coverPath(String code) {
return jdbc.queryForObject("SELECT cover_relative_path FROM robot_project WHERE project_code=?", String.class, code);
}
private String bearer(String value) {
return "Bearer " + value;
}
}
@@ -44,7 +44,7 @@ class ApiCorsConfigurationTest {
runner.withPropertyValues("spring.profiles.active=" + profile).run(context -> {
assertThat(context).hasNotFailed();
MockMvc mvc = MockMvcBuilders.webAppContextSetup(context).addFilters(new RequestIdFilter()).build();
for (String method : List.of("GET", "POST", "DELETE")) {
for (String method : List.of("GET", "POST", "PATCH", "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,authorization"))
@@ -96,7 +96,7 @@ class ApiCorsConfigurationTest {
@RestController
static class ProbeController {
@RequestMapping(value = "/api/cors-probe", method = {RequestMethod.GET, RequestMethod.POST, RequestMethod.DELETE})
@RequestMapping(value = "/api/cors-probe", method = {RequestMethod.GET, RequestMethod.POST, RequestMethod.PATCH, RequestMethod.DELETE})
public String probe() { return "ok"; }
}
}
@@ -0,0 +1,9 @@
package com.linkerbot.cadworld.dto.project;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
public record CreateProjectRequest(
@NotBlank @Size(max = 64) String analysisCode,
@NotBlank @Size(max = 128) String projectName,
@Size(max = 2000) String description) { }
@@ -0,0 +1,18 @@
package com.linkerbot.cadworld.dto.project;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.JsonNode;
import java.time.Instant;
/** 列表省略 snapshot,详情包含装配快照;不序列化数据库实体。 */
public record ProjectResponse(
String projectCode, String ownerUserCode, String projectName, String description,
String coverRelativePath, String coverUrl, String schemaVersion,
String matchStatus, String assemblyStatus, String sourceProjectCode,
String visibility, Instant publishedAt, Instant createdAt, Instant updatedAt,
@JsonInclude(JsonInclude.Include.NON_NULL) JsonNode snapshot) {
@Override
public String toString() {
return "ProjectResponse[projectCode=" + projectCode + ", visibility=" + visibility + "]";
}
}
@@ -0,0 +1,8 @@
package com.linkerbot.cadworld.dto.project;
import jakarta.validation.constraints.Size;
/** null 表示保持原值,简介传空字符串表示清空。 */
public record UpdateProjectRequest(
@Size(min = 1, max = 128) String projectName,
@Size(max = 2000) String description) { }
@@ -57,6 +57,7 @@ public class ApiSecurityConfiguration {
.requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
.requestMatchers(HttpMethod.GET, "/api/auth/captcha").permitAll()
.requestMatchers(HttpMethod.POST, "/api/auth/login").permitAll()
.requestMatchers(HttpMethod.GET, "/api/plaza/projects", "/api/plaza/projects/*").permitAll()
.anyRequest().authenticated())
.exceptionHandling(errors -> errors
.authenticationEntryPoint((request, response, exception) -> {
@@ -168,6 +168,25 @@ public class DemandRepository {
return rows.isEmpty() ? null : decode(rows.get(0));
}
/** 调用方必须在事务内插入项目,保持会话锁至项目快照落库,防止清理或新消息推进版本。 */
public JsonNode matchForProject(String code, String owner) {
List<String> conversations = jdbc.queryForList(
"SELECT conversation_code FROM robot_demand_analysis WHERE analysis_code=?", String.class, code);
if (conversations.isEmpty()) throw notFound();
Conversation current = conversation(conversations.get(0), owner, true);
// 使用锁定读获取最新已提交记录,避免 MySQL 可重复读下先前查询建立的旧快照。
List<Analysis> rows = jdbc.query("SELECT * FROM robot_demand_analysis WHERE analysis_code=? FOR UPDATE", this::analysis, code);
if (rows.isEmpty()) throw notFound();
Analysis analysis = rows.get(0);
if (analysis.revision() != current.revision() || !"ready".equals(analysis.status())) {
throw new BizException(409, "PROJECT_RESULT_UNAVAILABLE", "需求结果未完成或版本已更新,请使用当前已生成方案");
}
List<String> matches = jdbc.queryForList(
"SELECT result_json FROM robot_demand_match WHERE analysis_code=? FOR UPDATE", String.class, code);
if (matches.isEmpty()) throw new BizException(409, "PROJECT_RESULT_UNAVAILABLE", "需求尚未生成可保存的装配方案");
return decode(matches.get(0));
}
public void fail(String code, String state, String failure) {
jdbc.update("UPDATE robot_demand_analysis SET status=?,failure_code=?,updated_at=? WHERE analysis_code=? AND status='processing'",
state, failure, timestamp(Instant.now()), code);
@@ -0,0 +1,73 @@
package com.linkerbot.cadworld.service.project;
import com.linkerbot.cadworld.common.api.RequestIdHolder;
import com.linkerbot.cadworld.common.exception.BizException;
import com.linkerbot.cadworld.service.client.ObjectStorageClient;
import com.linkerbot.cadworld.service.impl.ObjectStorageUrlResolver;
import com.linkerbot.cadworld.service.support.StorageObjectKeys;
import java.io.ByteArrayInputStream;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.UUID;
import lombok.extern.slf4j.Slf4j;
/** 封面是项目唯一允许上传的图片资源,数据库路径不包含环境根目录。 */
@Slf4j
public class ProjectCoverStore {
public static final long MAX_BYTES = 8L * 1024 * 1024;
private final ObjectStorageClient storage;
private final StorageObjectKeys keys;
private final ObjectStorageUrlResolver urls;
public ProjectCoverStore(ObjectStorageClient storage, StorageObjectKeys keys, ObjectStorageUrlResolver urls) {
this.storage = storage;
this.keys = keys;
this.urls = urls;
}
public StoredCover upload(String projectCode, byte[] bytes, String mime) {
if (bytes.length > MAX_BYTES) throw new BizException(413, "UPLOAD_TOO_LARGE", "封面图片不能超过8MiB");
String extension = extension(bytes, mime);
String relativePath = "projects/" + projectCode + "/covers/" + UUID.randomUUID().toString().replace("-", "") + extension;
String objectKey = keys.underRoot(relativePath);
// 上传之前检查 URL 配置,避免 OSS 成功后因访问域名缺失而产生不可使用的封面。
urls.resolvePublicUrl(objectKey);
storage.putObject(objectKey, mime, new ByteArrayInputStream(bytes), bytes.length);
return new StoredCover(relativePath, objectKey);
}
public String url(String relativePath) {
return relativePath == null ? null : urls.resolvePublicUrl(keys.underRoot(relativePath));
}
public boolean exists(String relativePath) {
return relativePath != null && storage.objectExists(keys.underRoot(relativePath));
}
public void compensate(StoredCover cover, String projectCode, String owner) {
try {
storage.deleteObject(cover.objectKey());
} catch (RuntimeException exception) {
log.error("项目封面补偿清理失败 projectCode={} userCode={} keySummary={} requestId={} exceptionType={} location={}",
projectCode, owner, StorageObjectKeys.summary(cover.objectKey()), RequestIdHolder.get(),
exception.getClass().getSimpleName(), location(exception));
}
}
private String extension(byte[] bytes, String mime) {
if ("image/png".equals(mime) && bytes.length >= 8
&& Arrays.equals(Arrays.copyOf(bytes, 8), new byte[] {(byte) 137, 80, 78, 71, 13, 10, 26, 10})) return ".png";
if ("image/jpeg".equals(mime) && bytes.length >= 3
&& bytes[0] == (byte) 255 && bytes[1] == (byte) 216 && bytes[2] == (byte) 255) return ".jpg";
if ("image/webp".equals(mime) && bytes.length >= 12
&& "RIFF".equals(new String(bytes, 0, 4, StandardCharsets.US_ASCII))
&& "WEBP".equals(new String(bytes, 8, 4, StandardCharsets.US_ASCII))) return ".webp";
throw new BizException(422, "INVALID_PROJECT_COVER", "封面仅支持非空PNG、JPEG、WebP图片,文件内容须与格式一致");
}
static String location(RuntimeException exception) {
return exception.getStackTrace().length == 0 ? "unknown" : exception.getStackTrace()[0].toString();
}
public record StoredCover(String relativePath, String objectKey) { }
}
@@ -0,0 +1,139 @@
package com.linkerbot.cadworld.service.project;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linkerbot.cadworld.common.exception.BizException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.time.Instant;
import java.util.List;
import org.springframework.jdbc.core.JdbcTemplate;
/** 锁定读及写入由 ProjectService 的事务组织,所有定位条件均使用业务编码。 */
public class ProjectRepository {
private static final String SUMMARY_COLUMNS = "project_code,owner_user_code,project_name,description,"
+ "cover_relative_path,schema_version,match_status,assembly_status,source_analysis_code,"
+ "source_project_code,visibility,published_at,created_at,updated_at";
private final JdbcTemplate jdbc;
private final ObjectMapper json;
public ProjectRepository(JdbcTemplate jdbc, ObjectMapper json) {
this.jdbc = jdbc;
this.json = json;
}
public Project owned(String code, String owner, boolean lock) {
return require("project_code=? AND owner_user_code=? AND deleted=0", lock, code, owner);
}
public Project published(String code, boolean lock) {
return require("project_code=? AND visibility='PUBLIC' AND deleted=0", lock, code);
}
private Project require(String condition, boolean lock, Object... arguments) {
List<Project> rows = jdbc.query("SELECT " + SUMMARY_COLUMNS + ",snapshot_json FROM robot_project WHERE "
+ condition + (lock ? " FOR UPDATE" : ""),
(ResultSet row, int index) -> read(row, true), arguments);
if (rows.isEmpty()) throw notFound();
return rows.get(0);
}
public List<Project> list(String owner, long size, long offset) {
String condition = owner == null ? "visibility='PUBLIC'" : "owner_user_code=?";
String order = owner == null ? "published_at" : "updated_at";
Object[] arguments = owner == null ? new Object[] {size, offset} : new Object[] {owner, size, offset};
return jdbc.query("SELECT " + SUMMARY_COLUMNS + " FROM robot_project WHERE deleted=0 AND "
+ condition + " ORDER BY " + order + " DESC,project_code DESC LIMIT ? OFFSET ?",
(ResultSet row, int index) -> read(row, false), arguments);
}
public long count(String owner) {
Long total = owner == null
? jdbc.queryForObject("SELECT COUNT(*) FROM robot_project WHERE deleted=0 AND visibility='PUBLIC'", Long.class)
: jdbc.queryForObject("SELECT COUNT(*) FROM robot_project WHERE deleted=0 AND owner_user_code=?", Long.class, owner);
return total == null ? 0 : total;
}
public void insert(Project project) {
jdbc.update("""
INSERT INTO robot_project
(project_code,owner_user_code,project_name,description,cover_relative_path,snapshot_json,
schema_version,match_status,assembly_status,source_analysis_code,source_project_code,
visibility,published_at,deleted,created_at,updated_at)
VALUES (?,?,?,?,?,?,?,?,?,?,?,'PRIVATE',NULL,0,?,?)
""", project.projectCode(), project.ownerUserCode(), project.projectName(), project.description(),
project.coverRelativePath(), encode(project.snapshot()), project.schemaVersion(), project.matchStatus(),
project.assemblyStatus(), project.sourceAnalysisCode(), project.sourceProjectCode(),
Timestamp.from(project.createdAt()), Timestamp.from(project.updatedAt()));
}
public void updateMetadata(String code, String owner, String name, String description, Instant now) {
checkChanged(jdbc.update("UPDATE robot_project SET project_name=?,description=?,updated_at=? "
+ "WHERE project_code=? AND owner_user_code=? AND deleted=0",
name, description, Timestamp.from(now), code, owner));
}
public void updateCover(String code, String owner, String relativePath, Instant now) {
checkChanged(jdbc.update("UPDATE robot_project SET cover_relative_path=?,updated_at=? "
+ "WHERE project_code=? AND owner_user_code=? AND deleted=0",
relativePath, Timestamp.from(now), code, owner));
}
public void visibility(String code, String owner, boolean published, Instant now) {
checkChanged(jdbc.update("UPDATE robot_project SET visibility=?,published_at=?,updated_at=? "
+ "WHERE project_code=? AND owner_user_code=? AND deleted=0",
published ? "PUBLIC" : "PRIVATE", published ? Timestamp.from(now) : null,
Timestamp.from(now), code, owner));
}
public void delete(String code, String owner, Instant now) {
checkChanged(jdbc.update("UPDATE robot_project SET deleted=1,updated_at=? "
+ "WHERE project_code=? AND owner_user_code=? AND deleted=0", Timestamp.from(now), code, owner));
}
private Project read(ResultSet row, boolean withSnapshot) throws SQLException {
Timestamp publishedAt = row.getTimestamp("published_at");
return new Project(row.getString("project_code"), row.getString("owner_user_code"), row.getString("project_name"),
row.getString("description"), row.getString("cover_relative_path"), row.getString("schema_version"),
row.getString("match_status"), row.getString("assembly_status"), row.getString("source_analysis_code"),
row.getString("source_project_code"), row.getString("visibility"),
publishedAt == null ? null : publishedAt.toInstant(), row.getTimestamp("created_at").toInstant(),
row.getTimestamp("updated_at").toInstant(), withSnapshot ? decode(row.getString("snapshot_json")) : null);
}
private String encode(JsonNode value) {
try {
return json.writeValueAsString(value);
} catch (JsonProcessingException exception) {
throw new IllegalStateException("项目装配快照无法保存");
}
}
private JsonNode decode(String value) {
try {
return json.readTree(value);
} catch (JsonProcessingException exception) {
throw new IllegalStateException("项目装配快照格式错误");
}
}
private void checkChanged(int changed) {
if (changed != 1) throw notFound();
}
static BizException notFound() {
return new BizException(404, "PROJECT_NOT_FOUND", "项目不存在或无权访问");
}
public record Project(String projectCode, String ownerUserCode, String projectName, String description,
String coverRelativePath, String schemaVersion, String matchStatus, String assemblyStatus,
String sourceAnalysisCode, String sourceProjectCode, String visibility,
Instant publishedAt, Instant createdAt, Instant updatedAt, JsonNode snapshot) {
@Override
public String toString() {
return "Project[projectCode=" + projectCode + ", visibility=" + visibility + "]";
}
}
}
@@ -0,0 +1,169 @@
package com.linkerbot.cadworld.service.project;
import com.fasterxml.jackson.databind.JsonNode;
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.project.CreateProjectRequest;
import com.linkerbot.cadworld.dto.project.ProjectResponse;
import com.linkerbot.cadworld.dto.project.UpdateProjectRequest;
import com.linkerbot.cadworld.service.demand.DemandRepository;
import com.linkerbot.cadworld.service.project.ProjectRepository.Project;
import java.time.Instant;
import java.util.List;
import java.util.UUID;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
/** 由用户端专用配置注册,管理端无需初始化需求或项目业务。 */
@Slf4j
public class ProjectService {
private final ProjectRepository projects;
private final DemandRepository demands;
private final ProjectSnapshots snapshots;
private final ProjectCoverStore covers;
private final TransactionTemplate transactions;
public ProjectService(ProjectRepository projects, DemandRepository demands, ProjectSnapshots snapshots,
ProjectCoverStore covers, PlatformTransactionManager manager) {
this.projects = projects;
this.demands = demands;
this.snapshots = snapshots;
this.covers = covers;
this.transactions = new TransactionTemplate(manager);
}
public ProjectResponse create(String owner, String demandOwner, CreateProjectRequest request) {
Project project = transactions.execute(status -> {
JsonNode snapshot = snapshots.capture(demands.matchForProject(request.analysisCode(), demandOwner));
Project created = newProject(owner, requireName(request.projectName()),
request.description() == null ? "" : request.description(), null,
request.analysisCode(), null, snapshot);
projects.insert(created);
return created;
});
log.info("项目保存成功 projectCode={} userCode={} analysisCode={} matchStatus={} requestId={}",
project.projectCode(), owner, request.analysisCode(), project.matchStatus(), RequestIdHolder.get());
return response(project);
}
public PageResponse<ProjectResponse> list(String owner, long page, long size) {
if (page < 1 || size < 1 || size > 100 || page - 1 > Long.MAX_VALUE / size) {
throw new BizException(422, "INVALID_REQUEST", "分页参数非法,page至少为1,size范围为1至100");
}
List<ProjectResponse> items = projects.list(owner, size, (page - 1) * size).stream().map(this::response).toList();
return new PageResponse<>(items, page, size, projects.count(owner));
}
public ProjectResponse owned(String code, String owner) {
return response(projects.owned(code, owner, false));
}
public ProjectResponse published(String code) {
return response(projects.published(code, false));
}
public ProjectResponse update(String code, String owner, UpdateProjectRequest request) {
Project project = transactions.execute(status -> {
Project current = projects.owned(code, owner, true);
projects.updateMetadata(code, owner,
request.projectName() == null ? current.projectName() : requireName(request.projectName()),
request.description() == null ? current.description() : request.description(), Instant.now());
return projects.owned(code, owner, true);
});
log.info("项目资料更新成功 projectCode={} userCode={} requestId={}", code, owner, RequestIdHolder.get());
return response(project);
}
public void delete(String code, String owner) {
transactions.executeWithoutResult(status -> {
projects.owned(code, owner, true);
projects.delete(code, owner, Instant.now());
});
log.info("项目删除成功 projectCode={} userCode={} requestId={}", code, owner, RequestIdHolder.get());
}
public ProjectResponse uploadCover(String code, String owner, byte[] bytes, String mime) {
projects.owned(code, owner, false);
ProjectCoverStore.StoredCover cover;
try {
cover = covers.upload(code, bytes, mime);
} catch (RuntimeException exception) {
String reason = exception instanceof BizException business ? business.getCode() : exception.getClass().getSimpleName();
log.warn("项目封面上传失败 projectCode={} userCode={} reason={} requestId={} exceptionType={} location={}",
code, owner, reason, RequestIdHolder.get(), exception.getClass().getSimpleName(), ProjectCoverStore.location(exception));
throw exception;
}
Project project;
try {
project = transactions.execute(status -> {
// 网络上传不持有行锁;落库前重新核对,上传期间被删除时必须清理新对象。
projects.owned(code, owner, true);
projects.updateCover(code, owner, cover.relativePath(), Instant.now());
return projects.owned(code, owner, true);
});
} catch (RuntimeException exception) {
log.error("项目封面关联失败 projectCode={} userCode={} requestId={} exceptionType={} location={}",
code, owner, RequestIdHolder.get(), exception.getClass().getSimpleName(), ProjectCoverStore.location(exception));
covers.compensate(cover, code, owner);
throw exception;
}
log.info("项目封面更新成功 projectCode={} userCode={} sizeBytes={} requestId={}", code, owner, bytes.length, RequestIdHolder.get());
return response(project);
}
public ProjectResponse visibility(String code, String owner, boolean published) {
Project project = transactions.execute(status -> {
Project current = projects.owned(code, owner, true);
if (published) {
snapshots.validate(current.snapshot());
if (!covers.exists(current.coverRelativePath())) {
throw new BizException(409, "PROJECT_COVER_REQUIRED", "发布前请先上传有效的项目封面");
}
}
if ((published ? "PUBLIC" : "PRIVATE").equals(current.visibility())) return current;
projects.visibility(code, owner, published, Instant.now());
return projects.owned(code, owner, true);
});
log.info("项目发布状态更新成功 projectCode={} userCode={} visibility={} requestId={}",
code, owner, project.visibility(), RequestIdHolder.get());
return response(project);
}
public ProjectResponse fork(String sourceCode, String owner) {
Project project = transactions.execute(status -> {
// 与取消发布和删除共用来源行锁,确保只从当时仍公开的项目创建副本。
Project source = projects.published(sourceCode, true);
Project created = newProject(owner, source.projectName(), source.description(), source.coverRelativePath(),
null, source.projectCode(), snapshots.capture(source.snapshot()));
projects.insert(created);
return created;
});
log.info("项目fork成功 projectCode={} sourceProjectCode={} userCode={} requestId={}",
project.projectCode(), sourceCode, owner, RequestIdHolder.get());
return response(project);
}
private Project newProject(String owner, String name, String description, String cover,
String analysisCode, String sourceCode, JsonNode snapshot) {
Instant now = Instant.now();
return new Project("RP-" + UUID.randomUUID().toString().replace("-", ""), owner, name, description, cover,
ProjectSnapshots.SCHEMA_VERSION, snapshot.path("status").asText(), snapshot.path("assembly").path("status").asText(),
analysisCode, sourceCode, "PRIVATE", null, now, now, snapshot);
}
private String requireName(String name) {
if (name == null || name.isBlank() || name.length() > 128) {
throw new BizException(422, "INVALID_REQUEST", "项目名称不能为空且不能超过128字符");
}
return name.strip();
}
private ProjectResponse response(Project project) {
return new ProjectResponse(project.projectCode(), project.ownerUserCode(), project.projectName(), project.description(),
project.coverRelativePath(), covers.url(project.coverRelativePath()), project.schemaVersion(), project.matchStatus(),
project.assemblyStatus(), project.sourceProjectCode(), project.visibility(), project.publishedAt(),
project.createdAt(), project.updatedAt(), project.snapshot() == null ? null : snapshots.capture(project.snapshot()));
}
}
@@ -0,0 +1,80 @@
package com.linkerbot.cadworld.service.project;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.linkerbot.cadworld.common.exception.BizException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
/** 只保存可公开的装配展示字段,隔离需求原文、历史内部快照及候选方案。 */
public class ProjectSnapshots {
public static final String SCHEMA_VERSION = "project-v1";
private static final List<String> MATCH_FIELDS = List.of("status", "rootCategory", "searchLimited", "totals",
"unmetRequirements", "missingParts", "missingPartGroups", "requirementChecks", "assembly");
private static final List<String> COMPONENT_FIELDS = List.of("componentCode", "componentName", "category", "description",
"material", "massKg", "degreesOfFreedom", "rotationAxis", "functionDescription", "shape", "size", "torqueNm",
"bomList", "urdfInfo", "version", "stepUrl", "urdfUrl");
private static final Set<String> INTERNAL_FIELDS = Set.of("id", "snapshot", "ownerHash", "owner_hash", "ownerUserCode",
"analysisId", "analysisCode", "conversationId", "conversationCode", "matchId", "attachmentId", "attachmentIds",
"attachmentCode", "attachmentCodes", "messageId", "messageCode");
private final ObjectMapper json;
public ProjectSnapshots(ObjectMapper json) {
this.json = json;
}
public ObjectNode capture(JsonNode match) {
validate(match);
ObjectNode result = copyFields(match, MATCH_FIELDS);
ArrayNode components = result.putArray("components");
for (JsonNode component : match.path("components")) {
ObjectNode item = copyFields(component, List.of("instanceId", "resources", "resourceIssues", "urdfMainPath"));
item.set("component", copyFields(component.path("component"), COMPONENT_FIELDS));
components.add(item);
}
removeInternalFields(result);
return result;
}
public void validate(JsonNode match) {
if (match == null || !List.of("complete", "partial").contains(match.path("status").asText())
|| !List.of("ready", "partial").contains(match.path("assembly").path("status").asText())
|| !match.path("components").isArray() || match.path("components").isEmpty()) {
throw new BizException(409, "PROJECT_RESULT_UNAVAILABLE", "仅可保存或发布已生成且可预览的装配方案");
}
for (JsonNode component : match.path("components")) {
if (component.path("instanceId").asText().isBlank()
|| component.path("component").path("componentCode").asText().isBlank()) {
throw new BizException(409, "PROJECT_RESULT_UNAVAILABLE", "装配方案的组件实例信息不完整");
}
}
}
private ObjectNode copyFields(JsonNode source, List<String> fields) {
ObjectNode result = json.createObjectNode();
for (String field : fields) {
if (source.has(field)) result.set(field, source.get(field).deepCopy());
}
return result;
}
private void removeInternalFields(JsonNode node) {
if (node.isObject()) {
ObjectNode object = (ObjectNode) node;
List<String> removed = new ArrayList<>();
Iterator<String> names = object.fieldNames();
while (names.hasNext()) {
String name = names.next();
if (INTERNAL_FIELDS.contains(name)) removed.add(name);
else removeInternalFields(object.get(name));
}
object.remove(removed);
} else if (node.isArray()) {
for (JsonNode child : node) removeInternalFields(child);
}
}
}
@@ -0,0 +1,28 @@
package com.linkerbot.cadworld.service.project;
import com.linkerbot.cadworld.config.StorageProperties;
import com.linkerbot.cadworld.service.client.ObjectStorageClient;
import com.linkerbot.cadworld.service.impl.ObjectStorageUrlResolver;
import com.linkerbot.cadworld.service.support.StorageObjectKeys;
import java.time.Duration;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
class ProjectCoverStoreTest {
@Test
void sameDatabaseRelativePathUsesCurrentEnvironmentAndDomainExactlyOnce() {
String path = "projects/RP-test/covers/cover.png";
assertThat(store("cadworld_dev", "https://dev.example.test/").url(path))
.isEqualTo("https://dev.example.test/cadworld_dev/" + path);
assertThat(store("cadworld", "https://cdn.example.test").url(path))
.isEqualTo("https://cdn.example.test/cadworld/" + path);
assertThat(store("cadworld", "https://cdn.example.test").url(null)).isNull();
}
private ProjectCoverStore store(String root, String domain) {
StorageProperties properties = new StorageProperties(root, domain, Duration.ofMinutes(30), Duration.ofMinutes(5), 104857600);
return new ProjectCoverStore(mock(ObjectStorageClient.class), new StorageObjectKeys(properties), new ObjectStorageUrlResolver(properties));
}
}