Pagination / filter / ordering

pom.xml

@@ -47,6 +47,7 @@
         <jib.from.image>gridsuite/java-simulator:2.0.0</jib.from.image>
         <gridsuite-dependencies.version>27</gridsuite-dependencies.version>
         <liquibase-hibernate-package>org.gridsuite.securityanalysis.server</liquibase-hibernate-package>
+        <db-util.version>1.0.5</db-util.version>
     </properties>
 
     <build>
@@ -271,6 +272,12 @@
             <artifactId>h2</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.vladmihalcea</groupId>
+            <artifactId>db-util</artifactId>
+            <version>${db-util.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 </project>

src/main/java/org/gridsuite/securityanalysis/server/RestResponseEntityExceptionHandler.java

@@ -23,6 +23,8 @@ protected ResponseEntity<Object> handleStudyException(SecurityAnalysisException
         switch (exception.getType()) {
             case RESULT_NOT_FOUND :
                 return ResponseEntity.status(HttpStatus.NOT_FOUND).body(exception.getType());
+            case INVALID_FILTER_FORMAT:
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(exception.getType());
             default:
                 return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
         }

src/main/java/org/gridsuite/securityanalysis/server/RestTemplateConfig.java

@@ -7,8 +7,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-import com.fasterxml.jackson.databind.InjectableValues;
-import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.*;
 import com.powsybl.commons.reporter.ReporterModelDeserializer;
 import com.powsybl.commons.reporter.ReporterModelJsonModule;
 import com.powsybl.contingency.json.ContingencyJsonModule;
@@ -46,7 +45,8 @@ public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter()
     }
 
     private ObjectMapper createObjectMapper() {
-        ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
+        ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json()
+            .featuresToEnable(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS).build();
         objectMapper.registerModule(new ContingencyJsonModule());
         objectMapper.registerModule(new SecurityAnalysisJsonModule());
         objectMapper.registerModule(new LoadFlowParametersJsonModule());

src/main/java/org/gridsuite/securityanalysis/server/SecurityAnalysisController.java

@@ -6,6 +6,7 @@
  */
 package org.gridsuite.securityanalysis.server;
 
+import com.powsybl.loadflow.LoadFlowResult;
 import com.powsybl.security.SecurityAnalysisResult;
 import com.powsybl.security.results.PreContingencyResult;
 import io.swagger.v3.oas.annotations.Operation;
@@ -15,17 +16,19 @@
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import org.gridsuite.securityanalysis.server.dto.SubjectLimitViolationResultDTO;
-import org.gridsuite.securityanalysis.server.dto.ContingencyResultDTO;
-import org.gridsuite.securityanalysis.server.dto.SecurityAnalysisParametersInfos;
-import org.gridsuite.securityanalysis.server.dto.SecurityAnalysisStatus;
+import org.gridsuite.securityanalysis.server.dto.*;
+import org.gridsuite.securityanalysis.server.service.SecurityAnalysisResultService;
 import org.gridsuite.securityanalysis.server.service.SecurityAnalysisRunContext;
 import org.gridsuite.securityanalysis.server.service.SecurityAnalysisService;
 import org.gridsuite.securityanalysis.server.service.SecurityAnalysisWorkerService;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.UUID;
 
@@ -40,13 +43,16 @@
 @RequestMapping(value = "/" + SecurityAnalysisApi.API_VERSION)
 @Tag(name = "Security analysis server")
 public class SecurityAnalysisController {
-    private final SecurityAnalysisService service;
+    private final SecurityAnalysisService securityAnalysisService;
+
+    private final SecurityAnalysisResultService securityAnalysisResultService;
 
     private final SecurityAnalysisWorkerService workerService;
 
-    public SecurityAnalysisController(SecurityAnalysisService service, SecurityAnalysisWorkerService workerService) {
-        this.service = service;
+    public SecurityAnalysisController(SecurityAnalysisService securityAnalysisService, SecurityAnalysisWorkerService workerService, SecurityAnalysisResultService securityAnalysisResultService) {
+        this.securityAnalysisService = securityAnalysisService;
         this.workerService = workerService;
+        this.securityAnalysisResultService = securityAnalysisResultService;
     }
 
     @PostMapping(value = "/networks/{networkUuid}/run", produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
@@ -62,7 +68,7 @@ public ResponseEntity<SecurityAnalysisResult> run(@Parameter(description = "Netw
                                                             @Parameter(description = "reportUuid") @RequestParam(name = "reportUuid", required = false) UUID reportUuid,
                                                             @Parameter(description = "reporterId") @RequestParam(name = "reporterId", required = false) String reporterId,
                                                             @RequestBody(required = false) SecurityAnalysisParametersInfos parameters) {
-        String providerToUse = provider != null ? provider : service.getDefaultProvider();
+        String providerToUse = provider != null ? provider : securityAnalysisService.getDefaultProvider();
         SecurityAnalysisResult result = workerService.run(new SecurityAnalysisRunContext(networkUuid, variantId, contigencyListNames, null, providerToUse, parameters, reportUuid, reporterId));
 
         return ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON).body(result);
@@ -82,8 +88,8 @@ public ResponseEntity<UUID> runAndSave(@Parameter(description = "Network UUID")
                                                  @Parameter(description = "reportUuid") @RequestParam(name = "reportUuid", required = false) UUID reportUuid,
                                                  @Parameter(description = "reporterId") @RequestParam(name = "reporterId", required = false) String reporterId,
                                                  @RequestBody(required = false) SecurityAnalysisParametersInfos parameters) {
-        String providerToUse = provider != null ? provider : service.getDefaultProvider();
-        UUID resultUuid = service.runAndSaveResult(new SecurityAnalysisRunContext(networkUuid, variantId, contigencyListNames, receiver, providerToUse, parameters, reportUuid, reporterId));
+        String providerToUse = provider != null ? provider : securityAnalysisService.getDefaultProvider();
+        UUID resultUuid = securityAnalysisService.runAndSaveResult(new SecurityAnalysisRunContext(networkUuid, variantId, contigencyListNames, receiver, providerToUse, parameters, reportUuid, reporterId));
         return ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON).body(resultUuid);
     }
 
@@ -92,32 +98,37 @@ public ResponseEntity<UUID> runAndSave(@Parameter(description = "Network UUID")
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The security analysis result"),
         @ApiResponse(responseCode = "404", description = "Security analysis result has not been found")})
     public ResponseEntity<PreContingencyResult> getNResult(@Parameter(description = "Result UUID") @PathVariable("resultUuid") UUID resultUuid) {
-        PreContingencyResult result = service.getNResult(resultUuid);
+        PreContingencyResult result = securityAnalysisResultService.findNResult(resultUuid);
 
         return result != null
             ? ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON).body(result)
             : ResponseEntity.notFound().build();
     }
 
-    @GetMapping(value = "/results/{resultUuid}/nmk-contingencies-result", produces = APPLICATION_JSON_VALUE)
+    @GetMapping(value = "/results/{resultUuid}/nmk-contingencies-result/paged", produces = APPLICATION_JSON_VALUE)
     @Operation(summary = "Get a security analysis result from the database - NMK contingencies result")
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The security analysis result"),
         @ApiResponse(responseCode = "404", description = "Security analysis result has not been found")})
-    public ResponseEntity<List<ContingencyResultDTO>> getNmKContingenciesResult(@Parameter(description = "Result UUID") @PathVariable("resultUuid") UUID resultUuid) {
-        List<ContingencyResultDTO> result = service.getNmKContingenciesResult(resultUuid);
+    public ResponseEntity<Page<ContingencyResultDTO>> getNmKContingenciesResult(@Parameter(description = "Result UUID") @PathVariable("resultUuid") UUID resultUuid,
+                                                                                    @Parameter(description = "Filters") @RequestParam(name = "filters", required = false) String stringFilters,
+                                                                                    @Parameter(description = "Pagination parameters") Pageable pageable) {
+        String decodedStringFilters = stringFilters != null ? URLDecoder.decode(stringFilters, StandardCharsets.UTF_8) : null;
+        Page<ContingencyResultDTO> result = securityAnalysisResultService.findNmKContingenciesResult(resultUuid, decodedStringFilters, pageable);
 
         return result != null
             ? ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON).body(result)
             : ResponseEntity.notFound().build();
     }
 
-    @GetMapping(value = "/results/{resultUuid}/nmk-constraints-result", produces = APPLICATION_JSON_VALUE)
+    @GetMapping(value = "/results/{resultUuid}/nmk-constraints-result/paged", produces = APPLICATION_JSON_VALUE)
     @Operation(summary = "Get a security analysis result from the database - NMK contingencies result")
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The security analysis result"),
         @ApiResponse(responseCode = "404", description = "Security analysis result has not been found")})
