import shared composites

src/main/java/org/gridsuite/modification/server/CompositeController.java

@@ -12,6 +12,7 @@
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import org.gridsuite.modification.dto.ModificationInfos;
+import org.gridsuite.modification.server.dto.CompositesToBeInserted;
 import org.gridsuite.modification.server.dto.ModificationApplicationContext;
 import org.gridsuite.modification.server.dto.NetworkModificationsResult;
 import org.gridsuite.modification.server.service.NetworkModificationService;
@@ -50,7 +51,7 @@ public CompositeController(NetworkModificationService networkModificationService
     public CompletableFuture<ResponseEntity<NetworkModificationsResult>> insertCompositeModifications(
             @Parameter(description = "updated group UUID, where modifications are inserted") @PathVariable("groupUuid") UUID targetGroupUuid,
             @Parameter(description = "Insertion method", required = true) @RequestParam(value = "action") CompositeModificationAction action,
-            @RequestBody Pair<List<Pair<UUID, String>>, List<ModificationApplicationContext>> modificationContextInfos) {
+            @RequestBody Pair<List<CompositesToBeInserted>, List<ModificationApplicationContext>> modificationContextInfos) {
         return switch (action) {
             case SPLIT -> networkModificationService.splitCompositeModifications(
                             targetGroupUuid,

src/main/java/org/gridsuite/modification/server/NetworkModificationController.java

@@ -244,6 +244,39 @@
         return ResponseEntity.ok().build();
     }
 
+    /**
+     * filters out the netmods which are not references and returns the references data as :
+     * referenced element uuid -> container of the reference (uuid of the composite if there is one, null if it is at the root level)
+     */
+    @GetMapping(value = "/references", produces = MediaType.APPLICATION_JSON_VALUE)
+    @Operation(summary = "fetch references data of the network modifications")
+    @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The references data were returned")})
+    public ResponseEntity<Map<UUID, UUID>> getReferencesData(
+            @Parameter(description = "Network modification UUIDs") @RequestParam("uuids") List<UUID> networkModificationUuids) {
+        Map<UUID, UUID> referencesData = networkModificationService.getReferencesData(networkModificationUuids);
+        return ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON)
+                .body(referencesData);
+    }
+
+    /**
+     * filters out the netmods which are not references and returns the references data as :
+     * referenced element uuid -> container of the reference (uuid of the composite if there is one, null if it is at the root level)
+     */
+    @GetMapping(value = "/groups/{groupUuid}/references", produces = MediaType.APPLICATION_JSON_VALUE)
+    @Operation(summary = "Fetches references data of all the network modifications in a group, including in the composites' submodifications")
+    @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The references data were returned")})
+    public ResponseEntity<Map<UUID, UUID>> getAllReferencesDataFromGroup(
+            @Parameter(description = "Group UUID") @PathVariable("groupUuid") UUID groupUuid) {
+        // TODO GRD-4785 : for now shared modification are only at the root level and can't be inside composites,
+        // but when it will be the case a specific function will have to be done in order to fetch recursively all the references inside the composites and only return uuids
+        List<UUID> netModUuids = networkModificationService.getNetworkModifications(groupUuid, true, false, false)
+                .stream().map(ModificationInfos::getUuid)
+                .toList();
+        Map<UUID, UUID> referencesData = networkModificationService.getReferencesData(netModUuids);
+        return ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON)
+                .body(referencesData);
+    }
+
     @PutMapping(value = "/network-modifications", produces = MediaType.APPLICATION_JSON_VALUE)
     @Operation(summary = "Updates the metadata of network modifications")
     @ApiResponse(responseCode = "200", description = "The metadata of the network modifications has been successfully updated")

src/main/java/org/gridsuite/modification/server/dto/CompositesToBeInserted.java

@@ -0,0 +1,14 @@
+/*
+  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.modification.server.dto;
+
+import java.util.UUID;
+
+/**
+ * @author Mathieu Deharbe <mathieu.deharbe at rte-france.com>
+ */
+public record CompositesToBeInserted(UUID id, String name, boolean isShared) { }

src/main/java/org/gridsuite/modification/server/repositories/NetworkModificationRepository.java

@@ -18,6 +18,7 @@
 import org.gridsuite.modification.dto.tabular.TabularBaseInfos;
 import org.gridsuite.modification.dto.tabular.TabularCreationInfos;
 import org.gridsuite.modification.dto.tabular.TabularModificationInfos;
+import org.gridsuite.modification.server.dto.CompositesToBeInserted;
 import org.gridsuite.modification.server.dto.ModificationMetadata;
 import org.gridsuite.modification.server.elasticsearch.ModificationApplicationInfosService;
 import org.gridsuite.modification.server.entities.CompositeModificationEntity;
@@ -29,7 +30,6 @@
 import org.gridsuite.modification.server.entities.tabular.TabularPropertyEntity;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.data.util.Pair;
 import org.springframework.stereotype.Repository;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -710,6 +710,26 @@
         return getModificationEntityStream(groupUuid).filter(m -> !m.getStashed()).map(this::toModificationsInfosOptimized).toList();
     }
 
