Filter voltage init results with a global filter (#112)

* Add global filter parameter to filter voltage init results

Signed-off-by: Franck LECUYER <[email protected]>

Author: FranckLecuyer

pom.xml

@@ -134,7 +134,6 @@
                 <artifactId>powsybl-open-reac</artifactId>
                 <version>${powsybl-open-reac.version}</version>
             </dependency>
-
             <dependency>
                 <groupId>com.powsybl</groupId>
                 <artifactId>powsybl-optimizer-commons</artifactId>
@@ -158,6 +157,10 @@
             <groupId>com.powsybl</groupId>
             <artifactId>powsybl-open-reac</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.powsybl</groupId>
+            <artifactId>powsybl-security-analysis-api</artifactId>
+        </dependency>
         <dependency>
             <groupId>com.powsybl</groupId>
             <artifactId>powsybl-optimizer-commons</artifactId>
@@ -190,6 +193,10 @@
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <scope>provided</scope>
+        </dependency>
+         <dependency>
+            <groupId>org.gridsuite</groupId>
+            <artifactId>gridsuite-filter</artifactId>
         </dependency>
         <dependency>
             <groupId>com.powsybl</groupId>

src/main/java/org/gridsuite/voltageinit/server/VoltageInitController.java

@@ -23,6 +23,9 @@
 import java.util.List;
 import java.util.UUID;
 
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+
 import static com.powsybl.ws.commons.computation.service.NotificationService.HEADER_USER_ID;
 import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE;
 
@@ -60,8 +63,12 @@ public ResponseEntity<UUID> runAndSave(@Parameter(description = "Network UUID")
     @Operation(summary = "Get a voltage init result from the database")
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The voltage init result"),
         @ApiResponse(responseCode = "404", description = "Voltage init result has not been found")})
-    public ResponseEntity<VoltageInitResult> getResult(@Parameter(description = "Result UUID") @PathVariable("resultUuid") UUID resultUuid) {
-        VoltageInitResult result = voltageInitService.getResult(resultUuid);
+    public ResponseEntity<VoltageInitResult> getResult(@Parameter(description = "Result UUID") @PathVariable("resultUuid") UUID resultUuid,
+                                                       @Parameter(description = "Global Filters") @RequestParam(name = "globalFilters", required = false) String globalFilters,
+                                                       @Parameter(description = "network Uuid") @RequestParam(name = "networkUuid", required = false) UUID networkUuid,
+                                                       @Parameter(description = "variant Id") @RequestParam(name = "variantId", required = false) String variantId) {
+        String decodedStringGlobalFilters = globalFilters != null ? URLDecoder.decode(globalFilters, StandardCharsets.UTF_8) : null;
+        VoltageInitResult result = voltageInitService.getResult(resultUuid, decodedStringGlobalFilters, networkUuid, variantId);
         return result != null ? ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON).body(result)
                 : ResponseEntity.notFound().build();
     }

src/main/java/org/gridsuite/voltageinit/server/dto/ReactiveSlack.java