-    public ResponseEntity<List<SubjectLimitViolationResultDTO>> getNmKConstraintsResult(@Parameter(description = "Result UUID") @PathVariable("resultUuid") UUID resultUuid) {
-
-        List<SubjectLimitViolationResultDTO> result = service.getNmKConstraintsResult(resultUuid);
+    public ResponseEntity<Page<SubjectLimitViolationResultDTO>> getNmKConstraintsResult(@Parameter(description = "Result UUID") @PathVariable("resultUuid") UUID resultUuid,
+                                                                                        @Parameter(description = "Filters") @RequestParam(name = "filters", required = false) String stringFilters,
+                                                                                        @Parameter(description = "Pagination parameters") Pageable pageable) {
+        String decodedStringFilters = stringFilters != null ? URLDecoder.decode(stringFilters, StandardCharsets.UTF_8) : null;
+        Page<SubjectLimitViolationResultDTO> result = securityAnalysisResultService.findNmKConstraintsResult(resultUuid, decodedStringFilters, pageable);
         return result != null
             ? ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON).body(result)
             : ResponseEntity.notFound().build();
@@ -127,31 +138,31 @@ public ResponseEntity<List<SubjectLimitViolationResultDTO>> getNmKConstraintsRes
     @Operation(summary = "Delete a security analysis result from the database")
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The security analysis result has been deleted")})
     public ResponseEntity<Void> deleteResult(@Parameter(description = "Result UUID") @PathVariable("resultUuid") UUID resultUuid) {
-        service.deleteResult(resultUuid);
+        securityAnalysisService.deleteResult(resultUuid);
         return ResponseEntity.ok().build();
     }
 
     @DeleteMapping(value = "/results", produces = APPLICATION_JSON_VALUE)
     @Operation(summary = "Delete all security analysis results from the database")
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "All security analysis results have been deleted")})
     public ResponseEntity<Void> deleteResults() {
-        service.deleteResults();
+        securityAnalysisService.deleteResults();
         return ResponseEntity.ok().build();
     }
 
     @GetMapping(value = "/results/{resultUuid}/status", produces = APPLICATION_JSON_VALUE)
     @Operation(summary = "Get the security analysis status from the database")
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The security analysis status")})
     public ResponseEntity<SecurityAnalysisStatus> getStatus(@Parameter(description = "Result UUID") @PathVariable("resultUuid") UUID resultUuid) {
-        SecurityAnalysisStatus result = service.getStatus(resultUuid);
+        SecurityAnalysisStatus result = securityAnalysisService.getStatus(resultUuid);
         return ResponseEntity.ok().body(result);
     }
 
     @PutMapping(value = "/results/invalidate-status", produces = APPLICATION_JSON_VALUE)
     @Operation(summary = "Invalidate the security analysis status from the database")
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The security analysis status has been invalidated")})
     public ResponseEntity<Void> invalidateStatus(@Parameter(description = "Result uuids") @RequestParam(name = "resultUuid") List<UUID> resultUuids) {
-        service.setStatus(resultUuids, SecurityAnalysisStatus.NOT_DONE);
+        securityAnalysisService.setStatus(resultUuids, SecurityAnalysisStatus.NOT_DONE);
         return ResponseEntity.ok().build();
     }
 