+    /**
+     * @return elementUuid of the shared modification -> Uuid of the composite containing the reference, null if the composite is at the root level
+     */
+    @Transactional
+    public Map<UUID, UUID> getReferencesData(@NonNull List<UUID> modificationUuids) {
+        Map<UUID, UUID> referencesToBeDeleted = new HashMap<>();
+        for (UUID modificationUuid : modificationUuids) {
+            ModificationEntity modificationEntity = this.modificationRepository
+                    .findById(modificationUuid)
+                    .orElseThrow(() -> new NetworkModificationException(MODIFICATION_NOT_FOUND, String.format(MODIFICATION_NOT_FOUND_MESSAGE, modificationUuid)));
+            if (Boolean.FALSE.equals(modificationEntity.getStashed()) && modificationEntity instanceof ModificationReferenceEntity modificationReference) {
+                // TODO GRD-4785 : for now shared modification are only at the root level and can't be inside composites, so the composite uuid is set to null
+                // but when it will be the case a specific function will have to be done in order to fetch the composite containing the modificationReference (if there is one)
+                referencesToBeDeleted.putIfAbsent(modificationReference.getReferenceId(), null);
+            }
+        }
+
+        return referencesToBeDeleted;
+    }
+
     @Transactional
     public void stashNetworkModifications(@NonNull List<UUID> modificationUuids, int stashedModificationCount) {
         int stashModificationOrder = -stashedModificationCount - 1;
@@ -937,20 +957,35 @@
     @Transactional
     public List<ModificationInfos> insertCompositeModifications(
             @NonNull UUID targetGroupUuid,
-            @NonNull List<Pair<UUID, String>> compositesUuidName) {
-        List<UUID> compositeUuids = compositesUuidName.stream().map(Pair::getFirst).toList();
+            @NonNull List<CompositesToBeInserted> compositesToBeInserted) {
+        List<UUID> compositeUuids = compositesToBeInserted.stream().map(CompositesToBeInserted::id).toList();
         List<ModificationInfos> newCompositeModifications = new ArrayList<>();
         List<ModificationInfos> modificationInfos = getModificationsInfosNonTransactional(compositeUuids);
-        // apply the new composite name to the corresponding composite modifications
-        for (Pair<UUID, String> compositeUuidName : compositesUuidName) {
-            CompositeModificationInfos newCompositeModification = (CompositeModificationInfos) modificationInfos.stream()
-                    .filter(modif -> modif.getUuid().equals(compositeUuidName.getFirst()))
-                    .findFirst().orElse(null);
-            if (newCompositeModification != null) {
-                newCompositeModification.setName(compositeUuidName.getSecond());
-                newCompositeModifications.add(newCompositeModification);
+        for (CompositesToBeInserted compositeToBeInserted : compositesToBeInserted) {
+            if (compositeToBeInserted.isShared()) {
+                CompositeModificationInfos referencedCompositeModification = (CompositeModificationInfos) modificationInfos.stream()
+                        .filter(modif -> modif.getUuid().equals(compositeToBeInserted.id()))
+                        .findFirst().orElse(null);
+                if (referencedCompositeModification != null) {
+                    referencedCompositeModification.setName(compositeToBeInserted.name());
+                    ModificationReferenceInfos newModificationReference = ModificationReferenceInfos.builder()
+                            .referenceId(compositeToBeInserted.id())
+                            .referenceType(ModificationReferenceInfos.Type.BASIC)
+                            .referenceInfos(referencedCompositeModification)
+                            .build();
+                    newCompositeModifications.add(newModificationReference);
+                }
             } else {
-                LOGGER.error("Could not find composite modification with uuid {} to apply its name {}", compositeUuidName.getFirst(), compositeUuidName.getSecond());
+                // apply the new composite name to the corresponding composite modifications
+                CompositeModificationInfos newCompositeModification = (CompositeModificationInfos) modificationInfos.stream()
+                        .filter(modif -> modif.getUuid().equals(compositeToBeInserted.id()))
+                        .findFirst().orElse(null);
+                if (newCompositeModification != null) {
+                    newCompositeModification.setName(compositeToBeInserted.name());
+                    newCompositeModifications.add(newCompositeModification);
+                } else {
+                    LOGGER.error("Could not find composite modification with uuid {} to apply its name {}", compositeToBeInserted.id(), compositeToBeInserted.name());
+                }
             }
         }
         List<ModificationEntity> newEntities = saveModificationInfosNonTransactional(targetGroupUuid, newCompositeModifications);

src/main/java/org/gridsuite/modification/server/service/NetworkModificationService.java

@@ -27,6 +27,7 @@
 import org.gridsuite.modification.dto.ModificationInfos;
 import org.gridsuite.modification.server.NetworkModificationServerException;
 import org.gridsuite.modification.server.dto.*;
+import org.gridsuite.modification.server.dto.CompositesToBeInserted;
 import org.gridsuite.modification.server.dto.elasticsearch.ModificationApplicationInfos;
 import org.gridsuite.modification.server.elasticsearch.EquipmentInfosService;
 import org.gridsuite.modification.server.elasticsearch.ModificationApplicationInfosService;
@@ -269,6 +270,11 @@ public void updateNetworkModificationMetadata(@NonNull List<UUID> modificationUu
         networkModificationRepository.updateNetworkModificationMetadata(modificationUuids, metadata);
     }
 
+    @Transactional
+    public Map<UUID, UUID> getReferencesData(@NonNull List<UUID> modificationUuids) {
+        return networkModificationRepository.getReferencesData(modificationUuids);
+    }
+
     @Transactional
     public void stashNetworkModifications(UUID groupUuid, @NonNull List<UUID> modificationUuids) {
         for (UUID modificationUuid : modificationUuids) {
@@ -487,8 +493,8 @@ public CompletableFuture<NetworkModificationsResult> duplicateModifications(@Non
      */
     public CompletableFuture<NetworkModificationsResult> splitCompositeModifications(
             @NonNull UUID targetGroupUuid,
-            @NonNull Pair<List<Pair<UUID, String>>, List<ModificationApplicationContext>> modificationContextInfos) {
-        List<UUID> compositesUuids = modificationContextInfos.getFirst().stream().map(Pair::getFirst).toList();
+            @NonNull Pair<List<CompositesToBeInserted>, List<ModificationApplicationContext>> modificationContextInfos) {
+        List<UUID> compositesUuids = modificationContextInfos.getFirst().stream().map(CompositesToBeInserted::id).toList();
         List<ModificationInfos> modifications = networkModificationRepository.extractModificationsFromCompositesAndSave(targetGroupUuid, compositesUuids);
         List<UUID> ids = modifications.stream().map(ModificationInfos::getUuid).toList();
         return applyModifications(targetGroupUuid, modifications, modificationContextInfos.getSecond()).thenApply(result ->
@@ -497,7 +503,7 @@ public CompletableFuture<NetworkModificationsResult> splitCompositeModifications
 
     public CompletableFuture<NetworkModificationsResult> insertCompositeModifications(
             @NonNull UUID targetGroupUuid,
-            @NonNull Pair<List<Pair<UUID, String>>, List<ModificationApplicationContext>> modificationContextInfos) {
+            @NonNull Pair<List<CompositesToBeInserted>, List<ModificationApplicationContext>> modificationContextInfos) {
         List<ModificationInfos> modifications = networkModificationRepository.insertCompositeModifications(
                 targetGroupUuid, modificationContextInfos.getFirst());
         List<UUID> ids = modifications.stream().map(ModificationInfos::getUuid).toList();