From ed7920c9f6ecc05fdc5bf045dd8e10e75907aec8 Mon Sep 17 00:00:00 2001 From: lxp <2770281812@qq.com> Date: Wed, 4 Nov 2026 17:35:31 +0800 Subject: [PATCH] =?UTF-8?q?pcb=E9=A1=B9=E7=9B=AE=E6=8E=A5=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 8 + README.md | 4 +- docs/frontend-pcb-workspace.md | 128 ++++ docs/oss-storage-paths.md | 5 +- docs/pcb-database.md | 50 ++ docs/vibemake-api.md | 2 + .../controller/PcbWorkspaceController.java | 78 +++ .../src/main/resources/application.yml | 9 + .../vibemake/api/PcbWorkspaceTest.java | 628 ++++++++++++++++++ .../linkerbot/vibemake/api/SchemaSupport.java | 5 +- .../linkerbot/vibemake/api/WorkflowTest.java | 2 +- .../linkerbot/vibemake/bean/PcbContracts.java | 59 ++ .../vibemake/bean/entity/PcbProject.java | 25 + .../bean/entity/PcbProjectUpload.java | 22 + .../service/config/LimitProperties.java | 4 + .../service/config/PcbProperties.java | 41 ++ .../service/mapper/PcbProjectMapper.java | 12 + .../mapper/PcbProjectUploadMapper.java | 12 + .../service/oss/OssResourcePaths.java | 1 + .../service/pcb/AliyunPcbObjectStore.java | 118 ++++ .../vibemake/service/pcb/PcbObjectStore.java | 16 + .../service/pcb/PcbProjectService.java | 245 +++++++ .../service/state/HttpSafetyFilter.java | 3 +- .../service/oss/OssResourcePathsTest.java | 14 + .../service/pcb/AliyunPcbObjectStoreTest.java | 166 +++++ 25 files changed, 1651 insertions(+), 6 deletions(-) create mode 100644 docs/frontend-pcb-workspace.md create mode 100644 docs/pcb-database.md create mode 100644 vibemake-api/src/main/java/com/linkerbot/vibemake/api/controller/PcbWorkspaceController.java create mode 100644 vibemake-api/src/test/java/com/linkerbot/vibemake/api/PcbWorkspaceTest.java create mode 100644 vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/PcbContracts.java create mode 100644 vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/entity/PcbProject.java create mode 100644 vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/entity/PcbProjectUpload.java create mode 100644 vibemake-service/src/main/java/com/linkerbot/vibemake/service/config/PcbProperties.java create mode 100644 vibemake-service/src/main/java/com/linkerbot/vibemake/service/mapper/PcbProjectMapper.java create mode 100644 vibemake-service/src/main/java/com/linkerbot/vibemake/service/mapper/PcbProjectUploadMapper.java create mode 100644 vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/AliyunPcbObjectStore.java create mode 100644 vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/PcbObjectStore.java create mode 100644 vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/PcbProjectService.java create mode 100644 vibemake-service/src/test/java/com/linkerbot/vibemake/service/pcb/AliyunPcbObjectStoreTest.java diff --git a/.env.example b/.env.example index 3f79f0f..3ab555f 100644 --- a/.env.example +++ b/.env.example @@ -30,6 +30,10 @@ URDF_MAX_TOTAL_BYTES=209715200 URDF_MAX_FILES=500 # 管理端四类项目资源直传签名有效期;不设置应用层文件大小、数量及总量配额。 PROJECT_RESOURCE_SIGNATURE_VALIDITY=1h +# PCB 工程 ZIP 直传独立开关,共用上述 OSS 连接及环境根目录。 +PCB_OSS_ENABLED=false +PCB_MAX_FILE_BYTES=268435456 +PCB_UPLOAD_VALIDITY=15m # AI 默认关闭;启用后密钥仅在后端使用。两个环境均支持这些变量。 AI_ENABLED=false ARK_API_KEY='' @@ -88,6 +92,10 @@ RATE_FORK_PER_MINUTE=10 RATE_FILE_WRITE_PER_MINUTE=10 RATE_COVER_SIGN_PER_MINUTE=30 RATE_URDF_SIGN_PER_MINUTE=20 +RATE_PCB_CREATE_PER_MINUTE=5 +RATE_PCB_SIGN_PER_MINUTE=20 +RATE_PCB_SAVE_PER_MINUTE=30 +RATE_PCB_READ_PER_MINUTE=60 RATE_COMMENT_PER_MINUTE=10 RATE_LIKE_PER_MINUTE=60 diff --git a/README.md b/README.md index 9cf621f..5dc640d 100644 --- a/README.md +++ b/README.md @@ -103,7 +103,9 @@ SPRING_PROFILES_ACTIVE=prod java -Djava.awt.headless=true -jar vibemake-api/targ mvn clean verify ``` -普通测试固定使用 test 配置,覆盖连接为临时 H2 MySQL 模式及模拟 Gitea/AI/OSS,验证登录、权限、提交冲突、发布快照、Fork、评论、点赞、URDF 直传核验和独立复制,以及 AI 筛选、引用校验、创建、Fork 与候选选择、SSE、限流、超时和取消,不访问真实数据库、仓库、对象存储或模型。未加载外部服务凭据时,执行 `AI_ENABLED=false VIBEMAKE_AI_ENABLED=false OSS_ENABLED=false mvn verify`;其中 `VIBEMAKE_AI_ENABLED` 用于覆盖管理端当前固定开启的 AI 配置,AI 流程测试自行启用模拟模型。完整安装验证可执行 `AI_ENABLED=false VIBEMAKE_AI_ENABLED=false OSS_ENABLED=false mvn clean install`。 +普通测试固定使用 test 配置,覆盖连接为临时 H2 MySQL 模式及模拟 Gitea/AI/OSS,验证登录、权限、提交冲突、发布快照、Fork、评论、点赞、URDF 直传核验和独立复制,以及 AI 筛选、引用校验、创建、Fork 与候选选择、SSE、限流、超时和取消,不访问真实数据库、仓库、对象存储或模型。未加载外部服务凭据时,执行 `GIT_ENABLED=false AI_ENABLED=false VIBEMAKE_AI_ENABLED=false OSS_ENABLED=false mvn verify`;其中 `GIT_ENABLED` 关闭需要独立凭据的 Git 网关,`VIBEMAKE_AI_ENABLED` 用于覆盖管理端当前固定开启的 AI 配置,对应流程测试自行启用模拟服务。完整安装验证可执行 `GIT_ENABLED=false AI_ENABLED=false VIBEMAKE_AI_ENABLED=false OSS_ENABLED=false mvn clean install`。 + +PCB 个人工作空间提供 `/api/pcb/workspace/projects` 八个接口,支持独立列表、完整工程 ZIP 直传保存、幂等确认与版本冲突保护。上线前手工执行 [PCB 建表 SQL](docs/pcb-database.md),配置共用 OSS 后设置 `PCB_OSS_ENABLED=true`;默认关闭,ZIP 默认上限 256 MiB、上传有效期 15 分钟。前端对接与部署见 [PCB 工作空间文档](docs/frontend-pcb-workspace.md)。普通测试覆盖 PCB 与 CAD 保存链路,不访问真实 OSS。 真实 Gitea 联调: diff --git a/docs/frontend-pcb-workspace.md b/docs/frontend-pcb-workspace.md new file mode 100644 index 0000000..3d69fcd --- /dev/null +++ b/docs/frontend-pcb-workspace.md @@ -0,0 +1,128 @@ +# PCB 个人工作空间前端对接 + +PCB 工作空间使用独立的 `/api/pcb/workspace/projects`,与 CAD 共用 `/api/auth/login`、`/api/auth/logout` 和 `/api/users/me`,使用同一个 `Authorization: Bearer <平台 token>`。个人空间提供独立 PCB 分类;列表只包含本人未删除的 PCB 项目,不创建 Git 仓库、不自动发布社区。本文约定后端接口,PCB 编辑器及宿主网页需另行接入。 + +每次手动保存上传一个完整工程 ZIP。数据库保存项目元数据、当前文件引用和上传回执,原理图、PCB、工程配置与工程内私有依赖由前端打包和还原。后端不解压 ZIP、不解析 KiCad 文件,也不验证 ZIP 内容是否可编辑;文件名和大小校验不能代替前端格式验证。 + +文件读取沿用 CAD 的普通 OSS/CDN 地址规则:平台接口按用户隔离,文件直链权限由现有 Bucket/CDN 决定。公开配置下,拿到链接即可下载。逻辑删除不会撤销已有文件链接。 + +## 接口与数据 + +下表前缀为 `/api/pcb/workspace/projects`。全部需要登录,成功 HTTP 200,响应为 `{code,message,data,requestId}`,响应包含 `Cache-Control: no-store`。分页、上海业务时间和跨域约定沿用 [Vibemake 接入约定](vibemake-api.md#接入约定)。业务编码是不透明字符串,客户端不使用数据库 ID。 + +| 方法 | 相对路径 | 请求 | 成功 data | +| --- | --- | --- | --- | +| GET | 空 | `page=1&size=20&keyword=名称` | `{items,page,size,total}` | +| POST | 空 | `{name,description?,coverUrl?}` | 项目 | +| GET | `/{pcbProjectCode}` | 无 | 项目 | +| PATCH | `/{pcbProjectCode}` | `{name?,description?,coverUrl?}` | 项目 | +| DELETE | `/{pcbProjectCode}` | 无 | null | +| POST | `/{pcbProjectCode}/uploads/signature` | `{fileName,sizeBytes,expectedVersion}` | 上传签名 | +| PUT | `/{pcbProjectCode}/document` | `{uploadCode}` | 保存回执 | +| GET | `/{pcbProjectCode}/document` | 无 | ZIP 文件读取信息 | + +名称去除首尾空白后须为 1~100 字符,描述最多 2000 字符,新建默认空字符串。封面为完整 HTTPS 地址,最多 2048 字符,新建省略、null 或空白表示无封面。PATCH 省略或 null 表示保留;描述或封面传 `""` 可清空,至少提供一个非 null 字段。 + +同名项目允许存在。列表按最近更新时间倒序,同一时间按内部主键倒序稳定分页,主键不对外返回;名称支持包含搜索,关键词最多 100 字符。`page` 为 1~100000,`size` 为 1~100,默认 20。 + +```ts +interface PcbProject { + pcbProjectCode: string; + name: string; + description: string; + coverUrl: string | null; + hasDocument: boolean; + version: number; + fileName: string; + sizeBytes: number; + savedAt: string | null; + createdAt: string; + updatedAt: string; +} +interface PcbUploadSignature { + uploadCode: string; + uploadUrl: string; + formFields: Record; + expiresAt: string; +} +interface PcbSaveResult { + pcbProjectCode: string; + version: number; + savedAt: string; +} +interface PcbDocument { + downloadUrl: string; + expiresAt: null; + version: number; + fileName: string; + sizeBytes: number; +} +``` + +空项目 `hasDocument=false、version=0、fileName=""、sizeBytes=0、savedAt=null`。名称、描述和封面修改只更新元数据,不改变文件版本或 savedAt。 + +## 工程 ZIP、保存和重新打开 + +ZIP 应保留工程原有目录和文件名,包含 `.kicad_pro`、`.kicad_sch`、`.kicad_pcb` 及工程实际使用的私有符号库、封装库、库表、3D 模型、图像等项目文件。文件按原始字节保存,二进制文件不能先解码为文本。全局标准库仍由编辑器提供;工程外的本机绝对路径依赖需由前端迁入工程并处理引用,后端不会自动收集。 + +PCB 前端现有“归档项目”按扩展名白名单过滤,不能直接作为完整云端保存范围。前端需先刷新所有编辑器的最新序列化结果、等待本地写入完成,再读取完整工程快照打包;不上传浏览器缓存、`.git`、工具目录和本地历史记录。解压时由前端校验路径及资源限额,完整导入成功后再切换当前工程。 + +1. 首次保存先创建项目,保留返回的 `pcbProjectCode` 和 `version=0`,后续上传失败复用该项目。 +2. 从完整工程快照生成 ZIP。文件名为不含路径和控制字符的 `.zip` 名称,最多 255 字符,扩展名不区分大小写;文件非空,默认最大 268435456 字节(256 MiB)。 +3. 申请签名,提交 ZIP 实际字节数及编辑基础版本。`sizeBytes` 和 `expectedVersion` 必须是 JSON 整数,不接受字符串、小数、负数或 null,sizeBytes 必须大于零。 +4. 将所有 `formFields` 原样加入 FormData,最后追加 ZIP 文件,POST 到 `uploadUrl`。ZIP Blob MIME 使用 `application/zip`,不手写 multipart Content-Type,不携带平台 Authorization。OSS 成功为 HTTP 200,无需解析 JSON。 +5. 上传后提交原 `uploadCode` 确认。只有成功回执才能显示云端已保存;同一项目串行保存,打包或上传期间的新修改继续标记为未保存。 +6. 打开先读详情;空项目进入新工程,否则获取 `document`,fetch `downloadUrl` 得到 ZIP 并交给编辑器导入。**编辑基础版本使用 document.version**,不能混用此前详情的版本。 + +本期为手动云端保存,宿主保存按钮和 Ctrl+S 应接入上述链路。本地自动保存继续作为浏览器内恢复能力,不能显示为云端已保存。iframe 集成由宿主网页和编辑器完成;使用 postMessage 时校验精确 origin 与 source,平台 Token 不放 URL,直传和 OSS 文件读取不携带平台 Token。 + +签名及未确认批次默认 15 分钟后过期。业务时间采用上海时间、无时区后缀,前端解析时补 `+08:00`。下载地址为普通 OSS/CDN 地址,expiresAt 固定为 null,不需要下载签名续期。 + +相同 uploadCode 重复确认返回首次成功的 version 和 savedAt,不重复增加版本;即使已有更新版本,也不会重新绑定旧 ZIP。回执版本可能小于当前版本,需要时重新读项目。确认超时应保留原批次并重试确认;OSS 上传结果不明确时也先尝试确认,缺文件再处理上传,不盲目覆盖或重复创建项目。 + +两个标签页基于同一版本保存,仅一个成功,另一个收到 `PCB_VERSION_CONFLICT`。保留本地修改,提供重新打开最新工程、下载本地 ZIP 或另存项目入口,不能自动替换版本号后覆盖。401 时保留本地工程,重新登录后核对账号与归属;离开、切换工程、退出登录前处理未保存修改。 + +## 封面与错误处理 + +封面复用 `POST /api/uploads/project-covers/signature`,请求 `{contentType,fileSize}`,支持 JPG、PNG、WebP,最大 5 MiB。取得签名后直传图片,将完整 `coverUrl` 提交至 PCB 创建或 PATCH 接口;无需先创建 Git 项目。封面上传使用已有 `OSS_ENABLED` 开关,PCB 文件开关不代替它。 + +平台封面落库为 `/project-covers/...` 等环境相对路径,接口返回完整 URL;外部 HTTPS 图片沿用已有规则。工程保存保留封面,更新封面不改变工程版本;替换或清空封面、删除项目均保留原 OSS 对象。 + +| HTTP / code | 处理 | +| --- | --- | +| 400 `BAD_REQUEST` / `PCB_INVALID_FILE` | 检查元数据、ZIP 文件名及整数参数 | +| 401 `UNAUTHORIZED` | 保留工程,恢复登录后核对账号 | +| 404 `NOT_FOUND` | 项目或批次不存在、非本人或已删除,停止保存 | +| 404 `PCB_DOCUMENT_NOT_FOUND` | 空项目尚无云端 ZIP | +| 409 `PCB_VERSION_CONFLICT` | 保留本地修改,处理并发冲突 | +| 409 `PCB_FILE_MISSING` | 尚无上传对象,检查上传结果再重试确认 | +| 409 `PCB_FILE_SIZE_MISMATCH` | 当前文件不变,重新申请并上传正确文件 | +| 409 `PCB_UPLOAD_EXPIRED` | 重新申请批次 | +| 413 `PCB_FILE_TOO_LARGE` / `REQUEST_TOO_LARGE` | 文件或 JSON 请求超限 | +| 429 `RATE_LIMITED` | 按 Retry-After 等待后重试 | +| 502 `PCB_OSS_ERROR` | 保留工程及批次,稍后重试 | +| 503 `PCB_STORAGE_UNAVAILABLE` / `PCB_STORAGE_UNSAFE` | 存储未开启或连接不完整 | +| 503 `PCB_CODE_BUSY` / `REDIS_UNAVAILABLE` | 暂时无法处理,保留输入后重试 | + +## 部署与联调 + +先手工执行 [PCB 建表 SQL](pcb-database.md),再部署后端,配置当前环境 `pcb-projects/*` 的 RAM 权限及 OSS/CDN CORS,最后开启 PCB 存储。应用不自动创建或修改业务表,回滚时保留两张表和已有 OSS 对象。 + +| 配置项 | 默认值 / 要求 | +| --- | --- | +| `PCB_OSS_ENABLED` | false,配置完成后显式开启 | +| `PCB_MAX_FILE_BYTES` | 268435456;允许 1 字节至 5 GiB,需兼容编辑器读取限额 | +| `PCB_UPLOAD_VALIDITY` | 15m,允许 1 秒至 7 天 | +| `RATE_PCB_CREATE_PER_MINUTE` / `RATE_PCB_SIGN_PER_MINUTE` | 每用户 5 / 20 | +| `RATE_PCB_SAVE_PER_MINUTE` / `RATE_PCB_READ_PER_MINUTE` | 每用户 30 / 60,含确认及读取重试 | +| `OSS_REGION、OSS_ENDPOINT、OSS_BUCKET、OSS_ACCESS_KEY_ID、OSS_ACCESS_KEY_SECRET` | 共用现有 OSS 连接,前端不持有 RAM 密钥 | +| `OSS_PUBLIC_BASE_URL` | 共用普通 OSS/CDN 基础地址;为空时使用 Bucket 域名 | +| `vibemake.oss.root-directory` | test 为 vibemake_dev,prod 为 vibemake | + +PCB 开关独立于 CAD 和公共资源开关;`OSS_ENABLED=false` 时,只要共用连接完整,PCB 仍可开启。适配器仅本地签名、HEAD 核验大小及生成普通地址,不读取或修改 Bucket ACL、对象 ACL、版本控制或公开策略,不单独设置 private ACL。 + +数据库仅存 `/pcb-projects/{pcbProjectCode}/{uploadCode}/project.zip`,真实 OSS key 为环境根目录加此路径。前端原样使用 formFields.key,不自行拼接环境前缀。格式见 [OSS 引用规范](oss-storage-paths.md)。 + +RAM 授权覆盖当前环境 `pcb-projects/*` 的 `oss:PutObject` 与 `oss:GetObject`,用于直传和 HEAD;读取权限按已有普通地址方式配置。CORS 允许实际宿主或编辑器来源的 POST、GET 和 Content-Type,需要时暴露 Content-Length、Content-Disposition。平台 API 使用既有来源白名单。 + +联调验证创建工程、上传、确认、刷新列表、下载 ZIP、重新打开并继续编辑,以及账号隔离和双标签版本冲突。后端自动化使用模拟 OSS,真实 OSS/CDN 与编辑器联调在部署环境完成。首期不提供历史恢复、对象清理或自动云端保存。 diff --git a/docs/oss-storage-paths.md b/docs/oss-storage-paths.md index 8dff93a..46edcad 100644 --- a/docs/oss-storage-paths.md +++ b/docs/oss-storage-paths.md @@ -5,7 +5,8 @@ | 位置 | 数据库存储示例 | 实际 OSS key 示例 | | --- | --- | --- | | CAD 当前设计及上传批次 | `/cad-projects/{项目编码}/{批次编码}/design.sc` | `vibemake_dev/cad-projects/{项目编码}/{批次编码}/design.sc` | -| 平台托管封面(含 CAD 的 cover_url) | `/project-covers/{用户编码}/{日期}/{文件名}` | `vibemake_dev/project-covers/{用户编码}/{日期}/{文件名}` | +| PCB 当前工程及上传批次 | `/pcb-projects/{项目编码}/{批次编码}/project.zip` | `vibemake_dev/pcb-projects/{项目编码}/{批次编码}/project.zip` | +| 平台托管封面(含 CAD、PCB 的 cover_url) | `/project-covers/{用户编码}/{日期}/{文件名}` | `vibemake_dev/project-covers/{用户编码}/{日期}/{文件名}` | | URDF 主文件及目录 | `/urdf/{项目编码}/{批次编码}/...` | `vibemake_dev/urdf/{项目编码}/{批次编码}/...` | | STEP、GLB、零件、拼装步骤、行走资源 | `/project-resources/{项目编码}/{类型}/{批次编码}/...` | `vibemake_dev/project-resources/{项目编码}/{类型}/{批次编码}/...` | @@ -15,6 +16,8 @@ ## 现有数据手工转换 SQL +PCB 两张新表直接采用环境相对路径,建表见 [PCB 工作空间 SQL](pcb-database.md),无需执行下列 CAD 与社区资源的历史转换。 + 无需修改字段结构。先升级所有在线写入进程与导入工具,再暂停资源写入并备份业务库。在对应环境的业务数据库连接中执行;test 使用 `vibemake_dev`,prod 将 `@oss_root` 改为 `vibemake`。不会移动、复制或删除 OSS 对象,也不修改项目版本、保存时间、上传回执和业务更新时间。 仅当字段精确以当前环境和对应资源目录开头时转换,使用二进制前缀比较避免大小写或下划线通配符误匹配,不使用全局 REPLACE。已经是相对路径的记录、空值和其他环境路径不变;本转换可重复执行。 diff --git a/docs/pcb-database.md b/docs/pcb-database.md new file mode 100644 index 0000000..e9ca6d9 --- /dev/null +++ b/docs/pcb-database.md @@ -0,0 +1,50 @@ +# PCB 工作空间建表 SQL + +在启用 PCB 接口前,由运维在现有 `vibemake` 数据库手工执行以下 SQL(MySQL 8.0.13+)。应用不自动建表,不修改现有项目表。所有业务时间按上海时间写入。 + +`id` 和归属外键仅供服务内部使用,对外使用 `pcb_project_code` 和 `upload_code`。两张表与 Git 项目无关联。上线顺序:执行 SQL → 部署后端 → 验证共用 OSS 配置及文件读取 → 开放前端入口。回滚代码时保留两张表和 OSS 对象。 + +```sql +CREATE TABLE pcb_project ( + id BIGINT NOT NULL AUTO_INCREMENT COMMENT '内部主键,不对外返回', + pcb_project_code VARCHAR(32) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT 'PCB项目唯一业务编码', + owner_user_id BIGINT NOT NULL COMMENT '所属用户内部主键,关联sys_user.id', + name VARCHAR(100) NOT NULL COMMENT 'PCB项目名称', + description VARCHAR(2000) NOT NULL DEFAULT '' COMMENT 'PCB项目描述', + cover_url VARCHAR(2048) NULL COMMENT 'PCB项目封面,平台OSS资源存无环境前缀的相对路径', + document_object_key VARCHAR(512) CHARACTER SET ascii COLLATE ascii_bin NOT NULL DEFAULT '' COMMENT '当前工程ZIP文件环境相对路径,以斜杠开头,不含域名和环境根目录', + file_name VARCHAR(255) NOT NULL DEFAULT '' COMMENT '当前工程ZIP文件名称', + size_bytes BIGINT NOT NULL DEFAULT 0 COMMENT '当前工程ZIP文件大小,单位字节', + version BIGINT NOT NULL DEFAULT 0 COMMENT '当前保存版本,空项目为0,每次成功保存递增', + saved_at DATETIME(3) NULL COMMENT '最近成功保存工程ZIP文件的上海时间', + deleted TINYINT 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_pcb_project_code (pcb_project_code), + KEY idx_pcb_project_owner_list (owner_user_id, deleted, updated_at, id) +) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='PCB个人工作空间项目'; + +CREATE TABLE pcb_project_upload ( + id BIGINT NOT NULL AUTO_INCREMENT COMMENT '内部主键,不对外返回', + upload_code VARCHAR(32) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '上传批次唯一业务编码', + pcb_project_id BIGINT NOT NULL COMMENT '所属PCB项目内部主键,关联pcb_project.id', + expected_version BIGINT NOT NULL COMMENT '签发上传时的项目基础版本,用于并发保存校验', + object_key VARCHAR(512) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '本批次工程ZIP文件环境相对路径,以斜杠开头,不含域名和环境根目录', + file_name VARCHAR(255) NOT NULL COMMENT '本批次工程ZIP文件名称', + size_bytes BIGINT NOT NULL COMMENT '本批次声明的文件大小,单位字节', + expires_at DATETIME(3) NOT NULL COMMENT '未确认批次的截止上海时间,与上传签名一致', + saved_version BIGINT NULL COMMENT '确认成功的版本号,空值表示尚未确认', + saved_at DATETIME(3) NULL COMMENT '首次确认成功上海时间,重复确认返回原值', + created_at DATETIME(3) NOT NULL COMMENT '批次创建上海时间', + updated_at DATETIME(3) NOT NULL COMMENT '批次最近更新上海时间', + PRIMARY KEY (id), + UNIQUE KEY uk_pcb_upload_code (upload_code), + KEY idx_pcb_upload_project (pcb_project_id, created_at) +) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='PCB工程ZIP文件上传与保存确认批次'; +``` + +保存事务锁定当前用户的未删除项目和对应批次,按 `expected_version` 条件更新当前对象键和版本,同时写入批次回执。失败整体回滚。重放已确认批次只返回首次确认的版本和时间,不重新绑定旧对象;项目删除后仍拒绝重放。首期不清理上传批次或旧 OSS 对象,不提供历史恢复接口。 + +`document_object_key` 和 `object_key` 均保存 `/pcb-projects/{项目编码}/{批次编码}/project.zip`,不保存 `vibemake_dev/` 或 `vibemake/`。真实上传和读取在运行时补当前环境根目录。PCB 新建表直接采用该格式,无需执行 CAD 的历史路径转换 SQL。 + diff --git a/docs/vibemake-api.md b/docs/vibemake-api.md index ccd1545..282de97 100644 --- a/docs/vibemake-api.md +++ b/docs/vibemake-api.md @@ -10,6 +10,8 @@ ZIP、TAR.GZ 下载和 HTTPS Git 本地开发的独立前端交付文档见 [仓 CAD 个人工作空间使用独立的 `/api/cad/workspace/projects`,共用登录,但不创建 Git 仓库、不混入现有项目列表。接口、保存续编流程和共用 OSS 配置见 [CAD 工作空间前端对接](frontend-cad-workspace.md),上线前执行 [CAD 建表 SQL](cad-database.md)。 +PCB 个人工作空间使用独立的 `/api/pcb/workspace/projects`,共用登录,通过完整工程 ZIP 直传 OSS 保存与续编,个人空间按独立 PCB 分类查询。接口、版本冲突、重试和部署配置见 [PCB 工作空间前端对接](frontend-pcb-workspace.md),上线前手工执行 [PCB 建表 SQL](pcb-database.md)。 + CAD 网页 AI Agent 使用 `/api/cad/ai/capabilities` 和 `/api/cad/ai/chat`,支持流式回复及浏览器执行的 CAD 工具调用,复用豆包连接配置。功能默认关闭,聊天不落库;完整协议及 SolidCraft 网页适配要求见 [CAD AI Agent 前端对接](frontend-cad-ai-agent.md)。 ## 阅读导航 diff --git a/vibemake-api/src/main/java/com/linkerbot/vibemake/api/controller/PcbWorkspaceController.java b/vibemake-api/src/main/java/com/linkerbot/vibemake/api/controller/PcbWorkspaceController.java new file mode 100644 index 0000000..7981665 --- /dev/null +++ b/vibemake-api/src/main/java/com/linkerbot/vibemake/api/controller/PcbWorkspaceController.java @@ -0,0 +1,78 @@ +package com.linkerbot.vibemake.api.controller; + +import com.linkerbot.vibemake.bean.PcbContracts.*; +import com.linkerbot.vibemake.common.ApiResponse; +import com.linkerbot.vibemake.common.PageResponse; +import com.linkerbot.vibemake.security.CurrentUser; +import com.linkerbot.vibemake.service.pcb.PcbProjectService; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.validation.Valid; +import lombok.RequiredArgsConstructor; +import org.springframework.http.HttpHeaders; +import org.springframework.web.bind.annotation.*; +import jakarta.servlet.http.HttpServletResponse; + +@RestController +@RequiredArgsConstructor +@RequestMapping("/api/pcb/workspace/projects") +@Tag(name = "PCB 个人工作空间") +public class PcbWorkspaceController { + private final PcbProjectService projects; + + @ModelAttribute + public void noStore(HttpServletResponse response) { + response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store"); + } + + @GetMapping + @Operation(summary = "我的 PCB 项目分页列表") + public ApiResponse> list( + @RequestParam(defaultValue = "1") long page, @RequestParam(defaultValue = "20") long size, + @RequestParam(required = false) String keyword) { + return ApiResponse.success(projects.list(CurrentUser.required(), keyword, page, size)); + } + + @PostMapping + @Operation(summary = "创建空 PCB 项目") + public ApiResponse create(@Valid @RequestBody PcbCreateProjectInput input) { + return ApiResponse.success(projects.create(CurrentUser.required(), input)); + } + + @GetMapping("/{pcbProjectCode}") + @Operation(summary = "我的 PCB 项目详情") + public ApiResponse detail(@PathVariable String pcbProjectCode) { + return ApiResponse.success(projects.detail(CurrentUser.required(), pcbProjectCode)); + } + + @PatchMapping("/{pcbProjectCode}") + @Operation(summary = "修改 PCB 项目名称、描述和封面") + public ApiResponse update(@PathVariable String pcbProjectCode, @Valid @RequestBody PcbUpdateProjectInput input) { + return ApiResponse.success(projects.update(CurrentUser.required(), pcbProjectCode, input)); + } + + @DeleteMapping("/{pcbProjectCode}") + @Operation(summary = "逻辑删除 PCB 项目") + public ApiResponse delete(@PathVariable String pcbProjectCode) { + projects.delete(CurrentUser.required(), pcbProjectCode); + return ApiResponse.success(null); + } + + @PostMapping("/{pcbProjectCode}/uploads/signature") + @Operation(summary = "申请 PCB 工程 ZIP 文件 OSS 直传签名") + public ApiResponse sign(@PathVariable String pcbProjectCode, @Valid @RequestBody PcbUploadInput input) { + return ApiResponse.success(projects.sign(CurrentUser.required(), pcbProjectCode, input)); + } + + @PutMapping("/{pcbProjectCode}/document") + @Operation(summary = "确认文件上传并保存 PCB 最新工程") + public ApiResponse confirm(@PathVariable String pcbProjectCode, @Valid @RequestBody PcbConfirmInput input) { + return ApiResponse.success(projects.confirm(CurrentUser.required(), pcbProjectCode, input.uploadCode())); + } + + @GetMapping("/{pcbProjectCode}/document") + @Operation(summary = "获取 PCB 当前工程 ZIP 的 OSS/CDN 文件地址") + public ApiResponse document(@PathVariable String pcbProjectCode) { + return ApiResponse.success(projects.document(CurrentUser.required(), pcbProjectCode)); + } +} diff --git a/vibemake-api/src/main/resources/application.yml b/vibemake-api/src/main/resources/application.yml index d8b6e25..f379ff0 100644 --- a/vibemake-api/src/main/resources/application.yml +++ b/vibemake-api/src/main/resources/application.yml @@ -64,6 +64,10 @@ vibemake: cad-sign: ${RATE_CAD_SIGN_PER_MINUTE:20} cad-save: ${RATE_CAD_SAVE_PER_MINUTE:30} cad-read: ${RATE_CAD_READ_PER_MINUTE:60} + pcb-create: ${RATE_PCB_CREATE_PER_MINUTE:5} + pcb-sign: ${RATE_PCB_SIGN_PER_MINUTE:20} + pcb-save: ${RATE_PCB_SAVE_PER_MINUTE:30} + pcb-read: ${RATE_PCB_READ_PER_MINUTE:60} comment: ${RATE_COMMENT_PER_MINUTE:10} like: ${RATE_LIKE_PER_MINUTE:60} readme-images: @@ -97,6 +101,11 @@ vibemake: upload-validity: ${CAD_UPLOAD_VALIDITY:15m} oss: enabled: ${CAD_OSS_ENABLED:true} + pcb: + max-file-bytes: ${PCB_MAX_FILE_BYTES:268435456} + upload-validity: ${PCB_UPLOAD_VALIDITY:15m} + oss: + enabled: ${PCB_OSS_ENABLED:false} ai: enabled: ${AI_ENABLED:true} api-key: ${ARK_API_KEY:} diff --git a/vibemake-api/src/test/java/com/linkerbot/vibemake/api/PcbWorkspaceTest.java b/vibemake-api/src/test/java/com/linkerbot/vibemake/api/PcbWorkspaceTest.java new file mode 100644 index 0000000..8f63119 --- /dev/null +++ b/vibemake-api/src/test/java/com/linkerbot/vibemake/api/PcbWorkspaceTest.java @@ -0,0 +1,628 @@ +package com.linkerbot.vibemake.api; + +import static org.assertj.core.api.Assertions.*; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.linkerbot.vibemake.bean.PcbContracts.PcbSaveResult; +import com.linkerbot.vibemake.bean.entity.User; +import com.linkerbot.vibemake.common.BusinessException; +import com.linkerbot.vibemake.security.TokenService; +import com.linkerbot.vibemake.service.UserService; +import com.linkerbot.vibemake.service.pcb.PcbObjectStore; +import com.linkerbot.vibemake.service.pcb.PcbProjectService; +import com.linkerbot.vibemake.service.config.PcbProperties; +import com.linkerbot.vibemake.service.config.LimitProperties; +import com.linkerbot.vibemake.service.config.OssProperties; +import com.linkerbot.vibemake.service.oss.OssPostSigner; +import com.linkerbot.vibemake.service.oss.OssResourcePaths; +import com.linkerbot.vibemake.service.support.ProjectSupport; +import java.io.ByteArrayOutputStream; +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.*; +import java.util.zip.ZipEntry; +import java.util.zip.ZipOutputStream; +import org.junit.jupiter.api.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.*; +import org.springframework.boot.test.context.*; +import org.springframework.context.annotation.*; +import org.springframework.http.MediaType; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.web.servlet.*; +import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder; + +@SpringBootTest(properties = { + "spring.datasource.url=jdbc:h2:mem:pcb;MODE=MySQL;DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=10000", + "spring.datasource.username=sa", "spring.datasource.password=", + "spring.datasource.driver-class-name=org.h2.Driver", + "vibemake.repository-write.worker-enabled=false", "vibemake.oss.enabled=false", + "vibemake.pcb.oss.enabled=true", "vibemake.oss.bucket=shared-oss-tests", + "vibemake.oss.access-key-id=TestPcbKey", "vibemake.oss.access-key-secret=test-secret", + "vibemake.oss.public-base-url=https://pcb-cdn.example.com/resources", + "vibemake.ai.enabled=false", "vibemake.git.enabled=false", "vibemake.limits.enabled=false", + "logging.level.org.springframework=WARN" +}) +@ActiveProfiles("test") +@AutoConfigureMockMvc(print = MockMvcPrint.NONE) +@Import(PcbWorkspaceTest.Config.class) +class PcbWorkspaceTest { + private static final String BASE = "/api/pcb/workspace/projects"; + + @TestConfiguration + static class Config { + @Bean @Primary + FakePcbStore fakePcb(PcbProperties properties, OssProperties oss, ObjectMapper json) { + return new FakePcbStore(properties, oss, json); + } + } + + static class FakePcbStore implements PcbObjectStore { + final Map objects = new ConcurrentHashMap<>(); + final PcbProperties properties; + final OssProperties oss; + final OssPostSigner signer; + boolean unavailable; + Runnable afterSign; + Runnable afterSize; + CyclicBarrier sizeBarrier; + + FakePcbStore(PcbProperties properties, OssProperties oss, ObjectMapper json) { + this.properties = properties; + this.oss = oss; + this.signer = new OssPostSigner(oss, json); + } + + private void available() { + if (!properties.getOss().isEnabled()) throw new BusinessException(503, "PCB_STORAGE_UNAVAILABLE", "关闭"); + } + + @Override + public SignedUpload signUpload(String key, String name, long size, Duration validity) { + available(); + OssPostSigner.SignedPost post = signer.signObject(key, "application/zip", size, validity, null); + if (afterSign != null) { + Runnable action = afterSign; + afterSign = null; + action.run(); + } + return new SignedUpload(oss.uploadUrl(), post.formFields(), post.expiresAt()); + } + + @Override + public long size(String key) { + available(); + if (unavailable) throw new BusinessException(502, "PCB_OSS_ERROR", "不可用"); + byte[] bytes = objects.get(key); + if (bytes == null) throw new BusinessException(409, "PCB_FILE_MISSING", "缺文件"); + if (sizeBarrier != null) { + try { + sizeBarrier.await(5, TimeUnit.SECONDS); + } catch (Exception error) { + throw new IllegalStateException(error); + } + } + if (afterSize != null) { + Runnable action = afterSize; + afterSize = null; + action.run(); + } + return bytes.length; + } + + @Override + public String documentUrl(String key) { + available(); + return new OssResourcePaths(oss).publicUrl(key); + } + } + + @Autowired MockMvc mvc; + @Autowired ObjectMapper json; + @Autowired JdbcTemplate jdbc; + @Autowired UserService users; + @Autowired TokenService tokens; + @Autowired PcbProperties properties; + @Autowired LimitProperties limitProperties; + @Autowired OssProperties oss; + @Autowired PcbProjectService service; + @Autowired FakePcbStore store; + private String token; + private long userId; + + @BeforeEach + void reset() throws Exception { + SchemaSupport.reset(jdbc); + properties.getOss().setEnabled(true); + properties.setMaxFileBytes(268435456); + properties.setUploadValidity(Duration.ofMinutes(15)); + store.objects.clear(); + store.unavailable = false; + store.afterSign = null; + store.afterSize = null; + store.sizeBarrier = null; + User user = users.login("pcb-owner@example.invalid"); + userId = user.getId(); + token = tokens.issue(user.getId(), user.getSessionVersion()); + } + + private MockHttpServletRequestBuilder auth(MockHttpServletRequestBuilder request) { + return request.header("Authorization", "Bearer " + token); + } + + private JsonNode perform(MockHttpServletRequestBuilder request, int status) throws Exception { + MvcResult result = mvc.perform(request).andExpect(status().is(status)).andReturn(); + return json.readTree(result.getResponse().getContentAsString()); + } + + private MockHttpServletRequestBuilder body(MockHttpServletRequestBuilder request, Object body) throws Exception { + return request.contentType(MediaType.APPLICATION_JSON).content(json.writeValueAsBytes(body)); + } + + private String create(String name) throws Exception { + JsonNode project = perform(body(auth(post(BASE)), Map.of("name", name)), 200).path("data"); + assertThat(project.has("id")).isFalse(); + assertThat(project.has("ownerUserId")).isFalse(); + assertThat(project.path("hasDocument").asBoolean()).isFalse(); + assertThat(project.path("version").asLong()).isZero(); + assertThat(project.path("pcbProjectCode").asText()).matches("[0-9a-z]{12}"); + return project.path("pcbProjectCode").asText(); + } + + private JsonNode sign(String code, long version, long size) throws Exception { + return perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "控制板.zip", "sizeBytes", size, "expectedVersion", version)), 200).path("data"); + } + + private JsonNode upload(String code, long version, byte[] bytes) throws Exception { + JsonNode signature = sign(code, version, bytes.length); + store.objects.put(signature.path("formFields").path("key").asText(), bytes.clone()); + return signature; + } + + private JsonNode confirm(String code, JsonNode signature, int status) throws Exception { + return perform(body(auth(put(BASE + "/" + code + "/document")), + Map.of("uploadCode", signature.path("uploadCode").asText())), status); + } + + @Test + void sharedLoginSeparateWorkspaceAndZipReferencesRoundTrip() throws Exception { + perform(auth(get("/api/users/me")), 200); + String code = create(" PCB 控制板 "); + assertThat(perform(auth(get(BASE)), 200).path("data").path("total").asInt()).isEqualTo(1); + assertThat(perform(auth(get("/api/workspace/projects")), 200).path("data").path("total").asInt()).isZero(); + assertThat(perform(auth(get("/api/cad/workspace/projects")), 200).path("data").path("total").asInt()).isZero(); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM project", Long.class)).isZero(); + assertThat(perform(auth(get(BASE + "/" + code + "/document")), 404).path("code").asText()).isEqualTo("PCB_DOCUMENT_NOT_FOUND"); + + Map files = new HashMap<>(Map.of( + "控制板/控制板.kicad_pro", "{}".getBytes(StandardCharsets.UTF_8), + "控制板/控制板.kicad_sch", "(kicad_sch)".getBytes(StandardCharsets.UTF_8), + "控制板/控制板.kicad_pcb", "(kicad_pcb)".getBytes(StandardCharsets.UTF_8), + "控制板/私有.pretty/接口.kicad_mod", "(footprint)".getBytes(StandardCharsets.UTF_8), + "控制板/models/model.step", new byte[] {0, 1, 2, -1})); + byte[] firstBytes = zip(files); + JsonNode first = upload(code, 0, firstBytes); + assertThat(first.path("uploadUrl").asText()).isEqualTo(oss.uploadUrl()); + assertThat(first.path("formFields").path("key").asText()) + .startsWith(oss.getRootDirectory() + "/pcb-projects/" + code + "/"); + assertThat(first.path("formFields").path("x-oss-credential").asText()) + .startsWith(oss.getAccessKeyId() + "/"); + assertThat(first.path("formFields").has("x-oss-object-acl")).isFalse(); + assertThat(first.path("formFields").path("content-type").asText()).isEqualTo("application/zip"); + assertThat(confirm(code, first, 200).path("data").path("version").asLong()).isEqualTo(1); + JsonNode opened = perform(auth(get(BASE + "/" + code + "/document")), 200).path("data"); + assertThat(opened.path("version").asLong()).isEqualTo(1); + assertThat(opened.path("downloadUrl").asText()) + .isEqualTo(oss.publicBaseUrl() + "/" + first.path("formFields").path("key").asText()); + assertThat(opened.has("expiresAt")).isTrue(); + assertThat(opened.path("expiresAt").isNull()).isTrue(); + assertThat(store.objects.get(first.path("formFields").path("key").asText())).isEqualTo(firstBytes); + + files.put("控制板/控制板.kicad_pcb", "(kicad_pcb (net 1 GND))".getBytes(StandardCharsets.UTF_8)); + byte[] secondBytes = zip(files); + JsonNode second = upload(code, opened.path("version").asLong(), secondBytes); + JsonNode saved = confirm(code, second, 200).path("data"); + assertThat(saved.path("version").asLong()).isEqualTo(2); + JsonNode detail = perform(auth(get(BASE + "/" + code)), 200).path("data"); + assertThat(detail.path("hasDocument").asBoolean()).isTrue(); + assertThat(detail.path("fileName").asText()).isEqualTo("控制板.zip"); + assertThat(detail.path("sizeBytes").asLong()).isEqualTo(secondBytes.length); + assertThat(detail.path("savedAt").asText()).doesNotEndWith("Z"); + assertThat(detail.has("documentObjectKey")).isFalse(); + assertThat(jdbc.queryForObject("SELECT document_object_key FROM pcb_project WHERE pcb_project_code=?", + String.class, code)).isEqualTo("/pcb-projects/" + code + "/" + second.path("uploadCode").asText() + "/project.zip"); + assertThat(jdbc.queryForObject("SELECT object_key FROM pcb_project_upload WHERE upload_code=?", String.class, + second.path("uploadCode").asText())).isEqualTo("/pcb-projects/" + code + "/" + second.path("uploadCode").asText() + "/project.zip"); + + perform(body(auth(patch(BASE + "/" + code)), Map.of("name", "重命名", "description", "电机控制板")), 200); + assertThat(perform(auth(get(BASE + "?keyword=重命")), 200).path("data").path("total").asInt()).isEqualTo(1); + assertThat(perform(auth(get(BASE + "/" + code)), 200).path("data").path("version").asLong()).isEqualTo(2); + assertThat(store.objects).hasSize(2); + JsonNode current = perform(auth(get(BASE + "/" + code + "/document")), 200).path("data"); + assertThat(current.path("version").asLong()).isEqualTo(2); + assertThat(current.path("downloadUrl").asText()) + .isEqualTo(oss.publicBaseUrl() + "/" + second.path("formFields").path("key").asText()); + } + + private byte[] zip(Map files) throws Exception { + ByteArrayOutputStream bytes = new ByteArrayOutputStream(); + try (ZipOutputStream zip = new ZipOutputStream(bytes, StandardCharsets.UTF_8)) { + for (Map.Entry file : files.entrySet()) { + zip.putNextEntry(new ZipEntry(file.getKey())); + zip.write(file.getValue()); + zip.closeEntry(); + } + } + return bytes.toByteArray(); + } + + @Test + void pcbCoverRoundTripsThroughCreationListingUpdateClearAndDocumentSave() throws Exception { + String path = "/project-covers/" + "a".repeat(12) + "/20261104/" + "b".repeat(32) + ".png"; + String url = oss.publicBaseUrl() + "/" + oss.getRootDirectory() + path; + JsonNode created = perform(body(auth(post(BASE)), Map.of("name", "带封面的 PCB", "description", "参数化设计", "coverUrl", url)), 200).path("data"); + String code = created.path("pcbProjectCode").asText(); + assertThat(created.path("coverUrl").asText()).isEqualTo(url); + assertThat(created.path("version").asLong()).isZero(); + assertThat(jdbc.queryForObject("SELECT cover_url FROM pcb_project WHERE pcb_project_code=?", String.class, code)).isEqualTo(path); + assertThat(perform(auth(get(BASE)), 200).path("data").path("items").get(0).path("coverUrl").asText()).isEqualTo(url); + assertThat(perform(auth(get(BASE + "/" + code)), 200).path("data").path("coverUrl").asText()).isEqualTo(url); + + JsonNode receipt = confirm(code, upload(code, 0, new byte[] {80, 75, 3, 4}), 200).path("data"); + String nextPath = path.replace(".png", ".webp"); + String nextUrl = oss.publicBaseUrl() + "/" + oss.getRootDirectory() + nextPath; + JsonNode changed = perform(body(auth(patch(BASE + "/" + code)), Map.of("coverUrl", nextUrl)), 200).path("data"); + assertThat(changed.path("coverUrl").asText()).isEqualTo(nextUrl); + assertThat(changed.path("name").asText()).isEqualTo("带封面的 PCB"); + assertThat(changed.path("description").asText()).isEqualTo("参数化设计"); + assertThat(changed.path("version").asLong()).isEqualTo(1); + assertThat(changed.path("savedAt")).isEqualTo(receipt.path("savedAt")); + assertThat(jdbc.queryForObject("SELECT cover_url FROM pcb_project WHERE pcb_project_code=?", String.class, code)).isEqualTo(nextPath); + + JsonNode preserved = perform(body(auth(patch(BASE + "/" + code)), + json.createObjectNode().put("name", "改名").putNull("coverUrl")), 200).path("data"); + assertThat(preserved.path("coverUrl").asText()).isEqualTo(nextUrl); + confirm(code, upload(code, 1, new byte[] {80, 75, 3, 4, 5}), 200); + assertThat(perform(auth(get(BASE + "/" + code)), 200).path("data").path("coverUrl").asText()).isEqualTo(nextUrl); + + String ownerToken = token; + User other = users.login("pcb-cover-other@example.invalid"); + token = tokens.issue(other.getId(), other.getSessionVersion()); + perform(body(auth(patch(BASE + "/" + code)), Map.of("coverUrl", "")), 404); + token = ownerToken; + JsonNode cleared = perform(body(auth(patch(BASE + "/" + code)), Map.of("coverUrl", "")), 200).path("data"); + assertThat(cleared.path("coverUrl").isNull()).isTrue(); + assertThat(cleared.path("version").asLong()).isEqualTo(2); + assertThat(jdbc.queryForObject("SELECT cover_url FROM pcb_project WHERE pcb_project_code=?", String.class, code)).isNull(); + } + + @Test + void optionalAndExternalCoversFollowExistingCoverRules() throws Exception { + String code = create("无封面"); + assertThat(perform(auth(get(BASE + "/" + code)), 200).path("data").path("coverUrl").isNull()).isTrue(); + String external = "https://images.example.com/pcb.png"; + JsonNode view = perform(body(auth(patch(BASE + "/" + code)), Map.of("coverUrl", external)), 200).path("data"); + assertThat(view.path("coverUrl").asText()).isEqualTo(external); + assertThat(jdbc.queryForObject("SELECT cover_url FROM pcb_project WHERE pcb_project_code=?", String.class, code)).isEqualTo(external); + } + + @ParameterizedTest + @ValueSource(strings = {"http://images.example.com/pcb.png", "https://user:password@images.example.com/pcb.png", + "/project-covers/user/pcb.png", "data:image/png;base64,abcd"}) + void invalidCoverAddressesAreRejectedWithoutChangingProject(String invalid) throws Exception { + String code = create("封面验证"); + perform(body(auth(patch(BASE + "/" + code)), Map.of("coverUrl", invalid)), 400); + perform(body(auth(post(BASE)), Map.of("name", "非法封面", "coverUrl", invalid)), 400); + assertThat(jdbc.queryForObject("SELECT cover_url FROM pcb_project WHERE pcb_project_code=?", String.class, code)).isNull(); + } + + @Test + void confirmedBatchReplayReturnsOriginalReceiptEvenAfterLaterSaveExpiryAndOssFailure() throws Exception { + String code = create("幂等"); + JsonNode first = upload(code, 0, new byte[] {1}); + JsonNode original = confirm(code, first, 200).path("data"); + confirm(code, upload(code, 1, new byte[] {2}), 200); + jdbc.update("UPDATE pcb_project_upload SET expires_at=?", ProjectSupport.now().minusDays(1)); + store.unavailable = true; + assertThat(confirm(code, first, 200).path("data")).isEqualTo(original); + assertThat(service.detail(userId, code).version()).isEqualTo(2); + JsonNode document = perform(auth(get(BASE + "/" + code + "/document")), 200).path("data"); + assertThat(document.path("version").asLong()).isEqualTo(2); + assertThat(document.path("downloadUrl").asText()).startsWith(oss.publicBaseUrl() + "/"); + properties.getOss().setEnabled(false); + assertThat(confirm(code, first, 200).path("data")).isEqualTo(original); + } + + @Test + void foreignUsersAndProjectsCannotAccessOrConfirmUploads() throws Exception { + String code = create("私有设计"); + JsonNode pending = upload(code, 0, new byte[] {1}); + String another = create("另一项目"); + confirm(another, pending, 404); + User other = users.login("pcb-other@example.invalid"); + token = tokens.issue(other.getId(), other.getSessionVersion()); + assertThat(perform(auth(get(BASE)), 200).path("data").path("total").asInt()).isZero(); + perform(auth(get(BASE + "/" + code)), 404); + perform(auth(get(BASE + "/" + code + "/document")), 404); + perform(body(auth(patch(BASE + "/" + code)), Map.of("name", "越权")), 404); + perform(auth(delete(BASE + "/" + code)), 404); + perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0)), 404); + confirm(code, pending, 404); + } + + @Test + void failuresDoNotReplaceSavedDocumentAndUnconfirmedExpiryIsEnforced() throws Exception { + String code = create("失败保护"); + confirm(code, upload(code, 0, new byte[] {1}), 200); + JsonNode next = sign(code, 1, 2); + assertThat(confirm(code, next, 409).path("code").asText()).isEqualTo("PCB_FILE_MISSING"); + String key = next.path("formFields").path("key").asText(); + store.objects.put(key, new byte[] {2}); + assertThat(confirm(code, next, 409).path("code").asText()).isEqualTo("PCB_FILE_SIZE_MISMATCH"); + store.objects.put(key, new byte[] {2, 3}); + store.unavailable = true; + assertThat(confirm(code, next, 502).path("code").asText()).isEqualTo("PCB_OSS_ERROR"); + store.unavailable = false; + jdbc.update("UPDATE pcb_project_upload SET expires_at=? WHERE upload_code=?", + ProjectSupport.now().minusSeconds(1), next.path("uploadCode").asText()); + assertThat(confirm(code, next, 409).path("code").asText()).isEqualTo("PCB_UPLOAD_EXPIRED"); + assertThat(service.detail(userId, code).version()).isEqualTo(1); + assertThat(service.detail(userId, code).sizeBytes()).isEqualTo(1); + } + + @Test + void concurrentDifferentBatchesOnlyOneSaveWins() throws Exception { + String code = create("并发"); + JsonNode first = upload(code, 0, new byte[] {1}); + JsonNode second = upload(code, 0, new byte[] {2}); + store.sizeBarrier = new CyclicBarrier(2); + try (ExecutorService executor = Executors.newFixedThreadPool(2)) { + Future one = executor.submit(() -> confirmationOutcome(code, first)); + Future two = executor.submit(() -> confirmationOutcome(code, second)); + assertThat(List.of(one.get(10, TimeUnit.SECONDS), two.get(10, TimeUnit.SECONDS))) + .containsExactlyInAnyOrder("saved:1", "PCB_VERSION_CONFLICT"); + } + assertThat(service.detail(userId, code).version()).isEqualTo(1); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM pcb_project_upload WHERE saved_version IS NOT NULL", Long.class)).isEqualTo(1); + } + + @Test + void concurrentSameBatchOnlyIncrementsOnce() throws Exception { + String code = create("重复并发"); + JsonNode batch = upload(code, 0, new byte[] {1}); + store.sizeBarrier = new CyclicBarrier(2); + try (ExecutorService executor = Executors.newFixedThreadPool(2)) { + Future one = executor.submit(() -> service.confirm(userId, code, batch.path("uploadCode").asText())); + Future two = executor.submit(() -> service.confirm(userId, code, batch.path("uploadCode").asText())); + assertThat(one.get(10, TimeUnit.SECONDS)).isEqualTo(two.get(10, TimeUnit.SECONDS)); + } + assertThat(service.detail(userId, code).version()).isEqualTo(1); + } + + private String confirmationOutcome(String code, JsonNode batch) { + try { + return "saved:" + service.confirm(userId, code, batch.path("uploadCode").asText()).version(); + } catch (BusinessException error) { + return error.code(); + } + } + + @Test + void failedReceiptWriteRollsBackDocumentAndAllowsRetry() throws Exception { + String code = create("事务回滚"); + JsonNode batch = upload(code, 0, new byte[] {1}); + jdbc.execute("ALTER TABLE pcb_project_upload ADD CONSTRAINT reject_saved CHECK (saved_version IS NULL)"); + assertThatThrownBy(() -> service.confirm(userId, code, batch.path("uploadCode").asText())).isInstanceOf(RuntimeException.class); + assertThat(service.detail(userId, code).version()).isZero(); + assertThat(service.detail(userId, code).hasDocument()).isFalse(); + jdbc.execute("ALTER TABLE pcb_project_upload DROP CONSTRAINT reject_saved"); + assertThat(confirm(code, batch, 200).path("data").path("version").asLong()).isEqualTo(1); + } + + @Test + void deletionDuringHeadAndLaterReplayCannotRestoreProject() throws Exception { + String code = create("删除竞争"); + JsonNode saved = upload(code, 0, new byte[] {1}); + confirm(code, saved, 200); + JsonNode pending = upload(code, 1, new byte[] {2}); + store.afterSize = () -> service.delete(userId, code); + confirm(code, pending, 404); + confirm(code, saved, 404); + perform(auth(get(BASE + "/" + code)), 404); + perform(auth(get(BASE + "/" + code + "/document")), 404); + perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 1)), 404); + assertThat(perform(auth(get(BASE)), 200).path("data").path("total").asInt()).isZero(); + assertThat(store.objects).hasSize(2); + } + + @Test + void deletionDuringSigningDoesNotCreateOrReturnUploadBatch() throws Exception { + String code = create("签名删除竞争"); + store.afterSign = () -> service.delete(userId, code); + perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0)), 404); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM pcb_project_upload", Long.class)).isZero(); + } + + @Test + void versionChangeDuringSigningDoesNotReturnStaleCredentials() throws Exception { + String code = create("签名版本竞争"); + JsonNode first = upload(code, 0, new byte[] {1}); + store.afterSign = () -> service.confirm(userId, code, first.path("uploadCode").asText()); + assertThat(perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0)), 409) + .path("code").asText()).isEqualTo("PCB_VERSION_CONFLICT"); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM pcb_project_upload", Long.class)).isEqualTo(1); + assertThat(service.detail(userId, code).version()).isEqualTo(1); + } + + @Test + void expiryDuringHeadStillPreventsDocumentChange() throws Exception { + String code = create("确认过期竞争"); + JsonNode batch = upload(code, 0, new byte[] {1}); + store.afterSize = () -> jdbc.update("UPDATE pcb_project_upload SET expires_at=? WHERE upload_code=?", + ProjectSupport.now().minusSeconds(1), batch.path("uploadCode").asText()); + assertThat(confirm(code, batch, 409).path("code").asText()).isEqualTo("PCB_UPLOAD_EXPIRED"); + assertThat(service.detail(userId, code).version()).isZero(); + assertThat(jdbc.queryForObject("SELECT saved_version FROM pcb_project_upload WHERE upload_code=?", + Long.class, batch.path("uploadCode").asText())).isNull(); + } + + @Test + void independentRateLimitsApplyToEachPcbOperationAndUser() throws Exception { + boolean wasEnabled = limitProperties.isEnabled(); + Map original = new HashMap<>(limitProperties.getPerMinute()); + try { + limitProperties.setEnabled(true); + for (String group : List.of("pcb-create", "pcb-sign", "pcb-save", "pcb-read")) + limitProperties.getPerMinute().put(group, 1); + String code = create("限流"); + assertThat(perform(body(auth(post(BASE)), Map.of("name", "创建超额")), 429) + .path("code").asText()).isEqualTo("RATE_LIMITED"); + JsonNode batch = upload(code, 0, new byte[] {1}); + mvc.perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0))) + .andExpect(status().isTooManyRequests()).andExpect(header().exists("Retry-After")); + confirm(code, batch, 200); + assertThat(confirm(code, batch, 429).path("code").asText()).isEqualTo("RATE_LIMITED"); + perform(auth(get(BASE + "/" + code + "/document")), 200); + assertThat(perform(auth(get(BASE + "/" + code + "/document")), 429) + .path("code").asText()).isEqualTo("RATE_LIMITED"); + perform(body(auth(post("/api/cad/workspace/projects")), Map.of("name", "CAD 额度独立")), 200); + User other = users.login("pcb-rate-other@example.invalid"); + token = tokens.issue(other.getId(), other.getSessionVersion()); + String another = create("另一账号额度"); + confirm(another, upload(another, 0, new byte[] {2}), 200); + perform(auth(get(BASE + "/" + another + "/document")), 200); + } finally { + limitProperties.setPerMinute(original); + limitProperties.setEnabled(wasEnabled); + } + } + + @Test + void duplicateNamesStablePaginationAndDeletedFilteringPreserveMetadata() throws Exception { + String first = create("控制板"); + String second = create("控制板"); + jdbc.update("UPDATE pcb_project SET updated_at=?", ProjectSupport.now().minusDays(1)); + JsonNode page = perform(auth(get(BASE + "?page=1&size=1&keyword=控制")), 200).path("data"); + assertThat(page.path("total").asInt()).isEqualTo(2); + assertThat(page.path("items").get(0).path("pcbProjectCode").asText()).isEqualTo(second); + assertThat(perform(auth(get(BASE + "?page=2&size=1&keyword=控制")), 200) + .path("data").path("items").get(0).path("pcbProjectCode").asText()).isEqualTo(first); + perform(body(auth(patch(BASE + "/" + first)), Map.of("description", "待清空")), 200); + JsonNode cleared = perform(body(auth(patch(BASE + "/" + first)), Map.of("description", "")), 200).path("data"); + assertThat(cleared.path("description").asText()).isEmpty(); + assertThat(cleared.path("savedAt").isNull()).isTrue(); + perform(auth(delete(BASE + "/" + second)), 200); + assertThat(perform(auth(get(BASE)), 200).path("data").path("total").asInt()).isEqualTo(1); + } + + @Test + void staleVersionCannotObtainNewUploadCredentialsAndLogoutRevokesPcbAccess() throws Exception { + String code = create("登录与版本"); + confirm(code, upload(code, 0, new byte[] {1}), 200); + assertThat(perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0)), 409) + .path("code").asText()).isEqualTo("PCB_VERSION_CONFLICT"); + perform(auth(post("/api/auth/logout")), 200); + perform(auth(get(BASE + "/" + code)), 401); + perform(auth(get("/api/users/me")), 401); + } + + @Test + void validatesMetadataLimitsAndStorageDisabledWithoutBlockingProjectDeletion() throws Exception { + perform(body(auth(post(BASE)), Map.of("name", " ")), 400); + String code = create("参数检查"); + perform(body(auth(patch(BASE + "/" + code)), Map.of()), 400); + perform(body(auth(patch(BASE + "/" + code)), Map.of("name", " ")), 400); + perform(auth(get(BASE + "?page=0")), 400); + perform(auth(get(BASE + "?size=101")), 400); + perform(auth(get(BASE + "?keyword=" + "a".repeat(101))), 400); + properties.setMaxFileBytes(1); + assertThat(perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "test.zip", "sizeBytes", 2, "expectedVersion", 0)), 413).path("code").asText()).isEqualTo("PCB_FILE_TOO_LARGE"); + properties.getOss().setEnabled(false); + assertThat(perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0)), 503).path("code").asText()).isEqualTo("PCB_STORAGE_UNAVAILABLE"); + perform(auth(delete(BASE + "/" + code)), 200); + } + + @ParameterizedTest + @ValueSource(strings = {"../project.zip", "dir/project.zip", "dir\\project.zip", "test.step", ".zip", "test.zip\n", "test\u0000.zip"}) + void rejectsNonZipOrUnsafeFileNames(String fileName) throws Exception { + String code = create("文件名检查"); + perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", fileName, "sizeBytes", 1, "expectedVersion", 0)), 400); + } + + @ParameterizedTest + @ValueSource(strings = {"\"1\"", "1.5", "null", "-1", "9223372036854775808"}) + void rejectsCoercedOrInvalidNumericInput(String number) throws Exception { + String code = create("数字检查"); + for (String input : List.of( + "{\"fileName\":\"test.zip\",\"sizeBytes\":" + number + ",\"expectedVersion\":0}", + "{\"fileName\":\"test.zip\",\"sizeBytes\":1,\"expectedVersion\":" + number + "}")) { + perform(auth(post(BASE + "/" + code + "/uploads/signature")).contentType(MediaType.APPLICATION_JSON).content(input), 400); + } + } + + @Test + void acceptsUppercaseZipButRejectsEmptyAndOversizedMetadata() throws Exception { + String code = create("边界检查"); + perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "工程.ZIP", "sizeBytes", 1, "expectedVersion", 0)), 200); + perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "工程.zip", "sizeBytes", 0, "expectedVersion", 0)), 400); + perform(body(auth(post(BASE)), Map.of("name", "a".repeat(101))), 400); + perform(body(auth(patch(BASE + "/" + code)), Map.of("description", "a".repeat(2001))), 400); + perform(body(auth(post(BASE + "/" + code + "/uploads/signature")), + Map.of("fileName", "a".repeat(252) + ".zip", "sizeBytes", 1, "expectedVersion", 0)), 400); + } + + @Test + void authenticationCorsNoStoreAndOpenApiExposeAllEightOperations() throws Exception { + mvc.perform(get(BASE)).andExpect(status().isUnauthorized()).andExpect(header().string("Cache-Control", "no-store")); + mvc.perform(auth(get(BASE)).header("Origin", "https://dev-vibemake.robotquan.com")) + .andExpect(status().isOk()).andExpect(header().string("Access-Control-Allow-Origin", "https://dev-vibemake.robotquan.com")) + .andExpect(header().string("Cache-Control", "no-store")); + JsonNode spec = perform(get("/v3/api-docs"), 200); + JsonNode paths = spec.path("paths"); + assertThat(paths.path(BASE).has("get")).isTrue(); + assertThat(paths.path(BASE).has("post")).isTrue(); + assertThat(paths.path(BASE + "/{pcbProjectCode}").has("get")).isTrue(); + assertThat(paths.path(BASE + "/{pcbProjectCode}").has("patch")).isTrue(); + assertThat(paths.path(BASE + "/{pcbProjectCode}").has("delete")).isTrue(); + assertThat(paths.path(BASE + "/{pcbProjectCode}/uploads/signature").has("post")).isTrue(); + assertThat(paths.path(BASE + "/{pcbProjectCode}/document").has("get")).isTrue(); + assertThat(paths.path(BASE + "/{pcbProjectCode}/document").has("put")).isTrue(); + // PCB、CAD 与 Git 项目使用独立 DTO,避免 OpenAPI 模型相互污染。 + JsonNode schemas = spec.path("components").path("schemas"); + assertThat(schemas.path("PcbProjectView").path("properties").has("pcbProjectCode")).isTrue(); + assertThat(schemas.path("PcbProjectView").path("properties").has("coverUrl")).isTrue(); + assertThat(schemas.path("PcbCreateProjectInput").path("properties").has("coverUrl")).isTrue(); + assertThat(schemas.path("PcbUpdateProjectInput").path("properties").has("coverUrl")).isTrue(); + assertThat(schemas.path("PcbProjectView").path("properties").has("projectCode")).isFalse(); + assertThat(schemas.path("PcbProjectView").path("properties").has("cadProjectCode")).isFalse(); + assertThat(schemas.path("CadProjectView").path("properties").has("cadProjectCode")).isTrue(); + for (String name : List.of("PcbProjectView", "PcbUploadSignature", "PcbSaveResult", "PcbDocumentView")) { + assertThat(schemas.path(name).path("properties").has("id")).isFalse(); + assertThat(schemas.path(name).path("properties").has("ownerUserId")).isFalse(); + assertThat(schemas.path(name).path("properties").has("pcbProjectId")).isFalse(); + } + assertThat(schemas.path("ProjectView").path("properties").has("projectCode")).isTrue(); + assertThat(schemas.path("ProjectView").path("properties").has("pcbProjectCode")).isFalse(); + } +} diff --git a/vibemake-api/src/test/java/com/linkerbot/vibemake/api/SchemaSupport.java b/vibemake-api/src/test/java/com/linkerbot/vibemake/api/SchemaSupport.java index 16f23ae..8665939 100644 --- a/vibemake-api/src/test/java/com/linkerbot/vibemake/api/SchemaSupport.java +++ b/vibemake-api/src/test/java/com/linkerbot/vibemake/api/SchemaSupport.java @@ -15,7 +15,8 @@ final class SchemaSupport { Files.readString(path) + "\n" + Files.readString(path.resolveSibling("admin-database.md")) - + "\n" + Files.readString(path.resolveSibling("cad-database.md")); + + "\n" + Files.readString(path.resolveSibling("cad-database.md")) + + "\n" + Files.readString(path.resolveSibling("pcb-database.md")); Matcher matcher = Pattern.compile("CREATE TABLE [\\s\\S]*?;").matcher(content); jdbc.execute("DROP ALL OBJECTS"); int tables = 0; @@ -33,6 +34,6 @@ final class SchemaSupport { jdbc.execute(ddl); tables++; } - if (tables != 9) throw new IllegalStateException("必须包含九张业务与审计表"); + if (tables != 11) throw new IllegalStateException("必须包含十一张业务与审计表"); } } diff --git a/vibemake-api/src/test/java/com/linkerbot/vibemake/api/WorkflowTest.java b/vibemake-api/src/test/java/com/linkerbot/vibemake/api/WorkflowTest.java index a138737..501b93b 100644 --- a/vibemake-api/src/test/java/com/linkerbot/vibemake/api/WorkflowTest.java +++ b/vibemake-api/src/test/java/com/linkerbot/vibemake/api/WorkflowTest.java @@ -1271,7 +1271,7 @@ class WorkflowTest { "PROJECT_COMMENT", "PROJECT_LIKE", "PROJECT_IMPORT_TASK", "REPOSITORY_WRITE_OPERATION", "PROJECT_GIT_TOKEN", - "CAD_PROJECT", "CAD_PROJECT_UPLOAD"); + "CAD_PROJECT", "CAD_PROJECT_UPLOAD", "PCB_PROJECT", "PCB_PROJECT_UPLOAD"); } @Test diff --git a/vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/PcbContracts.java b/vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/PcbContracts.java new file mode 100644 index 0000000..baff191 --- /dev/null +++ b/vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/PcbContracts.java @@ -0,0 +1,59 @@ +package com.linkerbot.vibemake.bean; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonToken; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonDeserializer; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import jakarta.validation.constraints.*; +import java.io.IOException; +import java.time.LocalDateTime; +import java.util.Map; + +public final class PcbContracts { + private PcbContracts() {} + + public record PcbCreateProjectInput( + @NotBlank @Size(max = 100) String name, + @Size(max = 2000) String description, + @Size(max = 2048) String coverUrl) {} + + public record PcbUpdateProjectInput( + @Size(min = 1, max = 100) String name, + @Size(max = 2000) String description, + @Size(max = 2048) String coverUrl) {} + + public record PcbUploadInput( + @NotBlank @Size(max = 255) String fileName, + @NotNull @Positive @JsonDeserialize(using = StrictLongDeserializer.class) Long sizeBytes, + @NotNull @PositiveOrZero @JsonDeserialize(using = StrictLongDeserializer.class) Long expectedVersion) {} + + public record PcbConfirmInput(@NotBlank @Size(max = 32) String uploadCode) {} + + public record PcbProjectView( + String pcbProjectCode, String name, String description, String coverUrl, boolean hasDocument, + long version, String fileName, long sizeBytes, LocalDateTime savedAt, + LocalDateTime createdAt, LocalDateTime updatedAt) {} + + public record PcbUploadSignature( + String uploadCode, String uploadUrl, Map formFields, + LocalDateTime expiresAt) {} + + public record PcbSaveResult(String pcbProjectCode, long version, LocalDateTime savedAt) {} + + /** 普通 OSS/CDN 文件地址不设置业务过期时间,expiresAt 固定为 null,与 CAD 接口约定一致。 */ + public record PcbDocumentView( + String downloadUrl, LocalDateTime expiresAt, long version, + String fileName, long sizeBytes) {} + + /** 文件大小和版本必须是真正的 JSON 整数,拒绝小数截断及字符串自动转换。 */ + public static final class StrictLongDeserializer extends JsonDeserializer { + @Override + public Long deserialize(JsonParser parser, DeserializationContext context) throws IOException { + if (!parser.hasToken(JsonToken.VALUE_NUMBER_INT)) { + return (Long) context.handleUnexpectedToken(Long.class, parser); + } + return parser.getLongValue(); + } + } +} diff --git a/vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/entity/PcbProject.java b/vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/entity/PcbProject.java new file mode 100644 index 0000000..b519520 --- /dev/null +++ b/vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/entity/PcbProject.java @@ -0,0 +1,25 @@ +package com.linkerbot.vibemake.bean.entity; + +import com.baomidou.mybatisplus.annotation.TableName; +import java.time.LocalDateTime; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@TableName("pcb_project") +public class PcbProject extends BaseEntity { + private String pcbProjectCode; + private Long ownerUserId; + private String name; + private String description; + /** 平台 OSS 封面保存无环境前缀的相对路径,对外返回完整 URL。 */ + private String coverUrl; + /** 环境相对路径,以 /pcb-projects/ 开头;访问 OSS 时再补当前环境根目录。 */ + private String documentObjectKey; + private String fileName; + private Long sizeBytes; + private Long version; + private LocalDateTime savedAt; + private Boolean deleted; +} diff --git a/vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/entity/PcbProjectUpload.java b/vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/entity/PcbProjectUpload.java new file mode 100644 index 0000000..da9206c --- /dev/null +++ b/vibemake-bean/src/main/java/com/linkerbot/vibemake/bean/entity/PcbProjectUpload.java @@ -0,0 +1,22 @@ +package com.linkerbot.vibemake.bean.entity; + +import com.baomidou.mybatisplus.annotation.TableName; +import java.time.LocalDateTime; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@TableName("pcb_project_upload") +public class PcbProjectUpload extends BaseEntity { + private String uploadCode; + private Long pcbProjectId; + private Long expectedVersion; + /** 环境相对路径,不保存 Bucket、域名或环境根目录。 */ + private String objectKey; + private String fileName; + private Long sizeBytes; + private LocalDateTime expiresAt; + private Long savedVersion; + private LocalDateTime savedAt; +} diff --git a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/config/LimitProperties.java b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/config/LimitProperties.java index 5dfedaf..d81277a 100644 --- a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/config/LimitProperties.java +++ b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/config/LimitProperties.java @@ -45,6 +45,10 @@ public class LimitProperties { values.put("cad-sign", 20); values.put("cad-save", 30); values.put("cad-read", 60); + values.put("pcb-create", 5); + values.put("pcb-sign", 20); + values.put("pcb-save", 30); + values.put("pcb-read", 60); values.put("comment", 10); values.put("like", 60); return values; diff --git a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/config/PcbProperties.java b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/config/PcbProperties.java new file mode 100644 index 0000000..bd06074 --- /dev/null +++ b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/config/PcbProperties.java @@ -0,0 +1,41 @@ +package com.linkerbot.vibemake.service.config; + +import jakarta.validation.Valid; +import jakarta.validation.constraints.*; +import java.time.Duration; +import lombok.Getter; +import lombok.Setter; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.stereotype.Component; +import org.springframework.validation.annotation.Validated; + +@Getter +@Setter +@Validated +@Component +@ConfigurationProperties(prefix = "vibemake.pcb") +public class PcbProperties { + @Valid @NotNull + private OssSettings oss = new OssSettings(); + @Positive @Max(5368709120L) + private long maxFileBytes = 256L * 1024 * 1024; + @NotNull + private Duration uploadValidity = Duration.ofMinutes(15); + + /** PCB 独立开关,连接参数统一使用 vibemake.oss。 */ + @Getter + @Setter + public static class OssSettings { + private boolean enabled; + } + + @AssertTrue(message = "PCB 上传签名有效期必须在 1 秒至 7 天之间") + public boolean isValidityValid() { + return valid(uploadValidity); + } + + private boolean valid(Duration duration) { + return duration != null && duration.compareTo(Duration.ofSeconds(1)) >= 0 + && duration.compareTo(Duration.ofDays(7)) <= 0; + } +} diff --git a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/mapper/PcbProjectMapper.java b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/mapper/PcbProjectMapper.java new file mode 100644 index 0000000..8a89d23 --- /dev/null +++ b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/mapper/PcbProjectMapper.java @@ -0,0 +1,12 @@ +package com.linkerbot.vibemake.service.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.linkerbot.vibemake.bean.entity.PcbProject; +import org.apache.ibatis.annotations.*; + +@Mapper +public interface PcbProjectMapper extends BaseMapper { + @Select("SELECT * FROM pcb_project WHERE pcb_project_code = #{code} " + + "AND owner_user_id = #{userId} AND deleted = 0 FOR UPDATE") + PcbProject lockOwner(@Param("userId") long userId, @Param("code") String code); +} diff --git a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/mapper/PcbProjectUploadMapper.java b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/mapper/PcbProjectUploadMapper.java new file mode 100644 index 0000000..12fefed --- /dev/null +++ b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/mapper/PcbProjectUploadMapper.java @@ -0,0 +1,12 @@ +package com.linkerbot.vibemake.service.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.linkerbot.vibemake.bean.entity.PcbProjectUpload; +import org.apache.ibatis.annotations.*; + +@Mapper +public interface PcbProjectUploadMapper extends BaseMapper { + @Select("SELECT * FROM pcb_project_upload WHERE upload_code = #{code} " + + "AND pcb_project_id = #{projectId} FOR UPDATE") + PcbProjectUpload lockUpload(@Param("projectId") long projectId, @Param("code") String code); +} diff --git a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/oss/OssResourcePaths.java b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/oss/OssResourcePaths.java index 0000926..09e6396 100644 --- a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/oss/OssResourcePaths.java +++ b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/oss/OssResourcePaths.java @@ -70,6 +70,7 @@ public class OssResourcePaths { if (!path.startsWith("/project-covers/") && !path.startsWith("/urdf/") && !path.startsWith("/project-resources/") && !path.startsWith("/cad-projects/") + && !path.startsWith("/pcb-projects/") && !path.startsWith("/readme-images/")) throw invalidPath(); String relative = path.substring(1); if (relative.endsWith("/")) relative = relative.substring(0, relative.length() - 1); diff --git a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/AliyunPcbObjectStore.java b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/AliyunPcbObjectStore.java new file mode 100644 index 0000000..1b9c7aa --- /dev/null +++ b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/AliyunPcbObjectStore.java @@ -0,0 +1,118 @@ +package com.linkerbot.vibemake.service.pcb; + +import com.aliyun.oss.*; +import com.aliyun.oss.common.auth.DefaultCredentialProvider; +import com.aliyun.oss.common.comm.SignVersion; +import com.aliyun.oss.model.*; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.linkerbot.vibemake.common.BusinessException; +import com.linkerbot.vibemake.service.config.PcbProperties; +import com.linkerbot.vibemake.service.config.OssProperties; +import com.linkerbot.vibemake.service.oss.OssPostSigner; +import com.linkerbot.vibemake.service.oss.OssResourcePaths; +import jakarta.annotation.PreDestroy; +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ContentDisposition; +import org.springframework.stereotype.Component; + +@Component +public class AliyunPcbObjectStore implements PcbObjectStore { + private static final Logger log = LoggerFactory.getLogger(AliyunPcbObjectStore.class); + private final PcbProperties properties; + private final OssProperties oss; + private final OssPostSigner signer; + private final OssResourcePaths paths; + private OSS client; + + @Autowired + public AliyunPcbObjectStore(PcbProperties properties, OssProperties oss, ObjectMapper json) { + this(properties, oss, json, null); + } + + AliyunPcbObjectStore(PcbProperties properties, OssProperties oss, ObjectMapper json, OSS client) { + this.properties = properties; + this.oss = oss; + this.signer = new OssPostSigner(oss, json); + this.paths = new OssResourcePaths(oss); + this.client = client; + } + + private void requireConfiguration() { + if (!properties.getOss().isEnabled()) throw new BusinessException(503, "PCB_STORAGE_UNAVAILABLE", "PCB 文件存储暂未开启"); + if (!oss.hasValidStorageConfiguration()) { + log.error("PCB OSS 连接配置不完整 bucket={} region={}", oss.getBucket(), oss.getRegion()); + throw new BusinessException(503, "PCB_STORAGE_UNSAFE", "PCB 文件存储连接配置异常,请联系管理员"); + } + } + + private synchronized OSS client() { + requireConfiguration(); + if (client == null) { + ClientBuilderConfiguration configuration = new ClientBuilderConfiguration(); + configuration.setSignatureVersion(SignVersion.V4); + configuration.setConnectionTimeout(5000); + configuration.setSocketTimeout(30000); + configuration.setMaxErrorRetry(1); + client = OSSClientBuilder.create().endpoint(oss.resolvedEndpoint()).region(oss.getRegion()) + .credentialsProvider(new DefaultCredentialProvider(oss.getAccessKeyId(), oss.getAccessKeySecret())) + .clientConfiguration(configuration).build(); + } + return client; + } + + @Override + public SignedUpload signUpload(String objectKey, String fileName, long sizeBytes, Duration validity) { + // 签名仅做本地计算,不查询 Bucket 配置或对象 ACL。 + requireConfiguration(); + OssPostSigner.SignedPost post = signer.signObject(objectKey, "application/zip", + sizeBytes, validity, disposition(fileName)); + return new SignedUpload(oss.uploadUrl(), post.formFields(), post.expiresAt()); + } + + @Override + public long size(String objectKey) { + try { + return client().getObjectMetadata(oss.getBucket(), objectKey).getContentLength(); + } catch (OSSException error) { + if ("NoSuchKey".equals(error.getErrorCode())) { + log.warn("PCB 上传对象尚不存在 objectKey={} ossRequestId={}", objectKey, error.getRequestId()); + throw new BusinessException(409, "PCB_FILE_MISSING", "工程文件尚未上传完成"); + } + throw failure("head", objectKey, error); + } catch (ClientException error) { + throw transportFailure("head", objectKey, error); + } + } + + @Override + public String documentUrl(String objectKey) { + requireConfiguration(); + return paths.publicUrl(objectKey); + } + + private String disposition(String fileName) { + return ContentDisposition.attachment().filename(fileName, StandardCharsets.UTF_8).build().toString(); + } + + private BusinessException failure(String operation, String key, OSSException error) { + log.error("PCB OSS 操作失败 operation={} objectKey={} ossCode={} ossRequestId={}", + operation, key, error.getErrorCode(), error.getRequestId()); + return new BusinessException(502, "PCB_OSS_ERROR", "PCB 文件存储访问失败,请稍后重试"); + } + + private BusinessException transportFailure(String operation, String key, ClientException error) { + // SDK 异常正文可能带签名 URL,仅记录异常类型。 + log.error("PCB OSS 网络异常 operation={} objectKey={} errorType={}", + operation, key, error.getClass().getSimpleName()); + return new BusinessException(502, "PCB_OSS_ERROR", "PCB 文件存储访问失败,请稍后重试"); + } + + @PreDestroy + public synchronized void close() { + if (client != null) client.shutdown(); + } +} diff --git a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/PcbObjectStore.java b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/PcbObjectStore.java new file mode 100644 index 0000000..d138e63 --- /dev/null +++ b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/PcbObjectStore.java @@ -0,0 +1,16 @@ +package com.linkerbot.vibemake.service.pcb; + +import java.time.Duration; +import java.time.LocalDateTime; +import java.util.Map; + +/** 入参为包含环境根目录的真实 OSS key;数据库引用由业务层通过 OssResourcePaths 转换。权限由 Bucket/CDN 决定。 */ +public interface PcbObjectStore { + record SignedUpload(String uploadUrl, Map formFields, LocalDateTime expiresAt) {} + + SignedUpload signUpload(String objectKey, String fileName, long sizeBytes, Duration validity); + + long size(String objectKey); + + String documentUrl(String objectKey); +} diff --git a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/PcbProjectService.java b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/PcbProjectService.java new file mode 100644 index 0000000..e036bd0 --- /dev/null +++ b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/pcb/PcbProjectService.java @@ -0,0 +1,245 @@ +package com.linkerbot.vibemake.service.pcb; + +import static com.linkerbot.vibemake.service.support.ProjectSupport.now; +import static com.linkerbot.vibemake.service.support.ProjectSupport.pageCheck; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.linkerbot.vibemake.bean.PcbContracts.*; +import com.linkerbot.vibemake.bean.entity.PcbProject; +import com.linkerbot.vibemake.bean.entity.PcbProjectUpload; +import com.linkerbot.vibemake.common.*; +import com.linkerbot.vibemake.service.config.PcbProperties; +import com.linkerbot.vibemake.service.oss.OssResourcePaths; +import com.linkerbot.vibemake.service.mapper.PcbProjectMapper; +import com.linkerbot.vibemake.service.mapper.PcbProjectUploadMapper; +import com.linkerbot.vibemake.service.state.RateLimits; +import java.time.LocalDateTime; +import java.time.temporal.ChronoUnit; +import java.util.Locale; +import lombok.RequiredArgsConstructor; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.dao.DuplicateKeyException; +import org.springframework.stereotype.Service; +import org.springframework.transaction.support.TransactionTemplate; + +@Service +@RequiredArgsConstructor +public class PcbProjectService { + private static final Logger log = LoggerFactory.getLogger(PcbProjectService.class); + private final PcbProjectMapper projects; + private final PcbProjectUploadMapper uploads; + private final PcbProperties properties; + private final OssResourcePaths paths; + private final PcbObjectStore storage; + private final TransactionTemplate transactions; + private final RateLimits limits; + + public PageResponse list(long userId, String keyword, long page, long size) { + pageCheck(page, size); + if (keyword != null && keyword.length() > 100) throw BusinessException.badRequest("搜索词最多 100 个字符"); + String search = keyword == null ? "" : keyword.trim(); + Page result = projects.selectPage(new Page<>(page, size), + new LambdaQueryWrapper().eq(PcbProject::getOwnerUserId, userId) + .eq(PcbProject::getDeleted, false).like(!search.isEmpty(), PcbProject::getName, search) + .orderByDesc(PcbProject::getUpdatedAt).orderByDesc(PcbProject::getId)); + return new PageResponse<>(result.getRecords().stream().map(this::view).toList(), page, size, result.getTotal()); + } + + public PcbProjectView create(long userId, PcbCreateProjectInput input) { + limits.operation("pcb-create", userId); + PcbProject project = new PcbProject(); + project.setOwnerUserId(userId); + project.setName(name(input.name())); + project.setDescription(input.description() == null ? "" : input.description().trim()); + project.setCoverUrl(paths.coverStorage(input.coverUrl())); + project.setDocumentObjectKey(""); + project.setFileName(""); + project.setSizeBytes(0L); + project.setVersion(0L); + project.setDeleted(false); + project.setCreatedAt(now()); + project.setUpdatedAt(project.getCreatedAt()); + for (int attempt = 0; attempt < 5; attempt++) { + project.setPcbProjectCode(ProjectCodes.next()); + try { + projects.insert(project); + log.info("创建 PCB 项目 pcbProjectCode={}", project.getPcbProjectCode()); + return view(project); + } catch (DuplicateKeyException error) { + project.setId(null); + } + } + throw new BusinessException(503, "PCB_CODE_BUSY", "项目编码分配繁忙,请稍后重试"); + } + + public PcbProjectView detail(long userId, String code) { + return view(owner(userId, code)); + } + + public PcbProjectView update(long userId, String code, PcbUpdateProjectInput input) { + if (input.name() == null && input.description() == null && input.coverUrl() == null) + throw BusinessException.badRequest("请提供名称、描述或封面"); + PcbProjectView result = transactions.execute(status -> { + PcbProject project = lockedOwner(userId, code); + if (input.name() != null) project.setName(name(input.name())); + if (input.description() != null) project.setDescription(input.description().trim()); + if (input.coverUrl() != null) project.setCoverUrl(paths.coverStorage(input.coverUrl())); + project.setUpdatedAt(now()); + projects.update(null, new LambdaUpdateWrapper().eq(PcbProject::getId, project.getId()) + .set(PcbProject::getName, project.getName()).set(PcbProject::getDescription, project.getDescription()) + .set(input.coverUrl() != null, PcbProject::getCoverUrl, project.getCoverUrl()) + .set(PcbProject::getUpdatedAt, project.getUpdatedAt())); + return view(project); + }); + log.info("修改 PCB 项目信息 pcbProjectCode={} coverChanged={}", code, input.coverUrl() != null); + return result; + } + + public void delete(long userId, String code) { + transactions.executeWithoutResult(status -> { + PcbProject project = lockedOwner(userId, code); + projects.update(null, new LambdaUpdateWrapper().eq(PcbProject::getId, project.getId()) + .set(PcbProject::getDeleted, true).set(PcbProject::getUpdatedAt, now())); + }); + log.info("删除 PCB 项目 pcbProjectCode={}", code); + } + + public PcbUploadSignature sign(long userId, String code, PcbUploadInput input) { + PcbProject project = owner(userId, code); + limits.operation("pcb-sign", userId); + checkFile(input); + checkVersion(project, input.expectedVersion()); + String uploadCode = Codes.next(); + String path = "/pcb-projects/" + code + "/" + uploadCode + "/project.zip"; + PcbObjectStore.SignedUpload signature = storage.signUpload(paths.objectKey(path), input.fileName(), input.sizeBytes(), properties.getUploadValidity()); + transactions.executeWithoutResult(status -> { + PcbProject current = lockedOwner(userId, code); + checkVersion(current, input.expectedVersion()); + PcbProjectUpload upload = new PcbProjectUpload(); + upload.setUploadCode(uploadCode); + upload.setPcbProjectId(current.getId()); + upload.setExpectedVersion(input.expectedVersion()); + upload.setObjectKey(path); + upload.setFileName(input.fileName()); + upload.setSizeBytes(input.sizeBytes()); + upload.setExpiresAt(signature.expiresAt()); + upload.setCreatedAt(now()); + upload.setUpdatedAt(upload.getCreatedAt()); + uploads.insert(upload); + }); + log.info("签发 PCB 上传 pcbProjectCode={} uploadCode={} expectedVersion={} sizeBytes={}", + code, uploadCode, input.expectedVersion(), input.sizeBytes()); + return new PcbUploadSignature(uploadCode, signature.uploadUrl(), signature.formFields(), signature.expiresAt()); + } + + public PcbSaveResult confirm(long userId, String code, String uploadCode) { + PcbProject project = owner(userId, code); + limits.operation("pcb-save", userId); + PcbProjectUpload upload = uploads.selectOne(new LambdaQueryWrapper() + .eq(PcbProjectUpload::getPcbProjectId, project.getId()).eq(PcbProjectUpload::getUploadCode, uploadCode)); + if (upload == null) throw BusinessException.notFound(); + // HEAD 在事务之外执行,远程访问期间不占数据库行锁。已确认批次重试不再依赖 OSS。 + if (upload.getSavedVersion() == null) { + checkExpiry(code, upload); + checkVersion(project, upload.getExpectedVersion()); + long actualBytes = storage.size(paths.objectKey(upload.getObjectKey())); + if (actualBytes != upload.getSizeBytes()) { + log.warn("PCB 文件大小不符 pcbProjectCode={} uploadCode={} expectedBytes={} actualBytes={}", + code, uploadCode, upload.getSizeBytes(), actualBytes); + throw new BusinessException(409, "PCB_FILE_SIZE_MISMATCH", "工程文件大小不符,请重新上传"); + } + } + PcbSaveResult result = transactions.execute(status -> { + PcbProject current = lockedOwner(userId, code); + PcbProjectUpload pending = uploads.lockUpload(current.getId(), uploadCode); + if (pending == null) throw BusinessException.notFound(); + if (pending.getSavedVersion() != null) return receipt(code, pending); + checkExpiry(code, pending); + checkVersion(current, pending.getExpectedVersion()); + long version = Math.addExact(current.getVersion(), 1L); + // 与 DATETIME(3) 一致,保证首次回执和数据库重放回执完全相同。 + LocalDateTime savedAt = now().truncatedTo(ChronoUnit.MILLIS); + String path = paths.storagePath(pending.getObjectKey()); + int changed = projects.update(null, new LambdaUpdateWrapper() + .eq(PcbProject::getId, current.getId()).eq(PcbProject::getDeleted, false) + .eq(PcbProject::getVersion, pending.getExpectedVersion()) + .set(PcbProject::getDocumentObjectKey, path) + .set(PcbProject::getFileName, pending.getFileName()).set(PcbProject::getSizeBytes, pending.getSizeBytes()) + .set(PcbProject::getVersion, version).set(PcbProject::getSavedAt, savedAt).set(PcbProject::getUpdatedAt, savedAt)); + if (changed != 1) throw new BusinessException(409, "PCB_VERSION_CONFLICT", "项目已发生变化,请刷新后重试"); + pending.setSavedVersion(version); + pending.setObjectKey(path); + pending.setSavedAt(savedAt); + pending.setUpdatedAt(savedAt); + if (uploads.updateById(pending) != 1) throw new IllegalStateException("PCB 上传批次确认失败"); + return receipt(code, pending); + }); + log.info("确认 PCB 保存 pcbProjectCode={} uploadCode={} version={}", code, uploadCode, result.version()); + return result; + } + + public PcbDocumentView document(long userId, String code) { + PcbProject project = owner(userId, code); + limits.operation("pcb-read", userId); + if (project.getVersion() == 0) throw new BusinessException(404, "PCB_DOCUMENT_NOT_FOUND", "项目尚未保存工程文件"); + String downloadUrl = storage.documentUrl(paths.objectKey(project.getDocumentObjectKey())); + log.info("读取 PCB 文件地址 pcbProjectCode={} version={}", code, project.getVersion()); + return new PcbDocumentView(downloadUrl, null, project.getVersion(), project.getFileName(), project.getSizeBytes()); + } + + private PcbProject owner(long userId, String code) { + PcbProject project = projects.selectOne(new LambdaQueryWrapper() + .eq(PcbProject::getPcbProjectCode, code).eq(PcbProject::getOwnerUserId, userId).eq(PcbProject::getDeleted, false)); + if (project == null) throw BusinessException.notFound(); + return project; + } + + private PcbProject lockedOwner(long userId, String code) { + PcbProject project = projects.lockOwner(userId, code); + if (project == null) throw BusinessException.notFound(); + return project; + } + + private PcbProjectView view(PcbProject project) { + return new PcbProjectView(project.getPcbProjectCode(), project.getName(), project.getDescription(), paths.coverUrl(project.getCoverUrl()), project.getVersion() > 0, + project.getVersion(), project.getFileName(), project.getSizeBytes(), project.getSavedAt(), project.getCreatedAt(), project.getUpdatedAt()); + } + + private PcbSaveResult receipt(String code, PcbProjectUpload upload) { + return new PcbSaveResult(code, upload.getSavedVersion(), upload.getSavedAt()); + } + + private String name(String value) { + if (value == null || value.isBlank() || value.trim().length() > 100) throw BusinessException.badRequest("项目名称须为 1 至 100 个字符"); + return value.trim(); + } + + private void checkFile(PcbUploadInput input) { + String name = input.fileName(); + if (name == null || name.isBlank() || name.length() > 255 || name.indexOf('/') >= 0 + || name.indexOf('\\') >= 0 || name.chars().anyMatch(Character::isISOControl) + || !name.toLowerCase(Locale.ROOT).endsWith(".zip") || name.length() <= 4 + || input.sizeBytes() == null || input.sizeBytes() <= 0 || input.expectedVersion() == null || input.expectedVersion() < 0) { + throw new BusinessException(400, "PCB_INVALID_FILE", "请上传名称合法的非空 .zip 工程文件"); + } + if (input.sizeBytes() > properties.getMaxFileBytes()) throw new BusinessException(413, "PCB_FILE_TOO_LARGE", "工程文件超过大小限制"); + } + + private void checkVersion(PcbProject project, long expectedVersion) { + if (project.getVersion() != expectedVersion) { + log.warn("PCB 保存版本冲突 pcbProjectCode={} expectedVersion={} currentVersion={}", project.getPcbProjectCode(), expectedVersion, project.getVersion()); + throw new BusinessException(409, "PCB_VERSION_CONFLICT", "项目已有更新,请保留本地修改并刷新后处理"); + } + } + + private void checkExpiry(String code, PcbProjectUpload upload) { + if (!upload.getExpiresAt().isAfter(now())) { + log.warn("PCB 上传批次过期 pcbProjectCode={} uploadCode={} expiresAt={}", + code, upload.getUploadCode(), upload.getExpiresAt()); + throw new BusinessException(409, "PCB_UPLOAD_EXPIRED", "上传批次已过期,请重新申请上传"); + } + } +} diff --git a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/state/HttpSafetyFilter.java b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/state/HttpSafetyFilter.java index f5173a8..9e37ec0 100644 --- a/vibemake-service/src/main/java/com/linkerbot/vibemake/service/state/HttpSafetyFilter.java +++ b/vibemake-service/src/main/java/com/linkerbot/vibemake/service/state/HttpSafetyFilter.java @@ -62,7 +62,8 @@ public class HttpSafetyFilter extends OncePerRequestFilter { boolean read = "GET".equals(method) || "HEAD".equals(method); boolean acquired = false; try { - if (path.contains("/auth/") || path.endsWith("/signature") || path.startsWith("/api/cad/")) + if (path.contains("/auth/") || path.endsWith("/signature") + || path.startsWith("/api/cad/") || path.startsWith("/api/pcb/")) response.setHeader("Cache-Control", "no-store"); String ip = addresses.resolve(request); if (path.equals("/api/auth/captcha")) limits.request("captcha", ip); diff --git a/vibemake-service/src/test/java/com/linkerbot/vibemake/service/oss/OssResourcePathsTest.java b/vibemake-service/src/test/java/com/linkerbot/vibemake/service/oss/OssResourcePathsTest.java index 0ec303f..37e8e3d 100644 --- a/vibemake-service/src/test/java/com/linkerbot/vibemake/service/oss/OssResourcePathsTest.java +++ b/vibemake-service/src/test/java/com/linkerbot/vibemake/service/oss/OssResourcePathsTest.java @@ -97,6 +97,20 @@ class OssResourcePathsTest { assertThatThrownBy(() -> paths.objectKey("/urdf/../other/a.urdf")).isInstanceOf(BusinessException.class); } + @Test + void pcbArchivesKeepEnvironmentIsolationAndRejectUnsafePaths() { + String path = "/pcb-projects/7m4k9x2p8q6r/" + "a".repeat(32) + "/project.zip"; + assertThat(paths.storagePath("vibemake_dev" + path)).isEqualTo(path); + assertThat(paths.objectKey(path)).isEqualTo("vibemake_dev" + path); + assertThat(paths.publicUrl(path)).isEqualTo("https://cdn.example.com/assets/vibemake_dev" + path); + assertThatThrownBy(() -> paths.objectKey("vibemake" + path)).isInstanceOf(BusinessException.class); + assertThatThrownBy(() -> paths.objectKey("/pcb-projects/../other/project.zip")).isInstanceOf(BusinessException.class); + assertThatThrownBy(() -> paths.objectKey("/pcb-projects-evil/code/project.zip")).isInstanceOf(BusinessException.class); + oss.setRootDirectory("vibemake"); + assertThat(paths.objectKey(path)).isEqualTo("vibemake" + path); + assertThatThrownBy(() -> paths.objectKey("vibemake_dev" + path)).isInstanceOf(BusinessException.class); + } + @Test void normalizesEveryProjectBindingBeforeFullSaveWithoutChangingObjectLocations() { Project project = new Project(); diff --git a/vibemake-service/src/test/java/com/linkerbot/vibemake/service/pcb/AliyunPcbObjectStoreTest.java b/vibemake-service/src/test/java/com/linkerbot/vibemake/service/pcb/AliyunPcbObjectStoreTest.java new file mode 100644 index 0000000..30f6b4e --- /dev/null +++ b/vibemake-service/src/test/java/com/linkerbot/vibemake/service/pcb/AliyunPcbObjectStoreTest.java @@ -0,0 +1,166 @@ +package com.linkerbot.vibemake.service.pcb; + +import static org.assertj.core.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +import com.aliyun.oss.*; +import com.aliyun.oss.model.*; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.linkerbot.vibemake.common.BusinessException; +import com.linkerbot.vibemake.service.config.PcbProperties; +import com.linkerbot.vibemake.service.config.OssProperties; +import com.linkerbot.vibemake.service.support.ProjectSupport; +import jakarta.validation.Validation; +import jakarta.validation.ValidatorFactory; +import java.time.Duration; +import java.util.Base64; +import org.junit.jupiter.api.*; + +class AliyunPcbObjectStoreTest { + private final ObjectMapper json = new ObjectMapper(); + private final PcbProperties properties = new PcbProperties(); + private final OssProperties oss = new OssProperties(); + private final OSS sdk = mock(OSS.class); + private AliyunPcbObjectStore storage; + + @BeforeEach + void setup() { + properties.getOss().setEnabled(true); + oss.setEnabled(false); + oss.setRegion("cn-beijing"); + oss.setBucket("pcb-private-test"); + oss.setAccessKeyId("TestKey"); + oss.setAccessKeySecret("test-secret"); + oss.setRootDirectory("vibemake_dev"); + storage = new AliyunPcbObjectStore(properties, oss, json, sdk); + } + + @Test + void uploadUsesExistingOssPolicyWithoutOverridingObjectAcl() throws Exception { + PcbObjectStore.SignedUpload result = storage.signUpload("vibemake_dev/pcb-projects/code/batch/project.zip", + "控制板.zip", 1234, Duration.ofMinutes(15)); + assertThat(result.uploadUrl()).isEqualTo("https://pcb-private-test.oss-cn-beijing.aliyuncs.com"); + assertThat(result.formFields()).containsEntry("x-oss-forbid-overwrite", "true") + .containsEntry("x-oss-content-type", "application/zip") + .containsEntry("content-type", "application/zip") + .doesNotContainKey("x-oss-object-acl"); + JsonNode policy = json.readTree(Base64.getDecoder().decode(result.formFields().get("policy"))); + assertThat(policy.path("conditions").toString()).contains( + "[\"eq\",\"$x-oss-forbid-overwrite\",\"true\"]", + "[\"content-length-range\",1234,1234]", + "[\"eq\",\"$content-type\",\"application/zip\"]", + "[\"eq\",\"$x-oss-content-type\",\"application/zip\"]", + "[\"eq\",\"$key\",\"vibemake_dev/pcb-projects/code/batch/project.zip\"]", + "[\"eq\",\"$Content-Disposition\""); + assertThat(policy.path("conditions").toString()).doesNotContain("x-oss-object-acl"); + assertThat(result.expiresAt()).isBetween(ProjectSupport.now().plusMinutes(14), ProjectSupport.now().plusMinutes(16)); + verifyNoInteractions(sdk); + } + + @Test + void documentUsesConfiguredPublicCdnAndEnvironmentRootWithoutSigning() { + oss.setPublicBaseUrl("https://cdn.example.com/resources/"); + String key = "vibemake_dev/pcb-projects/code/batch/project.zip"; + assertThat(storage.documentUrl(key)).isEqualTo("https://cdn.example.com/resources/" + key); + verifyNoInteractions(sdk); + } + + @Test + void documentFallsBackToBucketUrlAndRejectsOtherEnvironmentKeys() { + String key = "vibemake_dev/pcb-projects/code/batch/project.zip"; + assertThat(storage.documentUrl(key)).isEqualTo(oss.uploadUrl() + "/" + key); + assertThatThrownBy(() -> storage.documentUrl("vibemake/pcb-projects/code/batch/project.zip")) + .isInstanceOfSatisfying(BusinessException.class, error -> assertThat(error.code()).isEqualTo("RESOURCE_PATH_INVALID")); + verifyNoInteractions(sdk); + } + + @Test + void signingAndSavingWorkWithoutBucketOrObjectAclReadPermissions() throws Exception { + OSSException denied = new OSSException("denied", "AccessDenied", "request-test", "host", null, null, null); + when(sdk.getBucketAcl(anyString())).thenThrow(denied); + when(sdk.getBucketPolicyStatus(anyString())).thenThrow(denied); + when(sdk.getBucketVersioning(anyString())).thenThrow(denied); + when(sdk.getObjectAcl(anyString(), anyString())).thenThrow(denied); + ObjectMetadata metadata = new ObjectMetadata(); + metadata.setContentLength(1234); + when(sdk.getObjectMetadata("pcb-private-test", "key")).thenReturn(metadata); + assertThat(storage.signUpload("key", "x.zip", 1234, Duration.ofMinutes(15)).uploadUrl()).isEqualTo(oss.uploadUrl()); + assertThat(storage.size("key")).isEqualTo(1234); + assertThat(storage.documentUrl("vibemake_dev/pcb-projects/code/batch/project.zip")) + .isEqualTo(oss.publicBaseUrl() + "/vibemake_dev/pcb-projects/code/batch/project.zip"); + verify(sdk, never()).getBucketAcl(anyString()); + verify(sdk, never()).getBucketPolicyStatus(anyString()); + verify(sdk, never()).getBucketVersioning(anyString()); + verify(sdk, never()).getObjectAcl(anyString(), anyString()); + verify(sdk, never()).setBucketAcl(anyString(), any(CannedAccessControlList.class)); + verify(sdk, never()).generatePresignedUrl(any(GeneratePresignedUrlRequest.class)); + } + + @Test + void pcbSwitchDisablesOperationsEvenWithValidSharedSettings() { + properties.getOss().setEnabled(false); + assertThatThrownBy(() -> storage.documentUrl("vibemake_dev/pcb-projects/code/batch/project.zip")) + .isInstanceOfSatisfying(BusinessException.class, error -> assertThat(error.code()).isEqualTo("PCB_STORAGE_UNAVAILABLE")); + verifyNoInteractions(sdk); + } + + @Test + void rejectsIncompleteSharedCredentialsEvenWhenPublicUploadsDisabled() { + oss.setAccessKeySecret(""); + assertUnsafe(() -> storage.signUpload("key", "x.zip", 1, Duration.ofMinutes(15))); + verifyNoInteractions(sdk); + } + + @Test + void missingObjectAndTransportErrorsHaveStableCodes() { + OSSException missing = new OSSException("not found", "NoSuchKey", "request-test", "host", null, null, null); + when(sdk.getObjectMetadata("pcb-private-test", "key")).thenThrow(missing); + assertThatThrownBy(() -> storage.size("key")).isInstanceOfSatisfying(BusinessException.class, + error -> assertThat(error.code()).isEqualTo("PCB_FILE_MISSING")); + doThrow(new ClientException("network")).when(sdk).getObjectMetadata("pcb-private-test", "key"); + assertThatThrownBy(() -> storage.size("key")).isInstanceOfSatisfying(BusinessException.class, + error -> assertThat(error.code()).isEqualTo("PCB_OSS_ERROR")); + doThrow(new OSSException("denied")).when(sdk).getObjectMetadata("pcb-private-test", "key"); + assertThatThrownBy(() -> storage.size("key")) + .isInstanceOfSatisfying(BusinessException.class, error -> assertThat(error.status()).isEqualTo(502)); + } + + @Test + void pcbStorageDefaultsToDisabledAndHasBoundedUploadSettings() { + PcbProperties defaults = new PcbProperties(); + assertThat(defaults.getOss().isEnabled()).isFalse(); + assertThat(defaults.getMaxFileBytes()).isEqualTo(256L * 1024 * 1024); + assertThat(defaults.getUploadValidity()).isEqualTo(Duration.ofMinutes(15)); + } + + @Test + void validatesSharedCredentialsSizeAndSignatureValidity() { + try (ValidatorFactory factory = Validation.buildDefaultValidatorFactory()) { + assertThat(factory.getValidator().validate(properties)).isEmpty(); + assertThat(oss.hasValidStorageConfiguration()).isTrue(); + oss.setAccessKeySecret(""); + assertThat(oss.hasValidStorageConfiguration()).isFalse(); + properties.setUploadValidity(Duration.ZERO); + assertThat(factory.getValidator().validate(properties)).isNotEmpty(); + properties.setUploadValidity(null); + assertThat(factory.getValidator().validate(properties)).isNotEmpty(); + properties.setUploadValidity(Duration.ofMillis(999)); + assertThat(factory.getValidator().validate(properties)).isNotEmpty(); + properties.setUploadValidity(Duration.ofMinutes(15)); + properties.setUploadValidity(Duration.ofDays(8)); + assertThat(factory.getValidator().validate(properties)).isNotEmpty(); + properties.setUploadValidity(Duration.ofMinutes(15)); + properties.setMaxFileBytes(5368709121L); + assertThat(factory.getValidator().validate(properties)).isNotEmpty(); + properties.setMaxFileBytes(0); + assertThat(factory.getValidator().validate(properties)).isNotEmpty(); + } + } + + private void assertUnsafe(org.assertj.core.api.ThrowableAssert.ThrowingCallable action) { + assertThatThrownBy(action).isInstanceOfSatisfying(BusinessException.class, + error -> assertThat(error.code()).isEqualTo("PCB_STORAGE_UNSAFE")); + } +}