From 0631bd5eccf367cebfc0c81800a26e394c7e18e9 Mon Sep 17 00:00:00 2001 From: lxp <2770281812@qq.com> Date: Tue, 20 Oct 2026 11:30:19 +0800 Subject: [PATCH] =?UTF-8?q?=E4=B8=AA=E4=BA=BA=E5=B7=A5=E4=BD=9C=E7=A9=BA?= =?UTF-8?q?=E9=97=B4=E5=92=8C=E5=B9=BF=E5=9C=BA=EF=BC=8C=E6=94=AF=E6=8C=81?= =?UTF-8?q?=E5=8F=91=E5=B8=83=E5=88=B0=E5=B9=BF=E5=9C=BA=E5=92=8Cfork?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cadworld-api/docs/project-api.md | 145 ++++++ cadworld-api/docs/project-schema.md | 55 +++ cadworld-api/docs/robot-demand-api.md | 1 + .../api/config/DemandConfiguration.java | 2 +- .../api/config/ProjectConfiguration.java | 46 ++ .../controller/RobotProjectController.java | 110 +++++ .../src/main/resources/application.yml | 5 + .../cadworld/api/ProjectApiTest.java | 455 ++++++++++++++++++ .../api/config/ApiCorsConfigurationTest.java | 4 +- .../dto/project/CreateProjectRequest.java | 9 + .../cadworld/dto/project/ProjectResponse.java | 18 + .../dto/project/UpdateProjectRequest.java | 8 + .../api/ApiSecurityConfiguration.java | 1 + .../service/demand/DemandRepository.java | 19 + .../service/project/ProjectCoverStore.java | 73 +++ .../service/project/ProjectRepository.java | 139 ++++++ .../service/project/ProjectService.java | 169 +++++++ .../service/project/ProjectSnapshots.java | 80 +++ .../project/ProjectCoverStoreTest.java | 28 ++ 19 files changed, 1364 insertions(+), 3 deletions(-) create mode 100644 cadworld-api/docs/project-api.md create mode 100644 cadworld-api/docs/project-schema.md create mode 100644 cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/ProjectConfiguration.java create mode 100644 cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/RobotProjectController.java create mode 100644 cadworld-api/src/test/java/com/linkerbot/cadworld/api/ProjectApiTest.java create mode 100644 cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/CreateProjectRequest.java create mode 100644 cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/ProjectResponse.java create mode 100644 cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/UpdateProjectRequest.java create mode 100644 cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectCoverStore.java create mode 100644 cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectRepository.java create mode 100644 cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectService.java create mode 100644 cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectSnapshots.java create mode 100644 cadworld-service/src/test/java/com/linkerbot/cadworld/service/project/ProjectCoverStoreTest.java diff --git a/cadworld-api/docs/project-api.md b/cadworld-api/docs/project-api.md new file mode 100644 index 0000000..1587d55 --- /dev/null +++ b/cadworld-api/docs/project-api.md @@ -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 时沿用现有鉴权规则返回 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 对象,一期不提供自动垃圾回收。 diff --git a/cadworld-api/docs/project-schema.md b/cadworld-api/docs/project-schema.md new file mode 100644 index 0000000..4075d20 --- /dev/null +++ b/cadworld-api/docs/project-schema.md @@ -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 可能共享这些对象;后续清理必须先确认没有项目引用。 diff --git a/cadworld-api/docs/robot-demand-api.md b/cadworld-api/docs/robot-demand-api.md index 7b84047..b59d733 100644 --- a/cadworld-api/docs/robot-demand-api.md +++ b/cadworld-api/docs/robot-demand-api.md @@ -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 `,不再依赖匿名 Cookie 或 `credentials:"include"`。会话和图片归属服务端认证的用户,同账号换设备登录后仍可通过原业务编码访问;其他账号访问返回 404。历史匿名会话不自动认领,保留至过期清理。不传 `userId`、用户编码、模型 Key 或系统提示词。生产使用 HTTPS;开发跨端口需配置具体允许域名。 diff --git a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/DemandConfiguration.java b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/DemandConfiguration.java index 30e3006..0118161 100644 --- a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/DemandConfiguration.java +++ b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/DemandConfiguration.java @@ -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)); } diff --git a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/ProjectConfiguration.java b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/ProjectConfiguration.java new file mode 100644 index 0000000..6b1792d --- /dev/null +++ b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/ProjectConfiguration.java @@ -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); + } +} diff --git a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/RobotProjectController.java b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/RobotProjectController.java new file mode 100644 index 0000000..ea2ab3d --- /dev/null +++ b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/RobotProjectController.java @@ -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 create(@Valid @RequestBody CreateProjectRequest request) { + return ApiResponse.success(projects.create(CurrentUser.required(), demandOwners.resolve(), request)); + } + + @GetMapping("/projects") + public ApiResponse> 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 detail(@PathVariable @NotBlank @Size(max = 64) String projectCode) { + return ApiResponse.success(projects.owned(projectCode, CurrentUser.required())); + } + + @PatchMapping("/projects/{projectCode}") + public ApiResponse 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 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 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 publish(@PathVariable @NotBlank @Size(max = 64) String projectCode) { + return ApiResponse.success(projects.visibility(projectCode, CurrentUser.required(), true)); + } + + @PostMapping("/projects/{projectCode}/unpublish") + public ApiResponse unpublish(@PathVariable @NotBlank @Size(max = 64) String projectCode) { + return ApiResponse.success(projects.visibility(projectCode, CurrentUser.required(), false)); + } + + @GetMapping("/plaza/projects") + public ApiResponse> 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 published(@PathVariable @NotBlank @Size(max = 64) String projectCode) { + return ApiResponse.success(projects.published(projectCode)); + } + + @PostMapping("/plaza/projects/{projectCode}/fork") + public ApiResponse fork(@PathVariable @NotBlank @Size(max = 64) String projectCode) { + return ApiResponse.success(projects.fork(projectCode, CurrentUser.required())); + } +} diff --git a/cadworld-api/src/main/resources/application.yml b/cadworld-api/src/main/resources/application.yml index fae8a51..a1eccbd 100644 --- a/cadworld-api/src/main/resources/application.yml +++ b/cadworld-api/src/main/resources/application.yml @@ -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 diff --git a/cadworld-api/src/test/java/com/linkerbot/cadworld/api/ProjectApiTest.java b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/ProjectApiTest.java new file mode 100644 index 0000000..49db62b --- /dev/null +++ b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/ProjectApiTest.java @@ -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 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) 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 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 fork = executor.submit(() -> service.fork(code, other)); + try { + assertThat(sourceLocked.await(5, TimeUnit.SECONDS)).isTrue(); + Future 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; + } +} diff --git a/cadworld-api/src/test/java/com/linkerbot/cadworld/api/config/ApiCorsConfigurationTest.java b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/config/ApiCorsConfigurationTest.java index 56fc674..015f3a1 100644 --- a/cadworld-api/src/test/java/com/linkerbot/cadworld/api/config/ApiCorsConfigurationTest.java +++ b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/config/ApiCorsConfigurationTest.java @@ -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"; } } } diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/CreateProjectRequest.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/CreateProjectRequest.java new file mode 100644 index 0000000..4bc128a --- /dev/null +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/CreateProjectRequest.java @@ -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) { } diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/ProjectResponse.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/ProjectResponse.java new file mode 100644 index 0000000..0fa088d --- /dev/null +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/ProjectResponse.java @@ -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 + "]"; + } +} diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/UpdateProjectRequest.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/UpdateProjectRequest.java new file mode 100644 index 0000000..ffe49e5 --- /dev/null +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/project/UpdateProjectRequest.java @@ -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) { } diff --git a/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/ApiSecurityConfiguration.java b/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/ApiSecurityConfiguration.java index ee05116..2d3e9aa 100644 --- a/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/ApiSecurityConfiguration.java +++ b/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/ApiSecurityConfiguration.java @@ -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) -> { diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/demand/DemandRepository.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/demand/DemandRepository.java index aa07bb9..366d532 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/demand/DemandRepository.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/demand/DemandRepository.java @@ -168,6 +168,25 @@ public class DemandRepository { return rows.isEmpty() ? null : decode(rows.get(0)); } + /** 调用方必须在事务内插入项目,保持会话锁至项目快照落库,防止清理或新消息推进版本。 */ + public JsonNode matchForProject(String code, String owner) { + List 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 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 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); diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectCoverStore.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectCoverStore.java new file mode 100644 index 0000000..8e08e9c --- /dev/null +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectCoverStore.java @@ -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) { } +} diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectRepository.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectRepository.java new file mode 100644 index 0000000..86d26b1 --- /dev/null +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectRepository.java @@ -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 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 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 + "]"; + } + } +} diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectService.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectService.java new file mode 100644 index 0000000..015eb8e --- /dev/null +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectService.java @@ -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 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 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())); + } +} diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectSnapshots.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectSnapshots.java new file mode 100644 index 0000000..8a6af98 --- /dev/null +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/project/ProjectSnapshots.java @@ -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 MATCH_FIELDS = List.of("status", "rootCategory", "searchLimited", "totals", + "unmetRequirements", "missingParts", "missingPartGroups", "requirementChecks", "assembly"); + private static final List 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 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 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 removed = new ArrayList<>(); + Iterator 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); + } + } +} diff --git a/cadworld-service/src/test/java/com/linkerbot/cadworld/service/project/ProjectCoverStoreTest.java b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/project/ProjectCoverStoreTest.java new file mode 100644 index 0000000..b5ce8a6 --- /dev/null +++ b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/project/ProjectCoverStoreTest.java @@ -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)); + } +}