@@ -160,7 +171,7 @@ public ResponseEntity<Void> invalidateStatus(@Parameter(description = "Result uu
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The security analysis has been stopped")})
     public ResponseEntity<Void> stop(@Parameter(description = "Result UUID") @PathVariable("resultUuid") UUID resultUuid,
                                            @Parameter(description = "Result receiver") @RequestParam(name = "receiver", required = false) String receiver) {
-        service.stop(resultUuid, receiver);
+        securityAnalysisService.stop(resultUuid, receiver);
         return ResponseEntity.ok().build();
     }
 
@@ -169,13 +180,20 @@ public ResponseEntity<Void> stop(@Parameter(description = "Result UUID") @PathVa
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "Security analysis providers have been found")})
     public ResponseEntity<List<String>> getProviders() {
         return ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON)
-                .body(service.getProviders());
+                .body(securityAnalysisService.getProviders());
     }
 
     @GetMapping(value = "/default-provider", produces = TEXT_PLAIN_VALUE)
     @Operation(summary = "Get security analysis default provider")
     @ApiResponses(@ApiResponse(responseCode = "200", description = "The security analysis default provider has been found"))
     public ResponseEntity<String> getDefaultProvider() {
-        return ResponseEntity.ok().body(service.getDefaultProvider());
+        return ResponseEntity.ok().body(securityAnalysisService.getDefaultProvider());
+    }
+
+    @GetMapping(value = "/computation-status", produces = APPLICATION_JSON_VALUE)
+    @Operation(summary = "Get available computation status")
+    @ApiResponses(@ApiResponse(responseCode = "200", description = "List of available computation status"))
+    public ResponseEntity<LoadFlowResult.ComponentResult.Status[]> getComputationStatus() {
+        return ResponseEntity.ok().body(LoadFlowResult.ComponentResult.Status.values());
     }
 }

