Get computation statuses for branch

src/main/java/org/gridsuite/study/server/controller/StudyController.java

@@ -20,6 +20,8 @@
 import org.gridsuite.filter.globalfilter.GlobalFilter;
 import org.gridsuite.filter.utils.EquipmentType;
 import org.gridsuite.study.server.StudyApi;
+import org.gridsuite.study.server.StudyConstants.CompositeModificationsActionType;
+import org.gridsuite.study.server.StudyConstants.ModificationsActionType;
 import org.gridsuite.study.server.dto.*;
 import org.gridsuite.study.server.dto.computation.LoadFlowComputationInfos;
 import org.gridsuite.study.server.dto.dynamicmargincalculation.DynamicMarginCalculationStatus;
@@ -882,8 +884,8 @@ public ResponseEntity<String> getShortCircuitAnalysisStatus(@Parameter(descripti
                                                                 @PathVariable("rootNetworkUuid") UUID rootNetworkUuid,
                                                                 @Parameter(description = "nodeUuid") @PathVariable("nodeUuid") UUID nodeUuid,
                                                                 @Parameter(description = "type") @RequestParam(value = "type", required = false, defaultValue = "ALL_BUSES") ShortcircuitAnalysisType type) {
-        String result = rootNetworkNodeInfoService.getShortCircuitAnalysisStatus(nodeUuid, rootNetworkUuid, type);
-        return result != null ? ResponseEntity.ok().body(result) :
+        ShortCircuitAnalysisStatus result = rootNetworkNodeInfoService.getShortCircuitAnalysisStatus(nodeUuid, rootNetworkUuid, type);
+        return result != null ? ResponseEntity.ok().body(result.name()) :
                 ResponseEntity.noContent().build();
     }
 
@@ -975,8 +977,8 @@ public ResponseEntity<String> getVoltageInitResult(@Parameter(description = "stu
     public ResponseEntity<String> getVoltageInitStatus(@Parameter(description = "Study UUID") @PathVariable("studyUuid") UUID studyUuid,
                                                        @Parameter(description = "rootNetworkUuid") @PathVariable("rootNetworkUuid") UUID rootNetworkUuid,
                                                        @Parameter(description = "nodeUuid") @PathVariable("nodeUuid") UUID nodeUuid) {
-        String result = rootNetworkNodeInfoService.getVoltageInitStatus(nodeUuid, rootNetworkUuid);
-        return result != null ? ResponseEntity.ok().body(result) :
+        VoltageInitStatus result = rootNetworkNodeInfoService.getVoltageInitStatus(nodeUuid, rootNetworkUuid);
+        return result != null ? ResponseEntity.ok().body(result.name()) :
                 ResponseEntity.noContent().build();
     }
 
@@ -1815,8 +1817,8 @@ public ResponseEntity<String> getSensitivityAnalysisFilterOptions(
     public ResponseEntity<String> getSensitivityAnalysisStatus(@Parameter(description = "Study UUID") @PathVariable("studyUuid") UUID studyUuid,
                                                                @Parameter(description = "rootNetworkUuid") @PathVariable("rootNetworkUuid") UUID rootNetworkUuid,
                                                                @Parameter(description = "nodeUuid") @PathVariable("nodeUuid") UUID nodeUuid) {
-        String result = rootNetworkNodeInfoService.getSensitivityAnalysisStatus(nodeUuid, rootNetworkUuid);
-        return result != null ? ResponseEntity.ok().body(result) :
+        SensitivityAnalysisStatus result = rootNetworkNodeInfoService.getSensitivityAnalysisStatus(nodeUuid, rootNetworkUuid);
+        return result != null ? ResponseEntity.ok().body(result.name()) :
             ResponseEntity.noContent().build();
     }
 
@@ -2394,8 +2396,8 @@ public ResponseEntity<String> getStateEstimationResult(@Parameter(description =
     public ResponseEntity<String> getStateEstimationStatus(@Parameter(description = "Study UUID") @PathVariable("studyUuid") UUID studyUuid,
                                                             @PathVariable("rootNetworkUuid") UUID rootNetworkUuid,
                                                             @Parameter(description = "nodeUuid") @PathVariable("nodeUuid") UUID nodeUuid) {
-        String status = rootNetworkNodeInfoService.getStateEstimationStatus(nodeUuid, rootNetworkUuid);
-        return status != null ? ResponseEntity.ok().body(status) : ResponseEntity.noContent().build();
+        StateEstimationStatus status = rootNetworkNodeInfoService.getStateEstimationStatus(nodeUuid, rootNetworkUuid);
+        return status != null ? ResponseEntity.ok().body(status.name()) : ResponseEntity.noContent().build();
     }
 
     @GetMapping(value = "/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/pcc-min/status")
@@ -2406,8 +2408,8 @@ public ResponseEntity<String> getStateEstimationStatus(@Parameter(description =
     public ResponseEntity<String> getPccMinStatus(@Parameter(description = "Study UUID") @PathVariable("studyUuid") UUID studyUuid,
                                                   @PathVariable("rootNetworkUuid") UUID rootNetworkUuid,
                                                   @Parameter(description = "nodeUuid") @PathVariable("nodeUuid") UUID nodeUuid) {
-        String status = rootNetworkNodeInfoService.getPccMinStatus(nodeUuid, rootNetworkUuid);
-        return status != null ? ResponseEntity.ok().body(status) : ResponseEntity.noContent().build();
+        PccMinStatus status = rootNetworkNodeInfoService.getPccMinStatus(nodeUuid, rootNetworkUuid);
+        return status != null ? ResponseEntity.ok().body(status.name()) : ResponseEntity.noContent().build();
     }
 
     @PutMapping(value = "/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/state-estimation/stop")

src/main/java/org/gridsuite/study/server/dto/ShortCircuitStatus.java → src/main/java/org/gridsuite/study/server/dto/ShortCircuitAnalysisStatus.java

@@ -9,7 +9,7 @@
 /**
  * @author Etienne Homer <etienne.homer at rte-france.com>
  */
-public enum ShortCircuitStatus {
+public enum ShortCircuitAnalysisStatus {
     NOT_DONE,
     RUNNING,
     COMPLETED

src/main/java/org/gridsuite/study/server/repository/rootnetwork/RootNetworkNodeInfoRepository.java

@@ -49,6 +49,8 @@ public interface RootNetworkNodeInfoRepository extends JpaRepository<RootNetwork
     @EntityGraph(attributePaths = {"rootNetwork"}, type = EntityGraph.EntityGraphType.LOAD)
     List<RootNetworkNodeInfoEntity> findAllWithRootNetworkByNodeInfoId(UUID nodeInfoId);
 
+    List<RootNetworkNodeInfoEntity> findAllByNodeInfoIdInAndRootNetworkId(List<UUID> nodeInfoIds, UUID rootNetworkUuid);
+
     Optional<RootNetworkNodeInfoEntity> findByNodeInfoIdAndRootNetworkId(UUID nodeInfoId, UUID rootNetworkUuid);
 
     @EntityGraph(attributePaths = {"modificationsUuidsToExclude"}, type = EntityGraph.EntityGraphType.LOAD)

src/main/java/org/gridsuite/study/server/service/LoadFlowService.java

@@ -20,15 +20,19 @@
 import org.springframework.http.*;
 import org.springframework.lang.Nullable;
 import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
 import org.springframework.web.client.RestTemplate;
 import org.springframework.web.util.UriComponentsBuilder;
 
 import java.io.UncheckedIOException;
 import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.UUID;
 
 import static org.gridsuite.study.server.StudyConstants.*;
@@ -133,14 +137,23 @@ public String getLoadFlowModifications(UUID resultUuid) {
     }
 
     public LoadFlowStatus getLoadFlowStatus(UUID resultUuid) {
-        if (resultUuid == null) {
-            return null;
+        return getLoadFlowStatuses(List.of(resultUuid)).get(resultUuid);
+    }
+
+    public Map<UUID, LoadFlowStatus> getLoadFlowStatuses(List<UUID> resultUuids) {
+        if (CollectionUtils.isEmpty(resultUuids)) {
+            return Map.of();
         }
 
-        UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromPath(DELIMITER + LOADFLOW_API_VERSION + "/results/{resultUuid}/status");
-        String path = uriComponentsBuilder.buildAndExpand(resultUuid).toUriString();
+        UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromPath(DELIMITER + LOADFLOW_API_VERSION + "/results/statuses");
+        String path = uriComponentsBuilder.toUriString();
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+
+        HttpEntity<List<UUID>> httpEntity = new HttpEntity<>(resultUuids, headers);
 
-        return restTemplate.getForObject(loadFlowServerBaseUri + path, LoadFlowStatus.class);
+        return restTemplate.exchange(loadFlowServerBaseUri + path, HttpMethod.POST, httpEntity, new ParameterizedTypeReference<Map<UUID, LoadFlowStatus>>() {
+        }).getBody();
     }
 
     public void stopLoadFlow(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid, UUID resultUuid, String userId) {
@@ -191,9 +204,10 @@ public void setLoadFlowServerBaseUri(String loadFlowServerBaseUri) {
         this.loadFlowServerBaseUri = loadFlowServerBaseUri;
     }
 
-    public void assertLoadFlowNotRunning(UUID resultUuid) {
-        LoadFlowStatus loadFlowStatus = getLoadFlowStatus(resultUuid);
-        if (LoadFlowStatus.RUNNING.equals(loadFlowStatus)) {
+    public void assertNoLoadFlowRunning(List<UUID> resultUuids) {
+        Map<UUID, LoadFlowStatus> loadFlowStatuses = getLoadFlowStatuses(resultUuids);
+        Set<LoadFlowStatus> values = new HashSet<>(loadFlowStatuses.values());
+        if (values.contains(LoadFlowStatus.RUNNING)) {
             throw new StudyException(COMPUTATION_RUNNING);
         }
     }

src/main/java/org/gridsuite/study/server/service/PccMinService.java

@@ -18,19 +18,24 @@
 import org.gridsuite.study.server.utils.ResultParameters;
 import org.gridsuite.study.server.utils.StudyUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.data.domain.Sort;
 import org.springframework.http.*;
 import org.springframework.lang.Nullable;
 import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
 import org.springframework.web.client.RestTemplate;
 import org.springframework.web.util.UriComponentsBuilder;
 
 import java.io.UncheckedIOException;
 import java.net.URI;
 import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.UUID;
 
 import org.springframework.data.domain.Pageable;
@@ -118,14 +123,24 @@ public void stopPccMin(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid, UUID
         restTemplate.put(pccMinServerBaseUri + path, Void.class);
     }
 
-    public String getPccMinStatus(UUID resultUuid) {
-        if (resultUuid == null) {
-            return null;
+    public PccMinStatus getPccMinStatus(UUID resultUuid) {
+        return getPccMinStatuses(List.of(resultUuid)).get(resultUuid);
+    }
+
+    public Map<UUID, PccMinStatus> getPccMinStatuses(List<UUID> resultUuids) {
+        if (CollectionUtils.isEmpty(resultUuids)) {
+            return Map.of();
         }
         String path = UriComponentsBuilder
-            .fromPath(PCC_MIN_URI + DELIMITER + "results/{resultUuid}/status")
-            .buildAndExpand(resultUuid).toUriString();
-        return restTemplate.getForObject(pccMinServerBaseUri + path, String.class);
+            .fromPath(PCC_MIN_URI + DELIMITER + "results/statuses")
+            .toUriString();
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+
+        HttpEntity<List<UUID>> httpEntity = new HttpEntity<>(resultUuids, headers);
+        return restTemplate.exchange(path, HttpMethod.POST, httpEntity, new ParameterizedTypeReference<Map<UUID, PccMinStatus>>() {
+        }).getBody();
     }
 
     public void deletePccMinResults(List<UUID> resultsUuids) {
@@ -142,9 +157,10 @@ public Integer getPccMinResultsCount() {
         return restTemplate.getForObject(pccMinServerBaseUri + path, Integer.class);
     }
 
-    public void assertPccMinNotRunning(UUID resultUuid) {
-        String status = getPccMinStatus(resultUuid);
-        if (PccMinStatus.RUNNING.name().equals(status)) {
+    public void assertNoPccMinRunning(List<UUID> resultUuids) {
+        Map<UUID, PccMinStatus> pccMinStatuses = getPccMinStatuses(resultUuids);
+        Set<PccMinStatus> values = new HashSet<>(pccMinStatuses.values());
+        if (values.contains(PccMinStatus.RUNNING)) {
             throw new StudyException(COMPUTATION_RUNNING);
         }
     }

src/main/java/org/gridsuite/study/server/service/RootNetworkNodeInfoService.java

@@ -10,6 +10,7 @@
 import lombok.NonNull;
 import org.apache.commons.lang3.StringUtils;
 import org.gridsuite.study.server.dto.*;
+import org.gridsuite.study.server.dto.InvalidateNodeTreeParameters.ComputationsInvalidationMode;
 import org.gridsuite.study.server.dto.computation.LoadFlowComputationInfos;
 import org.gridsuite.study.server.dto.dynamicmargincalculation.DynamicMarginCalculationStatus;
 import org.gridsuite.study.server.dto.dynamicsecurityanalysis.DynamicSecurityAnalysisStatus;
@@ -449,6 +450,10 @@ public Optional<RootNetworkNodeInfoEntity> getRootNetworkNodeInfo(UUID nodeUuid,
         return rootNetworkNodeInfoRepository.findByNodeInfoIdAndRootNetworkId(nodeUuid, rootNetworkUuid);
     }
 
+    public List<RootNetworkNodeInfoEntity> getRootNetworkNodeInfos(List<UUID> nodeUuids, UUID rootNetworkUuid) {
+        return rootNetworkNodeInfoRepository.findAllByNodeInfoIdInAndRootNetworkId(nodeUuids, rootNetworkUuid);
+    }
+
     private static UUID getComputationResultUuid(RootNetworkNodeInfoEntity rootNetworkNodeInfoEntity, ComputationType computationType) {
         return switch (computationType) {
             case LOAD_FLOW -> rootNetworkNodeInfoEntity.getLoadFlowResultUuid();
@@ -470,6 +475,14 @@ public UUID getComputationResultUuid(UUID nodeUuid, UUID rootNetworkUuid, Comput
         return rootNetworkNodeInfoEntityOpt.map(rootNetworkNodeInfoEntity -> getComputationResultUuid(rootNetworkNodeInfoEntity, computationType)).orElse(null);
     }
 
+    public List<UUID> getComputationResultUuids(List<UUID> nodeUuids, UUID rootNetworkUuid, ComputationType computationType) {
+        List<RootNetworkNodeInfoEntity> rootNetworkNodeInfoEntities = getRootNetworkNodeInfos(nodeUuids, rootNetworkUuid);
+        return rootNetworkNodeInfoEntities.stream()
+            .map(rootNetworkNodeInfoEntity -> getComputationResultUuid(rootNetworkNodeInfoEntity, computationType))
+            .filter(Objects::nonNull)
+            .toList();
+    }
+
     public List<UUID> getComputationResultUuids(UUID studyUuid, ComputationType computationType) {
         return rootNetworkNodeInfoRepository.findAllByRootNetworkStudyId(studyUuid).stream()
             .map(rootNetworkNodeInfoEntity -> getComputationResultUuid(rootNetworkNodeInfoEntity, computationType))
@@ -656,19 +669,21 @@ private List<UUID> getReportUuids(RootNetworkNodeInfo rootNetworkNodeInfo) {
             .toList();
     }
 
-    public void assertComputationNotRunning(UUID nodeUuid, UUID rootNetworkUuid) {
-        loadFlowService.assertLoadFlowNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, LOAD_FLOW));
-        securityAnalysisService.assertSecurityAnalysisNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, SECURITY_ANALYSIS));
-        dynamicSimulationService.assertDynamicSimulationNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, DYNAMIC_SIMULATION));
-        dynamicSecurityAnalysisService.assertDynamicSecurityAnalysisNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, DYNAMIC_SECURITY_ANALYSIS));
-        dynamicMarginCalculationService.assertDynamicMarginCalculationNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, DYNAMIC_MARGIN_CALCULATION));
-        sensitivityAnalysisService.assertSensitivityAnalysisNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, SENSITIVITY_ANALYSIS));
-        shortCircuitService.assertShortCircuitAnalysisNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, SHORT_CIRCUIT), getComputationResultUuid(nodeUuid, rootNetworkUuid, SHORT_CIRCUIT_ONE_BUS));
-        voltageInitService.assertVoltageInitNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, VOLTAGE_INITIALIZATION));
-        stateEstimationService.assertStateEstimationNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, STATE_ESTIMATION));
-        pccMinService.assertPccMinNotRunning(getComputationResultUuid(nodeUuid, rootNetworkUuid, PCC_MIN));
+    public void assertComputationsNotRunning(List<UUID> nodeUuids, UUID rootNetworkUuid) {
+        loadFlowService.assertNoLoadFlowRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, LOAD_FLOW));
+        securityAnalysisService.assertNoSecurityAnalysisRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, SECURITY_ANALYSIS));
+        dynamicSimulationService.assertNoDynamicSimulationRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, DYNAMIC_SIMULATION));
+        dynamicSecurityAnalysisService.assertNoDynamicSecurityAnalysisRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, DYNAMIC_SECURITY_ANALYSIS));
+        dynamicMarginCalculationService.assertNoDynamicMarginCalculationRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, DYNAMIC_MARGIN_CALCULATION));
+        sensitivityAnalysisService.assertNoSensitivityAnalysisRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, SENSITIVITY_ANALYSIS));
+        shortCircuitService.assertNoShortCircuitAnalysisRunning(Stream.concat(getComputationResultUuids(nodeUuids, rootNetworkUuid, SHORT_CIRCUIT).stream(), getComputationResultUuids(nodeUuids, rootNetworkUuid, SHORT_CIRCUIT_ONE_BUS).stream()).toList());
+        voltageInitService.assertNoVoltageInitRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, VOLTAGE_INITIALIZATION));
+        stateEstimationService.assertNoStateEstimationRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, STATE_ESTIMATION));
+        pccMinService.assertNoPccMinRunning(getComputationResultUuids(nodeUuids, rootNetworkUuid, PCC_MIN));
     }
 
