diff --git a/src/main/java/org/gridsuite/study/server/dto/ReferenceAttributes.java b/src/main/java/org/gridsuite/study/server/dto/ReferenceAttributes.java index fcfcbf5e7..7052fe855 100644 --- a/src/main/java/org/gridsuite/study/server/dto/ReferenceAttributes.java +++ b/src/main/java/org/gridsuite/study/server/dto/ReferenceAttributes.java @@ -6,33 +6,32 @@ */ package org.gridsuite.study.server.dto; -import com.fasterxml.jackson.annotation.JsonInclude; -import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; +import lombok.NonNull; import lombok.Setter; import lombok.experimental.SuperBuilder; import java.util.UUID; /** - * @author Mathieu Deharbe - * attributes of the references to the shared composites stored in directory server + * @author Maissa Souissi */ @Getter @Setter @NoArgsConstructor -@AllArgsConstructor @SuperBuilder -@JsonInclude(JsonInclude.Include.NON_NULL) public class ReferenceAttributes { public enum ReferenceType { STUDY_NODE, - NETWORK_MODIFICATION, - DIRECTORY_ELEMENT + STUDY_NODE_NETWORK_MODIFICATION, + DIRECTORY_NETWORK_MODIFICATION, } - private UUID referenceId; - private ReferenceType referenceType; + // id of the referenced shared composite modification + @NonNull private UUID referenceId; + // where the reference is used (see ReferenceType for the meaning of its ids) + @NonNull private ReferenceContainer referenceContainer; + @NonNull private ReferenceType referenceType; } diff --git a/src/main/java/org/gridsuite/study/server/dto/ReferenceContainer.java b/src/main/java/org/gridsuite/study/server/dto/ReferenceContainer.java new file mode 100644 index 000000000..fbbff83a3 --- /dev/null +++ b/src/main/java/org/gridsuite/study/server/dto/ReferenceContainer.java @@ -0,0 +1,33 @@ +/* + Copyright (c) 2026, RTE (http://www.rte-france.com) + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.study.server.dto; + +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.NonNull; +import lombok.Setter; +import lombok.experimental.SuperBuilder; + +import java.util.UUID; + +/** + * ReferenceContainer represents the information that makes it easy to locate the reference where it is used. + * It depends on the type of reference: + * STUDY_NODE: rootContainerId: studyId; containerId: nodeId + * STUDY_NODE_NETWORK_MODIFICATION: rootContainerId: nodeId; containerId: parentCompositeId + * DIRECTORY_NETWORK_MODIFICATION: rootContainerId: directoryId; containerId: parentCompositeId + * + * @author Maissa Souissi + */ +@Getter +@Setter +@NoArgsConstructor +@SuperBuilder +public class ReferenceContainer { + @NonNull private UUID rootContainerId; + @NonNull private UUID containerId; +} diff --git a/src/main/java/org/gridsuite/study/server/service/DirectoryService.java b/src/main/java/org/gridsuite/study/server/service/DirectoryService.java index 4f9bbbeb7..0b7edd9e2 100644 --- a/src/main/java/org/gridsuite/study/server/service/DirectoryService.java +++ b/src/main/java/org/gridsuite/study/server/service/DirectoryService.java @@ -12,6 +12,7 @@ import org.gridsuite.study.server.RemoteServicesProperties; import org.gridsuite.study.server.dto.ElementAttributes; import org.gridsuite.study.server.dto.ReferenceAttributes; +import org.gridsuite.study.server.dto.ReferenceContainer; import org.gridsuite.study.server.dto.networkexport.PermissionType; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.core.ParameterizedTypeReference; @@ -36,8 +37,10 @@ public class DirectoryService { public static final String PARAM_ACCESS_TYPE = "accessType"; public static final String PARAM_TARGET_DIRECTORY_UUID = "targetDirectoryUuid"; public static final String PARAM_RECURSIVE_CHECK = "recursiveCheck"; - public static final String PARAM_ORIGIN_REFERENCE_UUID = "originReferenceUuid"; - public static final String PARAM_TARGET_REFERENCE_UUID = "targetReferenceUuid"; + public static final String PARAM_ORIGIN_ROOT_CONTAINER_ID = "originRootContainerId"; + public static final String PARAM_ORIGIN_CONTAINER_ID = "originContainerId"; + public static final String PARAM_TARGET_ROOT_CONTAINER_ID = "targetRootContainerId"; + public static final String PARAM_TARGET_CONTAINER_ID = "targetContainerId"; public static final String PARAM_TARGET_REFERENCE_TYPE = "targetReferenceType"; private final RestTemplate restTemplate; @@ -113,28 +116,23 @@ public boolean elementExists(UUID directoryUuid, String elementName, String type /** * creates references and add them to shared composite modifications stored in directory server - * @param elementsUuids element uuids of the shared composites in directory server - * @param userId id of the user who creates the references - * @param targetReferenceUuid where the new references will point */ - public void createsReferencesToSharedComposites(@NonNull List elementsUuids, String userId, UUID targetReferenceUuid, ReferenceAttributes.ReferenceType targetReferenceType) { + public void createElementReference(@NonNull UUID elementUuid, @NonNull ReferenceAttributes referenceAttributes, String userId) { // TODO : instead of multiple calls, an endpoint in directory server should be created to handle multiple references creation // OR if not, turn this into simultaneous asynchronous calls - elementsUuids.forEach(elementUuid -> { - var path = UriComponentsBuilder.fromPath( - DELIMITER + DIRECTORY_API_VERSION + DELIMITER + "elements/{elementUuid}/references") - .buildAndExpand(elementUuid) - .toUriString(); - HttpHeaders headers = new HttpHeaders(); - headers.set(HEADER_USER_ID, userId); - headers.setContentType(MediaType.APPLICATION_JSON); + HttpHeaders headers = new HttpHeaders(); + headers.set(HEADER_USER_ID, userId); + headers.setContentType(MediaType.APPLICATION_JSON); - ReferenceAttributes referenceAttributes = new ReferenceAttributes(targetReferenceUuid, targetReferenceType); + HttpEntity requestEntity = new HttpEntity<>(referenceAttributes, headers); - HttpEntity requestEntity = new HttpEntity<>(referenceAttributes, headers); - restTemplate.exchange(getDirectoryServerServerBaseUri() + path, HttpMethod.POST, requestEntity, ElementAttributes.class); - }); + var path = UriComponentsBuilder.fromPath( + DELIMITER + DIRECTORY_API_VERSION + DELIMITER + "elements/{elementUuid}/references") + .buildAndExpand(elementUuid) + .toUriString(); + + restTemplate.exchange(getDirectoryServerServerBaseUri() + path, HttpMethod.POST, requestEntity, ElementAttributes.class); } /** @@ -143,7 +141,7 @@ public void createsReferencesToSharedComposites(@NonNull List elementsUuid * @param userId id of the user who caused the unreferencing * @param sharedElementUuid uuid of the referenced shared element in the directory-server */ - public void removeReference(UUID referenceUuid, String userId, UUID sharedElementUuid) { + public void removeElementReference(UUID referenceUuid, UUID sharedElementUuid, String userId) { Objects.requireNonNull(referenceUuid); Objects.requireNonNull(sharedElementUuid); @@ -192,13 +190,17 @@ public void checkPermission(List elementUuids, UUID targetDirectoryUuid, S * update references of shared composite modifications in directory server * @param elementsUuids element uuids of the shared composites * @param userId id of the user who moves the references - * @param originReferenceUuid uuid of the container whose references are updated - * @param targetReferenceUuid where the references will point after the update + * @param originRootContainerId root container of the reference location whose references are updated (see {@link ReferenceAttributes.ReferenceType}) + * @param originContainerId container of the reference location whose references are updated (see {@link ReferenceAttributes.ReferenceType}) + * @param targetRootContainerId root container of where the references will point after the update (see {@link ReferenceAttributes.ReferenceType}) + * @param targetContainerId container of where the references will point after the update (see {@link ReferenceAttributes.ReferenceType}) * @param targetReferenceType type where the references will point after the update */ - public void updateReferencesToSharedComposites(@NonNull List elementsUuids, String userId, @NonNull UUID originReferenceUuid, - UUID targetReferenceUuid, ReferenceAttributes.ReferenceType targetReferenceType) { - Objects.requireNonNull(originReferenceUuid); + public void updateElementsReferences(@NonNull List elementsUuids, String userId, + @NonNull UUID originRootContainerId, @NonNull UUID originContainerId, + UUID targetRootContainerId, UUID targetContainerId, ReferenceAttributes.ReferenceType targetReferenceType) { + Objects.requireNonNull(originRootContainerId); + Objects.requireNonNull(originContainerId); if (elementsUuids.isEmpty()) { return; @@ -206,8 +208,10 @@ public void updateReferencesToSharedComposites(@NonNull List elementsUuids String path = UriComponentsBuilder.fromPath(DELIMITER + DIRECTORY_API_VERSION + DELIMITER + "elements/references") .queryParam(PARAM_IDS, elementsUuids) - .queryParam(PARAM_ORIGIN_REFERENCE_UUID, originReferenceUuid) - .queryParam(PARAM_TARGET_REFERENCE_UUID, targetReferenceUuid) + .queryParam(PARAM_ORIGIN_ROOT_CONTAINER_ID, originRootContainerId) + .queryParam(PARAM_ORIGIN_CONTAINER_ID, originContainerId) + .queryParam(PARAM_TARGET_ROOT_CONTAINER_ID, targetRootContainerId) + .queryParam(PARAM_TARGET_CONTAINER_ID, targetContainerId) .queryParam(PARAM_TARGET_REFERENCE_TYPE, targetReferenceType) .buildAndExpand() .toUriString(); diff --git a/src/main/java/org/gridsuite/study/server/service/NetworkModificationService.java b/src/main/java/org/gridsuite/study/server/service/NetworkModificationService.java index 3a6470ae9..bac402b49 100644 --- a/src/main/java/org/gridsuite/study/server/service/NetworkModificationService.java +++ b/src/main/java/org/gridsuite/study/server/service/NetworkModificationService.java @@ -289,7 +289,7 @@ public void restoreModifications(UUID groupUUid, List modificationsUuids) /** * @return references data of the modificationsUuids found among modificationsUuids */ - public List getReferences(List modificationsUuids) { + public List getModificationReferences(List modificationsUuids) { Objects.requireNonNull(modificationsUuids); var path = UriComponentsBuilder .fromUriString(getNetworkModificationServerURI(false) + "references") diff --git a/src/main/java/org/gridsuite/study/server/service/StudyService.java b/src/main/java/org/gridsuite/study/server/service/StudyService.java index 7f19fdd37..622e0c715 100644 --- a/src/main/java/org/gridsuite/study/server/service/StudyService.java +++ b/src/main/java/org/gridsuite/study/server/service/StudyService.java @@ -1543,7 +1543,7 @@ public void deleteNetworkModifications(UUID studyUuid, UUID nodeUuid, List } UUID groupId = networkModificationTreeService.getModificationGroupUuid(nodeUuid); - List referencesToBeDeleted = networkModificationService.getReferences(modificationsUuids); + List referencesToBeDeleted = networkModificationService.getModificationReferences(modificationsUuids); networkModificationService.deleteModifications(groupId, modificationsUuids); // if there are unstashed references modifications in the deleted netmods, those references have to be removed from directory server removeReferences(referencesToBeDeleted, userId, nodeUuid); @@ -1555,7 +1555,7 @@ public void deleteNetworkModifications(UUID studyUuid, UUID nodeUuid, List private void removeReferences(List references, String userId, UUID nodeUuid) { references.forEach(reference -> - directoryService.removeReference(reference.containerId() != null ? reference.containerId() : nodeUuid, userId, reference.referenceId()) + directoryService.removeElementReference(reference.containerId() != null ? reference.containerId() : nodeUuid, reference.referenceId(), userId) ); } @@ -1826,7 +1826,7 @@ public void moveNetworkModifications( .map(rn -> rootNetworkNodeInfoService.getNetworkModificationApplicationContext(rn.getId(), targetNodeUuid, rn.getNetworkUuid())) .toList(); List allModificationUuids = modificationInfos.stream().map(ModificationMoveOrCopyInfos::modificationUuid).toList(); - List allReferencesToMove = networkModificationService.getReferences(allModificationUuids); + List allReferencesToMove = networkModificationService.getModificationReferences(allModificationUuids); for (Map.Entry> entry : modificationUuidsBySource.entrySet()) { ModificationContainerInfos source = entry.getKey(); @@ -1847,7 +1847,7 @@ public void moveNetworkModifications( emitNetworkModificationImpactsForAllRootNetworks(result.modificationResults(), studyEntity, targetNodeUuid); } - updateSharedCompositeReferencesForMove(result, source, resolvedTarget, referencesToMove, userId, originNodeUuid, targetNodeUuid, isTargetDifferentNode); + updateSharedCompositeReferencesForMove(result, source, resolvedTarget, referencesToMove, userId, studyUuid, originNodeUuid, targetNodeUuid, isTargetDifferentNode); } } finally { notificationService.emitModificationsUpdated(studyUuid, targetNodeUuid, targetChildrenUuids); @@ -1866,24 +1866,30 @@ public void moveNetworkModifications( * - moved to a different node (from a node-level group): the existing reference is repointed, not duplicated */ private void updateSharedCompositeReferencesForMove(NetworkModificationsResult result, ModificationContainerInfos source, ModificationContainerInfos target, - List referencesToMove, String userId, + List referencesToMove, String userId, UUID studyUuid, UUID originNodeUuid, UUID targetNodeUuid, boolean isTargetDifferentNode) { if (referencesToMove.isEmpty()) { return; } if (source.type() == ModificationContainerType.GROUP && target.type() == ModificationContainerType.COMPOSITE) { - updateReferenceWhenMoveModification(referencesToMove, userId, originNodeUuid, target.id(), ReferenceAttributes.ReferenceType.NETWORK_MODIFICATION); + // was a node-level reference (studyUuid, originNodeUuid) ; now targets the composite (originNodeUuid, target.id()) + updateReferenceWhenMoveModification(referencesToMove, userId, studyUuid, originNodeUuid, + originNodeUuid, target.id(), ReferenceAttributes.ReferenceType.STUDY_NODE_NETWORK_MODIFICATION); } if (target.type() == ModificationContainerType.GROUP && source.type() == ModificationContainerType.COMPOSITE) { - updateReferenceWhenMoveModification(referencesToMove, userId, source.id(), targetNodeUuid, ReferenceAttributes.ReferenceType.STUDY_NODE); + // was a composite-level reference (originNodeUuid, source.id()) ; now targets the node (studyUuid, targetNodeUuid) + updateReferenceWhenMoveModification(referencesToMove, userId, originNodeUuid, source.id(), + studyUuid, targetNodeUuid, ReferenceAttributes.ReferenceType.STUDY_NODE); } if (source.type() == ModificationContainerType.COMPOSITE && target.type() == ModificationContainerType.COMPOSITE && !source.id().equals(target.id())) { - updateReferenceWhenMoveModification(referencesToMove, userId, source.id(), target.id(), ReferenceAttributes.ReferenceType.NETWORK_MODIFICATION); + updateReferenceWhenMoveModification(referencesToMove, userId, originNodeUuid, source.id(), + originNodeUuid, target.id(), ReferenceAttributes.ReferenceType.STUDY_NODE_NETWORK_MODIFICATION); } // shared composites: the moved occurrence's node reference is updated, not duplicated if (result != null && isTargetDifferentNode && originNodeUuid != null) { - updateReferenceWhenMoveModification(referencesToMove, userId, originNodeUuid, targetNodeUuid, ReferenceAttributes.ReferenceType.STUDY_NODE); + updateReferenceWhenMoveModification(referencesToMove, userId, studyUuid, originNodeUuid, + studyUuid, targetNodeUuid, ReferenceAttributes.ReferenceType.STUDY_NODE); } } @@ -1891,16 +1897,18 @@ private void updateSharedCompositeReferencesForMove(NetworkModificationsResult r * updates, for each moved shared composite, the existing node-reference so that it points * to the target */ - private void updateReferenceWhenMoveModification(List referenceTargets, String userId, UUID originReferenceUuid, - UUID targetReferenceUuid, ReferenceAttributes.ReferenceType targetReferenceType) { + private void updateReferenceWhenMoveModification(List referenceTargets, String userId, + UUID originRootContainerId, UUID originContainerId, + UUID targetRootContainerId, UUID targetContainerId, + ReferenceAttributes.ReferenceType targetReferenceType) { List referenceModificationsUuids = referenceTargets.stream() .map(ReferenceData::referenceId) .collect(Collectors.toList()); - directoryService.updateReferencesToSharedComposites( + directoryService.updateElementsReferences( referenceModificationsUuids, userId, - originReferenceUuid, - targetReferenceUuid, + targetRootContainerId, + targetContainerId, targetReferenceType ); } @@ -1962,6 +1970,7 @@ public void duplicateNetworkModifications( UUID targetNodeUuid, List modificationsUuids, String userId) { + duplicateModificationsOrInsertComposites(targetStudyUuid, targetNodeUuid, (groupUuid, modificationApplicationContexts) -> { // fetched BEFORE the duplication. getReferences() only tells us whether a given modification IS @@ -1971,11 +1980,11 @@ public void duplicateNetworkModifications( List originalChildrenUuids = networkModificationService.findAllChildrenUuids(modificationsUuids); List allOriginalUuids = new ArrayList<>(modificationsUuids); allOriginalUuids.addAll(originalChildrenUuids); - List referenceTargets = networkModificationService.getReferences(allOriginalUuids); + List referenceTargets = networkModificationService.getModificationReferences(allOriginalUuids); NetworkModificationsResult networkModificationResults = networkModificationService.duplicateModifications(groupUuid, Pair.of(modificationsUuids, modificationApplicationContexts)); Map mappingModificationsUuids = buildModificationsUuidMapping(modificationsUuids, originalChildrenUuids, networkModificationResults); - createReferencesToSharedComposites(referenceTargets, modificationsUuids, mappingModificationsUuids, userId, targetNodeUuid); + createElementsReferences(referenceTargets, modificationsUuids, mappingModificationsUuids, userId, targetStudyUuid, targetNodeUuid); return networkModificationResults; }, userId); @@ -2008,8 +2017,8 @@ private Map buildModificationsUuidMapping(List copiedUuids, Li * {@link #removeReferences}, which likewise issues one removal per occurrence on delete) - so this must NOT be * deduplicated by referenceId. */ - private void createReferencesToSharedComposites(List references, List modificationsUuids, - Map mappingModificationsUuids, String userId, UUID targetNodeUuid) { + private void createElementsReferences(List references, List modificationsUuids, + Map mappingModificationsUuids, String userId, UUID studyUuid, UUID targetNodeUuid) { Set requestedUuids = new HashSet<>(modificationsUuids); List directlyRequestedReferenceIds = references.stream() @@ -2017,7 +2026,11 @@ private void createReferencesToSharedComposites(List references, .map(ReferenceData::referenceId) .toList(); if (!directlyRequestedReferenceIds.isEmpty()) { - directoryService.createsReferencesToSharedComposites(directlyRequestedReferenceIds, userId, targetNodeUuid, ReferenceAttributes.ReferenceType.STUDY_NODE); + directoryService.createElementReference(directlyRequestedReferenceIds, ReferenceAttributes.builder() + .referenceType(ReferenceAttributes.ReferenceType.STUDY_NODE. + .referenceId() + + targetNodeUuid, ReferenceAttributes.ReferenceType.STUDY_NODE); } Map> nestedReferenceIdsByNewComposite = references.stream() @@ -2026,7 +2039,7 @@ private void createReferencesToSharedComposites(List references, reference -> mappingModificationsUuids.get(reference.containerId()), Collectors.mapping(ReferenceData::referenceId, Collectors.toList()))); nestedReferenceIdsByNewComposite.forEach((newCompositeUuid, referenceIds) -> - directoryService.createsReferencesToSharedComposites(referenceIds, userId, newCompositeUuid, ReferenceAttributes.ReferenceType.NETWORK_MODIFICATION)); + directoryService.createElementReferences(referenceIds, userId, targetNodeUuid, newCompositeUuid, ReferenceAttributes.ReferenceType.STUDY_NODE_NETWORK_MODIFICATION)); } @Transactional @@ -2073,7 +2086,7 @@ public void shareCompositeNetworkModification( networkModificationService.extractCompositeModificationToShare(groupUuid, modificationUuid, name); // the composite modification keeps its uuid when extracted, so it is shared under that same uuid directoryService.createElement(parentDirectoryUuid, description, modificationUuid, name, DirectoryService.MODIFICATION, userId); - directoryService.createsReferencesToSharedComposites(List.of(modificationUuid), userId, nodeUuid, ReferenceAttributes.ReferenceType.STUDY_NODE); + directoryService.createElementReferences(List.of(modificationUuid), userId, studyUuid, nodeUuid, ReferenceAttributes.ReferenceType.STUDY_NODE); } finally { notificationService.emitModificationsUpdated(studyUuid, nodeUuid, childrenUuids); } @@ -2093,7 +2106,7 @@ public void insertCompositeNetworkModifications( .map(CompositeInfos::id) .toList(); if (action == StudyConstants.CompositeModificationsActionType.INSERT && !sharedCompositeUuids.isEmpty()) { - directoryService.createsReferencesToSharedComposites(sharedCompositeUuids, userId, targetNodeUuid, ReferenceAttributes.ReferenceType.STUDY_NODE); + directoryService.createElementReferences(sharedCompositeUuids, userId, targetStudyUuid, targetNodeUuid, ReferenceAttributes.ReferenceType.STUDY_NODE); } duplicateModificationsOrInsertComposites( diff --git a/src/test/java/org/gridsuite/study/server/NetworkModificationTest.java b/src/test/java/org/gridsuite/study/server/NetworkModificationTest.java index ee7fe8763..7cd8eaab2 100644 --- a/src/test/java/org/gridsuite/study/server/NetworkModificationTest.java +++ b/src/test/java/org/gridsuite/study/server/NetworkModificationTest.java @@ -89,8 +89,8 @@ import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig; import static org.gridsuite.study.server.StudyConstants.HEADER_ERROR_MESSAGE; import static org.gridsuite.study.server.StudyConstants.QUERY_PARAM_RECEIVER; -import static org.gridsuite.study.server.dto.ReferenceAttributes.ReferenceType.NETWORK_MODIFICATION; import static org.gridsuite.study.server.dto.ReferenceAttributes.ReferenceType.STUDY_NODE; +import static org.gridsuite.study.server.dto.ReferenceAttributes.ReferenceType.STUDY_NODE_NETWORK_MODIFICATION; import static org.gridsuite.study.server.error.StudyBusinessErrorCode.MAX_NODE_BUILDS_EXCEEDED; import static org.gridsuite.study.server.error.StudyBusinessErrorCode.NOT_FOUND; import static org.gridsuite.study.server.utils.ImpactUtils.createModificationResultWithElementImpact; @@ -2179,7 +2179,11 @@ void testInsertComposite() throws Exception { wireMockServer, "/v1/elements/" + sharedNetModId + "/references", Map.of(), - mapper.writeValueAsString(new ReferenceAttributes(nodeUuid1, STUDY_NODE))); + mapper.writeValueAsString(ReferenceAttributes.builder() + .referenceId(sharedNetModId) + .referenceContainer(ReferenceContainer.builder().rootContainerId(studyUuid).containerId(nodeUuid1).build()) + .referenceType(STUDY_NODE) + .build())); } @Test @@ -2237,7 +2241,11 @@ void testShareCompositeModification() throws Exception { wireMockServer, "/v1/elements/" + compositeUuid + "/references", Map.of(), - mapper.writeValueAsString(new ReferenceAttributes(nodeUuid1, STUDY_NODE))); + mapper.writeValueAsString(ReferenceAttributes.builder() + .referenceId(compositeUuid) + .referenceContainer(ReferenceContainer.builder().rootContainerId(studyUuid).containerId(nodeUuid1).build()) + .referenceType(STUDY_NODE) + .build())); } @Test @@ -2420,7 +2428,7 @@ void testDuplicateModification() throws Exception { void testDuplicateModificationCreatesReferencesToSharedComposites() throws Exception { // Verifies createReferencesToSharedComposites correctly splits references in two: // - a duplicated modification that IS itself a reference -> new reference points to the target node (STUDY_NODE) - // - a reference nested inside a duplicated composite -> new reference points to the composite's copy (NETWORK_MODIFICATION) + // - a reference nested inside a duplicated composite -> new reference points to the composite's copy (STUDY_NODE_NETWORK_MODIFICATION) String userId = "userId"; StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), CASE_UUID, "UCTE"); UUID studyUuid = studyEntity.getId(); @@ -2507,14 +2515,22 @@ void testDuplicateModificationCreatesReferencesToSharedComposites() throws Excep wireMockServer, "/v1/elements/" + sharedComposite1 + "/references", Map.of(), - mapper.writeValueAsString(new ReferenceAttributes(nodeUuid1, STUDY_NODE))); + mapper.writeValueAsString(ReferenceAttributes.builder() + .referenceId(sharedComposite1) + .referenceContainer(ReferenceContainer.builder().rootContainerId(studyUuid).containerId(nodeUuid1).build()) + .referenceType(STUDY_NODE) + .build())); // originalChild's reference is nested inside modification2 -> new reference targets modification2's copy WireMockUtilsCriteria.verifyPostRequest( wireMockServer, "/v1/elements/" + sharedComposite2 + "/references", Map.of(), - mapper.writeValueAsString(new ReferenceAttributes(copy2, NETWORK_MODIFICATION))); + mapper.writeValueAsString(ReferenceAttributes.builder() + .referenceId(sharedComposite2) + .referenceContainer(ReferenceContainer.builder().rootContainerId(nodeUuid1).containerId(copy2).build()) + .referenceType(STUDY_NODE_NETWORK_MODIFICATION) + .build())); } @Test @@ -3557,8 +3573,10 @@ void testMoveReferencedModification() throws Exception { // directory-server endpoint that moves the node reference - ids is modification1 itself UUID updateReferencesStubId = wireMockServer.stubFor(WireMock.put(WireMock.urlPathEqualTo("/v1/elements/references")) .withQueryParam("ids", WireMock.equalTo(modification1.toString())) - .withQueryParam("originReferenceUuid", WireMock.equalTo(nodeUuid1.toString())) - .withQueryParam("targetReferenceUuid", WireMock.equalTo(nodeUuid2.toString())) + .withQueryParam("originRootContainerId", WireMock.equalTo(studyUuid.toString())) + .withQueryParam("originContainerId", WireMock.equalTo(nodeUuid1.toString())) + .withQueryParam("targetRootContainerId", WireMock.equalTo(studyUuid.toString())) + .withQueryParam("targetContainerId", WireMock.equalTo(nodeUuid2.toString())) .withHeader(USER_ID_HEADER, WireMock.equalTo(userId)) .willReturn(WireMock.ok()) ).getId(); @@ -3594,8 +3612,10 @@ void testMoveReferencedModification() throws Exception { WireMockUtils.verifyPutRequest(wireMockServer, updateReferencesStubId, "/v1/elements/references", true, Map.of("ids", WireMock.equalTo(modification1.toString()), - "originReferenceUuid", WireMock.equalTo(nodeUuid1.toString()), - "targetReferenceUuid", WireMock.equalTo(nodeUuid2.toString())), + "originRootContainerId", WireMock.equalTo(studyUuid.toString()), + "originContainerId", WireMock.equalTo(nodeUuid1.toString()), + "targetRootContainerId", WireMock.equalTo(studyUuid.toString()), + "targetContainerId", WireMock.equalTo(nodeUuid2.toString())), null); }