component表的step_object_key、urdf_main_object_key、urdf_prefix不保存环境根目录

This commit is contained in:
lxp
2026-10-20 17:47:54 +08:00
parent a9a6ad6028
commit 5d94bc7871
14 changed files with 269 additions and 28 deletions
+1 -1
View File
@@ -74,7 +74,7 @@ mvn -f /path/to/cadworld/pom.xml -pl cadworld-api -am install
{环境根目录}/components/{组件编码}/urdf/{上传批次}/{相对路径}
```
数据库只保存对象键,不保存完整 URL。返回 URL 对每段路径编码,访问路径区分大小写;根目录不要填写 URL。跨环境、越界、非法路径会被拒绝。更改环境根目录后,原目录资源不能由该部署访问。
组件数据库中的文件键和目录前缀仅保存从 `components/` 开始的相对路径,不包含环境根目录或完整 URL;旧记录在再次成功保存时转换。上传授权、保存请求和详情响应仍使用带环境根目录的完整对象键,访问 URL 在响应时根据当前环境补全根目录并逐段编码。访问路径区分大小写;根目录不要填写 URL。跨环境上传、越界、非法路径会被拒绝。更改环境根目录不会移动 OSS 中的文件,新根目录须具备对应资源。
## 实例连接规则
+2
View File
@@ -185,6 +185,8 @@ PUT 是全量表单更新,前端应提交完整表单,每次都必须提交
后端根据实际对象生成 `urdfPrefix`、`urdfMainObjectKey` 和 `urdfFiles`,清单保留请求顺序,元素为 `relativePath` 和 `sizeBytes`。无需提交这些数据库维护字段。
数据库中的 `step_object_key`、`urdf_main_object_key`、`urdf_prefix` 仅保存从 `components/` 开始的相对路径,不包含 `app.storage.root-prefix` 环境根目录;目录前缀保留末尾 `/`。上传授权、保存请求和详情响应中的对象键仍包含环境根目录,访问 URL 根据当前环境配置生成,前端用法不变。兼容读取带当前环境根目录的旧记录,组件再次成功保存时统一转换这三个字段(仅修改业务信息也会转换),读取不会修改数据库,无需批量更新旧数据。
检查全部通过才写数据库。失败不切换原资源引用。旧批次、上传后未保存及删除组件后的文件暂不自动清理。校验覆盖清单的结构和对象存在性,不解析 URDF XML 内部的依赖引用。
### 4.3 旋转轴字段部署
@@ -363,6 +363,72 @@ class AdminApiTest {
assertThat(count("component")).isEqualTo(3);
}
@Test
void legacyStoragePathsAreReadWithoutWritesAndConvertedOnlyAfterSuccessfulSave() throws Exception {
JsonNode created = create(uploaded());
long id = created.path("id").asLong();
jdbc.update("UPDATE component SET step_object_key=?,urdf_prefix=?,urdf_main_object_key=? WHERE id=?",
created.path("stepObjectKey").asText(), created.path("urdfPrefix").asText(),
created.path("urdfMainObjectKey").asText(), id);
Map<String, Object> legacy = storedComponentPaths(id);
JsonNode queried = data(mvc.perform(get("/admin-api/components/{id}", id))
.andExpect(status().isOk()).andReturn());
assertThat(queried).isEqualTo(created);
mvc.perform(get("/admin-api/components").param("keyword", created.path("componentCode").asText()))
.andExpect(status().isOk())
.andExpect(jsonPath("$.data.items[0].stepUrl").value(created.path("stepUrl").asText()))
.andExpect(jsonPath("$.data.items[0].urdfUrl").value(created.path("urdfUrl").asText()));
assertThat(storedComponentPaths(id)).isEqualTo(legacy);
expectUpdateError(id, update(2), 409, "COMPONENT_REVISION_CONFLICT");
JsonNode session = sign(Map.of("componentId", id));
Map<String, Object> missingUpload = update(1);
missingUpload.put("uploadSessionToken", session.path("uploadSessionToken").asText());
missingUpload.put("stepObjectKey", session.path("step").path("keyPrefix").asText() + "missing.step");
expectUpdateError(id, missingUpload, 422, "COMPONENT_UPLOAD_OBJECT_MISSING");
assertThat(storedComponentPaths(id)).isEqualTo(legacy);
JsonNode changed = data(mvc.perform(put("/admin-api/components/{id}", id)
.contentType(MediaType.APPLICATION_JSON).content(json.writeValueAsString(update(1))))
.andExpect(status().isOk()).andReturn());
assertRelativeComponentPaths(changed);
assertThat(changed.path("version").asLong()).isEqualTo(2);
for (String field : List.of("stepObjectKey", "urdfPrefix", "urdfMainObjectKey", "stepUrl", "urdfUrl", "urdfBaseUrl", "urdfFiles")) {
assertThat(changed.get(field)).as(field).isEqualTo(created.get(field));
}
JsonNode savedAgain = data(mvc.perform(put("/admin-api/components/{id}", id)
.contentType(MediaType.APPLICATION_JSON).content(json.writeValueAsString(update(2))))
.andExpect(status().isOk()).andReturn());
assertRelativeComponentPaths(savedAgain);
assertThat(savedAgain.path("stepUrl")).isEqualTo(created.path("stepUrl"));
}
@Test
void storesNestedUrdfRelativePathsAndReturnsEncodedDownloadableUrls() throws Exception {
JsonNode session = sign(Map.of());
String step = session.path("step").path("keyPrefix").asText() + "模型 one.STEP";
String main = session.path("urdf").path("keyPrefix").asText() + "urdf/机器人 one.urdf";
String mesh = session.path("urdf").path("keyPrefix").asText() + "meshes/底座 one.stl";
storage.simulateDirectUpload(step, "application/octet-stream", new byte[]{1, 2});
storage.simulateDirectUpload(main, "application/xml", new byte[]{3});
storage.simulateDirectUpload(mesh, "application/octet-stream", new byte[]{4});
JsonNode created = create(Map.of("uploadSessionToken", session.path("uploadSessionToken").asText(),
"stepObjectKey", step, "urdfObjectKeys", List.of(main, mesh)));
assertThat(created.path("stepObjectKey").asText()).isEqualTo(step);
assertThat(created.path("urdfMainObjectKey").asText()).isEqualTo(main);
assertThat(created.path("stepUrl").asText()).contains("/cadworld_dev/components/").endsWith("%E6%A8%A1%E5%9E%8B%20one.STEP");
assertThat(created.path("urdfFiles").get(0).path("relativePath").asText()).isEqualTo("urdf/机器人 one.urdf");
assertThat(created.path("urdfUrl").asText()).contains("/urdf/").endsWith("%E6%9C%BA%E5%99%A8%E4%BA%BA%20one.urdf");
mvc.perform(get(java.net.URI.create(created.path("stepUrl").asText())))
.andExpect(status().isOk()).andExpect(content().bytes(new byte[]{1, 2}));
mvc.perform(get(java.net.URI.create(created.path("urdfUrl").asText())))
.andExpect(status().isOk()).andExpect(content().bytes(new byte[]{3}));
mvc.perform(get("/admin-api/components").param("keyword", created.path("componentCode").asText()))
.andExpect(status().isOk())
.andExpect(jsonPath("$.data.items[0].stepUrl").value(created.path("stepUrl").asText()))
.andExpect(jsonPath("$.data.items[0].urdfUrl").value(created.path("urdfUrl").asText()));
}
@Test
void stepAndUploadSessionRemainRequiredWhenOtherFieldsAreOmitted() throws Exception {
JsonNode session = sign(Map.of());
@@ -509,12 +575,13 @@ class AdminApiTest {
form.put("stepObjectKey", newKey);
expectUpdateError(id, form, 422, "COMPONENT_UPLOAD_OBJECT_MISSING");
assertThat(jdbc.queryForObject("SELECT step_object_key FROM component WHERE id=?",String.class,id))
.isEqualTo(created.path("stepObjectKey").asText());
.isEqualTo(created.path("stepObjectKey").asText().substring("cadworld_dev/".length()));
storage.simulateDirectUpload(newKey,"application/octet-stream",new byte[]{4,5});
JsonNode changed = data(mvc.perform(put("/admin-api/components/{id}",id).contentType(MediaType.APPLICATION_JSON)
.content(json.writeValueAsString(form))).andExpect(status().isOk()).andReturn());
assertThat(changed.path("stepObjectKey").asText()).isEqualTo(newKey);
assertThat(changed.path("urdfMainObjectKey")).isEqualTo(created.path("urdfMainObjectKey"));
assertRelativeComponentPaths(changed);
assertThat(storage.objectExists(created.path("stepObjectKey").asText())).isTrue();
Map<String,Object> another = uploaded();
form.put("version",2);
@@ -537,13 +604,14 @@ class AdminApiTest {
storage.simulateDirectUpload(main, "application/xml", new byte[]{1});
expectUpdateError(id, form, 422, "COMPONENT_UPLOAD_OBJECT_MISSING");
assertThat(jdbc.queryForObject("SELECT urdf_prefix FROM component WHERE id=?", String.class, id))
.isEqualTo(created.path("urdfPrefix").asText());
.isEqualTo(created.path("urdfPrefix").asText().substring("cadworld_dev/".length()));
storage.simulateDirectUpload(mesh, "application/octet-stream", new byte[]{2,3,4,5});
JsonNode changed = data(mvc.perform(put("/admin-api/components/{id}", id).contentType(MediaType.APPLICATION_JSON)
.content(json.writeValueAsString(form))).andExpect(status().isOk()).andReturn());
assertThat(changed.path("stepObjectKey")).isEqualTo(created.path("stepObjectKey"));
assertThat(changed.path("urdfPrefix").asText()).isEqualTo(prefix);
assertThat(changed.path("urdfMainObjectKey").asText()).isEqualTo(main);
assertRelativeComponentPaths(changed);
assertThat(changed.path("urdfFiles").get(1).path("relativePath").asText()).isEqualTo("meshes/new.stl");
assertThat(changed.path("urdfFiles").get(1).path("sizeBytes").asLong()).isEqualTo(4);
assertThat(storage.objectExists(created.path("urdfMainObjectKey").asText())).isTrue();
@@ -580,6 +648,7 @@ class AdminApiTest {
assertThat(changed.path("stepUrl").asText()).endsWith("replacement.STEP");
assertThat(changed.path("urdfPrefix").asText()).isEqualTo(prefix);
assertThat(changed.path("urdfMainObjectKey").asText()).isEqualTo(main);
assertRelativeComponentPaths(changed);
assertThat(changed.path("urdfFiles").get(1).path("relativePath").asText()).isEqualTo("meshes/new.stl");
assertThat(changed.path("urdfFiles").get(1).path("sizeBytes").asLong()).isEqualTo(3);
assertThat(storage.objectExists(created.path("stepObjectKey").asText())).isTrue();
@@ -937,8 +1006,24 @@ class AdminApiTest {
}
}
JsonNode create(Map<String,?> body) throws Exception {
return data(mvc.perform(post("/admin-api/components").contentType(MediaType.APPLICATION_JSON)
JsonNode created = data(mvc.perform(post("/admin-api/components").contentType(MediaType.APPLICATION_JSON)
.content(json.writeValueAsString(body))).andExpect(status().isOk()).andReturn());
assertRelativeComponentPaths(created);
return created;
}
Map<String, Object> storedComponentPaths(long id) {
return jdbc.queryForMap("SELECT step_object_key,urdf_prefix,urdf_main_object_key FROM component WHERE id=?", id);
}
void assertRelativeComponentPaths(JsonNode response) {
Map<String, Object> stored = storedComponentPaths(response.path("id").asLong());
Map<String, String> fields = Map.of("step_object_key", "stepObjectKey", "urdf_prefix", "urdfPrefix",
"urdf_main_object_key", "urdfMainObjectKey");
for (Map.Entry<String, String> field : fields.entrySet()) {
String objectKey = response.path(field.getValue()).asText();
if (!objectKey.isEmpty()) assertThat(objectKey).startsWith("cadworld_dev/components/");
String expectedPath = objectKey.isEmpty() ? "" : objectKey.substring("cadworld_dev/".length());
assertThat(stored.get(field.getKey())).as(field.getKey()).isEqualTo(expectedPath);
}
}
void expectCreateError(Map<String,?> body,int status,String code) throws Exception {
mvc.perform(post("/admin-api/components").contentType(MediaType.APPLICATION_JSON)
@@ -17,6 +17,7 @@ import com.linkerbot.cadworld.service.demand.DemandRules;
import com.linkerbot.cadworld.service.impl.ObjectStorageUrlResolver;
import com.linkerbot.cadworld.service.matching.MatchTextService;
import com.linkerbot.cadworld.service.matching.RobotMatchingService;
import com.linkerbot.cadworld.service.support.StorageObjectKeys;
import java.io.IOException;
import java.util.List;
import lombok.extern.slf4j.Slf4j;
@@ -46,8 +47,9 @@ public class DemandConfiguration {
@Bean DemandAssemblyValidator demandAssemblyValidator() { return new DemandAssemblyValidator(); }
@Bean DemandRequirementChecker demandRequirementChecker(ObjectMapper json, MatchTextService text) { return new DemandRequirementChecker(json, text); }
@Bean DemandMatchService demandMatchService(ObjectMapper json, RobotMatchingService matching, ComponentMapper mapper,
ObjectStorageUrlResolver urls, DemandAssemblyValidator assembly, DemandRequirementChecker requirements) {
return new DemandMatchService(json, matching, mapper, urls, assembly, requirements);
ObjectStorageUrlResolver urls, StorageObjectKeys keys,
DemandAssemblyValidator assembly, DemandRequirementChecker requirements) {
return new DemandMatchService(json, matching, mapper, urls, keys, assembly, requirements);
}
@Bean WebMvcConfigurer demandCors(DemandProperties properties) {
return new WebMvcConfigurer() {
@@ -38,7 +38,7 @@ app:
concurrent-analyses: ${APP_DEMAND_CONCURRENT_ANALYSES:4}
allowed-origins: ${APP_DEMAND_ALLOWED_ORIGINS:}
storage:
# 配置公开 OSS/CDN 域名,不能填管理端下载代理地址;对象键已包含环境根目录。
# 配置公开 OSS/CDN 域名,不能填管理端下载代理地址;组件访问 URL 在响应时补全环境根目录。
public-base-url: ${APP_STORAGE_PUBLIC_BASE_URL:}
oss:
access-key-id: ${OSS_ACCESS_KEY_ID:}
@@ -9,6 +9,7 @@ import com.linkerbot.cadworld.service.auth.LoginUserService;
import com.linkerbot.cadworld.service.demand.DemandMatchService;
import com.linkerbot.cadworld.service.demand.DemandMessage;
import com.linkerbot.cadworld.service.demand.DemandModelClient;
import com.linkerbot.cadworld.service.support.StorageObjectKeys;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
@@ -16,6 +17,7 @@ import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
@@ -72,6 +74,7 @@ class DemandFlowApiTest {
@Autowired private TokenService tokens;
@Autowired private ObjectMapper json;
@Autowired private JdbcTemplate jdbc;
@Autowired private StorageObjectKeys storageKeys;
@Autowired private com.linkerbot.cadworld.service.demand.DemandRepository repository;
@Autowired private com.linkerbot.cadworld.service.demand.DemandAttachmentStore attachments;
@MockitoBean private DemandModelClient model;
@@ -155,6 +158,48 @@ class DemandFlowApiTest {
org.mockito.Mockito.verify(model, org.mockito.Mockito.times(1)).analyze(anyList());
}
@ParameterizedTest
@ValueSource(strings = {"relative", "legacy", "mixed-prefix", "mixed-main"})
void componentResourcePathsUseCurrentEnvironmentWithoutChangingDatabase(String format) throws Exception {
components(true, 20);
String root = storageKeys.rootPrefix();
for (String code : List.of("CW-TORSO", "CW-ARM", "CW-ARM-ALT")) {
String step = "components/" + code + "/step/batch/model one.STEP";
String prefix = "components/" + code + "/urdf/batch/";
String main = prefix + "urdf/机器人 one.urdf";
String files = "[{\"relativePath\":\"urdf/机器人 one.urdf\",\"sizeBytes\":10},{\"relativePath\":\"meshes/base one.stl\",\"sizeBytes\":20}]";
jdbc.update("UPDATE component SET step_object_key=?,urdf_prefix=?,urdf_main_object_key=?,urdf_files=? WHERE component_code=?",
"legacy".equals(format) ? root + step : step,
Set.of("legacy", "mixed-prefix").contains(format) ? root + prefix : prefix,
Set.of("legacy", "mixed-main").contains(format) ? root + main : main, files, code);
}
List<Map<String, Object>> before = jdbc.queryForList("SELECT component_code,step_object_key,urdf_prefix,urdf_main_object_key,version FROM component ORDER BY component_code");
JsonNode match = submit(create(), "m-resource-paths", TEXT, List.of()).path("match");
assertThat(match.path("status").asText()).isEqualTo("complete");
assertThat(match.path("components")).hasSize(2);
List<JsonNode> results = new ArrayList<>();
match.path("components").forEach(results::add);
for (JsonNode group : match.path("alternatives")) group.path("items").forEach(results::add);
assertThat(results).hasSize(3);
for (JsonNode result : results) {
String code = result.path("component").path("componentCode").asText();
String prefix = "https://models.example.test/" + root + "components/" + code;
assertThat(result.path("component").path("stepUrl").asText()).isEqualTo(prefix + "/step/batch/model%20one.STEP");
assertThat(result.path("component").path("urdfUrl").asText())
.isEqualTo(prefix + "/urdf/batch/urdf/%E6%9C%BA%E5%99%A8%E4%BA%BA%20one.urdf");
assertThat(result.path("resourceIssues")).isEmpty();
assertThat(result.path("urdfMainPath").asText()).isEqualTo("urdf/机器人 one.urdf");
assertThat(result.path("resources").findValuesAsText("relativePath"))
.containsExactly("urdf/机器人 one.urdf", "meshes/base one.stl");
assertThat(result.path("resources").get(0).path("url").asText())
.isEqualTo(result.path("component").path("urdfUrl").asText());
assertThat(result.path("resources").get(1).path("url").asText())
.isEqualTo(prefix + "/urdf/batch/meshes/base%20one.stl");
}
assertThat(jdbc.queryForList("SELECT component_code,step_object_key,urdf_prefix,urdf_main_object_key,version FROM component ORDER BY component_code"))
.isEqualTo(before);
}
@Test void messageAutomaticallyReturnsAssemblyAndQueriesRemainIdempotent() throws Exception {
components(true, 20);
jdbc.update("UPDATE component SET rotation_axis='Z' WHERE component_code='CW-ARM'");
@@ -51,6 +51,7 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
"spring.datasource.url=jdbc:h2:mem:matching;MODE=MySQL;DB_CLOSE_DELAY=-1",
"spring.datasource.driver-class-name=org.h2.Driver", "spring.datasource.username=sa",
"spring.datasource.password=", "spring.sql.init.mode=never",
"app.storage.root-prefix=cadworld_dev",
"app.storage.public-base-url=https://models.example.test", "logging.file.path=target/test-logs",
"app.oss.access-key-id=", "app.oss.access-key-secret="
})
@@ -172,8 +173,9 @@ class MatchingApiTest {
.andExpect(jsonPath("$.data.category").value("LEG_L")).andExpect(jsonPath("$.data.id").doesNotExist());
}
@Test
void returnsOriginalNestedJsonInSelectedAlternativeAndDetailWithEncodedDirectUrls() throws Exception {
@ParameterizedTest
@ValueSource(booleans = {true, false})
void returnsOriginalNestedJsonInSelectedAlternativeAndDetailWithEncodedDirectUrls(boolean relativePaths) throws Exception {
JsonNode original = metadata("BASE", "ARM_R");
JsonNode bom = json.readTree("{\"items\":[{\"code\":\"bolt\",\"qty\":4,\"details\":{\"material\":\"steel\"}}]}");
save("CW-A", "TORSO_0", 0, "1", "0", "", original, bom);
@@ -181,9 +183,10 @@ class MatchingApiTest {
JsonNode alternativeInfo = metadata("OTHER_BASE", "ARM_R");
save("CW-B", "躯干_0", 0, "2", "0", "", alternativeInfo, alternativeBom);
save("CW-ARM", "臂_r", 4, "1", "20", "");
String root = relativePaths ? "" : "cadworld_dev/";
jdbc.update("UPDATE component SET step_object_key=?,urdf_main_object_key=? WHERE component_code=?",
"cadworld_dev/components/CW-A/step/batch/模型 one.STEP",
"cadworld_dev/components/CW-A/urdf/batch/L20/机器人.urdf", "CW-A");
root + "components/CW-A/step/batch/模型 one.STEP",
root + "components/CW-A/urdf/batch/L20/机器人.urdf", "CW-A");
JsonNode result = match(request("TORSO_0", "ARM_R"));
JsonNode selected = part(result, "TORSO_0");
assertThat(selected.get("bomList")).isEqualTo(bom);
@@ -17,6 +17,7 @@ import com.linkerbot.cadworld.entity.Component;
import com.linkerbot.cadworld.mapper.ComponentMapper;
import com.linkerbot.cadworld.service.impl.ObjectStorageUrlResolver;
import com.linkerbot.cadworld.service.matching.RobotMatchingService;
import com.linkerbot.cadworld.service.support.StorageObjectKeys;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.LinkedHashMap;
@@ -32,12 +33,14 @@ public final class DemandMatchService {
private final RobotMatchingService matching;
private final ComponentMapper mapper;
private final ObjectStorageUrlResolver urls;
private final StorageObjectKeys keys;
private final DemandAssemblyValidator assembly;
private final DemandRequirementChecker requirements;
public DemandMatchService(ObjectMapper json, RobotMatchingService matching, ComponentMapper mapper,
ObjectStorageUrlResolver urls, DemandAssemblyValidator assembly, DemandRequirementChecker requirements) {
this.json = json; this.matching = matching; this.mapper = mapper; this.urls = urls; this.assembly = assembly; this.requirements = requirements;
ObjectStorageUrlResolver urls, StorageObjectKeys keys,
DemandAssemblyValidator assembly, DemandRequirementChecker requirements) {
this.json = json; this.matching = matching; this.mapper = mapper; this.urls = urls; this.keys = keys; this.assembly = assembly; this.requirements = requirements;
}
public JsonNode match(String matchId, DemandRepository.Analysis analysis) {
@@ -121,8 +124,8 @@ public final class DemandMatchService {
result.set("component", json.valueToTree(part.withInstanceId(null)));
ArrayNode resources = result.putArray("resources");
ArrayNode issues = result.putArray("resourceIssues");
String prefix = stored.getUrdfPrefix();
String main = stored.getUrdfMainObjectKey();
String prefix = keys.resolveComponentPath(stored.getUrdfPrefix());
String main = keys.resolveComponentPath(stored.getUrdfMainObjectKey());
boolean directoryValid = prefix != null && !prefix.isBlank() && prefix.endsWith("/") && main != null && main.startsWith(prefix);
String relativeMain = main == null ? "" : directoryValid ? main.substring(prefix.length()) : main.substring(main.lastIndexOf('/') + 1);
if (!directoryValid) resourceIssue(issues, part, "INVALID_RESOURCE_MANIFEST", "组件资源目录不完整,请联系管理员补充");
@@ -11,10 +11,13 @@ import com.linkerbot.cadworld.dto.component.CustomField;
import com.linkerbot.cadworld.dto.component.UrdfFile;
import com.linkerbot.cadworld.entity.Component;
import com.linkerbot.cadworld.service.impl.ComponentUploadSupport.VerifiedUrdf;
import com.linkerbot.cadworld.service.support.StorageObjectKeys;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import lombok.RequiredArgsConstructor;
@@ -27,6 +30,7 @@ public class ComponentConverter {
private final ObjectMapper objectMapper;
private final ObjectStorageUrlResolver urls;
private final StorageObjectKeys keys;
public void applyForm(Component component, ComponentForm form, boolean requireUrdfInfo) {
component.setComponentName(text(form.componentName()));
@@ -56,16 +60,33 @@ public class ComponentConverter {
component.setUrdfFiles(objectMapper.valueToTree(urdf.files()));
}
public List<String> normalizeStoragePaths(Component component) {
String step = keys.toComponentRelativeKey(component.getStepObjectKey());
String prefix = keys.toComponentRelativePrefix(component.getUrdfPrefix());
String main = keys.toComponentRelativeKey(component.getUrdfMainObjectKey());
List<String> changedFields = new ArrayList<>();
if (!Objects.equals(step, component.getStepObjectKey())) changedFields.add("step_object_key");
if (!Objects.equals(prefix, component.getUrdfPrefix())) changedFields.add("urdf_prefix");
if (!Objects.equals(main, component.getUrdfMainObjectKey())) changedFields.add("urdf_main_object_key");
component.setStepObjectKey(step);
component.setUrdfPrefix(prefix);
component.setUrdfMainObjectKey(main);
return List.copyOf(changedFields);
}
public ComponentResponse toResponse(Component component) {
String step = keys.resolveComponentPath(component.getStepObjectKey());
String prefix = keys.resolveComponentPath(component.getUrdfPrefix());
String main = keys.resolveComponentPath(component.getUrdfMainObjectKey());
return new ComponentResponse(component.getId(), component.getComponentCode(), component.getComponentName(),
component.getCategory(), component.getDescription(), component.getMaterial(),
component.getMassKg(), component.getDegreesOfFreedom(), component.getRotationAxis(), component.getFunctionDescription(),
component.getShape(), component.getSize(), component.getTorqueNm(), component.getBomList(),
component.getUrdfInfo(), read(component.getBasicFields(), FIELDS),
read(component.getParameterFields(), FIELDS), component.getStepObjectKey(),
urls.resolvePublicUrl(component.getStepObjectKey()), component.getUrdfPrefix(),
urls.resolvePublicUrl(component.getUrdfPrefix()), component.getUrdfMainObjectKey(),
urls.resolvePublicUrl(component.getUrdfMainObjectKey()), read(component.getUrdfFiles(), FILES),
read(component.getParameterFields(), FIELDS), step,
urls.resolvePublicUrl(step), prefix,
urls.resolvePublicUrl(prefix), main,
urls.resolvePublicUrl(main), read(component.getUrdfFiles(), FILES),
component.getVersion(), component.getCreatedAt(), component.getUpdatedAt());
}
@@ -73,8 +94,8 @@ public class ComponentConverter {
return new ComponentListItemResponse(component.getId(), component.getComponentCode(), component.getComponentName(),
component.getCategory(), component.getDescription(), component.getDegreesOfFreedom(), component.getRotationAxis(),
component.getFunctionDescription(), component.getShape(), component.getSize(), component.getTorqueNm(),
urls.resolvePublicUrl(component.getStepObjectKey()),
urls.resolvePublicUrl(component.getUrdfMainObjectKey()), component.getVersion(),
urls.resolvePublicUrl(keys.resolveComponentPath(component.getStepObjectKey())),
urls.resolvePublicUrl(keys.resolveComponentPath(component.getUrdfMainObjectKey())), component.getVersion(),
component.getCreatedAt(), component.getUpdatedAt());
}
@@ -38,6 +38,7 @@ public class ComponentServiceImpl implements ComponentService {
@Override
public ComponentResponse createComponent(Long userId, CreateComponentRequest request) {
Component component = prepareCreate(userId, request);
List<String> normalizedStorageFields = converter.normalizeStoragePaths(component);
ComponentResponse response;
try {
response = transactions.execute(status -> {
@@ -48,8 +49,8 @@ public class ComponentServiceImpl implements ComponentService {
} catch (DuplicateKeyException exception) {
throw new BizException(409, "COMPONENT_CODE_DUPLICATE", "组件编码已存在,请勿重复新增");
}
log.info("组件新增成功 componentId={} componentCode={} rotationAxis={} userId={} requestId={}",
component.getId(), component.getComponentCode(), component.getRotationAxis(), userId, RequestIdHolder.get());
log.info("组件新增成功 componentId={} componentCode={} rotationAxis={} normalizedStorageFields={} userId={} requestId={}",
component.getId(), component.getComponentCode(), component.getRotationAxis(), normalizedStorageFields, userId, RequestIdHolder.get());
return response;
}
@@ -60,6 +61,7 @@ public class ComponentServiceImpl implements ComponentService {
validateUpdate(current, request);
replaceResources(userId, current, request);
converter.applyForm(current, request, true);
List<String> normalizedStorageFields = converter.normalizeStoragePaths(current);
current.setVersion(request.version() + 1);
ComponentResponse response = transactions.execute(status -> {
int changed = componentMapper.update(current, new LambdaUpdateWrapper<Component>()
@@ -70,8 +72,8 @@ public class ComponentServiceImpl implements ComponentService {
snapshot(current);
return converter.toResponse(require(id));
});
log.info("组件修改成功 componentId={} version={} rotationAxis={} userId={} requestId={}",
id, current.getVersion(), current.getRotationAxis(), userId, RequestIdHolder.get());
log.info("组件修改成功 componentId={} componentCode={} version={} rotationAxis={} normalizedStorageFields={} userId={} requestId={}",
id, current.getComponentCode(), current.getVersion(), current.getRotationAxis(), normalizedStorageFields, userId, RequestIdHolder.get());
return response;
}
@@ -6,6 +6,7 @@ import com.linkerbot.cadworld.dto.matching.PublicComponentResponse;
import com.linkerbot.cadworld.entity.Component;
import com.linkerbot.cadworld.mapper.ComponentMapper;
import com.linkerbot.cadworld.service.impl.ObjectStorageUrlResolver;
import com.linkerbot.cadworld.service.support.StorageObjectKeys;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
@@ -22,6 +23,7 @@ import org.springframework.transaction.annotation.Transactional;
public class PublicComponentQueryService {
private final ComponentMapper mapper;
private final ObjectStorageUrlResolver urls;
private final StorageObjectKeys keys;
@Transactional(readOnly = true)
public PublicComponentResponse get(String componentCode) {
@@ -65,7 +67,8 @@ public class PublicComponentQueryService {
component.getDescription(), component.getMaterial(), component.getMassKg(), component.getDegreesOfFreedom(), component.getRotationAxis(),
component.getFunctionDescription(), component.getShape(), component.getSize(), component.getTorqueNm(),
component.getBomList(), component.getUrdfInfo(), component.getVersion(),
urls.resolvePublicUrl(component.getStepObjectKey()), urls.resolvePublicUrl(component.getUrdfMainObjectKey()));
urls.resolvePublicUrl(keys.resolveComponentPath(component.getStepObjectKey())),
urls.resolvePublicUrl(keys.resolveComponentPath(component.getUrdfMainObjectKey())));
}
private LambdaQueryWrapper<Component> candidateFields() {
@@ -12,6 +12,7 @@ import org.springframework.util.StringUtils;
/** 对象键是桶内的相对路径;环境根目录只在生成对象键时添加一次。 */
@Component
public class StorageObjectKeys {
private static final String COMPONENT_PREFIX = "components/";
private final String rootPrefix;
public StorageObjectKeys(StorageProperties properties) {
@@ -51,6 +52,33 @@ public class StorageObjectKeys {
return requireKey(value.replaceAll("/+$", "")) + "/";
}
/** 组件入库时去掉当前环境根目录,也接受已经转换过的组件相对路径。 */
public String toComponentRelativeKey(String key) {
if (!StringUtils.hasText(key)) return "";
if (key.chars().anyMatch(Character::isISOControl)) throw invalidKey();
String value = key.trim();
if (value.startsWith(rootPrefix + COMPONENT_PREFIX)) {
return requireKey(value).substring(rootPrefix.length());
}
if (!value.startsWith(COMPONENT_PREFIX)) throw invalidKey();
underRoot(value);
return value;
}
public String toComponentRelativePrefix(String prefix) {
if (!StringUtils.hasText(prefix)) return "";
if (prefix.chars().anyMatch(Character::isISOControl)) throw invalidKey();
return toComponentRelativeKey(prefix.trim().replaceAll("/+$", "")) + "/";
}
/** 读取组件文件键或目录时补全根目录;历史完整路径保持原样,由资源清单校验报告无效数据。 */
public String resolveComponentPath(String storedPath) {
if (!StringUtils.hasText(storedPath)) return "";
String value = storedPath.trim();
if (value.startsWith(rootPrefix + COMPONENT_PREFIX)) return value;
return value.startsWith(COMPONENT_PREFIX) ? rootPrefix + value : value;
}
private static boolean validRelativePath(String path) {
if (!StringUtils.hasText(path) || path.contains(":") || path.contains("\\")
|| path.contains("?") || path.contains("#") || path.chars().anyMatch(Character::isISOControl)) {
@@ -32,6 +32,51 @@ class StorageObjectKeysTest {
.isInstanceOf(BizException.class).extracting("code").isEqualTo("STORAGE_CONFIG_ERROR");
}
@ParameterizedTest
@ValueSource(strings = {"cadworld_dev", "cadworld", "qa/models", "components", "components/preview/"})
void componentPathsRoundTripWithCurrentEnvironmentExactlyOnce(String root) {
StorageObjectKeys environmentKeys = new StorageObjectKeys(properties(root));
String path = "components/CW-test/urdf/batch/urdf/机器人 one.urdf";
String prefix = "components/CW-test/urdf/batch/";
String objectKey = environmentKeys.rootPrefix() + path;
String objectPrefix = environmentKeys.rootPrefix() + prefix;
assertThat(environmentKeys.toComponentRelativeKey(objectKey)).isEqualTo(path);
assertThat(environmentKeys.toComponentRelativeKey(path)).isEqualTo(path);
assertThat(environmentKeys.toComponentRelativePrefix(objectPrefix)).isEqualTo(prefix);
assertThat(environmentKeys.toComponentRelativePrefix(prefix)).isEqualTo(prefix);
assertThat(environmentKeys.resolveComponentPath(path)).isEqualTo(objectKey);
assertThat(environmentKeys.resolveComponentPath(objectKey)).isEqualTo(objectKey);
assertThat(environmentKeys.resolveComponentPath(prefix)).isEqualTo(objectPrefix);
assertThat(environmentKeys.resolveComponentPath(objectPrefix)).isEqualTo(objectPrefix);
}
@Test
void componentPathsKeepOptionalUrdfEmptyAndResolveUsingEachEnvironment() {
assertThat(keys.toComponentRelativeKey(null)).isEmpty();
assertThat(keys.toComponentRelativeKey("")).isEmpty();
assertThat(keys.toComponentRelativePrefix(null)).isEmpty();
assertThat(keys.toComponentRelativePrefix("")).isEmpty();
assertThat(keys.resolveComponentPath(null)).isEmpty();
assertThat(keys.resolveComponentPath("")).isEmpty();
String path = "components/CW-test/step/batch/model.step";
assertThat(keys.resolveComponentPath(path)).isEqualTo("cadworld_dev/" + path);
assertThat(new StorageObjectKeys(properties("cadworld")).resolveComponentPath(path))
.isEqualTo("cadworld/" + path);
// 读取历史无效目录时保留原值,让需求服务继续返回资源清单问题。
assertThat(keys.resolveComponentPath("cadworld_dev/components/CW-test/urdf/batch"))
.isEqualTo("cadworld_dev/components/CW-test/urdf/batch");
}
@ParameterizedTest
@ValueSource(strings = {"cadworld/components/CW-test/model.step", "cadworld_dev_other/components/CW-test/model.step",
"https://bucket.test/cadworld_dev/components/model.step", "components/../model.step",
"components//model.step", "components/model.step?token=x", "components/model.step#fragment",
"components/model.step\n", "cadworld_dev/components/model.step\n", "cadworld_dev/projects/cover.png"})
void rejectsUnsafeAndOtherEnvironmentPathsWhenSavingComponent(String path) {
assertThatThrownBy(() -> keys.toComponentRelativeKey(path)).isInstanceOf(BizException.class);
assertThatThrownBy(() -> keys.toComponentRelativePrefix(path)).isInstanceOf(BizException.class);
}
private StorageProperties properties(String root) {
return new StorageProperties(root, null, Duration.ofMinutes(30), Duration.ofMinutes(5), 1024);
}
@@ -8,6 +8,7 @@ import com.linkerbot.cadworld.dto.component.UpdateComponentRequest;
import com.linkerbot.cadworld.entity.Component;
import com.linkerbot.cadworld.mapper.ComponentMapper;
import com.linkerbot.cadworld.service.support.ComponentUploadSessionSupport;
import com.linkerbot.cadworld.service.support.StorageObjectKeys;
import java.time.Duration;
import org.junit.jupiter.api.Test;
import org.springframework.transaction.PlatformTransactionManager;
@@ -27,10 +28,11 @@ class ComponentServiceImplTest {
when(mapper.update(any(Component.class),any(com.baomidou.mybatisplus.core.conditions.Wrapper.class))).thenReturn(0);
PlatformTransactionManager manager = mock(PlatformTransactionManager.class);
when(manager.getTransaction(any())).thenReturn(new SimpleTransactionStatus());
StorageProperties properties = new StorageProperties("cadworld_dev", "http://localhost",
Duration.ofMinutes(30), Duration.ofMinutes(5), 1024);
ComponentServiceImpl service = new ComponentServiceImpl(mapper,
new ComponentConverter(new ObjectMapper(),
new ObjectStorageUrlResolver(new StorageProperties("cadworld_dev","http://localhost",
Duration.ofMinutes(30),Duration.ofMinutes(5),1024))),
new ObjectStorageUrlResolver(properties), new StorageObjectKeys(properties)),
mock(ComponentUploadSessionSupport.class),
mock(ComponentUploadSupport.class),new TransactionTemplate(manager));
UpdateComponentRequest request = new UpdateComponentRequest(null,"测试","分类",null,null,null,