diff --git a/.env.example b/.env.example index 3ba416c..3605946 100644 --- a/.env.example +++ b/.env.example @@ -5,6 +5,8 @@ APP_DB_URL='jdbc:mysql://39.105.93.138:3306/cadworld?useUnicode=true&characterEn APP_DB_USERNAME= APP_DB_PASSWORD= APP_STORAGE_PROVIDER=minio +# Maximum bytes per upload, including raw PUT streams (default 100 MiB). +APP_STORAGE_MAX_UPLOAD_BYTES=104857600 APP_MINIO_ENDPOINT= APP_MINIO_ACCESS_KEY= APP_MINIO_SECRET_KEY= diff --git a/AGENTS.md b/AGENTS.md index 38aaa34..c0cc05d 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1,6 +1,6 @@ ## 代码实现原则 - 优先保证业务正确性、可维护性、可读性,再考虑炫技。 -- 修改代码时忽略.sql文件,如果遇到需要改表结构,直接发我sql。 +- 修改代码时忽略.sql文件,如果遇到需要改表结构,直接发我sql,要求表字段规范且有中文注释。 ## 日志规范 - 关键业务节点必须补充必要日志,方便线上排查。 - 不要打印密码、Token、手机号、身份证、支付密钥等敏感信息。 diff --git a/README.md b/README.md index 9c8c1bb..ca5c32b 100644 --- a/README.md +++ b/README.md @@ -31,9 +31,47 @@ mysql -h 39.105.93.138 -P 3306 -u YOUR_USER -p cadworld < db/upgrade.sql mysql -h 39.105.93.138 -P 3306 -u YOUR_USER -p cadworld < db/init.sql ``` -两个脚本均可重复执行,不包含删表语句、数据改写或 Flyway 历史处理。增量脚本新增接口定义、历史修订、组件资源索引、操作日志表,并为 `sys_user` 增加 `deleted`。仅初始化本次业务需要的六张表;原系统其他业务表无需迁移。 +原有两个脚本保留不变。执行初始化或增量脚本后,还需执行下面的接口重构补充 SQL。当前业务使用五张表:`sys_user`、`component`、`interface_definition_v2`、`interface_definition_revision`、`sys_operation_log`;组件资源索引代码已移除。 -用户删除保留数据及手机号唯一索引,已删除用户的手机号不能重新注册。组件删除沿用物理删除及资源索引级联清理;接口删除保留历史修订,原接口 ID 不能再次创建。删除操作不会清理 MinIO 中的资源对象。 +用户删除保留数据及手机号唯一索引,已删除用户的手机号不能重新注册。组件删除沿用物理删除;接口删除保留历史修订,原接口 ID 不能再次创建。删除操作不会清理 MinIO 中的资源对象。 + +### 接口重构补充 SQL + +按项目约定,不改动 `.sql` 文件,新增结构单独提供。下面 SQL 需手动在目标数据库执行,可重复执行;应用不会自动迁移。先检查重复组件名,存在重复记录时需先整理,否则唯一索引无法建立。 + + +```sql +-- 检查已有组件名称是否重复。 +SELECT component_name, COUNT(*) AS duplicate_count +FROM component +GROUP BY component_name +HAVING COUNT(*) > 1; + +SET @cadworld_edit_revision_ddl = IF( + EXISTS (SELECT 1 FROM information_schema.COLUMNS + WHERE TABLE_SCHEMA = DATABASE() + AND TABLE_NAME = 'interface_definition_v2' AND COLUMN_NAME = 'edit_revision'), + 'SELECT 1', + 'ALTER TABLE interface_definition_v2 ADD COLUMN edit_revision BIGINT NOT NULL DEFAULT 1 COMMENT ''编辑版本号,每次修改或源文件绑定变化时递增,用于防止旧数据覆盖'''); +PREPARE cadworld_edit_revision_statement FROM @cadworld_edit_revision_ddl; +EXECUTE cadworld_edit_revision_statement; +DEALLOCATE PREPARE cadworld_edit_revision_statement; + +SET @cadworld_component_name_ddl = IF( + EXISTS (SELECT 1 FROM information_schema.STATISTICS + WHERE TABLE_SCHEMA = DATABASE() + AND TABLE_NAME = 'component' AND INDEX_NAME = 'uk_component_name'), + 'SELECT 1', + 'ALTER TABLE component ADD UNIQUE KEY uk_component_name (component_name) COMMENT ''组件名称唯一索引,防止并发创建同名组件'''); +PREPARE cadworld_component_name_statement FROM @cadworld_component_name_ddl; +EXECUTE cadworld_component_name_statement; +DEALLOCATE PREPARE cadworld_component_name_statement; + +-- 该表只重复登记模型和封面对象键,业务代码已不依赖它。 +DROP TABLE IF EXISTS component_asset; +``` + +前端联调变更见 [后台接口文档](cadworld-adminapi/docs/admin-api.md):接口修改携带 `editRevision` 和 `geometryRevision`;组件修改携带 `componentJson.componentRevision`;原始文件 PUT 发送上传地址响应中的 `uploadHeaders`。版本冲突返回 HTTP 409,不覆盖其他人的修改。 ## 配置与启动 @@ -58,6 +96,7 @@ java -jar cadworld-adminapi/target/cadworld-adminapi-0.0.1-SNAPSHOT.jar | APP_STORAGE_PUBLIC_API_BASE_URL | 生成上传地址所用的后台外部地址 | | APP_STORAGE_PUBLIC_BASE_URL | 生成下载地址的资源前缀,默认 `/admin-api/component-assets` | | APP_STORAGE_LOCAL_ROOT | 本地存储目录,默认 `./data/assets` | +| APP_STORAGE_MAX_UPLOAD_BYTES | 文件上传大小限制,默认 104857600 字节;原始 PUT 流同样检查 | | APP_UPLOAD_SESSION_SECRET | 至少 32 个 UTF-8 字节的上传签名密钥;留空时生成进程内随机密钥,重启后原上传会话失效 | | APP_ADMIN_OPERATOR_ID / APP_ADMIN_OPERATOR_NAME | 测试操作人,默认 `0 / TEST_OPERATOR` | | LOG_PATH | 运行日志目录,默认 `logs` | diff --git a/cadworld-adminapi/docs/admin-api.md b/cadworld-adminapi/docs/admin-api.md index 8d11506..faa25c3 100644 --- a/cadworld-adminapi/docs/admin-api.md +++ b/cadworld-adminapi/docs/admin-api.md @@ -69,7 +69,7 @@ JSON 请求使用 `Content-Type: application/json`。文件接口分别使用 mu } ``` -组件、用户和操作日志列表使用 `items / page / size / total`;`page` 从 1 开始,默认 1;`size` 默认 20,超过 100 按 100 处理。前端传正整数,用户和日志接口会对非正数返回 `422`。接口库列表不分页,`data` 直接为数组。 +组件、用户和操作日志列表使用 `items / page / size / total`;`page` 从 1 开始,默认 1;`size` 默认 20,超过 100 按 100 处理。前端传正整数,组件、用户和日志接口会对非正数返回 `422`。接口库列表不分页,`data` 直接为数组。 时间使用 ISO 本地时间,例如 `2026-10-09T17:00:00.123`,不带 `Z` 或时区偏移。日志时间及服务端维护的创建/更新时间按上海时区处理。 @@ -120,14 +120,15 @@ STEP 点坐标转换到接口几何前,乘以返回的 `scaleToMeters`,当 | 字段 | 类型 | 必填 | 说明 | | --- | --- | --- | --- | -| id | string | 创建时是 | 唯一且非空;建议不超过 64 字符;修改以路径 ID 为准 | -| name | string | 是 | 非空,建议不超过 128 字符 | -| description | string | 否 | 默认空串,建议不超过 500 字符 | +| id | string | 创建时是 | 唯一且非空;最多 64 字符;修改时若提供 ID,必须与路径一致 | +| name | string | 是 | 非空,最多 128 字符 | +| description | string | 否 | 默认空串,最多 500 字符 | | geometry | object | 是 | 安装平面与完整孔组,见下表 | | tolerances | object | 是 | 三个容差必须提供正值 | | displayForward | number[3] | 否 | 安装面内的默认前方;不传则服务端生成,不能平行于面法向 | | connectableTargets | string[] | 否 | 可连接目标路径,一维字符串数组;例如 `["机械臂/末端工具", "移动底盘/附件"]` | -| geometryRevision | integer | 修改时是 | 详情返回的当前修订号;创建自动为 1 | +| geometryRevision | integer | 修改时是 | 当前几何修订号;创建自动为 1,几何、容差或源文件变化时递增 | +| editRevision | integer | 修改时是 | 当前编辑版本;创建为 1,每次修改或源文件绑定变化时递增;从详情/保存响应取值 | | sourceAssetKey | string | 否 | 源文件上传后返回的存储 Key;前端不能通过保存定义直接绑定文件 | | sourceGeometryHash | string | 否 | 已绑定源文件的 SHA-256,通常带 `sha256:`;源文件变更时可随保存传入新哈希以清除旧绑定,最终绑定由上传源文件接口完成 | @@ -237,7 +238,8 @@ X-Request-Id: req-demo-001 "connectableTargets": [ "机械臂/末端工具", "移动底盘/附件" - ] + ], + "editRevision": 1 } ], "requestId": "req-demo-001" @@ -330,7 +332,8 @@ X-Request-Id: req-demo-001 "connectableTargets": [ "机械臂/末端工具", "移动底盘/附件" - ] + ], + "editRevision": 1 }, "requestId": "req-demo-001" } @@ -487,7 +490,8 @@ Content-Type: application/json "connectableTargets": [ "机械臂/末端工具", "移动底盘/附件" - ] + ], + "editRevision": 1 }, "requestId": "req-demo-001" } @@ -499,7 +503,7 @@ Content-Type: application/json `PUT /admin-api/interfaces/{id}` -请求字段见 2.1,必须携带当前 `geometryRevision`,并提交完整定义。省略描述、目标或展示方向可能将其恢复为空值/默认值。 +请求字段见 2.1,必须携带当前 `geometryRevision` 和 `editRevision`,并提交完整定义。省略描述、目标或展示方向可能将其恢复为空值/默认值。 **请求示例** @@ -573,7 +577,8 @@ Content-Type: application/json "机械臂/末端工具", "移动底盘/附件" ], - "geometryRevision": 1 + "geometryRevision": 1, + "editRevision": 1 } ``` @@ -587,7 +592,7 @@ Content-Type: application/json "id": "mount-2-hole", "name": "双孔安装接口", "description": "更新后的接口说明", - "geometryRevision": 2, + "geometryRevision": 1, "geometry": { "plane": { "pointM": [ @@ -646,16 +651,17 @@ Content-Type: application/json "机械臂/末端工具", "移动底盘/附件" ], - "sourceAssetKey": "interfaces/6d6f756e742d322d686f6c65/1/073b7cf3dbe11a465f34da53b9b5e765a489e970cbb0f6c3c2d8cd01553aedc7/plate.step", - "sourceGeometryHash": "sha256:073b7cf3dbe11a465f34da53b9b5e765a489e970cbb0f6c3c2d8cd01553aedc7" + "sourceAssetKey": "", + "sourceGeometryHash": "", + "editRevision": 2 }, "requestId": "req-demo-001" } ``` -示例从修订 1 更新为 2。修改名称、描述、孔组、容差或可连接目标等会产生新修订;仅展示方向变化且其他内容不变时通常保留修订号。始终以响应为准。 +名称、描述、可连接目标或展示方向修改只增加 `editRevision`,不增加 `geometryRevision`。几何、容差或源文件变化才产生新几何修订。下面示例只修改描述,几何修订仍为 1、编辑版本变为 2;始终以响应为准。 -旧修订仍保留历史快照。修订号不匹配返回 `422 / INVALID_INTERFACE`;前端应重新查询详情,再提示用户重新确认修改。引用旧修订的组件端口,在下一次保存组件时需要重新计算并确认。 +旧修订仍保留历史快照。编辑版本或几何修订号不匹配返回 `409 / INTERFACE_REVISION_CONFLICT`;前端应重新查询详情并保留本地编辑内容,再由用户确认合并。引用旧修订的组件端口,在下一次保存组件时需要重新计算并确认。 ### 2.6 删除接口 @@ -702,7 +708,7 @@ X-Request-Id: req-demo-001 先保存接口定义,再上传源文件。后端校验修订号,计算文件 SHA-256,并更新当前修订的源文件绑定。该接口本身不执行 STEP 解析或校验文件拓扑;需要精确解析时先调用第 5 节接口。 -单个文件和整个 multipart 请求默认均限制 100 MB;边界开销也占请求大小。当前修订已有不同内容的源文件时,绑定会被拒绝,应按源文件变更流程先保存新修订。 +单个文件和整个 multipart 请求默认均限制 100 MB;边界开销也占请求大小。源文件还受存储上传大小限制,绑定失败会补偿清理本次上传对象。上传成功后重新查询接口详情,取得最新 `editRevision`。当前修订已有不同内容的源文件时,绑定会被拒绝,应按源文件变更流程先保存新修订。 **请求示例** @@ -720,12 +726,12 @@ curl -X POST 'http://127.0.0.1:8992/admin-api/interfaces/mount-2-hole/assets?geo { "code": "OK", "message": "success", - "data": "interfaces/6d6f756e742d322d686f6c65/1/073b7cf3dbe11a465f34da53b9b5e765a489e970cbb0f6c3c2d8cd01553aedc7/plate.step", + "data": "interfaces/6d6f756e742d322d686f6c65/1/073b7cf3dbe11a465f34da53b9b5e765a489e970cbb0f6c3c2d8cd01553aedc7/22222222-2222-4222-8222-222222222222/plate.step", "requestId": "req-demo-001" } ``` -成功 `data` 是对象 Key 字符串,不是 URL。再调用接口详情可获得 `sourceAssetKey` 和 `sourceGeometryHash`。源文件可通过 `/admin-api/component-assets/{objectKey}` 下载,对象路径各段需要 URL 编码。 +成功 `data` 是对象 Key 字符串,不是 URL;Key 含本次上传的随机路径段,应保存服务端返回值,不要自行推导。再调用接口详情可获得 `sourceAssetKey` 和 `sourceGeometryHash`。源文件可通过 `/admin-api/component-assets/{objectKey}` 下载,对象路径各段需要 URL 编码。 **上传后的详情示例:HTTP 200** @@ -796,8 +802,9 @@ curl -X POST 'http://127.0.0.1:8992/admin-api/interfaces/mount-2-hole/assets?geo "机械臂/末端工具", "移动底盘/附件" ], - "sourceAssetKey": "interfaces/6d6f756e742d322d686f6c65/1/073b7cf3dbe11a465f34da53b9b5e765a489e970cbb0f6c3c2d8cd01553aedc7/plate.step", - "sourceGeometryHash": "sha256:073b7cf3dbe11a465f34da53b9b5e765a489e970cbb0f6c3c2d8cd01553aedc7" + "sourceAssetKey": "interfaces/6d6f756e742d322d686f6c65/1/073b7cf3dbe11a465f34da53b9b5e765a489e970cbb0f6c3c2d8cd01553aedc7/22222222-2222-4222-8222-222222222222/plate.step", + "sourceGeometryHash": "sha256:073b7cf3dbe11a465f34da53b9b5e765a489e970cbb0f6c3c2d8cd01553aedc7", + "editRevision": 2 }, "requestId": "req-demo-001" } @@ -1010,7 +1017,7 @@ Content-Type: application/json | selectedPose | object | 是 | 至少提供当前候选 `id`;建议同时复制候选的姿态、孔映射和方向字段 | | sourceGeometryHash | string | 是 | 与计算候选时一致的 URDF 源几何哈希 | | solverVersion | string | 是 | 复制候选集返回值,当前为 `mount-geometry-3` | -| connectableTargets | array | 否 | 不传或为空时使用模板目标;多目标建议采用二维路径数组,见下文 | +| connectableTargets | array | 否 | 不传或为空时使用模板目标;一维数组表示多个独立目标;兼容二维 Cascader 路径数组 | **请求示例** @@ -1211,7 +1218,7 @@ Content-Type: application/json 服务端依据候选 `id` 重新计算,返回规范化端口;提交的旋转和孔映射不会作为最终可信结果。该接口只计算和确认,不自动保存组件。 -**可连接目标的输入兼容规则**:接口定义 CRUD 使用一维路径字符串数组;`confirm-port` 和 `componentJson.interfaces` 会把一维字符串数组视为“一条级联路径”,例如 `["机械臂", "末端工具"]` 被合并为 `"机械臂/末端工具"`。多个目标请提交二维数组,例如 `[["机械臂", "末端工具"], ["移动底盘", "附件"]]`。返回统一为一维路径字符串数组。将确认结果用于保存组件时,多目标应先转换为二维数组,避免被合并为一条路径。 +**可连接目标的输入兼容规则**:接口定义、姿态确认和组件端口统一使用一维路径字符串数组,例如 `["机械臂/末端工具", "移动底盘/附件"]` 表示两个独立目标;兼容二维 Cascader 路径数组 `[["机械臂", "末端工具"], ["移动底盘", "附件"]]`。返回始终为一维字符串数组,可以直接用于后续确认和组件保存,无需再次转换。 @@ -1261,7 +1268,7 @@ Content-Type: application/json `componentJson.interfaces` 非空时,必须同时提供原始 `urdfSource` 快照、资源清单以及已经确认的端口。后端会核对源文件资源、link、源哈希、模板当前修订和选中候选;不能只填端口名称和坐标。详见 8.3。 -每次成功新增/修改会由后端写入或递增 `componentJson.componentRevision`。存在 `interfaces` 数组时会返回 `interfaceSchemaVersion: 3`;前端不自行生成这些版本值。 +每次成功新增/修改会由后端写入或递增 `componentJson.componentRevision`。修改时必须携带详情返回的当前值;缺少版本返回 `422 / INVALID_COMPONENT_REVISION`,版本冲突返回 `409 / COMPONENT_REVISION_CONFLICT`,旧数据不会覆盖新记录。历史组件未包含该字段时按 0 处理,修改时传 0。存在 `interfaces` 数组时会返回 `interfaceSchemaVersion: 3`;前端不自行生成这些版本值。 ### 3.2 查询组件列表 @@ -1776,7 +1783,7 @@ Content-Type: application/json `PUT /admin-api/components/{id}` -请求字段同新增。使用完整必填字段;省略分类、封面和描述会将这些可选文本重置为空。 +请求字段同新增,另须在 `componentJson` 中携带详情返回的 `componentRevision`。使用完整必填字段;省略分类、封面和描述会将这些可选文本重置为空。 **请求示例** @@ -1894,7 +1901,8 @@ Content-Type: application/json ] ] } - ] + ], + "componentRevision": 1 }, "assemblyMetadata": { "tags": [ @@ -2160,7 +2168,10 @@ Content-Type: application/json "message": "success", "data": { "uploadUrl": "http://127.0.0.1:8992/admin-api/component-assets/upload?objectKey=components/cover-images/0/20261009/22222222-2222-4222-8222-222222222222/cover.png", - "objectKey": "components/cover-images/0/20261009/22222222-2222-4222-8222-222222222222/cover.png" + "objectKey": "components/cover-images/0/20261009/22222222-2222-4222-8222-222222222222/cover.png", + "uploadHeaders": { + "X-Upload-Session-Token": "" + } }, "requestId": "req-demo-001" } @@ -2280,7 +2291,10 @@ Content-Type: application/json "message": "success", "data": { "uploadUrl": "http://127.0.0.1:8992/admin-api/component-assets/upload?objectKey=components/urdf/0/20261009/11111111-1111-4111-8111-111111111111/robot.urdf", - "objectKey": "components/urdf/0/20261009/11111111-1111-4111-8111-111111111111/robot.urdf" + "objectKey": "components/urdf/0/20261009/11111111-1111-4111-8111-111111111111/robot.urdf", + "uploadHeaders": { + "X-Upload-Session-Token": "" + } }, "requestId": "req-demo-001" } @@ -2349,6 +2363,7 @@ Content-Type: application/json | 位置 | 字段 | 必填 | 说明 | | --- | --- | --- | --- | | Query | objectKey | 是 | 获取上传地址返回的完整对象 Key;应直接使用返回的 `uploadUrl` | +| Header | X-Upload-Session-Token | 是 | 获取上传地址返回的 `uploadHeaders` 中的会话凭证;使用同一会话的当前值 | | Header | Content-Type | 否 | 真实文件 MIME 类型;省略时按通用二进制类型处理 | | Body | 文件二进制 | 是 | 直接发送 File/Blob/ArrayBuffer;不用 FormData,不做 JSON 或 Base64 包装 | @@ -2358,6 +2373,7 @@ Content-Type: application/json curl -X PUT \ 'http://127.0.0.1:8992/admin-api/component-assets/upload?objectKey=components/urdf/0/20261009/11111111-1111-4111-8111-111111111111/robot.urdf' \ -H 'Content-Type: application/xml' \ + -H 'X-Upload-Session-Token: ' \ -H 'X-Request-Id: req-demo-001' \ --data-binary '@./robot.urdf' ``` @@ -2369,9 +2385,9 @@ HTTP/1.1 204 No Content X-Request-Id: req-demo-001 ``` -响应体为空,不执行 `response.json()`。失败时仍按第 9 节处理 JSON 错误响应。当前应用只允许写入配置操作人的组件资源目录;接口源文件通过第 2.7 节上传。 +响应体为空,不执行 `response.json()`。失败时仍按第 9 节处理 JSON 错误响应。后端在实际 PUT 时校验会话签名、签发者、有效期、操作人和精确会话目录;不能直接拼接对象路径绕过会话。接口源文件通过第 2.7 节上传。 -这里的 PUT 是原始文件流,Spring multipart 的 100 MB 限制不直接作用于此接口;实际大小还可能受到部署网关限制,前端应与部署环境保持一致。 +原始 PUT 和接口源文件上传均受 `APP_STORAGE_MAX_UPLOAD_BYTES` 限制,默认 104857600 字节(100 MiB)。缺少 Content-Length 的流式上传同样检查实际读取大小;超限返回 `413 / UPLOAD_TOO_LARGE`。部署网关还可设置更小的限制。 ### 4.2 下载或读取资源 @@ -3067,7 +3083,7 @@ async function uploadModel(files) { }); const response = await fetch(prepared.uploadUrl, { method: 'PUT', - headers: { 'Content-Type': contentType }, + headers: { ...prepared.uploadHeaders, 'Content-Type': contentType }, body: file }); if (response.status !== 204) { @@ -3089,7 +3105,7 @@ async function uploadModel(files) { ### 8.3 保存带机械端口的组件 -1. 取得接口模板详情,记录 `geometryRevision`。 +1. 取得接口模板详情,记录 `geometryRevision`;编辑模板时还需携带 `editRevision`。 2. 保存原始 URDF XML 快照,并为其引用的网格/纹理建立资源清单;资源先通过模型会话上传。 3. 用 link 局部坐标中的实际几何调用 `/pose-candidates`。 4. 用户选择候选后,携带候选 ID、对应修订和源哈希调用 `/confirm-port`。 @@ -3153,11 +3169,11 @@ sourceGeometryHash = SHA256(documentHash + "\n" + manifest) } ``` -**接口修订过期失败示例:HTTP 422** +**接口编辑版本过期失败示例:HTTP 409** ```json { - "code": "INVALID_INTERFACE", + "code": "INTERFACE_REVISION_CONFLICT", "message": "接口已修改,请刷新后保存", "requestId": "req-demo-001" } @@ -3176,7 +3192,14 @@ sourceGeometryHash = SHA256(documentHash + "\n" + manifest) | HTTP | code | 前端处理建议 | | --- | --- | --- | | 422 | INVALID_REQUEST | 必填、字段长度、枚举、JSON 格式、参数类型或几何结构不合法,提示修改输入 | -| 422 | INVALID_INTERFACE | 接口不存在、ID 已占用/归档、修订过期或源文件绑定不合法;注意接口库“对象不存在”当前也可能返回此码 | +| 422 | INVALID_INTERFACE / INVALID_INTERFACE_ASSET | 接口业务校验或源文件绑定不合法 | +| 404 | INTERFACE_NOT_FOUND | 当前接口定义不存在 | +| 409 | INTERFACE_ID_DUPLICATE | 接口 ID 已占用或归档 | +| 409 | INTERFACE_REVISION_CONFLICT / COMPONENT_REVISION_CONFLICT | 编辑数据已过期;重新查询详情并确认修改 | +| 422 | INVALID_COMPONENT_REVISION | 修改组件缺少合法的客户端版本 | +| 405 | INVALID_REQUEST | HTTP 方法不支持,检查 Allow 响应头 | +| 415 | INVALID_REQUEST | Content-Type 不支持 | +| 413 | UPLOAD_TOO_LARGE | 文件超出存储上传大小限制 | | 409 | USER_PHONE_DUPLICATE | 手机号冲突,已删除用户也会占用手机号 | | 404 | USER_NOT_FOUND | 用户不存在或已删除 | | 409 | COMPONENT_NAME_DUPLICATE | 组件名称重复 | @@ -3193,7 +3216,7 @@ sourceGeometryHash = SHA256(documentHash + "\n" + manifest) | 503 | INTERFACE_BREP_UNAVAILABLE | 解析服务、脚本或 Python/OCP 依赖不可用,联系后端 | | 504 | INTERFACE_BREP_TIMEOUT | STEP 解析超时,拆分文件后重试 | | 500 | MINIO_CONFIG_ERROR / STORAGE_CONFIG_ERROR | 存储配置缺失或非法,联系后端 | -| 502 | MINIO_BUCKET_FAILED / MINIO_UPLOAD_FAILED / MINIO_OBJECT_CHECK_FAILED / MINIO_DOWNLOAD_FAILED | 存储连接、权限或读写失败,联系后端 | +| 502 | MINIO_BUCKET_FAILED / MINIO_UPLOAD_FAILED / MINIO_OBJECT_CHECK_FAILED / MINIO_DOWNLOAD_FAILED / MINIO_DELETE_FAILED | 存储连接、权限或读写失败,联系后端 | | 404 | MINIO_OBJECT_NOT_FOUND | 资源对象不存在 | | 422 | INVALID_STORAGE_OBJECT_KEY | 存储对象 Key 不合法 | | 503 | DATABASE_UNAVAILABLE | 数据库连接不可用,联系后端 | diff --git a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/audit/EarlyFailureAuditFilter.java b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/audit/EarlyFailureAuditFilter.java index 16150ca..a31404e 100644 --- a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/audit/EarlyFailureAuditFilter.java +++ b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/audit/EarlyFailureAuditFilter.java @@ -12,6 +12,10 @@ import org.springframework.core.annotation.Order; import org.springframework.stereotype.Component; import org.springframework.web.filter.OncePerRequestFilter; import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping; +import org.springframework.web.method.HandlerMethod; +import org.springframework.web.servlet.HandlerMapping; +import org.springframework.web.util.ServletRequestPathUtils; +import org.springframework.web.util.pattern.PathPattern; /** Multipart size failures can occur before an MVC interceptor is invoked. */ @Slf4j @@ -35,16 +39,15 @@ public class EarlyFailureAuditFilter extends OncePerRequestFilter { chain.doFilter(request, response); } finally { if (response.getStatus() >= 400 && request.getAttribute(OperationAuditInterceptor.CONTEXT) == null - && request.getRequestURI().startsWith("/admin-api/")) { + && request.getRequestURI().startsWith(request.getContextPath() + "/admin-api/")) { try { // DispatcherServlet clears its parsed path before returning to filters. - org.springframework.web.util.ServletRequestPathUtils.parseAndCache(request); - var handler = mappings.getHandler(request); + var handler = resolveWriteHandler(request); if (handler != null) { - audit.preHandle(request, response, handler.getHandler()); + audit.preHandle(request, response, handler); if (request.getAttribute(OperationAuditInterceptor.CONTEXT) instanceof OperationAuditInterceptor.Context context) { request.setAttribute(OperationAuditInterceptor.CONTEXT, new OperationAuditInterceptor.Context(context.event(), started)); - audit.afterCompletion(request, response, handler.getHandler(), null); + audit.afterCompletion(request, response, handler, null); } } } catch (Exception failure) { @@ -53,4 +56,26 @@ public class EarlyFailureAuditFilter extends OncePerRequestFilter { } } } + + private HandlerMethod resolveWriteHandler(HttpServletRequest request) { + ServletRequestPathUtils.parseAndCache(request); + HandlerMethod best = null; + PathPattern bestPattern = null; + for (var entry : mappings.getHandlerMethods().entrySet()) { + if (!entry.getValue().hasMethodAnnotation(AuditOperation.class) + || entry.getKey().getMethodsCondition().getMatchingCondition(request) == null) continue; + var paths = entry.getKey().getPathPatternsCondition().getMatchingCondition(request); + if (paths == null) continue; + PathPattern pattern = paths.getFirstPattern(); + if (bestPattern == null || pattern.compareTo(bestPattern) < 0) { + best = entry.getValue(); + bestPattern = pattern; + } + } + if (bestPattern != null) { + var match = bestPattern.matchAndExtract(ServletRequestPathUtils.getParsedRequestPath(request).pathWithinApplication()); + if (match != null) request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, match.getUriVariables()); + } + return best; + } } diff --git a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentAssetController.java b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentAssetController.java index dddc980..eda7212 100644 --- a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentAssetController.java +++ b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentAssetController.java @@ -41,11 +41,13 @@ public class ComponentAssetController { @ResponseStatus(HttpStatus.NO_CONTENT) public void upload( @RequestParam String objectKey, + @RequestHeader(ComponentUploadSupport.UPLOAD_TOKEN_HEADER) String uploadSessionToken, @RequestHeader(value = HttpHeaders.CONTENT_TYPE, required = false) String contentType, HttpServletRequest request ) throws IOException { componentUploadSupport.uploadObject( operatorProvider.userId(), + uploadSessionToken, objectKey, contentType, request.getInputStream(), diff --git a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentController.java b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentController.java index 8b2d33e..0768424 100644 --- a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentController.java +++ b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentController.java @@ -23,7 +23,9 @@ import com.linkerbot.cadworld.service.ComponentCoverImageUploadService; import com.linkerbot.cadworld.service.ComponentService; import com.linkerbot.cadworld.service.ComponentUrdfUploadService; import jakarta.validation.Valid; +import jakarta.validation.constraints.Min; import lombok.RequiredArgsConstructor; +import org.springframework.validation.annotation.Validated; import org.springframework.web.bind.annotation.DeleteMapping; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; @@ -37,6 +39,7 @@ import org.springframework.web.bind.annotation.RestController; @RestController @RequestMapping("/admin-api/components") @RequiredArgsConstructor +@Validated public class ComponentController { private final com.linkerbot.cadworld.service.AdminOperatorProvider operatorProvider; @@ -109,8 +112,8 @@ public class ComponentController { @ApiRequestLog("查询组件列表") @GetMapping public ApiResponse> list( - @RequestParam(defaultValue = "1") long page, - @RequestParam(defaultValue = "20") long size, + @RequestParam(defaultValue = "1") @Min(1) long page, + @RequestParam(defaultValue = "20") @Min(1) long size, @RequestParam(required = false) String keyword ) { return ApiResponse.success(componentService.listComponents(page, Math.min(size, 100), keyword)); diff --git a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/InterfaceDefinitionController.java b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/InterfaceDefinitionController.java index fa18ee0..0de7afd 100644 --- a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/InterfaceDefinitionController.java +++ b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/InterfaceDefinitionController.java @@ -1,66 +1,70 @@ package com.linkerbot.cadworld.controller; -import com.linkerbot.cadworld.logging.ApiRequestLog; - -import com.linkerbot.cadworld.audit.AuditOperation; - import com.fasterxml.jackson.databind.JsonNode; +import com.linkerbot.cadworld.audit.AuditOperation; import com.linkerbot.cadworld.common.api.ApiResponse; -import com.linkerbot.cadworld.common.api.PageResponse; import com.linkerbot.cadworld.dto.common.SuccessResponse; +import com.linkerbot.cadworld.dto.interfaces.SaveInterfaceDefinitionRequest; +import com.linkerbot.cadworld.logging.ApiRequestLog; +import com.linkerbot.cadworld.service.InterfaceAssetService; import com.linkerbot.cadworld.service.InterfaceDefinitionService; -import com.linkerbot.cadworld.service.client.ObjectStorageClient; -import java.io.IOException; -import java.security.MessageDigest; -import java.security.NoSuchAlgorithmException; +import jakarta.validation.Valid; +import jakarta.validation.constraints.Min; import java.util.List; import lombok.RequiredArgsConstructor; -import org.springframework.web.multipart.MultipartFile; -import org.springframework.web.bind.annotation.RequestPart; +import org.springframework.http.MediaType; +import org.springframework.validation.annotation.Validated; import org.springframework.web.bind.annotation.*; +import org.springframework.web.multipart.MultipartFile; @RestController @RequestMapping("/admin-api/interfaces") @RequiredArgsConstructor +@Validated public class InterfaceDefinitionController { private final InterfaceDefinitionService service; - private final ObjectStorageClient objectStorageClient; + private final InterfaceAssetService assets; + @ApiRequestLog("查询接口列表") - @GetMapping public ApiResponse> list(@RequestParam(required = false) String keyword) { return ApiResponse.success(service.list(keyword)); } + @GetMapping + public ApiResponse> list(@RequestParam(required = false) String keyword) { + return ApiResponse.success(service.list(keyword)); + } + @ApiRequestLog("查询接口详情") - @GetMapping("/{id}") public ApiResponse get(@PathVariable String id) { return ApiResponse.success(service.get(id)); } + @GetMapping("/{id}") + public ApiResponse get(@PathVariable String id) { + return ApiResponse.success(service.get(id)); + } + @AuditOperation(module = "INTERFACE", action = "CREATE") @ApiRequestLog("新增接口定义") - @PostMapping public ApiResponse create(@RequestBody JsonNode request) { return ApiResponse.success(service.create(request)); } + @PostMapping + public ApiResponse create(@Valid @RequestBody SaveInterfaceDefinitionRequest request) { + return ApiResponse.success(service.create(request)); + } + @AuditOperation(module = "INTERFACE", action = "UPDATE") @ApiRequestLog("修改接口定义") - @PutMapping("/{id}") public ApiResponse update(@PathVariable String id, @RequestBody JsonNode request) { return ApiResponse.success(service.update(id, request)); } + @PutMapping("/{id}") + public ApiResponse update(@PathVariable String id, @Valid @RequestBody SaveInterfaceDefinitionRequest request) { + return ApiResponse.success(service.update(id, request)); + } + @AuditOperation(module = "INTERFACE", action = "DELETE") @ApiRequestLog("删除接口定义") - @DeleteMapping("/{id}") public ApiResponse delete(@PathVariable String id) { service.delete(id); return ApiResponse.success(SuccessResponse.ok()); } + @DeleteMapping("/{id}") + public ApiResponse delete(@PathVariable String id) { + service.delete(id); + return ApiResponse.success(SuccessResponse.ok()); + } @AuditOperation(module = "INTERFACE", action = "UPLOAD") @ApiRequestLog("上传接口源文件") - @PostMapping("/{id}/assets") + @PostMapping(value = "/{id}/assets", consumes = MediaType.MULTIPART_FORM_DATA_VALUE) public ApiResponse uploadAsset(@PathVariable String id, - @RequestParam int geometryRevision, - @RequestPart("file") MultipartFile file) throws IOException { - if (file == null || file.isEmpty()) throw new IllegalArgumentException("接口源文件不能为空"); - String name = file.getOriginalFilename() == null ? "source.step" : file.getOriginalFilename().replace('\\', '/'); - name = name.substring(name.lastIndexOf('/') + 1).replaceAll("[^A-Za-z0-9._-]", "_"); - if(service.get(id).path("geometryRevision").asInt()!=geometryRevision)throw new IllegalArgumentException("接口已修订,请刷新"); - String key; - { - try { - byte[] bytes = file.getBytes(); - String hash = java.util.HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(bytes)); - key = "interfaces/" + java.util.HexFormat.of().formatHex(id.getBytes(java.nio.charset.StandardCharsets.UTF_8)) + "/" + geometryRevision + "/" + hash + "/" + name; - objectStorageClient.putObject(key, file.getContentType(), new java.io.ByteArrayInputStream(bytes), bytes.length); - service.attachAsset(id, geometryRevision, key, "sha256:" + hash); - } catch (NoSuchAlgorithmException exception) { - throw new IllegalStateException("SHA-256 不可用", exception); - } - } - return ApiResponse.success(key); + @RequestParam @Min(1) int geometryRevision, + @RequestPart("file") MultipartFile file) { + return ApiResponse.success(assets.upload(id, geometryRevision, file)); } } diff --git a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/InterfacePoseController.java b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/InterfacePoseController.java index 84d0339..fa656a0 100644 --- a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/InterfacePoseController.java +++ b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/InterfacePoseController.java @@ -1,60 +1,57 @@ package com.linkerbot.cadworld.controller; -import com.linkerbot.cadworld.logging.ApiRequestLog; - -import static com.linkerbot.cadworld.mechanicalinterface.InterfaceGeometry.*; -import com.linkerbot.cadworld.common.api.ApiResponse; -import com.linkerbot.cadworld.mechanicalinterface.MechanicalInterfaceSolver; -import com.linkerbot.cadworld.service.InterfaceDefinitionService; +import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; -import com.fasterxml.jackson.databind.DeserializationFeature; -import com.fasterxml.jackson.databind.node.ArrayNode; -import com.fasterxml.jackson.databind.node.ObjectNode; +import com.linkerbot.cadworld.common.api.ApiResponse; +import com.linkerbot.cadworld.logging.ApiRequestLog; +import com.linkerbot.cadworld.mechanicalinterface.InterfaceGeometry.CandidateSet; +import com.linkerbot.cadworld.mechanicalinterface.InterfaceGeometry.Port; +import com.linkerbot.cadworld.mechanicalinterface.InterfaceGeometry.PoseRequest; +import com.linkerbot.cadworld.mechanicalinterface.MechanicalInterfaceSolver; +import com.linkerbot.cadworld.service.InterfaceDefinitionService; +import java.io.IOException; import lombok.RequiredArgsConstructor; import org.springframework.web.bind.annotation.*; -@RestController @RequiredArgsConstructor +@RestController +@RequiredArgsConstructor @RequestMapping("/admin-api/interfaces/{id}") public class InterfacePoseController { private final InterfaceDefinitionService definitions; private final MechanicalInterfaceSolver solver; private final ObjectMapper objectMapper; + @ApiRequestLog("计算接口姿态候选") @PostMapping("/pose-candidates") - public ApiResponse candidates(@PathVariable String id,@RequestBody JsonNode body){ - PoseRequest request=read(body,PoseRequest.class); - return ApiResponse.success(solver.enumeratePortPoses(definitions.geometryDefinition(id,request.definitionRevision()),request)); + public ApiResponse candidates(@PathVariable String id, @RequestBody JsonNode body) { + PoseRequest request = read(body, PoseRequest.class); + var definition = definitions.geometryDefinition(id, request.definitionRevision()); + return ApiResponse.success(solver.enumeratePortPoses(definition, request)); } + @ApiRequestLog("确认组件端口姿态") @PostMapping("/confirm-port") - public ApiResponse confirm(@PathVariable String id,@RequestBody JsonNode body){ - Port request=read(body,Port.class); - if(!id.equals(request.definitionId()))throw new IllegalArgumentException("URL 与端口定义不一致"); - return ApiResponse.success(solver.confirmPortPose(definitions.geometryDefinition(id,request.definitionRevision()),request)); - } - private T read(JsonNode body,Class type){ - try{return objectMapper.readerFor(type).with(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES).readValue(normalizePortBody(body));} - catch(java.io.IOException | IllegalArgumentException e){throw new IllegalArgumentException("不支持的接口数据结构:"+rootMessage(e),e);} - } - private JsonNode normalizePortBody(JsonNode body){ - if(body==null||!body.isObject())return body; - ObjectNode copy=body.deepCopy();JsonNode targets=copy.get("connectableTargets"); - if(targets!=null&&!targets.isNull()){ - ArrayNode normalized=objectMapper.createArrayNode();flattenTargets(targets,normalized);copy.set("connectableTargets",normalized); + public ApiResponse confirm(@PathVariable String id, @RequestBody JsonNode body) { + Port request = read(body, Port.class); + if (!id.equals(request.definitionId())) { + throw new IllegalArgumentException("URL 与端口定义不一致"); } - return copy; + var definition = definitions.geometryDefinition(id, request.definitionRevision()); + return ApiResponse.success(solver.confirmPortPose(definition, request)); } - private void flattenTargets(JsonNode node,ArrayNode output){ - if(node==null||node.isNull())return; - if(node.isArray()){ - boolean path=true;StringBuilder joined=new StringBuilder(); - for(JsonNode child:node){if(!child.isTextual()){path=false;break;}if(joined.length()>0)joined.append('/');joined.append(child.asText());} - if(path){String value=joined.toString().trim();if(!value.isEmpty()&&!containsTarget(output,value))output.add(value);return;} - node.forEach(child->flattenTargets(child,output));return; + + private T read(JsonNode body, Class type) { + try { + return objectMapper.readerFor(type).with(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES).readValue(body); + } catch (IOException | IllegalArgumentException exception) { + throw new IllegalArgumentException("不支持的接口数据结构:" + rootMessage(exception), exception); } - String value=node.asText("").trim();if(!value.isEmpty()&&!containsTarget(output,value))output.add(value); } - private boolean containsTarget(ArrayNode output,String value){for(JsonNode item:output)if(value.equals(item.asText()))return true;return false;} - private String rootMessage(Throwable error){Throwable current=error;while(current.getCause()!=null)current=current.getCause();return current.getMessage()==null?"字段格式错误":current.getMessage();} + + private String rootMessage(Throwable error) { + Throwable current = error; + while (current.getCause() != null) current = current.getCause(); + return current.getMessage() == null ? "字段格式错误" : current.getMessage(); + } } diff --git a/cadworld-adminapi/src/main/resources/application.yml b/cadworld-adminapi/src/main/resources/application.yml index a3a7ed0..826cf3d 100644 --- a/cadworld-adminapi/src/main/resources/application.yml +++ b/cadworld-adminapi/src/main/resources/application.yml @@ -50,6 +50,7 @@ app: public-base-url: ${APP_STORAGE_PUBLIC_BASE_URL:http://127.0.0.1:${SERVER_PORT:8992}/admin-api/component-assets} local-root: ${APP_STORAGE_LOCAL_ROOT:./data/assets} upload-session-ttl: PT30M + max-upload-bytes: ${APP_STORAGE_MAX_UPLOAD_BYTES:104857600} minio: endpoint: ${APP_MINIO_ENDPOINT:} access-key: ${APP_MINIO_ACCESS_KEY:} diff --git a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminApiTest.java b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminApiTest.java index f5f2eb0..5bfb550 100644 --- a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminApiTest.java +++ b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminApiTest.java @@ -40,7 +40,8 @@ class AdminApiTest { @BeforeEach void clean() { - for (String table : new String[]{"component_asset", "component", "interface_definition_revision", "interface_definition_v2", "sys_user", "sys_operation_log"}) { + TestSchemaSupport.prepare(jdbc); + for (String table : new String[]{"component", "interface_definition_revision", "interface_definition_v2", "sys_user", "sys_operation_log"}) { jdbc.update("DELETE FROM " + table); } } @@ -143,7 +144,9 @@ class AdminApiTest { JsonNode result = send("/admin-api/components", component("sample")); long id = result.path("data").path("id").asLong(); assertThat(result.path("data").path("sourceUrl").asText()).contains("/admin-api/component-assets/"); - mvc.perform(put("/admin-api/components/{id}", id).contentType(MediaType.APPLICATION_JSON).content(json.writeValueAsString(component("renamed")))) + var update = json.valueToTree(component("renamed")); + ((com.fasterxml.jackson.databind.node.ObjectNode) update).set("componentJson", result.path("data").path("componentJson")); + mvc.perform(put("/admin-api/components/{id}", id).contentType(MediaType.APPLICATION_JSON).content(update.toString())) .andExpect(status().isOk()); mvc.perform(get("/admin-api/components")).andExpect(status().isOk()); mvc.perform(get("/admin-api/components/{id}", id)).andExpect(status().isOk()); @@ -173,16 +176,17 @@ class AdminApiTest { JsonNode created = send("/admin-api/interfaces", request).path("data"); ((com.fasterxml.jackson.databind.node.ObjectNode) created).put("name", "新版"); mvc.perform(put("/admin-api/interfaces/mount").contentType(MediaType.APPLICATION_JSON).content(created.toString())) - .andExpect(status().isOk()).andExpect(jsonPath("$.data.geometryRevision").value(2)); + .andExpect(status().isOk()).andExpect(jsonPath("$.data.geometryRevision").value(1)) + .andExpect(jsonPath("$.data.editRevision").value(2)); mvc.perform(put("/admin-api/interfaces/mount").contentType(MediaType.APPLICATION_JSON).content(created.toString())) - .andExpect(status().isUnprocessableEntity()); - assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM interface_definition_revision", Long.class)).isEqualTo(2); + .andExpect(status().isConflict()); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM interface_definition_revision", Long.class)).isEqualTo(1); mvc.perform(get("/admin-api/interfaces")).andExpect(status().isOk()); mvc.perform(delete("/admin-api/interfaces/mount")).andExpect(status().isOk()); assertThat(logCount()).isEqualTo(4); // Historical revisions survive deletion and still prohibit ID reuse. mvc.perform(post("/admin-api/interfaces").contentType(MediaType.APPLICATION_JSON).content(request.toString())) - .andExpect(status().isUnprocessableEntity()); + .andExpect(status().isConflict()); } @Test @@ -193,7 +197,9 @@ class AdminApiTest { Map.of("uploadSessionToken", token, "objectPath", "cover.png", "contentType", "image/png")).path("data"); assertThat(upload.path("uploadUrl").asText()).contains("/admin-api/component-assets/upload"); String key = upload.path("objectKey").asText(); - mvc.perform(put("/admin-api/component-assets/upload").param("objectKey", key).contentType("image/png").content(new byte[]{1, 2, 3})) + assertThat(upload.path("uploadHeaders").path("X-Upload-Session-Token").asText()).isEqualTo(token); + mvc.perform(put("/admin-api/component-assets/upload").param("objectKey", key) + .header("X-Upload-Session-Token", token).contentType("image/png").content(new byte[]{1, 2, 3})) .andExpect(status().isNoContent()); send("/admin-api/components/cover-image-upload-sessions/complete", Map.of("uploadSessionToken", token, "objectKeys", new String[]{key})); mvc.perform(get("/admin-api/component-assets/" + key)).andExpect(status().isOk()).andExpect(content().bytes(new byte[]{1, 2, 3})); @@ -201,6 +207,33 @@ class AdminApiTest { assertThat(jdbc.queryForList("SELECT * FROM sys_operation_log").toString()).doesNotContain(token); } + @Test + void sourceUploadBindsHashAndRetriesWithoutChangingGeometryOrLeakingNewKeys() throws Exception { + send("/admin-api/interfaces", interfaceRequest("source-upload")); + byte[] bytes = {1, 2, 3}; + var file = new org.springframework.mock.web.MockMultipartFile("file", "plate.step", "application/octet-stream", bytes); + var response = mvc.perform(multipart("/admin-api/interfaces/source-upload/assets") + .file(file).param("geometryRevision", "1")).andExpect(status().isOk()).andReturn(); + String key = json.readTree(response.getResponse().getContentAsString()).path("data").asText(); + mvc.perform(get("/admin-api/interfaces/source-upload")) + .andExpect(jsonPath("$.data.geometryRevision").value(1)) + .andExpect(jsonPath("$.data.editRevision").value(2)) + .andExpect(jsonPath("$.data.sourceAssetKey").value(key)) + .andExpect(jsonPath("$.data.sourceGeometryHash").value( + "sha256:039058c6f2c0cb492c533b0a4d14ef77cc0f78abccced5287d84a1a2011cfb81")); + mvc.perform(multipart("/admin-api/interfaces/source-upload/assets").file(file).param("geometryRevision", "1")) + .andExpect(status().isOk()).andExpect(jsonPath("$.data").value(key)); + mvc.perform(get("/admin-api/interfaces/source-upload")).andExpect(jsonPath("$.data.editRevision").value(2)); + mvc.perform(multipart("/admin-api/interfaces/source-upload/assets") + .file(new org.springframework.mock.web.MockMultipartFile("file", "plate.step", "application/octet-stream", new byte[]{9})) + .param("geometryRevision", "1")) + .andExpect(status().isUnprocessableEntity()); + mvc.perform(multipart("/admin-api/interfaces/source-upload/assets").file(file).param("geometryRevision", "2")) + .andExpect(status().isConflict()); + mvc.perform(get("/admin-api/component-assets/" + key)).andExpect(status().isOk()).andExpect(content().bytes(bytes)); + assertThat(logCount()).isEqualTo(5); + } + @Test void requiresNewLogSurvivesOuterRollbackAndOldRoutesAreAbsent() throws Exception { transactions.executeWithoutResult(tx -> { @@ -229,6 +262,144 @@ class AdminApiTest { assertThat(logCount()).isZero(); } + @Test + void staleAndConcurrentComponentUpdatesCannotOverwriteEachOther() throws Exception { + JsonNode created = send("/admin-api/components", component("concurrent")).path("data"); + long id = created.path("id").asLong(); + var body = (com.fasterxml.jackson.databind.node.ObjectNode) json.valueToTree(component("editor")); + body.set("componentJson", created.get("componentJson")); + var gate = new java.util.concurrent.CountDownLatch(1); + try (var workers = java.util.concurrent.Executors.newFixedThreadPool(2)) { + java.util.concurrent.Callable update = () -> { + gate.await(); + return mvc.perform(put("/admin-api/components/{id}", id).contentType(MediaType.APPLICATION_JSON) + .content(body.toString())).andReturn().getResponse().getStatus(); + }; + var first = workers.submit(update); + var second = workers.submit(update); + gate.countDown(); + assertThat(java.util.List.of(first.get(10, java.util.concurrent.TimeUnit.SECONDS), second.get(10, java.util.concurrent.TimeUnit.SECONDS))) + .containsExactlyInAnyOrder(200, 409); + } + mvc.perform(get("/admin-api/components/{id}", id)).andExpect(jsonPath("$.data.componentJson.componentRevision").value(2)); + assertThat(logCount()).isEqualTo(3); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_operation_log WHERE success=FALSE", Long.class)).isEqualTo(1); + } + + @Test + void concurrentComponentCreationHasDatabaseNameUniqueness() throws Exception { + var gate = new java.util.concurrent.CountDownLatch(1); + String body = json.writeValueAsString(component("same-name")); + try (var workers = java.util.concurrent.Executors.newFixedThreadPool(2)) { + java.util.concurrent.Callable create = () -> { + gate.await(); + return mvc.perform(post("/admin-api/components").contentType(MediaType.APPLICATION_JSON) + .content(body)).andReturn().getResponse().getStatus(); + }; + var first = workers.submit(create); + var second = workers.submit(create); + gate.countDown(); + assertThat(java.util.List.of(first.get(10, java.util.concurrent.TimeUnit.SECONDS), second.get(10, java.util.concurrent.TimeUnit.SECONDS))) + .containsExactlyInAnyOrder(200, 409); + } + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM component", Long.class)).isEqualTo(1); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM information_schema.tables WHERE LOWER(table_name)='component_asset'", Long.class)).isZero(); + } + + @Test + void componentUpdatesRequireClientRevisionAndPaginationRejectsNonPositiveValues() throws Exception { + long id = send("/admin-api/components", component("revision-required")).path("data").path("id").asLong(); + mvc.perform(put("/admin-api/components/{id}", id).contentType(MediaType.APPLICATION_JSON) + .content(json.writeValueAsString(component("new")))).andExpect(status().isUnprocessableEntity()); + for (String value : new String[]{"0", "-1"}) { + mvc.perform(get("/admin-api/components").param("page", value)).andExpect(status().isUnprocessableEntity()); + mvc.perform(get("/admin-api/components").param("size", value)).andExpect(status().isUnprocessableEntity()); + } + } + + @Test + void interfaceFieldLengthsFailBeforeDatabaseAndHttpErrorsHaveCorrectStatus() throws Exception { + var body = interfaceRequest("invalid-length"); + body.put("name", "x".repeat(129)); + mvc.perform(post("/admin-api/interfaces").contentType(MediaType.APPLICATION_JSON).content(body.toString())) + .andExpect(status().isUnprocessableEntity()).andExpect(jsonPath("$.message", org.hamcrest.Matchers.containsString("name"))); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM interface_definition_v2", Long.class)).isZero(); + body.put("name", "valid").put("unsupportedField", "must not be silently ignored"); + mvc.perform(post("/admin-api/interfaces").contentType(MediaType.APPLICATION_JSON).content(body.toString())) + .andExpect(status().isUnprocessableEntity()); + body.remove("unsupportedField"); + body.putArray("connectableTargets").add(123); + mvc.perform(post("/admin-api/interfaces").contentType(MediaType.APPLICATION_JSON).content(body.toString())) + .andExpect(status().isUnprocessableEntity()); + mvc.perform(patch("/admin-api/interfaces").contentType(MediaType.APPLICATION_JSON).content("{}")) + .andExpect(status().isMethodNotAllowed()).andExpect(header().exists("Allow")); + mvc.perform(post("/admin-api/interfaces").contentType(MediaType.TEXT_PLAIN).content("{}")) + .andExpect(status().isUnsupportedMediaType()); + } + + @Test + void flatTargetArraysSurvivePoseConfirmationAndRoundTrip() throws Exception { + var request = interfaceRequest("roundtrip"); + request.putArray("connectableTargets").add("A").add("B"); + JsonNode definition = send("/admin-api/interfaces", request).path("data"); + var pose = json.createObjectNode().put("definitionRevision", 1).put("linkName", "base").put("sourceGeometryHash", "hash"); + pose.set("geometryInLink", definition.get("geometry")); + JsonNode candidates = send("/admin-api/interfaces/roundtrip/pose-candidates", pose).path("data"); + var port = json.createObjectNode().put("id", "port").put("linkName", "base") + .put("definitionId", "roundtrip").put("definitionRevision", 1).put("sourceGeometryHash", "hash") + .put("solverVersion", candidates.path("solverVersion").asText()); + port.set("geometryInLink", definition.get("geometry")); + port.putObject("selectedPose").put("id", candidates.path("candidates").get(0).path("id").asText()); + port.set("connectableTargets", definition.get("connectableTargets")); + JsonNode confirmed = send("/admin-api/interfaces/roundtrip/confirm-port", port).path("data"); + assertThat(confirmed.path("connectableTargets").toString()).isEqualTo("[\"A\",\"B\"]"); + assertThat(send("/admin-api/interfaces/roundtrip/confirm-port", confirmed).path("data").path("connectableTargets")) + .isEqualTo(confirmed.get("connectableTargets")); + } + + @Test + void actualUploadRejectsMissingForgedExpiredAndCrossSessionTokens() throws Exception { + JsonNode session = send("/admin-api/components/cover-image-upload-sessions", null).path("data"); + String key = session.path("keyPrefix").asText() + "cover.png"; + mvc.perform(put("/admin-api/component-assets/upload").param("objectKey", key).content(new byte[]{1})) + .andExpect(status().isUnprocessableEntity()); + mvc.perform(put("/admin-api/component-assets/upload").param("objectKey", key) + .header("X-Upload-Session-Token", "forged-token").content(new byte[]{1})) + .andExpect(status().isUnprocessableEntity()); + String expired = uploadTokens + .generateToken(0L, com.linkerbot.cadworld.enums.ComponentUploadType.COVER_IMAGE, + session.path("keyPrefix").asText(), java.time.Instant.now().minusSeconds(30)); + mvc.perform(put("/admin-api/component-assets/upload").param("objectKey", key) + .header("X-Upload-Session-Token", expired).content(new byte[]{1})) + .andExpect(status().isUnprocessableEntity()); + mvc.perform(put("/admin-api/component-assets/upload").param("objectKey", "components/cover-images/0/other/cover.png") + .header("X-Upload-Session-Token", session.path("uploadSessionToken").asText()).content(new byte[]{1})) + .andExpect(status().isUnprocessableEntity()); + assertThat(logCount()).isEqualTo(5); + assertThat(jdbc.queryForList("SELECT * FROM sys_operation_log").toString()).doesNotContain(expired, "forged-token", session.path("uploadSessionToken").asText()); + } + + @Autowired com.linkerbot.cadworld.service.support.ComponentUploadSessionTokenProvider uploadTokens; + + private com.fasterxml.jackson.databind.node.ObjectNode interfaceRequest(String id) throws Exception { + return (com.fasterxml.jackson.databind.node.ObjectNode) json.readTree(""" + {"id":"%s","name":"安装接口","geometry":{"plane":{"pointM":[0,0,0],"outwardNormal":[0,0,1]}, + "holes":[{"id":"a","pointOnPlaneM":[-0.02,0,0],"axis":[0,0,1],"diameterM":0.004}, + {"id":"b","pointOnPlaneM":[0.02,0,0],"axis":[0,0,1],"diameterM":0.004}]}, + "tolerances":{"positionM":0.0002,"axisAngleRad":0.0174533,"planeAngleRad":0.0174533}} + """.formatted(id)); + } + + @Test + void sourceUploadUnsupportedMediaTypeStillHasExactlyOneFailedAudit() throws Exception { + mvc.perform(post("/admin-api/interfaces/missing/assets").param("geometryRevision", "1") + .contentType(MediaType.APPLICATION_JSON).content("{}")) + .andExpect(status().isUnsupportedMediaType()); + assertThat(logCount()).isEqualTo(1); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_operation_log WHERE module='INTERFACE' AND action='UPLOAD' AND success=FALSE AND target_id='missing' AND http_status=415", Long.class)) + .isEqualTo(1); + } + private JsonNode send(String path, Object body) throws Exception { var request = post(path); if (body != null) request.contentType(MediaType.APPLICATION_JSON).content(json.writeValueAsString(body)); diff --git a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/ExternalServicesIT.java b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/ExternalServicesIT.java index 240ac1f..28c7e76 100644 --- a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/ExternalServicesIT.java +++ b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/ExternalServicesIT.java @@ -1,10 +1,16 @@ package com.linkerbot.cadworld; import java.nio.file.Path; +import java.nio.file.Files; +import java.nio.charset.StandardCharsets; import java.sql.DriverManager; +import java.util.regex.Pattern; import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.core.io.FileSystemResource; +import org.springframework.core.io.ByteArrayResource; import org.springframework.jdbc.datasource.init.ScriptUtils; import static org.assertj.core.api.Assertions.*; @@ -20,6 +26,27 @@ import static org.assertj.core.api.Assertions.*; "app.minio.bucket=cadworld-verification", "logging.file.path=target/integration-logs" }) class ExternalServicesIT extends AdminApiTest { + @Autowired com.linkerbot.cadworld.service.client.ObjectStorageClient storage; + + @Test + void minioStreamLimitPreservesExistingObjectAndMapsTo413() throws Exception { + String key = "limit-verification/" + java.util.UUID.randomUUID() + "/model.rfs"; + try { + storage.putObject(key, "application/octet-stream", new java.io.ByteArrayInputStream(new byte[]{1, 2}), 2); + var bounded = com.linkerbot.cadworld.service.support.UploadLimits.bounded( + new java.io.ByteArrayInputStream(new byte[9]), 8); + assertThatThrownBy(() -> storage.putObject(key, "application/octet-stream", bounded, -1)) + .isInstanceOf(com.linkerbot.cadworld.common.exception.BizException.class) + .extracting("httpStatus").isEqualTo(413); + var downloaded = new java.io.ByteArrayOutputStream(); + storage.writeObjectTo(key, downloaded); + assertThat(downloaded.toByteArray()).containsExactly((byte) 1, (byte) 2); + } finally { + storage.deleteObject(key); + } + assertThat(storage.objectExists(key)).isFalse(); + } + @BeforeAll static void prepareAndVerifySql() throws Exception { String url = System.getProperty("cadworld.it.db-url", "jdbc:mysql://127.0.0.1:13306/cadworld_verification?serverTimezone=Asia/Shanghai"); @@ -46,6 +73,22 @@ class ExternalServicesIT extends AdminApiTest { try (var result = statement.executeQuery("SELECT COUNT(*) FROM sys_user WHERE nickname='sentinel' AND deleted=0")) { result.next(); assertThat(result.getInt(1)).isEqualTo(1); } + String readme = Files.readString(db.getParent().resolve("README.md")); + var supplement = Pattern.compile("\\s*```sql\\s*(.*?)```", Pattern.DOTALL) + .matcher(readme); + assertThat(supplement.find()).as("README must provide the schema supplement").isTrue(); + var sql = new ByteArrayResource(supplement.group(1).getBytes(StandardCharsets.UTF_8)); + ScriptUtils.executeSqlScript(connection, sql); + ScriptUtils.executeSqlScript(connection, sql); + try (var result = statement.executeQuery("SELECT COUNT(*) FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='interface_definition_v2' AND column_name='edit_revision'")) { + result.next(); assertThat(result.getInt(1)).isEqualTo(1); + } + try (var result = statement.executeQuery("SELECT COUNT(*) FROM information_schema.statistics WHERE table_schema=DATABASE() AND table_name='component' AND index_name='uk_component_name' AND non_unique=0")) { + result.next(); assertThat(result.getInt(1)).isEqualTo(1); + } + try (var result = statement.executeQuery("SELECT COUNT(*) FROM information_schema.tables WHERE table_schema=DATABASE() AND table_name='component_asset'")) { + result.next(); assertThat(result.getInt(1)).isZero(); + } } } } diff --git a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/TestSchemaSupport.java b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/TestSchemaSupport.java new file mode 100644 index 0000000..5560eb1 --- /dev/null +++ b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/TestSchemaSupport.java @@ -0,0 +1,40 @@ +package com.linkerbot.cadworld; + +import java.sql.Connection; +import org.springframework.jdbc.core.ConnectionCallback; +import org.springframework.jdbc.core.JdbcTemplate; + +/** Applies the separately delivered schema changes to disposable test databases only. */ +final class TestSchemaSupport { + private TestSchemaSupport() { } + + static void prepare(JdbcTemplate jdbc) { + jdbc.execute((ConnectionCallback) connection -> { + if (!"H2".equals(connection.getMetaData().getDatabaseProductName()) + && !"cadworld_verification".equals(connection.getCatalog())) { + throw new IllegalStateException("Schema preparation requires a disposable test database"); + } + try (var statement = connection.createStatement()) { + boolean hasRevision = false; + String componentTable = "component"; + try (var columns = connection.getMetaData().getColumns(connection.getCatalog(), null, "%", "%")) { + while (columns.next()) { + if ("interface_definition_v2".equalsIgnoreCase(columns.getString("TABLE_NAME")) + && "edit_revision".equalsIgnoreCase(columns.getString("COLUMN_NAME"))) hasRevision = true; + if ("component".equalsIgnoreCase(columns.getString("TABLE_NAME"))) componentTable = columns.getString("TABLE_NAME"); + } + } + if (!hasRevision) statement.execute("ALTER TABLE interface_definition_v2 ADD COLUMN edit_revision BIGINT NOT NULL DEFAULT 1 COMMENT '编辑版本号,每次修改递增,用于防止旧数据覆盖'"); + boolean hasNameIndex = false; + try (var indexes = connection.getMetaData().getIndexInfo(connection.getCatalog(), null, componentTable, false, false)) { + while (indexes.next()) { + if ("uk_component_name".equalsIgnoreCase(indexes.getString("INDEX_NAME"))) hasNameIndex = true; + } + } + if (!hasNameIndex) statement.execute("CREATE UNIQUE INDEX uk_component_name ON component(component_name)"); + statement.execute("DROP TABLE IF EXISTS component_asset"); + } + return null; + }); + } +} diff --git a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/UploadHttpTest.java b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/UploadHttpTest.java index b11b883..078e6db 100644 --- a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/UploadHttpTest.java +++ b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/UploadHttpTest.java @@ -20,6 +20,7 @@ import static org.assertj.core.api.Assertions.*; "spring.datasource.driver-class-name=org.h2.Driver", "spring.datasource.username=sa", "spring.datasource.password=", "spring.sql.init.mode=always", "spring.sql.init.schema-locations=classpath:test-schema.sql", "spring.servlet.multipart.max-file-size=1KB", "spring.servlet.multipart.max-request-size=2KB", + "app.storage.max-upload-bytes=1024", "app.storage.provider=local", "app.storage.local-root=target/test-http-assets", "logging.file.path=target/test-logs" }) @ActiveProfiles("verification") @@ -27,6 +28,28 @@ class UploadHttpTest { @Autowired TestRestTemplate http; @Autowired JdbcTemplate jdbc; + @Test + void realChunkedPutCannotBypassUploadLimit() throws Exception { + var session = http.postForObject("/admin-api/components/cover-image-upload-sessions", null, + com.fasterxml.jackson.databind.JsonNode.class).path("data"); + String objectKey = session.path("keyPrefix").asText() + "chunked.png"; + var uri = org.springframework.web.util.UriComponentsBuilder.fromUriString(http.getRootUri()) + .path("/admin-api/component-assets/upload").queryParam("objectKey", objectKey) + .build().encode().toUri(); + var request = java.net.http.HttpRequest.newBuilder(uri) + .header("X-Upload-Session-Token", session.path("uploadSessionToken").asText()) + .header("Content-Type", "image/png") + .PUT(java.net.http.HttpRequest.BodyPublishers.ofInputStream( + () -> new java.io.ByteArrayInputStream(new byte[1025]))).build(); + try (var client = java.net.http.HttpClient.newHttpClient()) { + var response = client.send(request, java.net.http.HttpResponse.BodyHandlers.ofString()); + assertThat(response.statusCode()).isEqualTo(413); + assertThat(response.body()).contains("UPLOAD_TOO_LARGE"); + } + assertThat(http.getForEntity("/admin-api/component-assets/" + objectKey, String.class).getStatusCode()) + .isEqualTo(HttpStatus.NOT_FOUND); + } + @Test void realServletMultipartSizeFailureReturns413AndPersistsAudit() { var body = new LinkedMultiValueMap(); diff --git a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/audit/OperationAuditInterceptorTest.java b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/audit/OperationAuditInterceptorTest.java index 6e6ff13..7afccfb 100644 --- a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/audit/OperationAuditInterceptorTest.java +++ b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/audit/OperationAuditInterceptorTest.java @@ -20,7 +20,11 @@ class OperationAuditInterceptorTest { var request = new MockHttpServletRequest("POST", "/admin-api/components"); var response = new MockHttpServletResponse(); var handler = new HandlerMethod(this, getClass().getDeclaredMethod("operation")); - when(mappings.getHandler(request)).thenReturn(new org.springframework.web.servlet.HandlerExecutionChain(handler)); + var options = new org.springframework.web.servlet.mvc.method.RequestMappingInfo.BuilderConfiguration(); + options.setPatternParser(new org.springframework.web.util.pattern.PathPatternParser()); + var mapping = org.springframework.web.servlet.mvc.method.RequestMappingInfo.paths("/admin-api/components") + .methods(org.springframework.web.bind.annotation.RequestMethod.POST).options(options).build(); + when(mappings.getHandlerMethods()).thenReturn(java.util.Map.of(mapping, handler)); var filter = new EarlyFailureAuditFilter(mappings, audit); filter.doFilter(request, response, (req, res) -> ((jakarta.servlet.http.HttpServletResponse) res).setStatus(413)); var captured = org.mockito.ArgumentCaptor.forClass(com.linkerbot.cadworld.entity.OperationLog.class); diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/component/PrepareObjectUploadUrlResponse.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/component/PrepareObjectUploadUrlResponse.java index d682b1b..e39484a 100644 --- a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/component/PrepareObjectUploadUrlResponse.java +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/component/PrepareObjectUploadUrlResponse.java @@ -1,7 +1,10 @@ package com.linkerbot.cadworld.dto.component; +import java.util.Map; + public record PrepareObjectUploadUrlResponse( String uploadUrl, - String objectKey + String objectKey, + Map uploadHeaders ) { } diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/interfaces/SaveInterfaceDefinitionRequest.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/interfaces/SaveInterfaceDefinitionRequest.java new file mode 100644 index 0000000..cbc0e1e --- /dev/null +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/interfaces/SaveInterfaceDefinitionRequest.java @@ -0,0 +1,36 @@ +package com.linkerbot.cadworld.dto.interfaces; + +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.databind.JsonNode; +import com.linkerbot.cadworld.common.json.ConnectableTargetsDeserializer; +import com.linkerbot.cadworld.mechanicalinterface.InterfaceGeometry.MountGeometry; +import com.linkerbot.cadworld.mechanicalinterface.InterfaceGeometry.Tolerances; +import jakarta.validation.constraints.Min; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; +import jakarta.validation.constraints.Size; +import java.util.List; + +public record SaveInterfaceDefinitionRequest( + @Size(max = 64) String id, + @NotBlank @Size(max = 128) String name, + @Size(max = 500) String description, + @Min(1) Integer geometryRevision, + @Min(1) Long editRevision, + @NotNull MountGeometry geometry, + @NotNull Tolerances tolerances, + @JsonDeserialize(using = ConnectableTargetsDeserializer.class) List connectableTargets, + @Size(min = 3, max = 3) double[] displayForward, + @Size(max = 512) String sourceAssetKey, + @Size(max = 128) String sourceGeometryHash +) { + public SaveInterfaceDefinitionRequest { + connectableTargets = connectableTargets == null ? List.of() : List.copyOf(connectableTargets); + } + + @JsonAnySetter + public void rejectUnknownField(String field, JsonNode value) { + throw new IllegalArgumentException("不支持的接口字段:" + field); + } +} diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/entity/ComponentAsset.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/entity/ComponentAsset.java deleted file mode 100644 index f0ac22c..0000000 --- a/cadworld-bean/src/main/java/com/linkerbot/cadworld/entity/ComponentAsset.java +++ /dev/null @@ -1,20 +0,0 @@ -package com.linkerbot.cadworld.entity; - -import com.baomidou.mybatisplus.annotation.IdType; -import com.baomidou.mybatisplus.annotation.TableId; -import com.baomidou.mybatisplus.annotation.TableName; -import lombok.Getter; import lombok.Setter; - -@Getter @Setter -@TableName("component_asset") -public class ComponentAsset extends BaseEntity { - @TableId(type = IdType.AUTO) private Long id; - private Long componentId; - private String objectKey; - private String relativePath; - private String assetKind; - private String contentType; - private Long size; - private String sha256; - private Boolean isPrimary; -} diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/entity/InterfaceDefinitionEntity.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/entity/InterfaceDefinitionEntity.java index be536c1..5cfca23 100644 --- a/cadworld-bean/src/main/java/com/linkerbot/cadworld/entity/InterfaceDefinitionEntity.java +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/entity/InterfaceDefinitionEntity.java @@ -15,6 +15,7 @@ public class InterfaceDefinitionEntity extends BaseEntity { private String name; private String description; private Integer geometryRevision; + private Long editRevision; @TableField(typeHandler = JsonNodeTypeHandler.class) private JsonNode geometryJson; @TableField(typeHandler = JsonNodeTypeHandler.class) private JsonNode tolerancesJson; @TableField(typeHandler = JsonNodeTypeHandler.class) private JsonNode connectableTargetsJson; diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/mechanicalinterface/InterfaceGeometry.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/mechanicalinterface/InterfaceGeometry.java similarity index 92% rename from cadworld-service/src/main/java/com/linkerbot/cadworld/mechanicalinterface/InterfaceGeometry.java rename to cadworld-bean/src/main/java/com/linkerbot/cadworld/mechanicalinterface/InterfaceGeometry.java index f7eebcc..37ba608 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/mechanicalinterface/InterfaceGeometry.java +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/mechanicalinterface/InterfaceGeometry.java @@ -1,6 +1,8 @@ package com.linkerbot.cadworld.mechanicalinterface; import java.util.List; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.linkerbot.cadworld.common.json.ConnectableTargetsDeserializer; /** Mechanical interface wire contract. All distances are metres; quaternions are XYZW. */ public final class InterfaceGeometry { @@ -29,7 +31,8 @@ public final class InterfaceGeometry { double[] orientationDirectionInLink) {} public record Port(String id, String linkName, String definitionId, int definitionRevision, MountGeometry geometryInLink, SelectedPose selectedPose, - String sourceGeometryHash, String solverVersion, List connectableTargets) { + String sourceGeometryHash, String solverVersion, + @JsonDeserialize(using = ConnectableTargetsDeserializer.class) List connectableTargets) { public Port(String id, String linkName, String definitionId, int definitionRevision, MountGeometry geometryInLink, SelectedPose selectedPose, String sourceGeometryHash, String solverVersion) { diff --git a/cadworld-common/src/main/java/com/linkerbot/cadworld/common/exception/GlobalExceptionHandler.java b/cadworld-common/src/main/java/com/linkerbot/cadworld/common/exception/GlobalExceptionHandler.java index a09ec82..35a2bfd 100644 --- a/cadworld-common/src/main/java/com/linkerbot/cadworld/common/exception/GlobalExceptionHandler.java +++ b/cadworld-common/src/main/java/com/linkerbot/cadworld/common/exception/GlobalExceptionHandler.java @@ -8,6 +8,9 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.dao.DataAccessResourceFailureException; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; +import org.springframework.http.HttpHeaders; +import org.springframework.web.bind.MissingRequestHeaderException; +import java.util.stream.Collectors; import org.springframework.transaction.CannotCreateTransactionException; import org.springframework.validation.BindException; import org.springframework.web.HttpMediaTypeNotSupportedException; @@ -40,19 +43,66 @@ public class GlobalExceptionHandler { MethodArgumentNotValidException.class, BindException.class, ConstraintViolationException.class, - HttpMediaTypeNotSupportedException.class, - HttpRequestMethodNotSupportedException.class, org.springframework.http.converter.HttpMessageNotReadableException.class, org.springframework.web.method.annotation.MethodArgumentTypeMismatchException.class, org.springframework.web.bind.MissingServletRequestParameterException.class, + MissingRequestHeaderException.class, org.springframework.web.multipart.support.MissingServletRequestPartException.class, org.springframework.web.method.annotation.HandlerMethodValidationException.class, IllegalArgumentException.class }) public ResponseEntity> handleBadRequest(Exception exception, HttpServletRequest request) { - request.setAttribute("cadworld.operationError", "请求参数或数据格式不合法"); + String message = validationMessage(exception); + request.setAttribute("cadworld.operationError", message); return ResponseEntity.unprocessableEntity() - .body(ApiResponse.failure(ApiCode.INVALID_REQUEST, exception.getMessage())); + .body(ApiResponse.failure(ApiCode.INVALID_REQUEST, message)); + } + + @ExceptionHandler(HttpRequestMethodNotSupportedException.class) + public ResponseEntity> handleMethodNotAllowed(HttpRequestMethodNotSupportedException exception, + HttpServletRequest request) { + request.setAttribute("cadworld.operationError", "请求方法不支持"); + var headers = new HttpHeaders(); + if (exception.getSupportedHttpMethods() != null) headers.setAllow(exception.getSupportedHttpMethods()); + return new ResponseEntity<>(ApiResponse.failure(ApiCode.INVALID_REQUEST, "请求方法不支持"), + headers, HttpStatus.METHOD_NOT_ALLOWED); + } + + @ExceptionHandler(HttpMediaTypeNotSupportedException.class) + public ResponseEntity> handleUnsupportedMediaType(HttpServletRequest request) { + request.setAttribute("cadworld.operationError", "请求内容类型不支持"); + return ResponseEntity.status(HttpStatus.UNSUPPORTED_MEDIA_TYPE) + .body(ApiResponse.failure(ApiCode.INVALID_REQUEST, "请求内容类型不支持")); + } + + private String validationMessage(Exception exception) { + if (exception instanceof BindException binding) { + return binding.getBindingResult().getFieldErrors().stream() + .map(error -> error.getField() + ": " + error.getDefaultMessage()) + .distinct().sorted().collect(Collectors.joining(";")); + } + if (exception instanceof ConstraintViolationException violations) { + return violations.getConstraintViolations().stream() + .map(error -> error.getPropertyPath() + ": " + error.getMessage()) + .distinct().sorted().collect(Collectors.joining(";")); + } + if (exception instanceof org.springframework.http.converter.HttpMessageNotReadableException) { + return "请求体格式不合法,请检查字段类型和JSON结构"; + } + if (exception instanceof org.springframework.web.method.annotation.MethodArgumentTypeMismatchException mismatch) { + return "参数 " + mismatch.getName() + " 格式不合法"; + } + if (exception instanceof MissingRequestHeaderException missing) { + return "缺少请求头 " + missing.getHeaderName(); + } + if (exception instanceof org.springframework.web.bind.MissingServletRequestParameterException missing) { + return "缺少请求参数 " + missing.getParameterName(); + } + if (exception instanceof org.springframework.web.multipart.support.MissingServletRequestPartException missing) { + return "缺少上传字段 " + missing.getRequestPartName(); + } + if (exception instanceof IllegalArgumentException) return exception.getMessage(); + return "请求参数或数据格式不合法"; } @ExceptionHandler({CannotCreateTransactionException.class, DataAccessResourceFailureException.class}) diff --git a/cadworld-common/src/main/java/com/linkerbot/cadworld/common/json/ConnectableTargetsDeserializer.java b/cadworld-common/src/main/java/com/linkerbot/cadworld/common/json/ConnectableTargetsDeserializer.java new file mode 100644 index 0000000..49fd1d1 --- /dev/null +++ b/cadworld-common/src/main/java/com/linkerbot/cadworld/common/json/ConnectableTargetsDeserializer.java @@ -0,0 +1,52 @@ +package com.linkerbot.cadworld.common.json; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonDeserializer; +import com.fasterxml.jackson.databind.JsonNode; +import java.io.IOException; +import java.util.ArrayList; +import java.util.LinkedHashSet; +import java.util.List; + +/** Flat strings are separate targets; nested arrays are Cascader paths. */ +public class ConnectableTargetsDeserializer extends JsonDeserializer> { + @Override + public List deserialize(JsonParser parser, DeserializationContext context) throws IOException { + JsonNode value = parser.readValueAsTree(); + if (!value.isArray()) { + throw context.weirdStringException("", List.class, "连接目标必须为数组"); + } + var targets = new LinkedHashSet(); + for (JsonNode item : value) { + String target; + if (item.isTextual()) { + target = item.asText().trim(); + } else if (item.isArray() && !item.isEmpty()) { + var segments = new ArrayList(); + for (JsonNode segment : item) { + if (!segment.isTextual() || segment.asText().isBlank()) { + throw context.weirdStringException(item.toString(), List.class, "连接目标路径必须由非空字符串组成"); + } + segments.add(segment.asText().trim()); + } + target = String.join("/", segments); + } else { + throw context.weirdStringException(item.toString(), List.class, "连接目标必须是字符串或路径数组"); + } + if (target.isEmpty() || target.length() > 512) { + throw context.weirdStringException("", List.class, "连接目标不能为空,长度不能超过512字符"); + } + targets.add(target); + if (targets.size() > 100) { + throw context.weirdStringException("", List.class, "连接目标不能超过100个"); + } + } + return List.copyOf(targets); + } + + @Override + public List getNullValue(DeserializationContext context) { + return List.of(); + } +} diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/config/StorageProperties.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/config/StorageProperties.java index e9dc0a6..4de7ea8 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/config/StorageProperties.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/config/StorageProperties.java @@ -3,6 +3,7 @@ package com.linkerbot.cadworld.config; import java.time.Duration; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.bind.ConstructorBinding; +import org.springframework.boot.context.properties.bind.DefaultValue; @ConfigurationProperties(prefix = "app.storage") public record StorageProperties( @@ -12,19 +13,17 @@ public record StorageProperties( String publicBaseUrl, String publicApiBaseUrl, String localRoot, - Duration uploadSessionTtl + Duration uploadSessionTtl, + @DefaultValue("104857600") long maxUploadBytes ) { @ConstructorBinding + public StorageProperties { } + public StorageProperties(String provider, String urdfPrefix, String coverImagePrefix, String publicBaseUrl, String publicApiBaseUrl, String localRoot, Duration uploadSessionTtl) { - this.provider = provider; - this.urdfPrefix = urdfPrefix; - this.coverImagePrefix = coverImagePrefix; - this.publicBaseUrl = publicBaseUrl; - this.publicApiBaseUrl = publicApiBaseUrl; - this.localRoot = localRoot; - this.uploadSessionTtl = uploadSessionTtl; + this(provider, urdfPrefix, coverImagePrefix, publicBaseUrl, publicApiBaseUrl, + localRoot, uploadSessionTtl, 104857600L); } public StorageProperties(String provider, String urdfPrefix, String coverImagePrefix, diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/mapper/ComponentAssetMapper.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/mapper/ComponentAssetMapper.java deleted file mode 100644 index f673ea6..0000000 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/mapper/ComponentAssetMapper.java +++ /dev/null @@ -1,4 +0,0 @@ -package com.linkerbot.cadworld.mapper; -import com.baomidou.mybatisplus.core.mapper.BaseMapper; -import com.linkerbot.cadworld.entity.ComponentAsset; -public interface ComponentAssetMapper extends BaseMapper {} diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/mechanicalinterface/ComponentPortValidationService.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/mechanicalinterface/ComponentPortValidationService.java index e7aff8e..52e09c8 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/mechanicalinterface/ComponentPortValidationService.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/mechanicalinterface/ComponentPortValidationService.java @@ -1,64 +1,72 @@ package com.linkerbot.cadworld.mechanicalinterface; -import static com.linkerbot.cadworld.mechanicalinterface.InterfaceGeometry.*; -import com.fasterxml.jackson.databind.*; -import com.fasterxml.jackson.databind.node.*; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.linkerbot.cadworld.mechanicalinterface.InterfaceGeometry.Port; import com.linkerbot.cadworld.service.InterfaceDefinitionService; +import java.io.IOException; import java.util.HashSet; import java.util.Set; import lombok.RequiredArgsConstructor; import org.springframework.stereotype.Service; -@Service @RequiredArgsConstructor +@Service +@RequiredArgsConstructor public class ComponentPortValidationService { private final InterfaceDefinitionService definitions; private final MechanicalInterfaceSolver solver; private final ObjectMapper mapper; private final UrdfSourceValidation sourceValidation; private final UrdfAssetVerifier assetVerifier; - public JsonNode validate(JsonNode componentJson){ - if(componentJson==null||!componentJson.isObject())throw new IllegalArgumentException("组件模型数据不合法"); - ObjectNode result=componentJson.deepCopy(); - JsonNode interfaces=result.get("interfaces"); - if(interfaces==null)return result; - if(!interfaces.isArray())throw new IllegalArgumentException("接口必须是数组"); - Set links=interfaces.isEmpty()?Set.of():sourceValidation.validate(result.get("urdfSource")); - if(!interfaces.isEmpty())assetVerifier.verify(result.get("urdfSource")); - ArrayNode confirmed=mapper.createArrayNode();Set ids=new HashSet<>(); - for(JsonNode raw:interfaces){ - Port port=readPort(raw); - if(!links.contains(port.linkName()))throw new IllegalArgumentException("接口所属 link 不存在于原始 URDF:"+port.linkName()); - if(!port.sourceGeometryHash().equals(result.path("urdfSource").path("sourceGeometryHash").asText()))throw new IllegalArgumentException("接口源几何已变化,请重新识别"); - if(definitions.get(port.definitionId()).path("geometryRevision").asInt()!=port.definitionRevision())throw new IllegalArgumentException("接口定义已修订,请重新确认组件接口"); - if(!ids.add(port.id()))throw new IllegalArgumentException("组件端口 ID 重复"); - Port canonical=solver.confirmPortPose(definitions.geometryDefinition(port.definitionId(),port.definitionRevision()),port); + public JsonNode validate(JsonNode componentJson) { + if (componentJson == null || !componentJson.isObject()) { + throw new IllegalArgumentException("组件模型数据不合法"); + } + ObjectNode result = componentJson.deepCopy(); + JsonNode interfaces = result.get("interfaces"); + if (interfaces == null) return result; + if (!interfaces.isArray()) throw new IllegalArgumentException("接口必须是数组"); + + JsonNode source = result.get("urdfSource"); + Set links = interfaces.isEmpty() ? Set.of() : sourceValidation.validate(source); + if (!interfaces.isEmpty()) assetVerifier.verify(source); + ArrayNode confirmed = mapper.createArrayNode(); + Set ids = new HashSet<>(); + for (JsonNode raw : interfaces) { + Port port = readPort(raw); + if (!links.contains(port.linkName())) { + throw new IllegalArgumentException("接口所属 link 不存在于原始 URDF:" + port.linkName()); + } + if (!port.sourceGeometryHash().equals(source.path("sourceGeometryHash").asText())) { + throw new IllegalArgumentException("接口源几何已变化,请重新识别"); + } + if (definitions.get(port.definitionId()).path("geometryRevision").asInt() != port.definitionRevision()) { + throw new IllegalArgumentException("接口定义已修订,请重新确认组件接口"); + } + if (!ids.add(port.id())) throw new IllegalArgumentException("组件端口 ID 重复"); + Port canonical = solver.confirmPortPose( + definitions.geometryDefinition(port.definitionId(), port.definitionRevision()), port); confirmed.add(mapper.valueToTree(canonical)); } - result.set("interfaces",confirmed);result.put("interfaceSchemaVersion",3); + result.set("interfaces", confirmed); + result.put("interfaceSchemaVersion", 3); return result; } - public Port readPort(JsonNode raw){ - try{return mapper.readerFor(Port.class).with(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES).readValue(normalizePort(raw));} - catch(java.io.IOException | IllegalArgumentException e){throw new IllegalArgumentException("不支持的接口结构,请重新识别并确认姿态:"+rootMessage(e),e);} - } - private JsonNode normalizePort(JsonNode raw){ - if(raw==null||!raw.isObject())return raw; - ObjectNode copy=raw.deepCopy();JsonNode targets=copy.get("connectableTargets"); - if(targets!=null&&!targets.isNull()){ - ArrayNode normalized=mapper.createArrayNode();flattenTargets(targets,normalized);copy.set("connectableTargets",normalized); + + public Port readPort(JsonNode raw) { + try { + return mapper.readerFor(Port.class).with(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES).readValue(raw); + } catch (IOException | IllegalArgumentException exception) { + throw new IllegalArgumentException("不支持的接口结构,请重新识别并确认姿态:" + rootMessage(exception), exception); } - return copy; } - private void flattenTargets(JsonNode node,ArrayNode output){ - if(node==null||node.isNull())return; - if(node.isArray()){ - boolean path=true;StringBuilder joined=new StringBuilder(); - for(JsonNode child:node){if(!child.isTextual()){path=false;break;}if(joined.length()>0)joined.append('/');joined.append(child.asText());} - if(path){String value=joined.toString().trim();if(!value.isEmpty()&&!containsTarget(output,value))output.add(value);return;} - node.forEach(child->flattenTargets(child,output));return; - } - String value=node.asText("").trim();if(!value.isEmpty()&&!containsTarget(output,value))output.add(value); + + private String rootMessage(Throwable error) { + Throwable current = error; + while (current.getCause() != null) current = current.getCause(); + return current.getMessage() == null ? "字段格式错误" : current.getMessage(); } - private boolean containsTarget(ArrayNode output,String value){for(JsonNode item:output)if(value.equals(item.asText()))return true;return false;} - private String rootMessage(Throwable error){Throwable current=error;while(current.getCause()!=null)current=current.getCause();return current.getMessage()==null?"字段格式错误":current.getMessage();} } diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/InterfaceAssetService.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/InterfaceAssetService.java new file mode 100644 index 0000000..67d93f7 --- /dev/null +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/InterfaceAssetService.java @@ -0,0 +1,110 @@ +package com.linkerbot.cadworld.service; + +import com.linkerbot.cadworld.common.api.RequestIdHolder; +import com.linkerbot.cadworld.common.exception.BizException; +import com.linkerbot.cadworld.config.StorageProperties; +import com.linkerbot.cadworld.service.client.ObjectStorageClient; +import com.linkerbot.cadworld.service.support.UploadLimits; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.security.DigestInputStream; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.HexFormat; +import java.util.UUID; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import org.springframework.web.multipart.MultipartFile; + +@Slf4j +@Service +@RequiredArgsConstructor +public class InterfaceAssetService { + private final InterfaceDefinitionService definitions; + private final ObjectStorageClient storage; + private final StorageProperties properties; + + public String upload(String definitionId, int geometryRevision, MultipartFile file) { + if (file == null || file.isEmpty()) throw new BizException(422, "INVALID_INTERFACE_ASSET", "接口源文件不能为空"); + var current = definitions.get(definitionId); + if (geometryRevision < 1 || current.path("geometryRevision").asInt() != geometryRevision) { + throw new BizException(409, "INTERFACE_REVISION_CONFLICT", "接口已修订,请刷新后重新上传"); + } + UploadLimits.checkLength(file.getSize(), properties.maxUploadBytes()); + Path temporary = null; + String uploadedKey = null; + try { + temporary = Files.createTempFile("cadworld-interface-", ".upload"); + MessageDigest digest = sha256(); + try (var input = new DigestInputStream(UploadLimits.bounded(file.getInputStream(), properties.maxUploadBytes()), digest)) { + Files.copy(input, temporary, java.nio.file.StandardCopyOption.REPLACE_EXISTING); + } + String hash = "sha256:" + HexFormat.of().formatHex(digest.digest()); + String oldKey = current.path("sourceAssetKey").asText(); + if (hash.equals(current.path("sourceGeometryHash").asText()) + && !oldKey.isBlank() && storage.objectExists(oldKey)) { + // Revalidate under the database lock even for an idempotent retry. + definitions.attachAsset(definitionId, geometryRevision, oldKey, hash, oldKey); + return oldKey; + } + if (!current.path("sourceGeometryHash").asText().isBlank() + && !hash.equals(current.path("sourceGeometryHash").asText())) { + throw new BizException(422, "INVALID_INTERFACE_ASSET", "该修订已有源文件,请创建新几何修订"); + } + String key = "interfaces/" + HexFormat.of().formatHex(definitionId.getBytes(StandardCharsets.UTF_8)) + + "/" + geometryRevision + "/" + hash.substring(7) + "/" + UUID.randomUUID() + + "/" + filename(file.getOriginalFilename()); + if (key.length() > 512) throw new BizException(422, "INVALID_INTERFACE_ASSET", "源文件对象路径超过512字符,请缩短文件名或接口ID"); + // Each request owns its object; compensation cannot delete another upload's object. + uploadedKey = key; + try (var input = Files.newInputStream(temporary)) { + storage.putObject(key, file.getContentType(), input, Files.size(temporary)); + } + definitions.attachAsset(definitionId, geometryRevision, key, hash, oldKey); + return key; + } catch (IOException exception) { + compensate(uploadedKey, definitionId, geometryRevision); + log.error("接口源文件处理失败 definitionId={} geometryRevision={} requestId={}", + definitionId, geometryRevision, RequestIdHolder.get(), exception); + throw new BizException(500, "INTERFACE_ASSET_PROCESSING_FAILED", "接口源文件处理失败,请重试"); + } catch (RuntimeException exception) { + compensate(uploadedKey, definitionId, geometryRevision); + throw exception; + } finally { + if (temporary != null) { + try { + Files.deleteIfExists(temporary); + } catch (IOException exception) { + log.warn("接口源文件临时文件清理失败 definitionId={} requestId={}", definitionId, RequestIdHolder.get(), exception); + } + } + } + } + + private void compensate(String key, String definitionId, int revision) { + if (key == null) return; + try { + storage.deleteObject(key); + } catch (RuntimeException exception) { + log.error("接口源文件补偿清理失败 definitionId={} geometryRevision={} requestId={} objectKey={}", + definitionId, revision, RequestIdHolder.get(), key, exception); + } + } + + private String filename(String original) { + String name = original == null ? "source.step" : original.replace('\\', '/'); + name = name.substring(name.lastIndexOf('/') + 1).replaceAll("[^A-Za-z0-9._-]", "_"); + return name.isBlank() ? "source.step" : name; + } + + private MessageDigest sha256() { + try { + return MessageDigest.getInstance("SHA-256"); + } catch (NoSuchAlgorithmException exception) { + throw new IllegalStateException("SHA-256 不可用", exception); + } + } +} diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/InterfaceDefinitionService.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/InterfaceDefinitionService.java index 0e57152..76af367 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/InterfaceDefinitionService.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/InterfaceDefinitionService.java @@ -2,13 +2,15 @@ package com.linkerbot.cadworld.service; import com.fasterxml.jackson.databind.JsonNode; import java.util.List; +import com.linkerbot.cadworld.dto.interfaces.SaveInterfaceDefinitionRequest; public interface InterfaceDefinitionService { List list(String keyword); JsonNode get(String id); - JsonNode create(JsonNode request); - JsonNode update(String id, JsonNode request); + JsonNode create(SaveInterfaceDefinitionRequest request); + JsonNode update(String id, SaveInterfaceDefinitionRequest request); void delete(String id); - void attachAsset(String definitionId, int geometryRevision, String objectKey, String sha256); + void attachAsset(String definitionId, int geometryRevision, String objectKey, String sha256, + String expectedAssetKey); com.linkerbot.cadworld.mechanicalinterface.InterfaceGeometry.Definition geometryDefinition(String id, int revision); } diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/LocalObjectStorageClient.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/LocalObjectStorageClient.java index 4046902..87529da 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/LocalObjectStorageClient.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/LocalObjectStorageClient.java @@ -42,7 +42,7 @@ public class LocalObjectStorageClient implements ObjectStorageClient { throw new BizException(HttpStatus.INTERNAL_SERVER_ERROR.value(), "STORAGE_CONFIG_ERROR", "上传会话有效期配置非法"); } String base = StringUtils.hasText(properties.publicApiBaseUrl()) - ? properties.publicApiBaseUrl().trim() : "http://127.0.0.1:8084"; + ? properties.publicApiBaseUrl().trim() : "http://127.0.0.1:8992"; return UriComponentsBuilder.fromUriString(base.replaceAll("/+$", "")) .path("/admin-api/component-assets/upload") .queryParam("objectKey", normalizeKey(objectKey)) @@ -52,12 +52,37 @@ public class LocalObjectStorageClient implements ObjectStorageClient { @Override public void putObject(String objectKey, String contentType, InputStream inputStream, long contentLength) { Path target = resolve(objectKey); + Path temporary = null; try { Files.createDirectories(Objects.requireNonNull(target.getParent())); - Files.copy(inputStream, target, java.nio.file.StandardCopyOption.REPLACE_EXISTING); + temporary = Files.createTempFile(target.getParent(), ".upload-", ".tmp"); + Files.copy(inputStream, temporary, java.nio.file.StandardCopyOption.REPLACE_EXISTING); + try { + Files.move(temporary, target, java.nio.file.StandardCopyOption.ATOMIC_MOVE, + java.nio.file.StandardCopyOption.REPLACE_EXISTING); + } catch (java.nio.file.AtomicMoveNotSupportedException exception) { + Files.move(temporary, target, java.nio.file.StandardCopyOption.REPLACE_EXISTING); + } } catch (IOException exception) { log.error("Failed to write local object {}", objectKey, exception); - throw new BizException(HttpStatus.INTERNAL_SERVER_ERROR.value(), "LOCAL_STORAGE_WRITE_FAILED", "文件写入本地目录失败"); + throw new BizException(500, "LOCAL_STORAGE_WRITE_FAILED", "文件写入本地目录失败"); + } finally { + if (temporary != null) { + try { + Files.deleteIfExists(temporary); + } catch (IOException exception) { + log.warn("Failed to clean local upload temporary file", exception); + } + } + } + } + + @Override + public void deleteObject(String objectKey) { + try { + Files.deleteIfExists(resolve(objectKey)); + } catch (IOException exception) { + throw new BizException(500, "LOCAL_STORAGE_DELETE_FAILED", "清理本地文件失败"); } } diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/MinioObjectStorageClient.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/MinioObjectStorageClient.java index 6d22258..3d5d2b5 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/MinioObjectStorageClient.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/MinioObjectStorageClient.java @@ -9,6 +9,8 @@ import io.minio.GetObjectResponse; import io.minio.MakeBucketArgs; import io.minio.MinioClient; import io.minio.PutObjectArgs; +import io.minio.RemoveObjectArgs; +import com.linkerbot.cadworld.service.support.UploadLimits; import io.minio.StatObjectArgs; import io.minio.StatObjectResponse; import java.io.InputStream; @@ -68,6 +70,7 @@ public class MinioObjectStorageClient implements ObjectStorageClient { .stream(inputStream, objectSize, partSize) .build()); } catch (Exception exception) { + UploadLimits.rethrowIfExceeded(exception); restoreInterrupt(exception); log.error("Failed to upload object to MinIO. objectKey={}", objectKey, exception); throw new BizException(HttpStatus.BAD_GATEWAY.value(), "MINIO_UPLOAD_FAILED", "文件上传到 MinIO 失败"); @@ -98,6 +101,18 @@ public class MinioObjectStorageClient implements ObjectStorageClient { } } + @Override + public void deleteObject(String objectKey) { + validateConfiguration(); + try { + getMinioClient().removeObject(RemoveObjectArgs.builder() + .bucket(properties.bucket().trim()).object(normalizeObjectKey(objectKey)).build()); + } catch (Exception exception) { + restoreInterrupt(exception); + throw new BizException(502, "MINIO_DELETE_FAILED", "清理 MinIO 文件失败"); + } + } + @Override public StoredObject statObject(String objectKey) { validateConfiguration(); diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/ObjectStorageClient.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/ObjectStorageClient.java index 3e153b0..0eac344 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/ObjectStorageClient.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/client/ObjectStorageClient.java @@ -14,6 +14,10 @@ public interface ObjectStorageClient { boolean objectExists(String objectKey); + default void deleteObject(String objectKey) { + throw new UnsupportedOperationException(); + } + default StoredObject statObject(String objectKey) { throw new UnsupportedOperationException(); } diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentCoverImageUploadServiceImpl.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentCoverImageUploadServiceImpl.java index 5f24940..c9c7820 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentCoverImageUploadServiceImpl.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentCoverImageUploadServiceImpl.java @@ -50,7 +50,7 @@ public class ComponentCoverImageUploadServiceImpl implements ComponentCoverImage request.objectPath(), request.contentType() ); - return new PrepareObjectUploadUrlResponse(upload.uploadUrl(), upload.objectKey()); + return new PrepareObjectUploadUrlResponse(upload.uploadUrl(), upload.objectKey(), upload.uploadHeaders()); } @Override diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentServiceImpl.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentServiceImpl.java index 2f79006..10b5806 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentServiceImpl.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentServiceImpl.java @@ -3,6 +3,8 @@ package com.linkerbot.cadworld.service.impl; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ObjectNode; import com.linkerbot.cadworld.common.api.PageResponse; import com.linkerbot.cadworld.common.exception.BizException; import com.linkerbot.cadworld.dto.component.ComponentAssemblyMetadata; @@ -11,18 +13,18 @@ import com.linkerbot.cadworld.dto.component.ComponentResponse; import com.linkerbot.cadworld.dto.component.CreateComponentRequest; import com.linkerbot.cadworld.dto.component.UpdateComponentRequest; import com.linkerbot.cadworld.entity.Component; -import com.linkerbot.cadworld.entity.ComponentAsset; import com.linkerbot.cadworld.mapper.ComponentMapper; -import com.linkerbot.cadworld.mapper.ComponentAssetMapper; import com.linkerbot.cadworld.service.ComponentService; +import com.linkerbot.cadworld.mechanicalinterface.ComponentPortValidationService; +import lombok.RequiredArgsConstructor; import org.springframework.dao.DuplicateKeyException; -import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.util.StringUtils; @Service +@RequiredArgsConstructor public class ComponentServiceImpl implements ComponentService { private static final String COMPONENT_NOT_FOUND = "COMPONENT_NOT_FOUND"; @@ -30,22 +32,9 @@ public class ComponentServiceImpl implements ComponentService { private static final String COMPONENT_NAME_DUPLICATE_MESSAGE = "组件名称已存在,请更换名称"; private final ComponentMapper componentMapper; - private final ComponentAssetMapper componentAssetMapper; private final ObjectStorageUrlResolver objectStorageUrlResolver; private final ObjectMapper objectMapper; - private final com.linkerbot.cadworld.mechanicalinterface.ComponentPortValidationService portValidation; - - @Autowired - public ComponentServiceImpl(ComponentMapper componentMapper, ComponentAssetMapper componentAssetMapper, - ObjectStorageUrlResolver objectStorageUrlResolver, - ObjectMapper objectMapper, - com.linkerbot.cadworld.mechanicalinterface.ComponentPortValidationService portValidation) { - this.componentMapper = componentMapper; - this.componentAssetMapper = componentAssetMapper; - this.objectStorageUrlResolver = objectStorageUrlResolver; - this.objectMapper = objectMapper; - this.portValidation = portValidation; - } + private final ComponentPortValidationService portValidation; @Override @Transactional @@ -58,7 +47,6 @@ public class ComponentServiceImpl implements ComponentService { request.assemblyMetadata()); try { componentMapper.insert(component); - syncAssetIndex(component); } catch (DuplicateKeyException exception) { throw duplicateComponentNameException(); } @@ -90,15 +78,21 @@ public class ComponentServiceImpl implements ComponentService { @Override @Transactional public ComponentResponse updateComponent(Long userId, Long id, UpdateComponentRequest request) { - Component component = requireComponent(id); + Component component = componentMapper.selectOne(new LambdaQueryWrapper() + .eq(Component::getId, id).last("FOR UPDATE")); + if (component == null) { + throw new BizException(404, COMPONENT_NOT_FOUND, "组件不存在"); + } + assertRevisionMatches(component, request.componentJson()); String componentName = request.componentName().trim(); assertComponentNameAvailable(componentName, id); apply(component, componentName, request.category(), request.robotType(), request.company(), request.model(), request.source(), request.coverImageKey(), request.description(), request.componentJson(), request.assemblyMetadata()); try { - componentMapper.updateById(component); - syncAssetIndex(component); + if (componentMapper.updateById(component) != 1) { + throw new BizException(409, "COMPONENT_REVISION_CONFLICT", "组件已删除,请刷新后保存"); + } } catch (DuplicateKeyException exception) { throw duplicateComponentNameException(); } @@ -142,7 +136,7 @@ public class ComponentServiceImpl implements ComponentService { String source, String coverImageKey, String description, - com.fasterxml.jackson.databind.JsonNode componentJson, + JsonNode componentJson, ComponentAssemblyMetadata assemblyMetadata) { component.setComponentName(componentName.trim()); component.setCategory(normalizeOptionalText(category)); @@ -152,9 +146,10 @@ public class ComponentServiceImpl implements ComponentService { component.setSource(source.trim()); component.setCoverImageKey(normalizeOptionalText(coverImageKey)); component.setDescription(normalizeOptionalText(description)); - int previousRevision=component.getComponentJson()==null?0:component.getComponentJson().path("componentRevision").asInt(0); - var validated=(com.fasterxml.jackson.databind.node.ObjectNode)portValidation.validate(componentJson); - validated.put("componentRevision",previousRevision+1); + int previousRevision = component.getComponentJson() == null ? 0 + : component.getComponentJson().path("componentRevision").asInt(0); + ObjectNode validated = (ObjectNode) portValidation.validate(componentJson); + validated.put("componentRevision", Math.incrementExact(previousRevision)); component.setComponentJson(validated); component.setAssemblyMetadata(objectMapper.valueToTree( ComponentTagSupport.mergeLegacy(assemblyMetadata, category) @@ -211,28 +206,15 @@ public class ComponentServiceImpl implements ComponentService { return objectStorageUrlResolver.resolvePublicUrl(coverImageKey); } - private void syncAssetIndex(Component component) { - if (componentAssetMapper == null || component.getId() == null) { - return; + private void assertRevisionMatches(Component current, JsonNode submitted) { + var revision = submitted == null ? null : submitted.get("componentRevision"); + if (revision == null || !revision.isIntegralNumber() || !revision.canConvertToInt() + || revision.intValue() < 0) { + throw new BizException(422, "INVALID_COMPONENT_REVISION", "修改组件必须提供 componentJson.componentRevision"); } - componentAssetMapper.delete(new LambdaQueryWrapper() - .eq(ComponentAsset::getComponentId, component.getId())); - addAsset(component, component.getSource(), "RFS", true); - addAsset(component, component.getCoverImageKey(), "COVER", false); - } - - private void addAsset(Component component, String objectKey, String assetKind, boolean primary) { - if (!StringUtils.hasText(objectKey)) { - return; + int expected = current.getComponentJson() == null ? 0 : current.getComponentJson().path("componentRevision").asInt(0); + if (revision.intValue() != expected) { + throw new BizException(409, "COMPONENT_REVISION_CONFLICT", "组件已修改,请刷新后保存"); } - ComponentAsset asset = new ComponentAsset(); - asset.setComponentId(component.getId()); - asset.setObjectKey(objectKey.trim()); - int separator = objectKey.lastIndexOf('/'); - asset.setRelativePath(separator >= 0 ? objectKey.substring(separator + 1) : objectKey); - asset.setAssetKind(assetKind); - asset.setIsPrimary(primary); - asset.setSize(0L); - componentAssetMapper.insert(asset); } } diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentUploadSupport.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentUploadSupport.java index 255171b..2d7f959 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentUploadSupport.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentUploadSupport.java @@ -11,7 +11,9 @@ import java.time.Duration; import java.time.LocalDate; import java.time.format.DateTimeFormatter; import java.util.List; +import java.util.Map; import java.util.UUID; +import com.linkerbot.cadworld.service.support.UploadLimits; import lombok.RequiredArgsConstructor; import org.springframework.http.HttpStatus; import org.springframework.stereotype.Component; @@ -20,6 +22,7 @@ import org.springframework.util.StringUtils; @Component @RequiredArgsConstructor public class ComponentUploadSupport { + public static final String UPLOAD_TOKEN_HEADER = "X-Upload-Session-Token"; private final StorageProperties storageProperties; private final ObjectStorageClient objectStorageClient; @@ -96,8 +99,10 @@ public class ComponentUploadSupport { userId, uploadSessionToken, expectedType, invalidCode); String objectKey = resolveObjectKey(claims.keyPrefix(), objectPath); return new PreparedObjectUpload( - objectStorageClient.createUploadUrl(objectKey, contentType, resolveUploadSessionTtl()), - objectKey + objectStorageClient.createUploadUrl(objectKey, contentType, + Duration.between(java.time.Instant.now(), claims.expiresAt())), + objectKey, + Map.of(UPLOAD_TOKEN_HEADER, uploadSessionToken) ); } @@ -125,18 +130,32 @@ public class ComponentUploadSupport { } public void uploadObject(Long userId, + String uploadSessionToken, String objectKey, String contentType, InputStream inputStream, long contentLength) { + var claims = requireActualUploadSession(userId, uploadSessionToken); String normalizedKey = normalizeObjectKey(objectKey); + validateSessionObjectKey(claims.keyPrefix(), normalizedKey); String userSegment = "/" + userId + "/"; String urdfPrefix = normalizeConfiguredPrefix(storageProperties.urdfPrefix(), "components/urdf") + userSegment; String coverPrefix = normalizeConfiguredPrefix(storageProperties.coverImagePrefix(), "components/cover-images") + userSegment; if (!normalizedKey.startsWith(urdfPrefix) && !normalizedKey.startsWith(coverPrefix)) { throw invalidUploadObject("无权上传到该对象路径"); } - objectStorageClient.putObject(normalizedKey, contentType, inputStream, contentLength); + UploadLimits.checkLength(contentLength, storageProperties.maxUploadBytes()); + objectStorageClient.putObject(normalizedKey, contentType, + UploadLimits.bounded(inputStream, storageProperties.maxUploadBytes()), contentLength); + } + + private ComponentUploadSessionTokenProvider.UploadSessionClaims requireActualUploadSession(Long userId, String token) { + try { + var claims = componentUploadSessionTokenProvider.parseToken(token); + return requireUploadSession(userId, token, claims.uploadType(), "INVALID_COMPONENT_UPLOAD_SESSION"); + } catch (JwtException | IllegalArgumentException exception) { + throw invalidUploadSession("INVALID_COMPONENT_UPLOAD_SESSION", "上传会话无效或已过期"); + } } private BizException invalidUploadSession(String code, String message) { @@ -204,7 +223,8 @@ public class ComponentUploadSupport { public record PreparedObjectUpload( String uploadUrl, - String objectKey + String objectKey, + Map uploadHeaders ) { } } diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentUrdfUploadServiceImpl.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentUrdfUploadServiceImpl.java index 720e746..ed74c4c 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentUrdfUploadServiceImpl.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/ComponentUrdfUploadServiceImpl.java @@ -49,7 +49,7 @@ public class ComponentUrdfUploadServiceImpl implements ComponentUrdfUploadServic request.objectPath(), request.contentType() ); - return new PrepareObjectUploadUrlResponse(upload.uploadUrl(), upload.objectKey()); + return new PrepareObjectUploadUrlResponse(upload.uploadUrl(), upload.objectKey(), upload.uploadHeaders()); } @Override diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/InterfaceDefinitionServiceImpl.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/InterfaceDefinitionServiceImpl.java index 7005475..3b5441f 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/InterfaceDefinitionServiceImpl.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/InterfaceDefinitionServiceImpl.java @@ -1,11 +1,13 @@ package com.linkerbot.cadworld.service.impl; import static com.linkerbot.cadworld.mechanicalinterface.InterfaceGeometry.*; + import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.ObjectNode; import com.linkerbot.cadworld.common.exception.BizException; +import com.linkerbot.cadworld.dto.interfaces.SaveInterfaceDefinitionRequest; import com.linkerbot.cadworld.entity.InterfaceDefinitionEntity; import com.linkerbot.cadworld.entity.InterfaceDefinitionRevisionEntity; import com.linkerbot.cadworld.mapper.InterfaceDefinitionMapper; @@ -14,87 +16,213 @@ import com.linkerbot.cadworld.mechanicalinterface.MechanicalInterfaceSolver; import com.linkerbot.cadworld.service.InterfaceDefinitionService; import java.util.List; import lombok.RequiredArgsConstructor; +import org.springframework.dao.DuplicateKeyException; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; +import org.springframework.util.StringUtils; -@Service @RequiredArgsConstructor +@Service +@RequiredArgsConstructor public class InterfaceDefinitionServiceImpl implements InterfaceDefinitionService { private final InterfaceDefinitionMapper definitionMapper; private final InterfaceDefinitionRevisionMapper revisionMapper; private final ObjectMapper objectMapper; private final MechanicalInterfaceSolver solver; + @Override public List list(String keyword) { - LambdaQueryWrapper query=new LambdaQueryWrapper<>(); - if(keyword!=null&&!keyword.isBlank())query.and(w->w.like(InterfaceDefinitionEntity::getName,keyword).or().like(InterfaceDefinitionEntity::getDescription,keyword)); - return definitionMapper.selectList(query.orderByDesc(InterfaceDefinitionEntity::getUpdatedAt)).stream().map(this::toJson).toList(); - } - public JsonNode get(String id){return toJson(require(id));} - @Transactional public JsonNode create(JsonNode request){ - String id=required(request,"id"); - if(definitionMapper.selectById(id)!=null||revisionMapper.selectById(id+":1")!=null)throw invalid("接口 ID 已存在或已归档"); - return save(new InterfaceDefinitionEntity(),request,id,false); - } - @Transactional public JsonNode update(String id,JsonNode request){ - InterfaceDefinitionEntity entity=definitionMapper.selectOne(new LambdaQueryWrapper().eq(InterfaceDefinitionEntity::getId,id).last("FOR UPDATE")); - if(entity==null)throw invalid("接口不存在"); - if(request.path("geometryRevision").asInt()!=entity.getGeometryRevision())throw invalid("接口已修改,请刷新后保存"); - return save(entity,request,id,true); - } - private JsonNode save(InterfaceDefinitionEntity entity,JsonNode request,String id,boolean existing){ - rejectLegacy(request); - MountGeometry geometry=objectMapper.convertValue(request.get("geometry"),MountGeometry.class); - Tolerances tolerances=objectMapper.convertValue(request.get("tolerances"),Tolerances.class); - int revision=existing?entity.getGeometryRevision()+1:1; - List connectableTargets=targets(request.get("connectableTargets")); - Definition definition=new Definition(id,revision,required(request,"name"),geometry,tolerances,connectableTargets, - objectMapper.convertValue(request.get("displayForward"),double[].class)); - solver.validateDefinition(definition); - JsonNode normalizedGeometry=objectMapper.valueToTree(solver.normalize(geometry,tolerances)); - boolean displayOnly=existing && normalizedGeometry.equals(entity.getGeometryJson()) - && objectMapper.valueToTree(tolerances).equals(entity.getTolerancesJson()) - && definition.name().equals(entity.getName()) - && request.path("description").asText("").equals(entity.getDescription()==null?"":entity.getDescription()) - && connectableTargets.equals(targets(entity.getConnectableTargetsJson())) - && (request.path("sourceGeometryHash").asText("").isBlank() - || request.path("sourceGeometryHash").asText().equals(entity.getSourceGeometryHash())); - if(displayOnly)revision=entity.getGeometryRevision(); - entity.setDisplayForwardJson(objectMapper.valueToTree(solver.displayForward(definition))); - entity.setId(id);entity.setName(definition.name());entity.setDescription(request.path("description").asText("")); - entity.setGeometryRevision(revision);entity.setGeometryJson(objectMapper.valueToTree(solver.normalize(geometry,tolerances))); - entity.setTolerancesJson(objectMapper.valueToTree(tolerances)); - entity.setConnectableTargetsJson(objectMapper.valueToTree(connectableTargets)); - String sourceHash=request.path("sourceGeometryHash").asText(""); - if(!sourceHash.isBlank() && !sourceHash.equals(entity.getSourceGeometryHash()) && !("sha256:"+sourceHash).equals(entity.getSourceGeometryHash())) { - entity.setSourceAssetKey("");entity.setSourceGeometryHash(""); + var query = new LambdaQueryWrapper(); + if (StringUtils.hasText(keyword)) { + query.and(matches -> matches.like(InterfaceDefinitionEntity::getName, keyword) + .or().like(InterfaceDefinitionEntity::getDescription, keyword)); } - if(existing)definitionMapper.updateById(entity);else definitionMapper.insert(entity); - InterfaceDefinitionRevisionEntity snapshot=new InterfaceDefinitionRevisionEntity(); - snapshot.setId(id+":"+revision);snapshot.setDefinitionId(id);snapshot.setGeometryRevision(revision);snapshot.setDefinitionJson(toJson(entity, connectableTargets)); - if(displayOnly)revisionMapper.updateById(snapshot);else revisionMapper.insert(snapshot); + return definitionMapper.selectList(query.orderByDesc(InterfaceDefinitionEntity::getUpdatedAt)) + .stream().map(this::toJson).toList(); + } + + @Override + public JsonNode get(String id) { + return toJson(require(id, false)); + } + + @Override + @Transactional + public JsonNode create(SaveInterfaceDefinitionRequest request) { + if (!StringUtils.hasText(request.id())) { + throw invalid("id 不能为空"); + } + String id = request.id().trim(); + if (definitionMapper.selectById(id) != null || revisionMapper.selectById(id + ":1") != null) { + throw new BizException(409, "INTERFACE_ID_DUPLICATE", "接口 ID 已存在或已归档"); + } + try { + return save(new InterfaceDefinitionEntity(), request, id, false); + } catch (DuplicateKeyException exception) { + throw new BizException(409, "INTERFACE_ID_DUPLICATE", "接口 ID 已存在或已归档"); + } + } + + @Override + @Transactional + public JsonNode update(String id, SaveInterfaceDefinitionRequest request) { + InterfaceDefinitionEntity entity = require(id, true); + if (request.id() != null && !id.equals(request.id())) { + throw invalid("URL 与接口定义 ID 不一致"); + } + if (request.editRevision() == null || request.geometryRevision() == null) { + throw invalid("修改接口必须提供 editRevision 和 geometryRevision"); + } + if (!request.editRevision().equals(entity.getEditRevision()) + || !request.geometryRevision().equals(entity.getGeometryRevision())) { + throw new BizException(409, "INTERFACE_REVISION_CONFLICT", "接口已修改,请刷新后保存"); + } + return save(entity, request, id, true); + } + + private JsonNode save(InterfaceDefinitionEntity entity, SaveInterfaceDefinitionRequest request, + String id, boolean existing) { + Definition proposed = new Definition(id, existing ? entity.getGeometryRevision() : 1, + request.name().trim(), request.geometry(), request.tolerances(), + request.connectableTargets(), request.displayForward()); + solver.validateDefinition(proposed); + JsonNode geometry = objectMapper.valueToTree(solver.normalize(request.geometry(), request.tolerances())); + JsonNode tolerances = objectMapper.valueToTree(request.tolerances()); + boolean sourceChanged = existing && StringUtils.hasText(request.sourceGeometryHash()) + && !normalizeHash(request.sourceGeometryHash()).equals(normalizeHash(entity.getSourceGeometryHash())); + boolean geometryChanged = existing && (sourceChanged || !geometry.equals(entity.getGeometryJson()) + || !tolerances.equals(entity.getTolerancesJson())); + int geometryRevision = existing + ? (geometryChanged ? Math.incrementExact(entity.getGeometryRevision()) : entity.getGeometryRevision()) + : 1; + long editRevision = existing ? Math.incrementExact(entity.getEditRevision()) : 1L; + + entity.setId(id); + entity.setName(proposed.name()); + entity.setDescription(request.description() == null ? "" : request.description()); + entity.setGeometryRevision(geometryRevision); + entity.setEditRevision(editRevision); + entity.setGeometryJson(geometry); + entity.setTolerancesJson(tolerances); + entity.setConnectableTargetsJson(objectMapper.valueToTree(request.connectableTargets())); + entity.setDisplayForwardJson(objectMapper.valueToTree(solver.displayForward(proposed))); + // Source bindings are established by server-side file hashing only. + if (sourceChanged) { + entity.setSourceAssetKey(""); + entity.setSourceGeometryHash(""); + } + if (existing) { + if (definitionMapper.updateById(entity) != 1) { + throw new BizException(409, "INTERFACE_REVISION_CONFLICT", "接口已删除,请刷新后保存"); + } + } else { + definitionMapper.insert(entity); + } + saveSnapshot(entity, !existing || geometryChanged); return toJson(entity); } - public Definition geometryDefinition(String id,int revision){ - InterfaceDefinitionRevisionEntity entity=revisionMapper.selectById(id+":"+revision); - if(entity==null)throw invalid("接口几何修订不存在,请重新识别"); - JsonNode n=entity.getDefinitionJson(); - return new Definition(id,revision,n.path("name").asText(),objectMapper.convertValue(n.get("geometry"),MountGeometry.class),objectMapper.convertValue(n.get("tolerances"),Tolerances.class),targets(n.get("connectableTargets")),objectMapper.convertValue(n.get("displayForward"),double[].class)); + + @Override + public Definition geometryDefinition(String id, int revision) { + InterfaceDefinitionRevisionEntity snapshot = revisionMapper.selectById(id + ":" + revision); + if (snapshot == null) { + throw invalid("接口几何修订不存在,请重新识别"); + } + JsonNode json = snapshot.getDefinitionJson(); + return new Definition(id, revision, json.path("name").asText(), + objectMapper.convertValue(json.get("geometry"), MountGeometry.class), + objectMapper.convertValue(json.get("tolerances"), Tolerances.class), + targets(json.get("connectableTargets")), + objectMapper.convertValue(json.get("displayForward"), double[].class)); } - @Transactional public void delete(String id){require(id);definitionMapper.deleteById(id);} - @Transactional public void attachAsset(String id,int revision,String key,String hash){ - InterfaceDefinitionEntity e=definitionMapper.selectOne(new LambdaQueryWrapper().eq(InterfaceDefinitionEntity::getId,id).last("FOR UPDATE")); - if(e==null||e.getGeometryRevision()!=revision)throw invalid("接口已修订,请刷新后重新保存源文件"); - if(e.getSourceGeometryHash()!=null && !e.getSourceGeometryHash().isBlank() && !hash.equals(e.getSourceGeometryHash()))throw invalid("该修订已有源文件,请创建新几何修订"); - e.setSourceAssetKey(key);e.setSourceGeometryHash(hash);definitionMapper.updateById(e); - InterfaceDefinitionRevisionEntity snapshot=revisionMapper.selectById(id+":"+revision); - if(snapshot==null)throw invalid("接口修订不存在"); - snapshot.setDefinitionJson(toJson(e));revisionMapper.updateById(snapshot); + + @Override + @Transactional + public void delete(String id) { + require(id, true); + definitionMapper.deleteById(id); + } + + @Override + @Transactional + public void attachAsset(String id, int revision, String key, String hash, String expectedAssetKey) { + InterfaceDefinitionEntity entity = require(id, true); + if (entity.getGeometryRevision() != revision) { + throw new BizException(409, "INTERFACE_REVISION_CONFLICT", "接口已修订,请刷新后重新保存源文件"); + } + if (StringUtils.hasText(entity.getSourceGeometryHash()) && !hash.equals(entity.getSourceGeometryHash())) { + throw invalid("该修订已有源文件,请创建新几何修订"); + } + if (key.equals(entity.getSourceAssetKey()) && hash.equals(entity.getSourceGeometryHash())) { + return; + } + String boundKey = entity.getSourceAssetKey() == null ? "" : entity.getSourceAssetKey(); + if (!boundKey.equals(expectedAssetKey)) { + throw new BizException(409, "INTERFACE_REVISION_CONFLICT", "源文件绑定已变化,请刷新后重试"); + } + entity.setSourceAssetKey(key); + entity.setSourceGeometryHash(hash); + entity.setEditRevision(Math.incrementExact(entity.getEditRevision())); + if (definitionMapper.updateById(entity) != 1) { + throw new BizException(409, "INTERFACE_REVISION_CONFLICT", "接口已删除,请刷新后重试"); + } + saveSnapshot(entity, false); + } + + private void saveSnapshot(InterfaceDefinitionEntity entity, boolean insert) { + var snapshot = new InterfaceDefinitionRevisionEntity(); + snapshot.setId(entity.getId() + ":" + entity.getGeometryRevision()); + snapshot.setDefinitionId(entity.getId()); + snapshot.setGeometryRevision(entity.getGeometryRevision()); + snapshot.setDefinitionJson(toJson(entity)); + if (insert) { + revisionMapper.insert(snapshot); + } else if (revisionMapper.updateById(snapshot) != 1) { + throw new IllegalStateException("接口几何修订快照缺失"); + } + } + + private InterfaceDefinitionEntity require(String id, boolean lock) { + InterfaceDefinitionEntity entity = lock + ? definitionMapper.selectOne(new LambdaQueryWrapper() + .eq(InterfaceDefinitionEntity::getId, id).last("FOR UPDATE")) + : definitionMapper.selectById(id); + if (entity == null) { + throw new BizException(404, "INTERFACE_NOT_FOUND", "接口不存在"); + } + return entity; + } + + private JsonNode toJson(InterfaceDefinitionEntity entity) { + ObjectNode json = objectMapper.createObjectNode(); + json.put("id", entity.getId()); + json.put("name", entity.getName()); + json.put("description", entity.getDescription()); + json.put("geometryRevision", entity.getGeometryRevision()); + json.put("editRevision", entity.getEditRevision()); + json.set("geometry", entity.getGeometryJson()); + json.set("displayForward", entity.getDisplayForwardJson()); + json.set("tolerances", entity.getTolerancesJson()); + json.set("connectableTargets", entity.getConnectableTargetsJson()); + if (entity.getSourceAssetKey() != null) json.put("sourceAssetKey", entity.getSourceAssetKey()); + if (entity.getSourceGeometryHash() != null) json.put("sourceGeometryHash", entity.getSourceGeometryHash()); + return json; + } + + private List targets(JsonNode value) { + if (value == null || value.isNull()) return List.of(); + try { + return objectMapper.readerForListOf(String.class).readValue(value); + } catch (java.io.IOException exception) { + throw new IllegalStateException("接口连接目标存储格式不合法", exception); + } + } + + private String normalizeHash(String hash) { + String value = hash == null ? "" : hash.trim(); + return value.startsWith("sha256:") ? value.substring(7) : value; + } + + private BizException invalid(String message) { + return new BizException(422, "INVALID_INTERFACE", message); } - private InterfaceDefinitionEntity require(String id){InterfaceDefinitionEntity e=definitionMapper.selectById(id);if(e==null)throw invalid("接口不存在");return e;} - private JsonNode toJson(InterfaceDefinitionEntity e){return toJson(e, targets(e.getConnectableTargetsJson()));} -private JsonNode toJson(InterfaceDefinitionEntity e,List connectableTargets){ObjectNode n=objectMapper.createObjectNode();n.put("id",e.getId());n.put("name",e.getName());n.put("description",e.getDescription());n.put("geometryRevision",e.getGeometryRevision());n.set("geometry",e.getGeometryJson());n.set("displayForward",e.getDisplayForwardJson());n.set("tolerances",e.getTolerancesJson());n.set("connectableTargets",objectMapper.valueToTree(connectableTargets));if(e.getSourceAssetKey()!=null)n.put("sourceAssetKey",e.getSourceAssetKey());if(e.getSourceGeometryHash()!=null)n.put("sourceGeometryHash",e.getSourceGeometryHash());return n;} - private List targets(JsonNode value){if(value==null||value.isNull()||!value.isArray())return List.of();List result=new java.util.ArrayList<>();value.forEach(item->{String target=item.asText("").trim();if(!target.isEmpty()&&!result.contains(target))result.add(target);});return List.copyOf(result);} - private String required(JsonNode n,String key){String s=n.path(key).asText("").trim();if(s.isEmpty())throw invalid(key+" 不能为空");return s;} - private void rejectLegacy(JsonNode n){for(String key:List.of("profiles","mateRules","frameInComponent","allowedClockingDeg","xAxisAngleDeg"))if(n.has(key))throw invalid("不支持的接口结构:"+key);} - private BizException invalid(String message){return new BizException(422,"INVALID_INTERFACE",message);} } diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/support/ComponentUploadSessionTokenProvider.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/support/ComponentUploadSessionTokenProvider.java index 96616b1..c263b8f 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/support/ComponentUploadSessionTokenProvider.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/support/ComponentUploadSessionTokenProvider.java @@ -52,6 +52,7 @@ public class ComponentUploadSessionTokenProvider { private Claims parseClaims(String token) { return Jwts.parser() .verifyWith(secretKey) + .requireIssuer(properties.issuer()) .build() .parseSignedClaims(token) .getPayload(); diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/support/UploadLimits.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/support/UploadLimits.java new file mode 100644 index 0000000..01381b2 --- /dev/null +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/support/UploadLimits.java @@ -0,0 +1,78 @@ +package com.linkerbot.cadworld.service.support; + +import com.linkerbot.cadworld.common.exception.BizException; +import java.io.FilterInputStream; +import java.io.IOException; +import java.io.InputStream; + +public final class UploadLimits { + private UploadLimits() { } + + public static void checkLength(long length, long limit) { + if (limit <= 0) throw new BizException(500, "STORAGE_CONFIG_ERROR", "上传大小限制配置非法"); + if (length > limit) throw tooLarge(); + } + + public static InputStream bounded(InputStream input, long limit) { + checkLength(0, limit); + return new FilterInputStream(input) { + private long count; + + @Override + public int read() throws IOException { + int value = in.read(); + if (value >= 0) checkLength(++count, limit); + return value; + } + + @Override + public int read(byte[] bytes, int offset, int length) throws IOException { + int read = in.read(bytes, offset, (int) Math.min(length, remainingIncludingProbe())); + if (read > 0) { + count += read; + checkLength(count, limit); + } + return read; + } + + @Override + public long skip(long length) throws IOException { + if (length <= 0) return 0; + long skipped = in.skip(Math.min(length, remainingIncludingProbe())); + count += skipped; + checkLength(count, limit); + return skipped; + } + + private long remainingIncludingProbe() { + long remaining = limit - count; + return remaining == Long.MAX_VALUE ? Long.MAX_VALUE : remaining + 1; + } + + @Override + public boolean markSupported() { + return false; + } + + @Override + public synchronized void mark(int readLimit) { + // Rewinding would make the byte limit ambiguous; this stream is forward-only. + } + + @Override + public synchronized void reset() throws IOException { + throw new IOException("Bounded upload streams do not support reset"); + } + }; + } + + public static void rethrowIfExceeded(Throwable exception) { + for (Throwable cause = exception; cause != null; cause = cause.getCause()) { + if (cause instanceof BizException failure && "UPLOAD_TOO_LARGE".equals(failure.getCode())) throw failure; + } + } + + private static BizException tooLarge() { + return new BizException(413, "UPLOAD_TOO_LARGE", "上传文件超过大小限制"); + } +} diff --git a/cadworld-service/src/test/java/com/linkerbot/cadworld/service/InterfaceAssetServiceTest.java b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/InterfaceAssetServiceTest.java new file mode 100644 index 0000000..5c68968 --- /dev/null +++ b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/InterfaceAssetServiceTest.java @@ -0,0 +1,71 @@ +package com.linkerbot.cadworld.service; + +import static org.assertj.core.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.linkerbot.cadworld.common.exception.BizException; +import com.linkerbot.cadworld.config.StorageProperties; +import com.linkerbot.cadworld.service.client.ObjectStorageClient; +import java.io.InputStream; +import java.time.Duration; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.springframework.mock.web.MockMultipartFile; + +class InterfaceAssetServiceTest { + final InterfaceDefinitionService definitions = mock(InterfaceDefinitionService.class); + final ObjectStorageClient storage = mock(ObjectStorageClient.class); + final InterfaceAssetService service = new InterfaceAssetService(definitions, storage, + new StorageProperties("local", "models", "covers", "http://localhost", "http://localhost", ".", Duration.ofMinutes(30), 16)); + + @BeforeEach + void currentDefinition() { + when(definitions.get("mount")).thenReturn(new ObjectMapper().createObjectNode().put("geometryRevision", 1)); + } + + @Test + void hashesFromStreamAndNeverLoadsMultipartBytes() throws Exception { + var file = spy(new MockMultipartFile("file", "source.step", "application/octet-stream", new byte[]{1, 2, 3})); + doThrow(new AssertionError("getBytes must not be used")).when(file).getBytes(); + String key = service.upload("mount", 1, file); + assertThat(key).startsWith("interfaces/6d6f756e74/1/").endsWith("/source.step"); + verify(file, never()).getBytes(); + verify(definitions).attachAsset(eq("mount"), eq(1), eq(key), startsWith("sha256:"), eq("")); + verify(storage, never()).deleteObject(anyString()); + } + + @Test + void bindingFailureDeletesOnlyTheObjectOwnedByThisRequest() { + var conflict = new BizException(409, "INTERFACE_REVISION_CONFLICT", "接口已修订"); + doThrow(conflict).when(definitions).attachAsset(anyString(), anyInt(), anyString(), anyString(), anyString()); + assertThatThrownBy(() -> service.upload("mount", 1, + new MockMultipartFile("file", "source.step", "application/octet-stream", new byte[]{1}))) + .isSameAs(conflict); + var key = ArgumentCaptor.forClass(String.class); + verify(storage).putObject(key.capture(), anyString(), any(InputStream.class), eq(1L)); + verify(storage).deleteObject(key.getValue()); + } + + @Test + void compensationFailureDoesNotReplaceOriginalBusinessFailure() { + var conflict = new BizException(409, "CONFLICT", "接口已修订"); + doThrow(conflict).when(definitions).attachAsset(anyString(), anyInt(), anyString(), anyString(), anyString()); + doThrow(new IllegalStateException("storage unavailable")).when(storage).deleteObject(anyString()); + assertThatThrownBy(() -> service.upload("mount", 1, + new MockMultipartFile("file", "source.step", "application/octet-stream", new byte[]{1}))) + .isSameAs(conflict); + } + + @Test + void staleRevisionAndOversizeFilesFailBeforeStorageWrites() { + var file = new MockMultipartFile("file", "source.step", "application/octet-stream", new byte[17]); + assertThatThrownBy(() -> service.upload("mount", 2, file)).isInstanceOf(BizException.class) + .extracting("httpStatus").isEqualTo(409); + assertThatThrownBy(() -> service.upload("mount", 1, file)).isInstanceOf(BizException.class) + .extracting("httpStatus").isEqualTo(413); + verifyNoInteractions(storage); + } +} diff --git a/cadworld-service/src/test/java/com/linkerbot/cadworld/service/UploadIntegrityTest.java b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/UploadIntegrityTest.java new file mode 100644 index 0000000..f1f29b0 --- /dev/null +++ b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/UploadIntegrityTest.java @@ -0,0 +1,49 @@ +package com.linkerbot.cadworld.service; + +import static org.assertj.core.api.Assertions.*; + +import com.linkerbot.cadworld.common.exception.BizException; +import com.linkerbot.cadworld.config.StorageProperties; +import com.linkerbot.cadworld.config.UploadSessionProperties; +import com.linkerbot.cadworld.enums.ComponentUploadType; +import com.linkerbot.cadworld.service.client.LocalObjectStorageClient; +import com.linkerbot.cadworld.service.impl.ComponentUploadSupport; +import com.linkerbot.cadworld.service.support.ComponentUploadSessionTokenProvider; +import java.io.ByteArrayInputStream; +import java.nio.file.Path; +import java.time.Duration; +import java.time.Instant; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +class UploadIntegrityTest { + @TempDir Path root; + final String secret = "test-upload-signing-key-32-bytes-long"; + + @Test + void unknownLengthUploadIsBoundedAndCannotDestroyExistingObject() throws Exception { + var properties = new StorageProperties("local", "components/urdf", "components/cover-images", "http://localhost", + "http://localhost", root.toString(), Duration.ofMinutes(30), 8); + var storage = new LocalObjectStorageClient(properties); + var tokens = new ComponentUploadSessionTokenProvider(new UploadSessionProperties("upload", secret)); + var support = new ComponentUploadSupport(properties, storage, tokens); + String prefix = "components/urdf/0/session/"; + String key = prefix + "model.rfs"; + String token = tokens.generateToken(0L, ComponentUploadType.URDF, prefix, Instant.now().plusSeconds(60)); + support.uploadObject(0L, token, key, "application/octet-stream", new ByteArrayInputStream(new byte[]{1, 2}), -1); + assertThatThrownBy(() -> support.uploadObject(0L, token, key, "application/octet-stream", new ByteArrayInputStream(new byte[9]), -1)) + .isInstanceOf(BizException.class).extracting("httpStatus").isEqualTo(413); + assertThat(java.nio.file.Files.readAllBytes(root.resolve(key))).containsExactly((byte) 1, (byte) 2); + try (var files = java.nio.file.Files.walk(root)) { + assertThat(files.filter(java.nio.file.Files::isRegularFile).count()).isEqualTo(1); + } + } + + @Test + void uploadTokenFromAnotherIssuerIsRejectedEvenWithTheSameSigningKey() { + var expected = new ComponentUploadSessionTokenProvider(new UploadSessionProperties("expected", secret)); + var other = new ComponentUploadSessionTokenProvider(new UploadSessionProperties("other", secret)); + String token = other.generateToken(0L, ComponentUploadType.URDF, "components/urdf/0/session/", Instant.now().plusSeconds(60)); + assertThatThrownBy(() -> expected.parseToken(token)).isInstanceOf(io.jsonwebtoken.JwtException.class); + } +} diff --git a/cadworld-service/src/test/java/com/linkerbot/cadworld/service/impl/ComponentServiceImplTest.java b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/impl/ComponentServiceImplTest.java index 1846dd8..d4d61cf 100644 --- a/cadworld-service/src/test/java/com/linkerbot/cadworld/service/impl/ComponentServiceImplTest.java +++ b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/impl/ComponentServiceImplTest.java @@ -38,7 +38,6 @@ class ComponentServiceImplTest { void setUp() { service = new ComponentServiceImpl( componentMapper, - null, objectStorageUrlResolver, new ObjectMapper(), new com.linkerbot.cadworld.mechanicalinterface.ComponentPortValidationService( MechanicalTestFixtures.definitions(),MechanicalTestFixtures.SOLVER,new ObjectMapper(), diff --git a/cadworld-service/src/test/java/com/linkerbot/cadworld/service/impl/InterfaceDefinitionRevisionTest.java b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/impl/InterfaceDefinitionRevisionTest.java index 7518a30..e60effd 100644 --- a/cadworld-service/src/test/java/com/linkerbot/cadworld/service/impl/InterfaceDefinitionRevisionTest.java +++ b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/impl/InterfaceDefinitionRevisionTest.java @@ -24,17 +24,19 @@ class InterfaceDefinitionRevisionTest { new Hole("b",new double[]{.02,0,0},new double[]{0,0,1},.004))); InterfaceDefinitionEntity current(){ InterfaceDefinitionEntity e=new InterfaceDefinitionEntity(); - e.setId("mount");e.setName("mount");e.setGeometryRevision(1); + e.setId("mount");e.setName("mount");e.setGeometryRevision(1);e.setEditRevision(1L); e.setGeometryJson(json.valueToTree(geometry));e.setTolerancesJson(json.valueToTree(Tolerances.defaults())); e.setSourceGeometryHash("sha256:old");e.setSourceAssetKey("interfaces/old.step"); - when(definitions.selectOne(any())).thenReturn(e);return e; + when(definitions.selectOne(any())).thenReturn(e); + when(definitions.updateById(any(InterfaceDefinitionEntity.class))).thenReturn(1); + when(revisions.updateById(any(InterfaceDefinitionRevisionEntity.class))).thenReturn(1);return e; } ObjectNode request(){ - ObjectNode n=json.createObjectNode().put("id","mount").put("name","updated").put("geometryRevision",1); + ObjectNode n=json.createObjectNode().put("id","mount").put("name","updated").put("geometryRevision",1).put("editRevision",1); n.set("geometry",json.valueToTree(geometry));n.set("tolerances",json.valueToTree(Tolerances.defaults()));return n; } @Test void editsAppendRevisionAndDoNotOverwriteOldSnapshot(){ - current();var result=service.update("mount",request()); + current();var result=service.update("mount",dto(changedGeometry())); assertThat(result.path("geometryRevision").asInt()).isEqualTo(2); assertThat(result.path("sourceAssetKey").asText()).isEqualTo("interfaces/old.step"); ArgumentCaptor capture=ArgumentCaptor.forClass(InterfaceDefinitionRevisionEntity.class); @@ -42,16 +44,16 @@ class InterfaceDefinitionRevisionTest { verify(revisions,never()).updateById(any(InterfaceDefinitionRevisionEntity.class)); } @Test void staleEditsAndAssetUploadsAreRejected(){ - current();assertThatThrownBy(()->service.update("mount",request().put("geometryRevision",2))).hasMessageContaining("刷新"); - assertThatThrownBy(()->service.attachAsset("mount",2,"other.step","sha256:new")).hasMessageContaining("修订"); - assertThatThrownBy(()->service.attachAsset("mount",1,"other.step","sha256:new")).hasMessageContaining("新几何修订"); + current();assertThatThrownBy(()->service.update("mount",dto(request().put("geometryRevision",2)))).hasMessageContaining("刷新"); + assertThatThrownBy(()->service.attachAsset("mount",2,"other.step","sha256:new","interfaces/old.step")).hasMessageContaining("修订"); + assertThatThrownBy(()->service.attachAsset("mount",1,"other.step","sha256:new","interfaces/old.step")).hasMessageContaining("新几何修订"); verify(definitions,never()).updateById(any(InterfaceDefinitionEntity.class)); } @Test void displayOnlyEditPersistsWithoutInvalidatingGeometryRevision(){ InterfaceDefinitionEntity e=current(); ObjectNode body=request().put("name",e.getName()); body.set("displayForward",json.valueToTree(new double[]{0,1,0})); - var result=service.update("mount",body); + var result=service.update("mount",dto(body)); assertThat(result.path("geometryRevision").asInt()).isEqualTo(1); assertThat(result.path("displayForward")).isEqualTo(body.path("displayForward")); ArgumentCaptor capture=ArgumentCaptor.forClass(InterfaceDefinitionRevisionEntity.class); @@ -60,13 +62,42 @@ class InterfaceDefinitionRevisionTest { assertThat(service.geometryDefinition("mount",1).displayForward()).containsExactly(0,1,0); } @Test void replacingSourceClearsOldAssetAndAttachesOnlyToNewRevision(){ - InterfaceDefinitionEntity e=current();var result=service.update("mount",request().put("sourceGeometryHash","new")); + InterfaceDefinitionEntity e=current();var result=service.update("mount",dto(request().put("sourceGeometryHash","new"))); assertThat(result.path("sourceAssetKey").asText()).isEmpty(); assertThat(e.getSourceGeometryHash()).isEmpty(); InterfaceDefinitionRevisionEntity snapshot=new InterfaceDefinitionRevisionEntity();snapshot.setId("mount:2"); - when(revisions.selectById("mount:2")).thenReturn(snapshot); - service.attachAsset("mount",2,"interfaces/new.step","sha256:new"); - assertThat(snapshot.getDefinitionJson().path("sourceAssetKey").asText()).isEqualTo("interfaces/new.step"); - assertThat(snapshot.getDefinitionJson().path("geometryRevision").asInt()).isEqualTo(2); + service.attachAsset("mount",2,"interfaces/new.step","sha256:new",""); + ArgumentCaptor capture=ArgumentCaptor.forClass(InterfaceDefinitionRevisionEntity.class); + verify(revisions).updateById(capture.capture()); + assertThat(capture.getValue().getDefinitionJson().path("sourceAssetKey").asText()).isEqualTo("interfaces/new.step"); + assertThat(capture.getValue().getDefinitionJson().path("geometryRevision").asInt()).isEqualTo(2); + } + ObjectNode changedGeometry() { + ObjectNode body = request(); + ((ObjectNode) body.path("geometry").path("holes").get(1)) + .set("pointOnPlaneM", json.valueToTree(new double[]{.03,0,0})); + return body; + } + com.linkerbot.cadworld.dto.interfaces.SaveInterfaceDefinitionRequest dto(ObjectNode body) { + return json.convertValue(body, com.linkerbot.cadworld.dto.interfaces.SaveInterfaceDefinitionRequest.class); + } + @Test void metadataEditsDoNotInvalidateGeometryButRejectStaleEditors() { + InterfaceDefinitionEntity entity = current(); + var result = service.update("mount", dto(request())); + assertThat(result.path("geometryRevision").asInt()).isEqualTo(1); + assertThat(result.path("editRevision").asLong()).isEqualTo(2); + assertThatThrownBy(() -> service.update("mount", dto(request()))) + .isInstanceOf(com.linkerbot.cadworld.common.exception.BizException.class) + .hasMessageContaining("刷新"); + assertThat(entity.getEditRevision()).isEqualTo(2L); + } + + @Test void concurrentUploadsCannotReplaceAnotherSuccessfulBinding() { + InterfaceDefinitionEntity entity = current(); + assertThatThrownBy(() -> service.attachAsset("mount", 1, "interfaces/loser.step", "sha256:old", "")) + .isInstanceOf(com.linkerbot.cadworld.common.exception.BizException.class) + .hasMessageContaining("绑定已变化"); + assertThat(entity.getSourceAssetKey()).isEqualTo("interfaces/old.step"); + verify(definitions, never()).updateById(any(InterfaceDefinitionEntity.class)); } }