src/main/java/org/gridsuite/securityanalysis/server/dto/ContingencyDTO.java

@@ -15,13 +15,13 @@
 @Builder
 public class ContingencyDTO {
     private String contingencyId;
-    private String computationStatus;
+    private String status;
     private List<ContingencyElementDTO> elements;
 
     public static ContingencyDTO toDto(ContingencyEntity contingency) {
         return ContingencyDTO.builder()
             .contingencyId(contingency.getContingencyId())
-            .computationStatus(contingency.getStatus())
+            .status(contingency.getStatus())
             .elements(contingency.getContingencyElements().stream().map(ContingencyElementDTO::toDto).collect(Collectors.toList()))
             .build();
     }

src/main/java/org/gridsuite/securityanalysis/server/dto/ResourceFilterDTO.java

@@ -0,0 +1,42 @@
+/**
+* Copyright (c) 2023, 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.securityanalysis.server.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+/**
+ * An object that can be used to filter data with the JPA Criteria API (via Spring Specification)
+ * @param dataType the type of data we want to filter (text, number)
+ * @param type the type of filter (contains, startsWith...)
+ * @param value the value of the filter
+ * @param column the column / field on which the filter will be applied
+ *
+ * @author Kevin Le Saulnier <kevin.lesaulnier at rte-france.com>
+ */
+public record ResourceFilterDTO(DataType dataType, Type type, Object value, Column column) {
+
+    public enum DataType {
+        @JsonProperty("text")
+        TEXT,
+    }
+
+    public enum Type {
+        CONTAINS,
+        @JsonProperty("startsWith")
+        STARTS_WITH,
+        EQUALS
+    }
+
+    public enum Column {
+        @JsonProperty("contingencyId")
+        CONTINGENCY_ID,
+        STATUS,
+        @JsonProperty("subjectId")
+        SUBJECT_ID
+    }
+}

src/main/java/org/gridsuite/securityanalysis/server/entities/ContingencyLimitViolationEntity.java

@@ -22,7 +22,7 @@
 @Entity
 @Table(name = "contingency_limit_violation")
 public class ContingencyLimitViolationEntity extends AbstractLimitViolationEntity {
-    @ManyToOne(fetch = FetchType.LAZY)
+    @ManyToOne
     @Setter
     private ContingencyEntity contingency;
 

src/main/java/org/gridsuite/securityanalysis/server/entities/SecurityAnalysisResultEntity.java

@@ -10,7 +10,7 @@
 import jakarta.persistence.*;
 import lombok.*;
 import org.gridsuite.securityanalysis.server.dto.SecurityAnalysisStatus;
-import org.gridsuite.securityanalysis.server.service.SecurityAnalysisResultService;
+import org.jgrapht.alg.util.Pair;
 
 import java.util.List;
 import java.util.Map;
@@ -51,7 +51,7 @@ public SecurityAnalysisResultEntity(UUID id) {
     }
 
     public static SecurityAnalysisResultEntity toEntity(UUID resultUuid, SecurityAnalysisResult securityAnalysisResult, SecurityAnalysisStatus securityAnalysisStatus) {
-        Map<String, SubjectLimitViolationEntity> subjectLimitViolationsBySubjectId = SecurityAnalysisResultService.getUniqueSubjectLimitViolationsFromResult(securityAnalysisResult)
+        Map<String, SubjectLimitViolationEntity> subjectLimitViolationsBySubjectId = getUniqueSubjectLimitViolationsFromResult(securityAnalysisResult)
             .stream().collect(Collectors.toMap(
                 SubjectLimitViolationEntity::getSubjectId,
                 subjectLimitViolation -> subjectLimitViolation)
@@ -85,4 +85,14 @@ public static SecurityAnalysisResultEntity toEntity(UUID resultUuid, SecurityAna
         subjectLimitViolations.forEach(subjectLimitViolation -> subjectLimitViolation.setResult(securityAnalysisResultEntity));
         return securityAnalysisResultEntity;
     }
+
+    private static List<SubjectLimitViolationEntity> getUniqueSubjectLimitViolationsFromResult(SecurityAnalysisResult securityAnalysisResult) {
+        return Stream.concat(
+                securityAnalysisResult.getPostContingencyResults().stream().flatMap(pcr -> pcr.getLimitViolationsResult().getLimitViolations().stream()),
+                securityAnalysisResult.getPreContingencyResult().getLimitViolationsResult().getLimitViolations().stream())
+            .map(lm -> new Pair<>(lm.getSubjectId(), lm.getSubjectName()))
+            .distinct()
+            .map(pair -> new SubjectLimitViolationEntity(pair.getFirst(), pair.getSecond()))
+            .toList();
+    }
 }