Sorting and filtering in shortcircuit results (#77)

Signed-off-by: Mathieu DEHARBE <[email protected]>

Author: Mathieu-Deharbe

src/main/java/org/gridsuite/shortcircuit/server/entities/FaultResultEntity.java

@@ -10,6 +10,7 @@
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
+import lombok.experimental.FieldNameConstants;
 
 import java.util.List;
 import java.util.UUID;
@@ -19,6 +20,7 @@
  */
 @Getter
 @Setter
+@FieldNameConstants
 @NoArgsConstructor
 @Entity
 @Table(indexes = {
@@ -54,6 +56,13 @@ public class FaultResultEntity {
                     columnList = "fault_result_entity_fault_result_uuid")})
     private List<LimitViolationEmbeddable> limitViolations;
 
+    /**
+     * first limit violation of the fault result entity, from 'limitViolations'
+     * Must save it inside the same table in order to get pageable FaultResultEntity sortable by this firstLimitViolation data
+     */
+    @Embedded
+    private LimitViolationEmbeddable firstLimitViolation;
+
     /*
     Bidirectional relation is not needed here and is done for performance
     https://vladmihalcea.com/the-best-way-to-map-a-onetomany-association-with-jpa-and-hibernate/
@@ -114,6 +123,9 @@ public FaultResultEntity(FaultEmbeddable fault, double current, double shortCirc
         if (limitViolations != null) {
             this.limitViolations = limitViolations;
             this.nbLimitViolations = limitViolations.size();
+            if (!this.limitViolations.isEmpty()) {
+                this.firstLimitViolation = this.limitViolations.get(0);
+            }
         }
         this.ipMin = ipMin;
         this.ipMax = ipMax;

src/main/java/org/gridsuite/shortcircuit/server/entities/FeederResultEntity.java

@@ -10,6 +10,7 @@
 import lombok.NoArgsConstructor;
 
 import jakarta.persistence.*;
+import lombok.experimental.FieldNameConstants;
 
 import java.util.UUID;
 
@@ -19,6 +20,7 @@
 @Getter
 @NoArgsConstructor
 @Entity
+@FieldNameConstants
 @Table(name = "feeder_results",
         indexes = {@Index(name = "feeder_results_fault_result_idx",
                 columnList = "fault_result_entity_fault_result_uuid")})

src/main/java/org/gridsuite/shortcircuit/server/entities/LimitViolationEmbeddable.java

@@ -15,6 +15,7 @@
 import jakarta.persistence.Embeddable;
 import jakarta.persistence.EnumType;
 import jakarta.persistence.Enumerated;
+import lombok.experimental.FieldNameConstants;
 
 /**
  * @author Nicolas Noir <nicolas.noir at rte-france.com>
@@ -23,6 +24,7 @@
 @AllArgsConstructor
 @NoArgsConstructor
 @Embeddable
+@FieldNameConstants
 public class LimitViolationEmbeddable {
 
     @Column

src/main/java/org/gridsuite/shortcircuit/server/entities/ShortCircuitAnalysisResultEntity.java

@@ -11,6 +11,8 @@
 import lombok.Setter;
 
 import jakarta.persistence.*;
+import lombok.experimental.FieldNameConstants;
+
 import java.time.ZonedDateTime;
 import java.util.Set;
 import java.util.UUID;
@@ -19,6 +21,7 @@
  * @author Nicolas Noir <nicolas.noir at rte-france.com>
  */
 @Getter
+@FieldNameConstants
 @NoArgsConstructor
 @Entity
 @Table(name = "shortcircuit_result")

src/main/java/org/gridsuite/shortcircuit/server/repositories/FaultResultRepository.java

@@ -7,6 +7,7 @@
 package org.gridsuite.shortcircuit.server.repositories;
 
 import org.gridsuite.shortcircuit.server.entities.FaultResultEntity;
+import org.springframework.data.jpa.domain.Specification;
 import org.springframework.data.jpa.repository.*;
 import org.springframework.data.jpa.repository.EntityGraph.EntityGraphType;
 import org.springframework.stereotype.Repository;
@@ -24,6 +25,9 @@ public interface FaultResultRepository extends JpaRepository<FaultResultEntity,
     @EntityGraph(attributePaths = {"limitViolations"}, type = EntityGraphType.LOAD)
     Set<FaultResultEntity> findAllWithLimitViolationsByFaultResultUuidIn(List<UUID> faultResultsUUID);
 
+    @EntityGraph(attributePaths = {"feederResults"}, type = EntityGraphType.LOAD)
+    List<FaultResultEntity> findAll(Specification<FaultResultEntity> specification);
+
     @EntityGraph(attributePaths = {"feederResults"}, type = EntityGraphType.LOAD)
     Set<FaultResultEntity> findAllWithFeederResultsByFaultResultUuidIn(List<UUID> faultResultsUUID);
 
@@ -46,4 +50,9 @@ public interface FaultResultRepository extends JpaRepository<FaultResultEntity,
     @Query(value = "DELETE FROM feeder_results WHERE fault_result_entity_fault_result_uuid IN ?1", nativeQuery = true)
     void deleteFeederResultsByFaultResultUuids(Set<UUID> ids);
 
+    List<FaultResultEntity> findAllByFaultResultUuidIn(List<UUID> uuids);
+
+    interface EntityId {
+        UUID getFaultResultUuid();
+    }
 }