+
+
     /***************************
      * GET COMPUTATION RESULTS *
      ***************************/
@@ -857,32 +872,32 @@ public DynamicMarginCalculationStatus getDynamicMarginCalculationStatus(UUID nod
         return dynamicMarginCalculationService.getStatus(resultUuid);
     }
 
-    public String getSensitivityAnalysisStatus(UUID nodeUuid, UUID rootNetworkUuid) {
+    public SensitivityAnalysisStatus getSensitivityAnalysisStatus(UUID nodeUuid, UUID rootNetworkUuid) {
         UUID resultUuid = getComputationResultUuid(nodeUuid, rootNetworkUuid, SENSITIVITY_ANALYSIS);
         return sensitivityAnalysisService.getSensitivityAnalysisStatus(resultUuid);
     }
 
     @Transactional(readOnly = true)
-    public String getShortCircuitAnalysisStatus(UUID nodeUuid, UUID rootNetworkUuid, ShortcircuitAnalysisType type) {
+    public ShortCircuitAnalysisStatus getShortCircuitAnalysisStatus(UUID nodeUuid, UUID rootNetworkUuid, ShortcircuitAnalysisType type) {
         UUID resultUuid = getComputationResultUuid(nodeUuid, rootNetworkUuid,
             type == ShortcircuitAnalysisType.ALL_BUSES ? SHORT_CIRCUIT : SHORT_CIRCUIT_ONE_BUS);
         return shortCircuitService.getShortCircuitAnalysisStatus(resultUuid);
     }
 
     @Transactional(readOnly = true)
-    public String getVoltageInitStatus(UUID nodeUuid, UUID rootNetworkUuid) {
+    public VoltageInitStatus getVoltageInitStatus(UUID nodeUuid, UUID rootNetworkUuid) {
         UUID resultUuid = getComputationResultUuid(nodeUuid, rootNetworkUuid, VOLTAGE_INITIALIZATION);
         return voltageInitService.getVoltageInitStatus(resultUuid);
     }
 
     @Transactional(readOnly = true)
-    public String getStateEstimationStatus(UUID nodeUuid, UUID rootNetworkUuid) {
+    public StateEstimationStatus getStateEstimationStatus(UUID nodeUuid, UUID rootNetworkUuid) {
         UUID resultUuid = getComputationResultUuid(nodeUuid, rootNetworkUuid, STATE_ESTIMATION);
         return stateEstimationService.getStateEstimationStatus(resultUuid);
     }
 
     @Transactional(readOnly = true)
-    public String getPccMinStatus(UUID nodeUuid, UUID rootNetworkUuid) {
+    public PccMinStatus getPccMinStatus(UUID nodeUuid, UUID rootNetworkUuid) {
         UUID resultUuid = getComputationResultUuid(nodeUuid, rootNetworkUuid, PCC_MIN);
         return pccMinService.getPccMinStatus(resultUuid);
     }