Merge branch 'main' into handle_errors_when_getting_modifications

Author: FranckLecuyer

monitor-server/src/main/java/org/gridsuite/monitor/server/mapper/SecurityAnalysisConfigMapper.java

@@ -6,7 +6,6 @@
  */
 package org.gridsuite.monitor.server.mapper;
 
-import org.gridsuite.monitor.commons.PersistedProcessConfig;
 import org.gridsuite.monitor.commons.SecurityAnalysisConfig;
 import org.gridsuite.monitor.server.entities.SecurityAnalysisConfigEntity;
 import org.mapstruct.Mapper;
@@ -23,8 +22,5 @@ public interface SecurityAnalysisConfigMapper {
 
     SecurityAnalysisConfig toDto(SecurityAnalysisConfigEntity dto);
 
-    @Mapping(target = "processConfig", source = ".")
-    PersistedProcessConfig toPersistedProcessConfigDto(SecurityAnalysisConfigEntity entity);
-
     void updateEntityFromDto(SecurityAnalysisConfig dto, @MappingTarget SecurityAnalysisConfigEntity entity);
 }

monitor-server/src/main/java/org/gridsuite/monitor/server/services/MonitorService.java

@@ -8,6 +8,8 @@
 
 import com.powsybl.commons.PowsyblException;
 import org.gridsuite.monitor.commons.PersistedProcessConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.gridsuite.monitor.commons.ProcessExecutionStep;
 import org.gridsuite.monitor.commons.ProcessStatus;
 import org.gridsuite.monitor.commons.ProcessType;