src/main/java/org/gridsuite/shortcircuit/server/repositories/ShortCircuitAnalysisResultRepository.java

@@ -12,9 +12,9 @@
 import org.gridsuite.shortcircuit.server.dto.ResourceFilter;
 import org.gridsuite.shortcircuit.server.dto.ShortCircuitLimits;
 import org.gridsuite.shortcircuit.server.entities.*;
+import org.gridsuite.shortcircuit.server.repositories.specifications.FaultResultSpecificationBuilder;
 import org.gridsuite.shortcircuit.server.service.ShortCircuitRunContext;
-import org.gridsuite.shortcircuit.server.utils.FaultResultSpecificationBuilder;
-import org.gridsuite.shortcircuit.server.utils.FeederResultSpecificationBuilder;
+import org.gridsuite.shortcircuit.server.repositories.specifications.FeederResultSpecificationBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -65,7 +65,7 @@ private static List<LimitViolationEmbeddable> extractLimitViolations(FaultResult
             .map(limitViolation -> new LimitViolationEmbeddable(limitViolation.getSubjectId(),
                 limitViolation.getLimitType(), limitViolation.getLimit(),
                 limitViolation.getLimitName(), limitViolation.getValue()))
-            .collect(Collectors.toList());
+            .toList();
     }
 
     public static ShortCircuitAnalysisResultEntity toResultEntity(UUID resultUuid, ShortCircuitAnalysisResult result, Map<String, ShortCircuitLimits> allShortCircuitLimits) {
@@ -116,7 +116,7 @@ private static FaultResultEntity toMagnitudeFaultResultEntity(MagnitudeFaultResu
         entity.setFeederResults(faultResult.getFeederResults().stream()
                 .map(feederResult -> new FeederResultEntity(feederResult.getConnectableId(),
                         ((MagnitudeFeederResult) feederResult).getCurrent(), null))
-                .collect(Collectors.toList()));
+                .toList());
         if (shortCircuitLimits != null) {
             entity.setDeltaCurrentIpMin(current - entity.getIpMin() / 1000.0);
             entity.setDeltaCurrentIpMax(current - entity.getIpMax() / 1000.0);
@@ -138,7 +138,7 @@ private static FaultResultEntity toFortescueFaultResultEntity(FortescueFaultResu
                             feederFortescueThreePhaseValue.getMagnitudeC(), feederFortescueThreePhaseValue.getAngleA(),
                             feederFortescueThreePhaseValue.getAngleB(), feederFortescueThreePhaseValue.getAngleC()));
                 })
-                .collect(Collectors.toList()));
+                .toList());
 
         final FortescueValue current = faultResult.getCurrent();
         if (shortCircuitLimits != null) {
@@ -163,7 +163,7 @@ private static GlobalStatusEntity toStatusEntity(UUID resultUuid, String status)
     public void insertStatus(List<UUID> resultUuids, String status) {
         Objects.requireNonNull(resultUuids);
         globalStatusRepository.saveAll(resultUuids.stream()
-            .map(uuid -> toStatusEntity(uuid, status)).collect(Collectors.toList()));
+            .map(uuid -> toStatusEntity(uuid, status)).toList());
     }
 
     @Transactional
@@ -238,7 +238,7 @@ public Optional<ShortCircuitAnalysisResultEntity> findResultsWithLimitViolations
         List<UUID> faultResultsUuidWithLimitViolations = result.get().getFaultResults().stream()
                                                             .filter(fr -> !fr.getLimitViolations().isEmpty())
                                                             .map(FaultResultEntity::getFaultResultUuid)
-                                                            .collect(Collectors.toList());
+                                                            .toList();
         // using the Hibernate First-Level Cache or Persistence Context
         // cf.https://vladmihalcea.com/spring-data-jpa-multiplebagfetchexception/
         if (!result.get().getFaultResults().isEmpty()) {
@@ -248,20 +248,70 @@ public Optional<ShortCircuitAnalysisResultEntity> findResultsWithLimitViolations
     }
 
     @Transactional(readOnly = true)
