Custom message if no extension data + fix bug (#47)

Tristan-WorkGH · web-flow · commit 6c1b46fdc58c · 2023-10-30T16:13:14.000+01:00
* Resolve ClassCastException in repository `insert()` with better support of unknown implementations
* Add custom message for missing extension and fix wrong condition
diff --git a/src/main/java/org/gridsuite/shortcircuit/server/entities/FaultResultEntity.java b/src/main/java/org/gridsuite/shortcircuit/server/entities/FaultResultEntity.java
@@ -6,18 +6,19 @@
  */
 package org.gridsuite.shortcircuit.server.entities;
 
+import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 
-import jakarta.persistence.*;
 import java.util.List;
 import java.util.UUID;
 
 /**
  * @author Nicolas Noir <nicolas.noir at rte-france.com>
  */
 @Getter
+@Setter
 @NoArgsConstructor
 @Entity
 @Table(indexes = @Index(name = "result_uuid_nbLimitViolations_idx", columnList = "result_result_uuid, nbLimitViolations"))
diff --git a/src/main/java/org/gridsuite/shortcircuit/server/repositories/ShortCircuitAnalysisResultRepository.java b/src/main/java/org/gridsuite/shortcircuit/server/repositories/ShortCircuitAnalysisResultRepository.java
@@ -7,9 +7,11 @@
 package org.gridsuite.shortcircuit.server.repositories;
 
 import com.powsybl.shortcircuit.*;
+import lombok.extern.slf4j.Slf4j;
 import org.gridsuite.shortcircuit.server.dto.ShortCircuitLimits;
 import org.gridsuite.shortcircuit.server.entities.*;
 import org.gridsuite.shortcircuit.server.utils.ShortcircuitUtils;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Repository;
@@ -24,15 +26,14 @@
 /**
  * @author Etienne Homer <etienne.homer at rte-france.com
  */
+@Slf4j
 @Repository
 public class ShortCircuitAnalysisResultRepository {
+    private final GlobalStatusRepository globalStatusRepository;
+    private final ResultRepository resultRepository;
+    private final FaultResultRepository faultResultRepository;
 
-    private GlobalStatusRepository globalStatusRepository;
-
-    private ResultRepository resultRepository;
-
-    private FaultResultRepository faultResultRepository;
-
+    @Autowired
     public ShortCircuitAnalysisResultRepository(GlobalStatusRepository globalStatusRepository,
             ResultRepository resultRepository,
             FaultResultRepository faultResultRepository) {
@@ -49,69 +50,91 @@ private static List<LimitViolationEmbeddable> extractLimitViolations(FaultResult
             .collect(Collectors.toList());
     }
 
-    private static ShortCircuitAnalysisResultEntity toResultEntity(UUID resultUuid, ShortCircuitAnalysisResult result, Map<String, ShortCircuitLimits> allShortCircuitLimits, boolean isWithFortescueResult) {
-        Set<FaultResultEntity> faultResults = result.getFaultResults().stream().map(faultResult -> isWithFortescueResult ? toFortescueFaultResultEntity(faultResult, allShortCircuitLimits.get(faultResult.getFault().getId())) : toMagnitudeFaultResultEntity(faultResult, allShortCircuitLimits.get(faultResult.getFault().getId()))).collect(Collectors.toSet());
+    private static ShortCircuitAnalysisResultEntity toResultEntity(UUID resultUuid, ShortCircuitAnalysisResult result, Map<String, ShortCircuitLimits> allShortCircuitLimits) {
+        Set<FaultResultEntity> faultResults = result.getFaultResults()
+                .stream()
+                .map(faultResult -> {
+                    if (faultResult instanceof FailedFaultResult failedFaultResult) {
+                        return toGenericFaultResultEntity(failedFaultResult, null);
+                    } else if (faultResult instanceof FortescueFaultResult fortescueFaultResult) {
+                        return toFortescueFaultResultEntity(fortescueFaultResult, allShortCircuitLimits.get(faultResult.getFault().getId()));
+                    } else if (faultResult instanceof MagnitudeFaultResult magnitudeFaultResult) {
+                        return toMagnitudeFaultResultEntity(magnitudeFaultResult, allShortCircuitLimits.get(faultResult.getFault().getId()));
+                    } else {
+                        log.warn("Unknown FaultResult class: {}", faultResult.getClass());
+                        return toGenericFaultResultEntity(faultResult, allShortCircuitLimits.get(faultResult.getFault().getId()));
+                    }
+                })
+                .collect(Collectors.toSet());
         //We need to limit the precision to avoid database precision storage limit issue (postgres has a precision of 6 digits while h2 can go to 9)
         return new ShortCircuitAnalysisResultEntity(resultUuid, ZonedDateTime.now(ZoneOffset.UTC).truncatedTo(ChronoUnit.MICROS), faultResults);
     }
 
-    private static FaultResultEntity toMagnitudeFaultResultEntity(FaultResult faultResult, ShortCircuitLimits shortCircuitLimits) {
-        Fault fault = faultResult.getFault();
-        double current = ((MagnitudeFaultResult) faultResult).getCurrent();
-        double shortCircuitPower = faultResult.getShortCircuitPower();
-        FaultEmbeddable faultEmbedded = new FaultEmbeddable(fault.getId(), fault.getElementId(), fault.getFaultType());
-        List<LimitViolationEmbeddable> limitViolations = extractLimitViolations(faultResult);
-        List<FeederResultEmbeddable> feederResults = faultResult.getFeederResults().stream()
-                .map(feederResult -> new FeederResultEmbeddable(feederResult.getConnectableId(),
-                        ((MagnitudeFeederResult) feederResult).getCurrent(), null))
-                .collect(Collectors.toList());
-
+    private static FaultResultEntity toGenericFaultResultEntity(final FaultResult faultResult, final ShortCircuitLimits shortCircuitLimits) {
+        final Fault fault = faultResult.getFault();
         double ipMax = Double.NaN;
         double ipMin = Double.NaN;
-        double deltaCurrentIpMin = Double.NaN;
-        double deltaCurrentIpMax = Double.NaN;
         if (shortCircuitLimits != null) {
             ipMax = shortCircuitLimits.getIpMax();
             ipMin = shortCircuitLimits.getIpMin();
-            deltaCurrentIpMin = current - ipMin / 1000;
-            deltaCurrentIpMax = current - ipMax / 1000;
         }
-        return new FaultResultEntity(faultEmbedded, current, shortCircuitPower, limitViolations, feederResults, ipMin, ipMax, null, null, deltaCurrentIpMin, deltaCurrentIpMax);
-    }
-
-    private static FaultResultEntity toFortescueFaultResultEntity(FaultResult faultResult, ShortCircuitLimits shortCircuitLimits) {
-        Fault fault = faultResult.getFault();
-        double shortCircuitPower = faultResult.getShortCircuitPower();
-        FaultEmbeddable faultEmbedded = new FaultEmbeddable(fault.getId(), fault.getElementId(), fault.getFaultType());
-        List<LimitViolationEmbeddable> limitViolations = extractLimitViolations(faultResult);
-        List<FeederResultEmbeddable> feederResults = faultResult.getFeederResults().stream()
-            .map(feederResult -> {
-                FortescueValue feederFortescueCurrent = ((FortescueFeederResult) feederResult).getCurrent();
-                FortescueValue.ThreePhaseValue feederFortescueThreePhaseValue = ShortcircuitUtils.toThreePhaseValue(feederFortescueCurrent);
-                return new FeederResultEmbeddable(feederResult.getConnectableId(),
-                    Double.NaN, new FortescueResultEmbeddable(feederFortescueCurrent.getPositiveMagnitude(), feederFortescueCurrent.getZeroMagnitude(), feederFortescueCurrent.getNegativeMagnitude(), feederFortescueCurrent.getPositiveAngle(), feederFortescueCurrent.getZeroAngle(), feederFortescueCurrent.getNegativeAngle(), feederFortescueThreePhaseValue.getMagnitudeA(), feederFortescueThreePhaseValue.getMagnitudeB(), feederFortescueThreePhaseValue.getMagnitudeC(), feederFortescueThreePhaseValue.getAngleA(), feederFortescueThreePhaseValue.getAngleB(), feederFortescueThreePhaseValue.getAngleC()));
-            })
-            .collect(Collectors.toList());
+        return new FaultResultEntity(
+                new FaultEmbeddable(fault.getId(), fault.getElementId(), fault.getFaultType()),
+                Double.NaN,
+                faultResult.getShortCircuitPower(),
+                extractLimitViolations(faultResult),
+                null,
+                ipMin, ipMax,
+                null, null,
+                Double.NaN, Double.NaN
+        );
+    }
 
-        double ipMax = Double.NaN;
-        double ipMin = Double.NaN;
-        double deltaCurrentIpMin = Double.NaN;
-        double deltaCurrentIpMax = Double.NaN;
-        FortescueValue current = ((FortescueFaultResult) faultResult).getCurrent();
+    private static FaultResultEntity toMagnitudeFaultResultEntity(MagnitudeFaultResult faultResult, ShortCircuitLimits shortCircuitLimits) {
+        FaultResultEntity entity = toGenericFaultResultEntity(faultResult, shortCircuitLimits);
+        final double current = faultResult.getCurrent();
+        entity.setCurrent(current);
+        entity.setFeederResults(faultResult.getFeederResults().stream()
+                .map(feederResult -> new FeederResultEmbeddable(feederResult.getConnectableId(),
+                        ((MagnitudeFeederResult) feederResult).getCurrent(), null))
+                .collect(Collectors.toList()));
         if (shortCircuitLimits != null) {
-            ipMax = shortCircuitLimits.getIpMax();
-            ipMin = shortCircuitLimits.getIpMin();
-            deltaCurrentIpMin = current.getPositiveMagnitude() - ipMin / 1000;
-            deltaCurrentIpMax = current.getPositiveMagnitude() - ipMax / 1000;
+            entity.setDeltaCurrentIpMin(current - entity.getIpMin() / 1000.0);
+            entity.setDeltaCurrentIpMax(current - entity.getIpMax() / 1000.0);
+        }
+        return entity;
+    }
+
+    private static FaultResultEntity toFortescueFaultResultEntity(FortescueFaultResult faultResult, ShortCircuitLimits shortCircuitLimits) {
+        FaultResultEntity entity = toGenericFaultResultEntity(faultResult, shortCircuitLimits);
+        entity.setFeederResults(faultResult.getFeederResults().stream()
+                .map(feederResult -> {
+                    final FortescueValue feederFortescueCurrent = ((FortescueFeederResult) feederResult).getCurrent();
+                    final FortescueValue.ThreePhaseValue feederFortescueThreePhaseValue = ShortcircuitUtils.toThreePhaseValue(feederFortescueCurrent);
+                    return new FeederResultEmbeddable(feederResult.getConnectableId(), Double.NaN, new FortescueResultEmbeddable(
+                            feederFortescueCurrent.getPositiveMagnitude(), feederFortescueCurrent.getZeroMagnitude(),
+                            feederFortescueCurrent.getNegativeMagnitude(), feederFortescueCurrent.getPositiveAngle(),
+                            feederFortescueCurrent.getZeroAngle(), feederFortescueCurrent.getNegativeAngle(),
+                            feederFortescueThreePhaseValue.getMagnitudeA(), feederFortescueThreePhaseValue.getMagnitudeB(),
+                            feederFortescueThreePhaseValue.getMagnitudeC(), feederFortescueThreePhaseValue.getAngleA(),
+                            feederFortescueThreePhaseValue.getAngleB(), feederFortescueThreePhaseValue.getAngleC()));
+                })
+                .collect(Collectors.toList()));
+
+        final FortescueValue current = faultResult.getCurrent();
+        if (shortCircuitLimits != null) {
+            entity.setDeltaCurrentIpMin(current.getPositiveMagnitude() - entity.getIpMin() / 1000.0);
+            entity.setDeltaCurrentIpMax(current.getPositiveMagnitude() - entity.getIpMax() / 1000.0);
         }
 
-        FortescueValue voltage = ((FortescueFaultResult) faultResult).getVoltage();
-        //We here use the function toThreePhaseValue from the utils class instead of FortescueValue's one because it is curently privated by mistake, to be changed once Powsybl core 6.0.0 is out
-        FortescueValue.ThreePhaseValue currentThreePhaseValue = ShortcircuitUtils.toThreePhaseValue(current);
-        FortescueValue.ThreePhaseValue voltageThreePhaseValue = ShortcircuitUtils.toThreePhaseValue(voltage);
-        FortescueResultEmbeddable fortescueCurrent = new FortescueResultEmbeddable(current.getPositiveMagnitude(), current.getZeroMagnitude(), current.getNegativeMagnitude(), current.getPositiveAngle(), current.getZeroAngle(), current.getNegativeAngle(), currentThreePhaseValue.getMagnitudeA(), currentThreePhaseValue.getMagnitudeB(), currentThreePhaseValue.getMagnitudeC(), currentThreePhaseValue.getAngleA(), currentThreePhaseValue.getAngleB(), currentThreePhaseValue.getAngleC());
-        FortescueResultEmbeddable fortescueVoltage = new FortescueResultEmbeddable(voltage.getPositiveMagnitude(), voltage.getZeroMagnitude(), voltage.getNegativeMagnitude(), voltage.getPositiveAngle(), voltage.getZeroAngle(), voltage.getNegativeAngle(), voltageThreePhaseValue.getMagnitudeA(), voltageThreePhaseValue.getMagnitudeB(), voltageThreePhaseValue.getMagnitudeC(), voltageThreePhaseValue.getAngleA(), voltageThreePhaseValue.getAngleB(), voltageThreePhaseValue.getAngleC());
-        return new FaultResultEntity(faultEmbedded, Double.NaN, shortCircuitPower, limitViolations, feederResults, ipMin, ipMax, fortescueCurrent, fortescueVoltage, deltaCurrentIpMin, deltaCurrentIpMax);
+        //We here use the function toThreePhaseValue from the utils class instead of FortescueValue's one because it is currently private by mistake, to be changed once Powsybl core 6.0.0 is out
+        final FortescueValue.ThreePhaseValue currentThreePhaseValue = ShortcircuitUtils.toThreePhaseValue(current);
+        entity.setFortescueCurrent(new FortescueResultEmbeddable(current.getPositiveMagnitude(), current.getZeroMagnitude(), current.getNegativeMagnitude(), current.getPositiveAngle(), current.getZeroAngle(), current.getNegativeAngle(), currentThreePhaseValue.getMagnitudeA(), currentThreePhaseValue.getMagnitudeB(), currentThreePhaseValue.getMagnitudeC(), currentThreePhaseValue.getAngleA(), currentThreePhaseValue.getAngleB(), currentThreePhaseValue.getAngleC()));
+        final FortescueValue voltage = faultResult.getVoltage();
+        final FortescueValue.ThreePhaseValue voltageThreePhaseValue = ShortcircuitUtils.toThreePhaseValue(voltage);
+        entity.setFortescueVoltage(new FortescueResultEmbeddable(voltage.getPositiveMagnitude(), voltage.getZeroMagnitude(), voltage.getNegativeMagnitude(), voltage.getPositiveAngle(), voltage.getZeroAngle(), voltage.getNegativeAngle(), voltageThreePhaseValue.getMagnitudeA(), voltageThreePhaseValue.getMagnitudeB(), voltageThreePhaseValue.getMagnitudeC(), voltageThreePhaseValue.getAngleA(), voltageThreePhaseValue.getAngleB(), voltageThreePhaseValue.getAngleC()));
+
+        return entity;
     }
 
     private static GlobalStatusEntity toStatusEntity(UUID resultUuid, String status) {
@@ -126,10 +149,10 @@ public void insertStatus(List<UUID> resultUuids, String status) {
     }
 
     @Transactional
-    public void insert(UUID resultUuid, ShortCircuitAnalysisResult result, Map<String, ShortCircuitLimits> allCurrentLimits, boolean isWithFortescueResult, String status) {
+    public void insert(UUID resultUuid, ShortCircuitAnalysisResult result, Map<String, ShortCircuitLimits> allCurrentLimits, String status) {
         Objects.requireNonNull(resultUuid);
-        if (result != null) {
-            resultRepository.save(toResultEntity(resultUuid, result, allCurrentLimits, isWithFortescueResult));
+        if (result != null && result.getFaultResults().stream().map(FaultResult::getStatus).noneMatch(FaultResult.Status.NO_SHORT_CIRCUIT_DATA::equals)) {
+            resultRepository.save(toResultEntity(resultUuid, result, allCurrentLimits));
         }
         globalStatusRepository.save(toStatusEntity(resultUuid, status));
     }
diff --git a/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitWorkerService.java b/src/main/java/org/gridsuite/shortcircuit/server/service/ShortCircuitWorkerService.java
@@ -17,10 +17,7 @@
 import com.powsybl.iidm.network.extensions.IdentifiableShortCircuit;
 import com.powsybl.network.store.client.NetworkStoreService;
 import com.powsybl.network.store.client.PreloadingStrategy;
-import com.powsybl.shortcircuit.BusFault;
-import com.powsybl.shortcircuit.Fault;
-import com.powsybl.shortcircuit.ShortCircuitAnalysis;
-import com.powsybl.shortcircuit.ShortCircuitAnalysisResult;
+import com.powsybl.shortcircuit.*;
 import org.apache.commons.lang3.StringUtils;
 import org.gridsuite.shortcircuit.server.dto.ShortCircuitAnalysisStatus;
 import org.gridsuite.shortcircuit.server.dto.ShortCircuitLimits;
@@ -237,13 +234,20 @@ public Consumer<Message<String>> consumeRun() {
                 long nanoTime = System.nanoTime();
                 LOGGER.info("Just run in {}s", TimeUnit.NANOSECONDS.toSeconds(nanoTime - startTime.getAndSet(nanoTime)));
 
-                resultRepository.insert(resultContext.getResultUuid(), result, shortCircuitLimits, resultContext.getRunContext().getParameters().isWithFortescueResult(), ShortCircuitAnalysisStatus.COMPLETED.name());
+                resultRepository.insert(resultContext.getResultUuid(), result, shortCircuitLimits, ShortCircuitAnalysisStatus.COMPLETED.name());
                 long finalNanoTime = System.nanoTime();
                 LOGGER.info("Stored in {}s", TimeUnit.NANOSECONDS.toSeconds(finalNanoTime - startTime.getAndSet(finalNanoTime)));
 
                 if (result != null) {  // result available
-                    notificationService.sendResultMessage(resultContext.getResultUuid(), resultContext.getRunContext().getReceiver(), resultContext.getRunContext().getBusId());
-                    LOGGER.info("Short circuit analysis complete (resultUuid='{}')", resultContext.getResultUuid());
+                    if (result.getFaultResults().stream().map(FaultResult::getStatus).anyMatch(FaultResult.Status.NO_SHORT_CIRCUIT_DATA::equals)) {
+                        LOGGER.error("Short circuit analysis failed (resultUuid='{}')", resultContext.getResultUuid());
+                        notificationService.publishFail(resultContext.getResultUuid(), resultContext.getRunContext().getReceiver(),
+                                "Missing short-circuit extension data",
+                                resultContext.getRunContext().getUserId(), resultContext.getRunContext().getBusId());
+                    } else {
+                        notificationService.sendResultMessage(resultContext.getResultUuid(), resultContext.getRunContext().getReceiver(), resultContext.getRunContext().getBusId());
+                        LOGGER.info("Short circuit analysis complete (resultUuid='{}')", resultContext.getResultUuid());
+                    }
                 } else {  // result not available : stop computation request
                     if (cancelComputationRequests.get(resultContext.getResultUuid()) != null) {
                         cleanShortCircuitAnalysisResultsAndPublishCancel(resultContext.getResultUuid(), cancelComputationRequests.get(resultContext.getResultUuid()).getReceiver());