@@ -17,6 +17,7 @@
 @AllArgsConstructor
 @NoArgsConstructor
 public class ReactiveSlack {
+    private String voltageLevelId;
 
     private String busId;
 

src/main/java/org/gridsuite/voltageinit/server/entities/ReactiveSlackEmbeddable.java

@@ -21,6 +21,8 @@
 @NoArgsConstructor
 @Embeddable
 public class ReactiveSlackEmbeddable {
+    @Column
+    private String voltageLevelId;
 
     @Column
     private String busId;

src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitResultService.java

@@ -48,7 +48,7 @@ private static VoltageInitResultEntity toVoltageInitResultEntity(UUID resultUuid
                                                                      boolean isReactiveSlacksOverThreshold, Double reactiveSlacksThreshold) {
         Map<String, String> indicators = result.getIndicators();
         List<ReactiveSlackEmbeddable> reactiveSlacks = result.getReactiveSlacks().stream().map(rs ->
-                new ReactiveSlackEmbeddable(rs.getBusId(), rs.getSlack()))
+                new ReactiveSlackEmbeddable(rs.getVoltageLevelId(), rs.getBusId(), rs.getSlack()))
             .collect(Collectors.toList());
         Map<String, Pair<Double, Double>> voltageProfile = result.getVoltageProfile();
         List<BusVoltageEmbeddable> busVoltages = voltageProfile.entrySet().stream()

src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java

@@ -9,14 +9,18 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.powsybl.network.store.client.NetworkStoreService;
 
+import com.powsybl.ws.commons.computation.dto.GlobalFilter;
 import com.powsybl.ws.commons.computation.service.AbstractComputationService;
 import com.powsybl.ws.commons.computation.service.NotificationService;
 import com.powsybl.ws.commons.computation.service.UuidGeneratorService;
+import com.powsybl.ws.commons.computation.utils.FilterUtils;
+import org.apache.commons.collections4.CollectionUtils;
 import org.gridsuite.voltageinit.server.dto.BusVoltage;
 import org.gridsuite.voltageinit.server.dto.ReactiveSlack;
 import org.gridsuite.voltageinit.server.dto.VoltageInitResult;
 import org.gridsuite.voltageinit.server.dto.VoltageInitStatus;
 import org.gridsuite.voltageinit.server.entities.VoltageInitResultEntity;
+import org.gridsuite.voltageinit.server.service.parameters.FilterService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.stereotype.Service;
@@ -36,13 +40,17 @@ public class VoltageInitService extends AbstractComputationService<VoltageInitRu
     @Autowired
     NetworkModificationService networkModificationService;
 
+    private final FilterService filterService;
+
     public VoltageInitService(NotificationService notificationService,
                               NetworkModificationService networkModificationService,
                               UuidGeneratorService uuidGeneratorService,
                               VoltageInitResultService resultService,
+                              FilterService filterService,
                               ObjectMapper objectMapper) {
         super(notificationService, resultService, objectMapper, uuidGeneratorService, null);
         this.networkModificationService = Objects.requireNonNull(networkModificationService);
+        this.filterService = Objects.requireNonNull(filterService);
     }
 
     @Override
@@ -63,20 +71,32 @@ public List<String> getProviders() {
     }
 
     @Transactional(readOnly = true)
-    public VoltageInitResult getResult(UUID resultUuid) {
+    public VoltageInitResult getResult(UUID resultUuid, String stringGlobalFilters, UUID networkUuid, String variantId) {
         Optional<VoltageInitResultEntity> result = resultService.find(resultUuid);
-        return result.map(VoltageInitService::fromEntity).orElse(null);
+
+        List<String> voltageLevelIds;
+        // get global filters
+        GlobalFilter globalFilter = FilterUtils.fromStringGlobalFiltersToDTO(stringGlobalFilters, objectMapper);
+        if (globalFilter != null) {
+            voltageLevelIds = filterService.getResourceFilters(networkUuid, variantId, globalFilter);
+        } else {
+            voltageLevelIds = null;
+        }
+
+        return result.map(entity -> VoltageInitService.fromEntity(entity, voltageLevelIds)).orElse(null);
     }
 
-    private static VoltageInitResult fromEntity(VoltageInitResultEntity resultEntity) {
+    private static VoltageInitResult fromEntity(VoltageInitResultEntity resultEntity, List<String> voltageLevelIds) {
         LinkedHashMap<String, String> sortedIndicators = resultEntity.getIndicators().entrySet()
             .stream()
             .sorted(Map.Entry.comparingByKey(String.CASE_INSENSITIVE_ORDER))
             .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (collisionValue1, collisionValue2) -> collisionValue1, LinkedHashMap::new));
         List<ReactiveSlack> reactiveSlacks = resultEntity.getReactiveSlacks().stream()
-            .map(slack -> new ReactiveSlack(slack.getBusId(), slack.getSlack()))
+            .filter(slack -> CollectionUtils.isEmpty(voltageLevelIds) || voltageLevelIds.contains(slack.getVoltageLevelId()))
+            .map(slack -> new ReactiveSlack(slack.getVoltageLevelId(), slack.getBusId(), slack.getSlack()))
             .toList();
         List<BusVoltage> busVoltages = resultEntity.getBusVoltages().stream()
+            .filter(bv -> CollectionUtils.isEmpty(voltageLevelIds) || voltageLevelIds.contains(bv.getVoltageLevelId()))
             .map(bv -> new BusVoltage(bv.getVoltageLevelId(), bv.getBusId(), bv.getV(), bv.getAngle()))
             .toList();
         return new VoltageInitResult(resultEntity.getResultUuid(), resultEntity.getWriteTimeStamp(), sortedIndicators,