-    public Page<FaultResultEntity> findFaultResultsPage(ShortCircuitAnalysisResultEntity result, List<ResourceFilter> resourceFilters, Pageable pageable, FaultResultsMode mode) {
+    public Page<FaultResultEntity> findFaultResultsPage(ShortCircuitAnalysisResultEntity result,
+                                                        List<ResourceFilter> resourceFilters,
+                                                        Pageable pageable,
+                                                        FaultResultsMode mode) {
         Objects.requireNonNull(result);
+
+        Optional<Sort.Order> childrenSort = extractChildrenSort(pageable);
+
+        Pageable modifiedPageable = addDefaultSort(filterOutChildrenSort(pageable, childrenSort),
+                DEFAULT_FAULT_RESULT_SORT_COLUMN);
         Specification<FaultResultEntity> specification = FaultResultSpecificationBuilder.buildSpecification(result.getResultUuid(), resourceFilters);
         // WARN org.hibernate.hql.internal.ast.QueryTranslatorImpl -
         // HHH000104: firstResult/maxResults specified with collection fetch; applying in memory!
         // cf. https://vladmihalcea.com/fix-hibernate-hhh000104-entity-fetch-pagination-warning-message/
         // We must separate in two requests, one with pagination the other one with Join Fetch
-        Page<FaultResultEntity> faultResultsPage = faultResultRepository.findAll(specification, addDefaultSort(pageable, DEFAULT_FAULT_RESULT_SORT_COLUMN));
-        if (faultResultsPage.hasContent() && mode != FaultResultsMode.BASIC) {
-            appendLimitViolationsAndFeederResults(faultResultsPage);
+
+        Page<FaultResultRepository.EntityId> uuidPage = faultResultRepository.findBy(specification, q ->
+                q.project(FaultResultEntity.Fields.faultResultUuid)
+                        .as(FaultResultRepository.EntityId.class)
+                        .sortBy(modifiedPageable.getSort())
+                        .page(modifiedPageable)
+        );
+
+        if (!uuidPage.hasContent()) {
+            return Page.empty();
+        }
+
+        List<UUID> faultResultsUuids = uuidPage
+                .map(FaultResultRepository.EntityId::getFaultResultUuid)
+                .toList();
+        // Then we fetch the main entities data for each UUID
+        List<FaultResultEntity> faultResults = faultResultRepository.findAllByFaultResultUuidIn(faultResultsUuids);
+        faultResults.sort(Comparator.comparing(fault -> faultResultsUuids.indexOf(fault.getFaultResultUuid())));
+        Page<FaultResultEntity> faultResultsPage = new PageImpl<>(faultResults, modifiedPageable, uuidPage.getTotalElements());
+
+        if (mode != FaultResultsMode.BASIC) {
+            // then we append the missing data, and filter some of the Lazy Loaded collections
+            appendLimitViolationsAndFeederResults(faultResultsPage, childrenSort, resourceFilters);
         }
+
         return faultResultsPage;
     }
 
+    private Pageable filterOutChildrenSort(Pageable pageable, Optional<Sort.Order> childrenSort) {
+        if (childrenSort.isEmpty()) {
+            return pageable;
+        }
+        return PageRequest.of(
+                pageable.getPageNumber(),
+                pageable.getPageSize(),
+                Sort.by(pageable.getSort().stream().filter(sortOrder ->
+                                !sortOrder.getProperty().equals(childrenSort.get().getProperty())
+                        ).toList()
+                )
+        );
+    }
+
+    private Optional<Sort.Order> extractChildrenSort(Pageable pageable) {
+        return pageable.getSort().stream()
+                .filter(sortOrder ->
+                        sortOrder.getProperty().contains(FeederResultEntity.Fields.connectableId))
+                .findFirst();
+    }
+
     @Transactional(readOnly = true)
     public Page<FeederResultEntity> findFeederResultsPage(ShortCircuitAnalysisResultEntity result, List<ResourceFilter> resourceFilters, Pageable pageable) {
         Objects.requireNonNull(result);
@@ -270,30 +320,78 @@ public Page<FeederResultEntity> findFeederResultsPage(ShortCircuitAnalysisResult
     }
 
     @Transactional(readOnly = true)
-    public Page<FaultResultEntity> findFaultResultsWithLimitViolationsPage(ShortCircuitAnalysisResultEntity result, List<ResourceFilter> resourceFilters, Pageable pageable) {
+    public Page<FaultResultEntity> findFaultResultsWithLimitViolationsPage(ShortCircuitAnalysisResultEntity result,
+                                                                           List<ResourceFilter> resourceFilters,
+                                                                           Pageable pageable) {
         Objects.requireNonNull(result);
+
+        Optional<Sort.Order> childrenSort = extractChildrenSort(pageable);
+
+        Pageable modifiedPageable = addDefaultSort(filterOutChildrenSort(pageable, childrenSort),
+                DEFAULT_FAULT_RESULT_SORT_COLUMN);
         Specification<FaultResultEntity> specification = FaultResultSpecificationBuilder.buildSpecification(result.getResultUuid(), resourceFilters);
         specification = FaultResultSpecificationBuilder.appendWithLimitViolationsToSpecification(specification);
         // WARN org.hibernate.hql.internal.ast.QueryTranslatorImpl -
         // HHH000104: firstResult/maxResults specified with collection fetch; applying in memory!
         // cf. https://vladmihalcea.com/fix-hibernate-hhh000104-entity-fetch-pagination-warning-message/
         // We must separate in two requests, one with pagination the other one with Join Fetch
-        Page<FaultResultEntity> faultResultsPage = faultResultRepository.findAll(specification, addDefaultSort(pageable, DEFAULT_FAULT_RESULT_SORT_COLUMN));
-        if (faultResultsPage.hasContent()) {
-            appendLimitViolationsAndFeederResults(faultResultsPage);
+
+        Page<FaultResultRepository.EntityId> uuidPage = faultResultRepository.findBy(specification, q ->
+                q.project(FaultResultEntity.Fields.faultResultUuid)
+                        .as(FaultResultRepository.EntityId.class)
+                        .sortBy(modifiedPageable.getSort())
+                        .page(modifiedPageable)
+        );
+
+        if (!uuidPage.hasContent()) {
+            return Page.empty();
         }
+
+        List<UUID> faultResultsUuids = uuidPage
+                .map(FaultResultRepository.EntityId::getFaultResultUuid)
+                .toList();
+        // Then we fetch the main entities data for each UUID
+        List<FaultResultEntity> faultResults = faultResultRepository.findAllByFaultResultUuidIn(faultResultsUuids);
+        faultResults.sort(Comparator.comparing(fault -> faultResultsUuids.indexOf(fault.getFaultResultUuid())));
+        Page<FaultResultEntity> faultResultsPage = new PageImpl<>(faultResults, modifiedPageable, uuidPage.getTotalElements());
+
+        // then we append the missing data, and filter some of the Lazy Loaded collections
+        appendLimitViolationsAndFeederResults(faultResultsPage, childrenSort, resourceFilters);
+
         return faultResultsPage;
     }
 
-    private void appendLimitViolationsAndFeederResults(Page<FaultResultEntity> pagedFaultResults) {
+    private void appendLimitViolationsAndFeederResults(Page<FaultResultEntity> pagedFaultResults,
+                                                       Optional<Sort.Order> childrenSort,
+                                                       List<ResourceFilter> resourceFilters) {
         // using the Hibernate First-Level Cache or Persistence Context
         // cf.https://vladmihalcea.com/spring-data-jpa-multiplebagfetchexception/
         if (!pagedFaultResults.isEmpty()) {
             List<UUID> faultResultsUuids = pagedFaultResults.stream()
                     .map(FaultResultEntity::getFaultResultUuid)
-                    .collect(Collectors.toList());
+                    .toList();
+
+            Specification<FaultResultEntity> specification = FaultResultSpecificationBuilder.buildFeedersSpecification(faultResultsUuids, resourceFilters);
+            faultResultRepository.findAll(specification);
+
             faultResultRepository.findAllWithLimitViolationsByFaultResultUuidIn(faultResultsUuids);
-            faultResultRepository.findAllWithFeederResultsByFaultResultUuidIn(faultResultsUuids);
+
+            sortFeeders(pagedFaultResults, childrenSort);
+        }
+    }
+
+    private void sortFeeders(Page<FaultResultEntity> pagedFaultResults, Optional<Sort.Order> childrenSort) {
+        // feeders may only be sorted by connectableId
+        if (childrenSort.isPresent()) {
+            pagedFaultResults.forEach(res -> res.getFeederResults().sort(
+                childrenSort.get().isAscending() ?
+                    Comparator.comparing(FeederResultEntity::getConnectableId) :
+                    Comparator.comparing(FeederResultEntity::getConnectableId).reversed()
+            ));
+        } else {
+            // otherwise by default feederResults (within each individual faultResult) are sorted by 'current' in descending order :
+            pagedFaultResults.forEach(res -> res.getFeederResults().sort(
+                    Comparator.comparingDouble(FeederResultEntity::getCurrent).reversed()));
         }
     }