@@ -33,6 +35,8 @@
 @Service
 public class MonitorService {
 
+    private static final Logger LOGGER = LoggerFactory.getLogger(MonitorService.class);
+
     private final ProcessExecutionRepository executionRepository;
     private final NotificationService notificationService;
     private final ProcessConfigService processConfigService;
@@ -93,7 +97,7 @@ public Optional<UUID> executeProcess(UUID caseUuid, String userId, UUID processC
 
     @Transactional
     public void updateExecutionStatus(UUID executionId, ProcessStatus status, String executionEnvName, Instant startedAt, Instant completedAt) {
-        executionRepository.findById(executionId).ifPresent(execution -> {
+        executionRepository.findById(executionId).ifPresentOrElse(execution -> {
             execution.setStatus(status);
             if (executionEnvName != null) {
                 execution.setExecutionEnvName(executionEnvName);
@@ -105,7 +109,7 @@ public void updateExecutionStatus(UUID executionId, ProcessStatus status, String
                 execution.setCompletedAt(completedAt);
             }
             executionRepository.save(execution);
-        });
+        }, () -> LOGGER.warn("Execution {} not found in DB, ignoring status update", executionId));
     }
 
     private void updateStep(ProcessExecutionEntity execution, ProcessExecutionStepEntity stepEntity) {
@@ -124,22 +128,22 @@ private void updateStep(ProcessExecutionEntity execution, ProcessExecutionStepEn
 
     @Transactional
     public void updateStepStatus(UUID executionId, ProcessExecutionStep processExecutionStep) {
-        executionRepository.findById(executionId).ifPresent(execution -> {
+        executionRepository.findById(executionId).ifPresentOrElse(execution -> {
             ProcessExecutionStepEntity stepEntity = processExecutionStepMapper.toEntity(processExecutionStep);
             updateStep(execution, stepEntity);
             executionRepository.save(execution);
-        });
+        }, () -> LOGGER.warn("Execution {} not found in DB, ignoring step update", executionId));
     }
 
     @Transactional
     public void updateStepsStatuses(UUID executionId, List<ProcessExecutionStep> processExecutionSteps) {
-        executionRepository.findById(executionId).ifPresent(execution -> {
+        executionRepository.findById(executionId).ifPresentOrElse(execution -> {
             processExecutionSteps.forEach(processExecutionStep -> {
                 ProcessExecutionStepEntity stepEntity = processExecutionStepMapper.toEntity(processExecutionStep);
                 updateStep(execution, stepEntity);
             });
             executionRepository.save(execution);
-        });
+        }, () -> LOGGER.warn("Execution {} not found in DB, ignoring steps update", executionId));
     }
 
     @Transactional(readOnly = true)

monitor-server/src/main/java/org/gridsuite/monitor/server/services/ProcessConfigService.java

@@ -10,20 +10,16 @@
 import org.gridsuite.monitor.commons.ProcessConfig;
 import org.gridsuite.monitor.commons.ProcessType;
 import org.gridsuite.monitor.commons.SecurityAnalysisConfig;
-import org.gridsuite.monitor.server.entities.ProcessConfigEntity;
 import org.gridsuite.monitor.server.dto.ProcessConfigComparison;
 import org.gridsuite.monitor.server.dto.ProcessConfigFieldComparison;
+import org.gridsuite.monitor.server.entities.ProcessConfigEntity;
 import org.gridsuite.monitor.server.entities.SecurityAnalysisConfigEntity;
 import org.gridsuite.monitor.server.mapper.SecurityAnalysisConfigMapper;
 import org.gridsuite.monitor.server.repositories.ProcessConfigRepository;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.UUID;
+import java.util.*;
 
 /**
  * @author Franck Lecuyer <franck.lecuyer at rte-france.com>
@@ -50,10 +46,7 @@ public UUID createProcessConfig(ProcessConfig processConfig) {
 
     @Transactional(readOnly = true)
     public Optional<PersistedProcessConfig> getProcessConfig(UUID processConfigUuid) {
-        return processConfigRepository.findById(processConfigUuid).flatMap(entity -> switch (entity) {
-            case SecurityAnalysisConfigEntity sae -> Optional.of(securityAnalysisConfigMapper.toPersistedProcessConfigDto(sae));
-            default -> throw new IllegalArgumentException("Unsupported entity type: " + entity.getProcessType());
-        });
+        return processConfigRepository.findById(processConfigUuid).map(this::toPersistedProcessConfig);
     }
 
     @Transactional
@@ -84,24 +77,33 @@ public boolean deleteProcessConfig(UUID processConfigUuid) {
 
     @Transactional(readOnly = true)
     public List<PersistedProcessConfig> getProcessConfigs(ProcessType processType) {
-        List<ProcessConfigEntity> processConfigs = processConfigRepository.findAllByProcessType(processType);
-        return processConfigs.stream().map(entity -> switch (entity) {
-            case SecurityAnalysisConfigEntity sae -> securityAnalysisConfigMapper.toPersistedProcessConfigDto(sae);
+        return processConfigRepository.findAllByProcessType(processType).stream()
+                .map(this::toPersistedProcessConfig)
+                .toList();
+    }
+
+    private ProcessConfig toProcessConfig(ProcessConfigEntity entity) {
+        return switch (entity) {
+            case SecurityAnalysisConfigEntity sae -> securityAnalysisConfigMapper.toDto(sae);
             default -> throw new IllegalArgumentException("Unsupported entity type: " + entity.getProcessType());
-        }).toList();
+        };
+    }
+
+    private PersistedProcessConfig toPersistedProcessConfig(ProcessConfigEntity entity) {
+        return new PersistedProcessConfig(entity.getId(), toProcessConfig(entity));
     }
 
     @Transactional(readOnly = true)
     public Optional<ProcessConfigComparison> compareProcessConfigs(UUID uuid1, UUID uuid2) {
-        Optional<PersistedProcessConfig> config1 = getProcessConfig(uuid1);
-        Optional<PersistedProcessConfig> config2 = getProcessConfig(uuid2);
+        Optional<ProcessConfigEntity> processConfigEntity1 = processConfigRepository.findById(uuid1);
+        Optional<ProcessConfigEntity> processConfigEntity2 = processConfigRepository.findById(uuid2);
 
-        if (config1.isEmpty() || config2.isEmpty()) {
+        if (processConfigEntity1.isEmpty() || processConfigEntity2.isEmpty()) {
             return Optional.empty();
         }
 
-        ProcessConfig processConfig1 = config1.get().processConfig();
-        ProcessConfig processConfig2 = config2.get().processConfig();
+        ProcessConfig processConfig1 = toProcessConfig(processConfigEntity1.get());
+        ProcessConfig processConfig2 = toProcessConfig(processConfigEntity2.get());
 
         if (processConfig1.processType() != processConfig2.processType()) {
             throw new IllegalArgumentException("Cannot compare different process config types: " + processConfig1.processType() + " vs " + processConfig2.processType());

monitor-server/src/test/java/org/gridsuite/monitor/server/mapper/SecurityAnalysisConfigMapperTest.java

@@ -6,7 +6,6 @@
  */
 package org.gridsuite.monitor.server.mapper;
 
-import org.gridsuite.monitor.commons.PersistedProcessConfig;
 import org.gridsuite.monitor.commons.SecurityAnalysisConfig;
 import org.gridsuite.monitor.server.entities.SecurityAnalysisConfigEntity;
 import org.junit.jupiter.api.Test;
@@ -40,27 +39,4 @@ void toEntity() {
         assertThat(entity.getModificationUuids()).isEqualTo(dto.modificationUuids());
         assertThat(entity.getProcessType()).isEqualTo(dto.processType());
     }
-
-    @Test
-    void entityToPersistedConfig() {
-        SecurityAnalysisConfigEntity entity = new SecurityAnalysisConfigEntity(
-                UUID.randomUUID(),
-                UUID.randomUUID()
-        );
-        entity.setId(UUID.randomUUID());
-        entity.setModificationUuids(
-                List.of(UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID())
-        );
-
-        PersistedProcessConfig persistedProcessConfig = mapper.toPersistedProcessConfigDto(entity);
-
-        assertThat(persistedProcessConfig).isNotNull();
-        assertThat(persistedProcessConfig.id()).isEqualTo(entity.getId());
-
-        SecurityAnalysisConfig sac = (SecurityAnalysisConfig) persistedProcessConfig.processConfig();
-
-        assertThat(sac.securityAnalysisParametersUuid()).isEqualTo(entity.getSecurityAnalysisParametersUuid());
-        assertThat(sac.loadflowParametersUuid()).isEqualTo(entity.getLoadflowParametersUuid());
-        assertThat(sac.modificationUuids()).isEqualTo(entity.getModificationUuids());
-    }
 }