diff --git a/src/main/java/org/gridsuite/study/server/dto/computation/ComputationsParameters.java b/src/main/java/org/gridsuite/study/server/dto/computation/ComputationsParameters.java new file mode 100644 index 0000000000..1db3413e31 --- /dev/null +++ b/src/main/java/org/gridsuite/study/server/dto/computation/ComputationsParameters.java @@ -0,0 +1,24 @@ +/** + * Copyright (c) 2026, 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.study.server.dto.computation; + +import lombok.Builder; + +import java.util.UUID; + +@Builder +public record ComputationsParameters(UUID loadFlowParametersUuid, + UUID shortCircuitParametersUuid, + UUID dynamicSimulationParametersUuid, + UUID voltageInitParametersUuid, + UUID securityAnalysisParametersUuid, + UUID sensitivityAnalysisParametersUuid, + UUID dynamicSecurityAnalysisParametersUuid, + UUID dynamicMarginCalculationParametersUuid, + UUID stateEstimationParametersUuid, + UUID pccMinParametersUuid) { +} diff --git a/src/main/java/org/gridsuite/study/server/service/ComputationParametersService.java b/src/main/java/org/gridsuite/study/server/service/ComputationParametersService.java new file mode 100644 index 0000000000..20244d6029 --- /dev/null +++ b/src/main/java/org/gridsuite/study/server/service/ComputationParametersService.java @@ -0,0 +1,288 @@ +/** + * Copyright (c) 2026, 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.study.server.service; + +import org.gridsuite.study.server.dto.ComputationType; +import org.gridsuite.study.server.dto.UserProfileInfos; +import org.gridsuite.study.server.dto.computation.ComputationsParameters; +import org.gridsuite.study.server.repository.StudyEntity; +import org.gridsuite.study.server.service.common.ComputationParameters; +import org.gridsuite.study.server.service.dynamicmargincalculation.DynamicMarginCalculationService; +import org.gridsuite.study.server.service.dynamicsecurityanalysis.DynamicSecurityAnalysisService; +import org.gridsuite.study.server.service.dynamicsimulation.DynamicSimulationService; +import org.gridsuite.study.server.service.shortcircuit.ShortCircuitService; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.UUID; +import java.util.function.BiConsumer; +import java.util.function.Function; +import java.util.function.Supplier; + +/** + * @author Abdelsalem HEDHILI + */ + +@Service +public class ComputationParametersService { + + private static final Logger LOGGER = LoggerFactory.getLogger(ComputationParametersService.class); + + private final StateEstimationService stateEstimationService; + private final UserAdminService userAdminService; + private final List computationParametersDefinitions; + + // this is useful to avoid repetitive calls when doing operation on all computation types (duplicate, delete) + private record ComputationParametersDefinition( + ComputationType type, + Function studyParameterGetter, + Function profileParameterGetter, + ComputationParameters service, + Supplier defaultParametersSupplier, + BiConsumer parametersSetter, + Function parametersGetter, + String defaultErrorLabel + ) { + } + + public ComputationParametersService(SecurityAnalysisService securityAnalysisService, + SensitivityAnalysisService sensitivityAnalysisService, + LoadFlowService loadFlowService, + ShortCircuitService shortCircuitService, + VoltageInitService voltageInitService, + DynamicSimulationService dynamicSimulationService, + DynamicSecurityAnalysisService dynamicSecurityAnalysisService, + DynamicMarginCalculationService dynamicMarginCalculationService, + StateEstimationService stateEstimationService, + PccMinService pccMinService, + UserAdminService userAdminService) { + + this.stateEstimationService = stateEstimationService; + this.userAdminService = userAdminService; + this.computationParametersDefinitions = List.of( + new ComputationParametersDefinition( + ComputationType.LOAD_FLOW, + StudyEntity::getLoadFlowParametersUuid, + UserProfileInfos::getLoadFlowParameterId, + loadFlowService, + loadFlowService::createDefaultLoadFlowParameters, + ComputationsParameters.ComputationsParametersBuilder::loadFlowParametersUuid, + ComputationsParameters::loadFlowParametersUuid, + "LoadFlow analysis"), + new ComputationParametersDefinition( + ComputationType.SHORT_CIRCUIT, + StudyEntity::getShortCircuitParametersUuid, + UserProfileInfos::getShortcircuitParameterId, + shortCircuitService, + () -> shortCircuitService.createParameters(null), + ComputationsParameters.ComputationsParametersBuilder::shortCircuitParametersUuid, + ComputationsParameters::shortCircuitParametersUuid, + "ShortCircuit analysis"), + new ComputationParametersDefinition( + ComputationType.DYNAMIC_SIMULATION, + StudyEntity::getDynamicSimulationParametersUuid, + UserProfileInfos::getDynamicSimulationParameterId, + dynamicSimulationService, + dynamicSimulationService::createDefaultParameters, + ComputationsParameters.ComputationsParametersBuilder::dynamicSimulationParametersUuid, + ComputationsParameters::dynamicSimulationParametersUuid, + "dynamic simulation"), + new ComputationParametersDefinition( + ComputationType.VOLTAGE_INITIALIZATION, + StudyEntity::getVoltageInitParametersUuid, + UserProfileInfos::getVoltageInitParameterId, + voltageInitService, + () -> voltageInitService.createVoltageInitParameters(null), + ComputationsParameters.ComputationsParametersBuilder::voltageInitParametersUuid, + ComputationsParameters::voltageInitParametersUuid, + "voltage init"), + new ComputationParametersDefinition( + ComputationType.SECURITY_ANALYSIS, + StudyEntity::getSecurityAnalysisParametersUuid, + UserProfileInfos::getSecurityAnalysisParameterId, + securityAnalysisService, + securityAnalysisService::createDefaultSecurityAnalysisParameters, + ComputationsParameters.ComputationsParametersBuilder::securityAnalysisParametersUuid, + ComputationsParameters::securityAnalysisParametersUuid, + "Security analysis"), + new ComputationParametersDefinition( + ComputationType.SENSITIVITY_ANALYSIS, + StudyEntity::getSensitivityAnalysisParametersUuid, + UserProfileInfos::getSensitivityAnalysisParameterId, + sensitivityAnalysisService, + sensitivityAnalysisService::createDefaultSensitivityAnalysisParameters, + ComputationsParameters.ComputationsParametersBuilder::sensitivityAnalysisParametersUuid, + ComputationsParameters::sensitivityAnalysisParametersUuid, + "Sensitivity analysis"), + new ComputationParametersDefinition( + ComputationType.DYNAMIC_SECURITY_ANALYSIS, + StudyEntity::getDynamicSecurityAnalysisParametersUuid, + UserProfileInfos::getDynamicSecurityAnalysisParameterId, + dynamicSecurityAnalysisService, + dynamicSecurityAnalysisService::createDefaultParameters, + ComputationsParameters.ComputationsParametersBuilder::dynamicSecurityAnalysisParametersUuid, + ComputationsParameters::dynamicSecurityAnalysisParametersUuid, + "dynamic security analysis"), + new ComputationParametersDefinition( + ComputationType.DYNAMIC_MARGIN_CALCULATION, + StudyEntity::getDynamicMarginCalculationParametersUuid, + UserProfileInfos::getDynamicMarginCalculationParameterId, + dynamicMarginCalculationService, + dynamicMarginCalculationService::createDefaultParameters, + ComputationsParameters.ComputationsParametersBuilder::dynamicMarginCalculationParametersUuid, + ComputationsParameters::dynamicMarginCalculationParametersUuid, + "dynamic margin calculation"), + new ComputationParametersDefinition( + ComputationType.STATE_ESTIMATION, + StudyEntity::getStateEstimationParametersUuid, + userProfileInfos -> null, + stateEstimationService, + this::createDefaultStateEstimationParameters, + ComputationsParameters.ComputationsParametersBuilder::stateEstimationParametersUuid, + ComputationsParameters::stateEstimationParametersUuid, + "state estimation"), + new ComputationParametersDefinition( + ComputationType.PCC_MIN, + StudyEntity::getPccMinParametersUuid, + UserProfileInfos::getPccMinParameterId, + pccMinService, + pccMinService::createDefaultPccMinParameters, + ComputationsParameters.ComputationsParametersBuilder::pccMinParametersUuid, + ComputationsParameters::pccMinParametersUuid, + "pcc min") + ); + } + + public ComputationsParameters createDefaultComputationParameters(String userId, UserProfileInfos userProfileInfos) { + ComputationsParameters.ComputationsParametersBuilder parametersBuilder = ComputationsParameters.builder(); + computationParametersDefinitions.forEach(definition -> + definition.parametersSetter().accept(parametersBuilder, createDefaultParameters(userId, userProfileInfos, definition))); + return parametersBuilder.build(); + } + + public ComputationsParameters duplicateParameters(StudyEntity sourceStudyEntity) { + ComputationsParameters.ComputationsParametersBuilder parametersBuilder = ComputationsParameters.builder(); + computationParametersDefinitions.forEach(definition -> { + UUID sourceParametersUuid = definition.studyParameterGetter().apply(sourceStudyEntity); + if (sourceParametersUuid != null) { + definition.parametersSetter().accept(parametersBuilder, definition.service().duplicateParameters(sourceParametersUuid)); + } + }); + return parametersBuilder.build(); + } + + public void deleteComputationsParameters(ComputationsParameters parameters) { + computationParametersDefinitions.forEach(definition -> + deleteComputationParameters(definition.parametersGetter().apply(parameters), definition.service(), definition.type().getLabel())); + } + + public void deleteComputationParameters(UUID parametersUuid, ComputationParameters computationParameters, String computationType) { + if (parametersUuid != null) { + try { + computationParameters.deleteParameters(parametersUuid); + } catch (Exception e) { + LOGGER.error("Could not remove {} parameters with uuid: {}", computationType, parametersUuid, e); + } + } + } + + public boolean createOrUpdateParameters( + StudyEntity studyEntity, + T parameters, + String userId, + Function studyParameterGetter, + BiConsumer studyParameterSetter, + Function profileParameterGetter, + ComputationParameters computationParameters, + Function createParameters, + BiConsumer updateParameters, + String parameterLabel + ) { + boolean userProfileIssue = false; + UUID existingParametersUuid = studyParameterGetter.apply(studyEntity); + + UserProfileInfos userProfileInfos = parameters == null ? userAdminService.getUserProfile(userId) : null; + UUID profileParameterId = userProfileInfos == null ? null : profileParameterGetter.apply(userProfileInfos); + + if (parameters == null && profileParameterId != null) { + try { + UUID parametersFromProfileUuid = computationParameters.duplicateParameters(profileParameterId); + studyParameterSetter.accept(studyEntity, parametersFromProfileUuid); + deleteComputationParameters(existingParametersUuid, computationParameters, parameterLabel); + return false; + } catch (Exception e) { + userProfileIssue = true; + LOGGER.error( + "Could not duplicate {} parameters with id '{}' from user/profile '{}/{}'. Using default parameters", + parameterLabel, + profileParameterId, + userId, + userProfileInfos.getName(), + e + ); + } + } + + if (existingParametersUuid == null) { + UUID newParametersUuid = createParameters.apply(parameters); + studyParameterSetter.accept(studyEntity, newParametersUuid); + } else { + updateParameters.accept(existingParametersUuid, parameters); + } + return userProfileIssue; + } + + public void createOrUpdateParameters( + StudyEntity studyEntity, + T parameters, + Function studyParameterGetter, + BiConsumer studyParameterSetter, + Function createParameters, + BiConsumer updateParameters + ) { + UUID existingParametersUuid = studyParameterGetter.apply(studyEntity); + if (existingParametersUuid == null) { + UUID newParametersUuid = createParameters.apply(parameters); + studyParameterSetter.accept(studyEntity, newParametersUuid); + } else { + updateParameters.accept(existingParametersUuid, parameters); + } + } + + private UUID createDefaultParameters(String userId, UserProfileInfos userProfileInfos, ComputationParametersDefinition definition) { + UUID profileParameterId = userProfileInfos == null ? + null : + definition.profileParameterGetter().apply(userProfileInfos); + + if (profileParameterId != null) { + try { + return definition.service().duplicateParameters(profileParameterId); + } catch (Exception e) { + LOGGER.error("Could not duplicate {} parameters with id '{}' from user/profile '{}/{}'. Using default parameters", + definition.type().getLabel(), profileParameterId, userId, userProfileInfos.getName(), e); + } + } + + try { + return definition.defaultParametersSupplier().get(); + } catch (Exception e) { + LOGGER.error("Error while creating default parameters for {}", definition.defaultErrorLabel(), e); + return null; + } + } + + private UUID createDefaultStateEstimationParameters() { + try { + return stateEstimationService.createDefaultStateEstimationParameters(); + } catch (final Exception e) { + LOGGER.error("Error while creating state estimation default parameters", e); + return null; + } + } +} diff --git a/src/main/java/org/gridsuite/study/server/service/ConsumerService.java b/src/main/java/org/gridsuite/study/server/service/ConsumerService.java index 8091b8aeab..bfc431386e 100644 --- a/src/main/java/org/gridsuite/study/server/service/ConsumerService.java +++ b/src/main/java/org/gridsuite/study/server/service/ConsumerService.java @@ -15,6 +15,7 @@ import org.gridsuite.study.server.dto.*; import org.gridsuite.study.server.dto.caseimport.CaseImportAction; import org.gridsuite.study.server.dto.caseimport.CaseImportReceiver; +import org.gridsuite.study.server.dto.computation.ComputationsParameters; import org.gridsuite.study.server.dto.modification.NetworkModificationResult; import org.gridsuite.study.server.dto.networkexport.ExportNetworkStatus; import org.gridsuite.study.server.dto.networkexport.NetworkExportReceiver; @@ -24,10 +25,6 @@ import org.gridsuite.study.server.networkmodificationtree.dto.BuildStatus; import org.gridsuite.study.server.networkmodificationtree.dto.NodeBuildStatus; import org.gridsuite.study.server.notification.NotificationService; -import org.gridsuite.study.server.service.dynamicmargincalculation.DynamicMarginCalculationService; -import org.gridsuite.study.server.service.dynamicsecurityanalysis.DynamicSecurityAnalysisService; -import org.gridsuite.study.server.service.dynamicsimulation.DynamicSimulationService; -import org.gridsuite.study.server.service.shortcircuit.ShortCircuitService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.context.annotation.Bean; @@ -64,58 +61,34 @@ public class ConsumerService { private final NotificationService notificationService; private final StudyService studyService; - private final SecurityAnalysisService securityAnalysisService; - private final SensitivityAnalysisService sensitivityAnalysisService; private final CaseService caseService; private final LoadFlowService loadFlowService; private final NetworkModificationTreeService networkModificationTreeService; private final StudyConfigService studyConfigService; - private final ShortCircuitService shortCircuitService; private final RootNetworkNodeInfoService rootNetworkNodeInfoService; - private final VoltageInitService voltageInitService; - private final DynamicSimulationService dynamicSimulationService; - private final DynamicSecurityAnalysisService dynamicSecurityAnalysisService; - private final DynamicMarginCalculationService dynamicMarginCalculationService; - private final StateEstimationService stateEstimationService; - private final PccMinService pccMinService; private final DirectoryService directoryService; + private final ComputationParametersService computationParametersService; public ConsumerService(ObjectMapper objectMapper, NotificationService notificationService, StudyService studyService, - SecurityAnalysisService securityAnalysisService, CaseService caseService, LoadFlowService loadFlowService, - ShortCircuitService shortCircuitService, NetworkModificationTreeService networkModificationTreeService, - SensitivityAnalysisService sensitivityAnalysisService, StudyConfigService studyConfigService, RootNetworkNodeInfoService rootNetworkNodeInfoService, - VoltageInitService voltageInitService, - DynamicSimulationService dynamicSimulationService, - DynamicSecurityAnalysisService dynamicSecurityAnalysisService, - DynamicMarginCalculationService dynamicMarginCalculationService, - StateEstimationService stateEstimationService, - PccMinService pccMinService, - DirectoryService directoryService) { + DirectoryService directoryService, + ComputationParametersService computationParametersService) { this.objectMapper = objectMapper; this.notificationService = notificationService; this.studyService = studyService; - this.securityAnalysisService = securityAnalysisService; this.caseService = caseService; this.loadFlowService = loadFlowService; this.networkModificationTreeService = networkModificationTreeService; - this.sensitivityAnalysisService = sensitivityAnalysisService; this.studyConfigService = studyConfigService; - this.shortCircuitService = shortCircuitService; this.rootNetworkNodeInfoService = rootNetworkNodeInfoService; - this.voltageInitService = voltageInitService; - this.dynamicSimulationService = dynamicSimulationService; - this.dynamicSecurityAnalysisService = dynamicSecurityAnalysisService; - this.dynamicMarginCalculationService = dynamicMarginCalculationService; - this.stateEstimationService = stateEstimationService; - this.pccMinService = pccMinService; this.directoryService = directoryService; + this.computationParametersService = computationParametersService; } @Bean @@ -294,128 +267,16 @@ private void insertStudy(UUID studyUuid, String userId, NetworkInfos networkInfo Map importParameters, UUID importReportUuid) { UserProfileInfos userProfileInfos = studyService.getUserProfile(userId); - UUID loadFlowParametersUuid = createDefaultLoadFlowParameters(userId, userProfileInfos); - UUID shortCircuitParametersUuid = createDefaultShortCircuitAnalysisParameters(userId, userProfileInfos); - UUID securityAnalysisParametersUuid = createDefaultSecurityAnalysisParameters(userId, userProfileInfos); - UUID sensitivityAnalysisParametersUuid = createDefaultSensitivityAnalysisParameters(userId, userProfileInfos); + ComputationsParameters computationsParameters = computationParametersService.createDefaultComputationParameters(userId, userProfileInfos); UUID networkVisualizationParametersUuid = createDefaultNetworkVisualizationParameters(userId, userProfileInfos); - UUID voltageInitParametersUuid = createDefaultVoltageInitParameters(userId, userProfileInfos); - UUID dynamicSimulationParametersUuid = createDefaultDynamicSimulationParameters(userId, userProfileInfos); - UUID dynamicSecurityAnalysisParametersUuid = createDefaultDynamicSecurityAnalysisParameters(userId, userProfileInfos); - UUID dynamicMarginCalculationParametersUuid = createDefaultDynamicMarginCalculationParameters(userId, userProfileInfos); - UUID stateEstimationParametersUuid = createDefaultStateEstimationParameters(); - UUID pccMinParametersUuid = createDefaultPccMinParameters(userId, userProfileInfos); UUID spreadsheetConfigCollectionUuid = createDefaultSpreadsheetConfigCollection(userId, userProfileInfos); UUID workspacesConfigUuid = createWorkspacesConfig(userProfileInfos); - studyService.insertStudy(studyUuid, userId, networkInfos, caseInfos, loadFlowParametersUuid, - shortCircuitParametersUuid, dynamicSimulationParametersUuid, - voltageInitParametersUuid, securityAnalysisParametersUuid, sensitivityAnalysisParametersUuid, - networkVisualizationParametersUuid, dynamicSecurityAnalysisParametersUuid, dynamicMarginCalculationParametersUuid, - stateEstimationParametersUuid, pccMinParametersUuid, spreadsheetConfigCollectionUuid, workspacesConfigUuid, + studyService.insertStudy(studyUuid, userId, networkInfos, caseInfos, computationsParameters, + networkVisualizationParametersUuid, spreadsheetConfigCollectionUuid, workspacesConfigUuid, importParameters, importReportUuid); } - private UUID createDefaultLoadFlowParameters(String userId, UserProfileInfos userProfileInfos) { - if (userProfileInfos != null && userProfileInfos.getLoadFlowParameterId() != null) { - // try to access/duplicate the user profile LF parameters - try { - return loadFlowService.duplicateLoadFlowParameters(userProfileInfos.getLoadFlowParameterId()); - } catch (Exception e) { - // TODO try to report a log in Root subreporter ? - LOGGER.error(String.format("Could not duplicate loadflow parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getLoadFlowParameterId(), userId, userProfileInfos.getName()), e); - } - } - // no profile, or no/bad LF parameters in profile => use default values - try { - return loadFlowService.createDefaultLoadFlowParameters(); - } catch (final Exception e) { - LOGGER.error("Error while creating default parameters for LoadFlow analysis", e); - return null; - } - } - - private UUID createDefaultShortCircuitAnalysisParameters(String userId, UserProfileInfos userProfileInfos) { - if (userProfileInfos != null && userProfileInfos.getShortcircuitParameterId() != null) { - // try to access/duplicate the user profile shortcircuit parameters - try { - return shortCircuitService.duplicateParameters(userProfileInfos.getShortcircuitParameterId()); - } catch (Exception e) { - // TODO try to report a log in Root subreporter ? - LOGGER.error(String.format("Could not duplicate shortcircuit parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getShortcircuitParameterId(), userId, userProfileInfos.getName()), e); - } - } - // no profile, or no/bad shortcircuit parameters in profile => use default values - try { - return shortCircuitService.createParameters(null); - } catch (final Exception e) { - LOGGER.error("Error while creating default parameters for ShortCircuit analysis", e); - return null; - } - } - - private UUID createDefaultSensitivityAnalysisParameters(String userId, UserProfileInfos userProfileInfos) { - if (userProfileInfos != null && userProfileInfos.getSensitivityAnalysisParameterId() != null) { - // try to access/duplicate the user profile sensitivity analysis parameters - try { - return sensitivityAnalysisService.duplicateSensitivityAnalysisParameters(userProfileInfos.getSensitivityAnalysisParameterId()); - } catch (Exception e) { - // TODO try to report a log in Root subreporter ? - LOGGER.error(String.format("Could not duplicate sensitivity analysis parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getSensitivityAnalysisParameterId(), userId, userProfileInfos.getName()), e); - } - } - // no profile, or no/bad sensitivity analysis parameters in profile => use default values - try { - return sensitivityAnalysisService.createDefaultSensitivityAnalysisParameters(); - } catch (final Exception e) { - LOGGER.error("Error while creating default parameters for Sensitivity analysis", e); - return null; - } - } - - private UUID createDefaultSecurityAnalysisParameters(String userId, UserProfileInfos userProfileInfos) { - if (userProfileInfos != null && userProfileInfos.getSecurityAnalysisParameterId() != null) { - // try to access/duplicate the user profile security analysis parameters - try { - return securityAnalysisService.duplicateSecurityAnalysisParameters(userProfileInfos.getSecurityAnalysisParameterId()); - } catch (Exception e) { - // TODO try to report a log in Root subreporter ? - LOGGER.error(String.format("Could not duplicate security analysis parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getSecurityAnalysisParameterId(), userId, userProfileInfos.getName()), e); - } - } - // no profile, or no/bad security analysis parameters in profile => use default values - try { - return securityAnalysisService.createDefaultSecurityAnalysisParameters(); - } catch (final Exception e) { - LOGGER.error("Error while creating default parameters for Security analysis", e); - return null; - } - } - - private UUID createDefaultVoltageInitParameters(String userId, UserProfileInfos userProfileInfos) { - if (userProfileInfos != null && userProfileInfos.getVoltageInitParameterId() != null) { - // try to access/duplicate the user profile voltage init parameters - try { - return voltageInitService.duplicateVoltageInitParameters(userProfileInfos.getVoltageInitParameterId()); - } catch (Exception e) { - // TODO try to report a log in Root subreporter ? - LOGGER.error(String.format("Could not duplicate voltage init parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getVoltageInitParameterId(), userId, userProfileInfos.getName()), e); - } - } - // no profile, or no/bad voltage init parameters in profile => use default values - try { - return voltageInitService.createVoltageInitParameters(null); - } catch (final Exception e) { - LOGGER.error("Error while creating default parameters for voltage init", e); - return null; - } - } - private UUID createDefaultNetworkVisualizationParameters(String userId, UserProfileInfos userProfileInfos) { if (userProfileInfos != null && userProfileInfos.getNetworkVisualizationParameterId() != null) { // try to access/duplicate the user profile network visualization parameters @@ -436,95 +297,6 @@ private UUID createDefaultNetworkVisualizationParameters(String userId, UserProf } } - private UUID createDefaultDynamicSimulationParameters(String userId, UserProfileInfos userProfileInfos) { - if (userProfileInfos != null && userProfileInfos.getDynamicSimulationParameterId() != null) { - // try to access/duplicate the user profile Dynamic Simulation parameters - try { - return dynamicSimulationService.duplicateParameters(userProfileInfos.getDynamicSimulationParameterId()); - } catch (Exception e) { - // TODO try to report a log in Root subreporter ? - LOGGER.error(String.format("Could not duplicate dynamic simulation parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getDynamicSimulationParameterId(), userId, userProfileInfos.getName()), e); - } - } - // no profile, or no/bad dynamic simulation parameters in profile => use default values - try { - return dynamicSimulationService.createDefaultParameters(); - } catch (final Exception e) { - LOGGER.error("Error while creating default parameters for dynamic simulation", e); - return null; - } - } - - private UUID createDefaultDynamicSecurityAnalysisParameters(String userId, UserProfileInfos userProfileInfos) { - if (userProfileInfos != null && userProfileInfos.getDynamicSecurityAnalysisParameterId() != null) { - // try to access/duplicate the user profile Dynamic Security Analysis parameters - try { - return dynamicSecurityAnalysisService.duplicateParameters(userProfileInfos.getDynamicSecurityAnalysisParameterId()); - } catch (Exception e) { - // TODO try to report a log in Root subreporter ? - LOGGER.error(String.format("Could not duplicate dynamic security analysis parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getDynamicSecurityAnalysisParameterId(), userId, userProfileInfos.getName()), e); - } - } - // no profile, or no/bad dynamic security analysis parameters in profile => use default values - try { - return dynamicSecurityAnalysisService.createDefaultParameters(); - } catch (final Exception e) { - LOGGER.error("Error while creating default parameters for dynamic security analysis", e); - return null; - } - } - - private UUID createDefaultDynamicMarginCalculationParameters(String userId, UserProfileInfos userProfileInfos) { - if (userProfileInfos != null && userProfileInfos.getDynamicMarginCalculationParameterId() != null) { - // try to access/duplicate the user profile Dynamic Margin Calculation parameters - try { - return dynamicMarginCalculationService.duplicateParameters(userProfileInfos.getDynamicMarginCalculationParameterId()); - } catch (Exception e) { - // TODO try to report a log in Root subreporter ? - LOGGER.error(String.format("Could not duplicate dynamic margin calculation parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getDynamicMarginCalculationParameterId(), userId, userProfileInfos.getName()), e); - } - } - // no profile, or no/bad dynamic margin calculation parameters in profile => use default values - try { - return dynamicMarginCalculationService.createDefaultParameters(); - } catch (final Exception e) { - LOGGER.error("Error while creating default parameters for dynamic margin calculation", e); - return null; - } - } - - private UUID createDefaultStateEstimationParameters() { - try { - return stateEstimationService.createDefaultStateEstimationParameters(); - } catch (final Exception e) { - LOGGER.error("Error while creating state estimation default parameters", e); - return null; - } - } - - private UUID createDefaultPccMinParameters(String userId, UserProfileInfos userProfileInfos) { - if (userProfileInfos != null && userProfileInfos.getPccMinParameterId() != null) { - // try to access/duplicate the user profile pccmin parameters - try { - return pccMinService.duplicatePccMinParameters(userProfileInfos.getPccMinParameterId()); - } catch (Exception e) { - // TODO try to report a log in Root subreporter ? - LOGGER.error(String.format("Could not duplicate pccmin parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getPccMinParameterId(), userId, userProfileInfos.getName()), e); - } - } - // no profile, or no/bad pcc min parameters in profile => use default values - try { - return pccMinService.createDefaultPccMinParameters(); - } catch (final Exception e) { - LOGGER.error("Error while creating pcc min default parameters", e); - return null; - } - } - private UUID createDefaultSpreadsheetConfigCollection(String userId, UserProfileInfos userProfileInfos) { if (userProfileInfos != null && userProfileInfos.getSpreadsheetConfigCollectionId() != null) { // try to access/duplicate the user profile spreadsheet config collection diff --git a/src/main/java/org/gridsuite/study/server/service/LoadFlowService.java b/src/main/java/org/gridsuite/study/server/service/LoadFlowService.java index 7945e6d33f..4415357a5f 100644 --- a/src/main/java/org/gridsuite/study/server/service/LoadFlowService.java +++ b/src/main/java/org/gridsuite/study/server/service/LoadFlowService.java @@ -15,6 +15,7 @@ import org.gridsuite.study.server.dto.*; import org.gridsuite.study.server.repository.StudyEntity; import org.gridsuite.study.server.service.common.AbstractComputationService; +import org.gridsuite.study.server.service.common.ComputationParameters; import org.springframework.core.ParameterizedTypeReference; import org.springframework.data.domain.Sort; import org.springframework.http.*; @@ -38,7 +39,7 @@ * @author Kevin Le Saulnier */ @Service -public class LoadFlowService extends AbstractComputationService { +public class LoadFlowService extends AbstractComputationService implements ComputationParameters { private static final String QUERY_PARAM_APPLY_SOLVED_VALUES = "applySolvedValues"; private static final String RESULT_UUID = "resultUuid"; @@ -254,8 +255,8 @@ public UUID createLoadFlowParameters(String parameters) { return restTemplate.postForObject(loadFlowServerBaseUri + path, httpEntity, UUID.class); } - public UUID duplicateLoadFlowParameters(UUID sourceParametersUuid) { - + @Override + public UUID duplicateParameters(UUID sourceParametersUuid) { Objects.requireNonNull(sourceParametersUuid); var path = UriComponentsBuilder @@ -280,10 +281,11 @@ public void updateLoadFlowParameters(UUID parametersUuid, @Nullable String param restTemplate.put(loadFlowServerBaseUri + path, httpEntity); } - public void deleteLoadFlowParameters(UUID uuid) { - Objects.requireNonNull(uuid); + @Override + public void deleteParameters(UUID parametersUuid) { + Objects.requireNonNull(parametersUuid); String path = UriComponentsBuilder.fromPath(DELIMITER + LOADFLOW_API_VERSION + PARAMETERS_URI) - .buildAndExpand(uuid) + .buildAndExpand(parametersUuid) .toUriString(); restTemplate.delete(loadFlowServerBaseUri + path); diff --git a/src/main/java/org/gridsuite/study/server/service/PccMinService.java b/src/main/java/org/gridsuite/study/server/service/PccMinService.java index e9b9d8b09b..8460e227ea 100644 --- a/src/main/java/org/gridsuite/study/server/service/PccMinService.java +++ b/src/main/java/org/gridsuite/study/server/service/PccMinService.java @@ -15,6 +15,7 @@ import org.gridsuite.study.server.dto.*; import org.gridsuite.study.server.repository.StudyEntity; import org.gridsuite.study.server.service.common.AbstractComputationService; +import org.gridsuite.study.server.service.common.ComputationParameters; import org.gridsuite.study.server.utils.ResultParameters; import org.gridsuite.study.server.utils.StudyUtils; import org.springframework.beans.factory.annotation.Autowired; @@ -43,7 +44,7 @@ * @author Maissa SOUISSI */ @Service -public class PccMinService extends AbstractComputationService { +public class PccMinService extends AbstractComputationService implements ComputationParameters { static final String RESULT_UUID = "resultUuid"; static final String RESULTS = "results"; static final String BUS_ID = "busId"; @@ -240,7 +241,8 @@ public String getPccMinParameters(UUID parametersUuid) { return restTemplate.getForObject(pccMinServerBaseUri + path, String.class); } - public void deletePccMinParameters(UUID uuid) { + @Override + public void deleteParameters(UUID uuid) { Objects.requireNonNull(uuid); String path = UriComponentsBuilder @@ -251,7 +253,8 @@ public void deletePccMinParameters(UUID uuid) { restTemplate.delete(pccMinServerBaseUri + path); } - public UUID duplicatePccMinParameters(UUID sourceParametersUuid) { + @Override + public UUID duplicateParameters(UUID sourceParametersUuid) { Objects.requireNonNull(sourceParametersUuid); String path = UriComponentsBuilder diff --git a/src/main/java/org/gridsuite/study/server/service/SecurityAnalysisService.java b/src/main/java/org/gridsuite/study/server/service/SecurityAnalysisService.java index 348f36e735..929076285c 100644 --- a/src/main/java/org/gridsuite/study/server/service/SecurityAnalysisService.java +++ b/src/main/java/org/gridsuite/study/server/service/SecurityAnalysisService.java @@ -18,6 +18,7 @@ import org.gridsuite.study.server.dto.SecurityAnalysisStatus; import org.gridsuite.study.server.repository.StudyEntity; import org.gridsuite.study.server.service.common.AbstractComputationService; +import org.gridsuite.study.server.service.common.ComputationParameters; import org.gridsuite.study.server.service.securityanalysis.SecurityAnalysisResultType; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.domain.Pageable; @@ -42,7 +43,7 @@ * @author Kevin Le Saulnier */ @Service -public class SecurityAnalysisService extends AbstractComputationService { +public class SecurityAnalysisService extends AbstractComputationService implements ComputationParameters { static final String RESULT_UUID = "resultUuid"; @@ -236,7 +237,8 @@ public void updateSecurityAnalysisParameters(UUID parametersUuid, @Nullable Stri restTemplate.put(securityAnalysisServerBaseUri + path, httpEntity); } - public UUID duplicateSecurityAnalysisParameters(UUID sourceParametersUuid) { + @Override + public UUID duplicateParameters(UUID sourceParametersUuid) { Objects.requireNonNull(sourceParametersUuid); var path = UriComponentsBuilder.fromPath(DELIMITER + SECURITY_ANALYSIS_API_VERSION + DELIMITER + PATH_PARAM_PARAMETERS) @@ -266,7 +268,8 @@ public UUID getSecurityAnalysisParametersUuidOrElseCreateDefaults(StudyEntity st return studyEntity.getSecurityAnalysisParametersUuid(); } - public void deleteSecurityAnalysisParameters(UUID uuid) { + @Override + public void deleteParameters(UUID uuid) { Objects.requireNonNull(uuid); String path = UriComponentsBuilder.fromPath(DELIMITER + SECURITY_ANALYSIS_API_VERSION + PARAMETERS_URI) .buildAndExpand(uuid) diff --git a/src/main/java/org/gridsuite/study/server/service/SensitivityAnalysisService.java b/src/main/java/org/gridsuite/study/server/service/SensitivityAnalysisService.java index 63cde0e41e..36fccf141d 100644 --- a/src/main/java/org/gridsuite/study/server/service/SensitivityAnalysisService.java +++ b/src/main/java/org/gridsuite/study/server/service/SensitivityAnalysisService.java @@ -16,6 +16,7 @@ import org.gridsuite.study.server.dto.sensianalysis.SensitivityAnalysisCsvFileInfos; import org.gridsuite.study.server.repository.StudyEntity; import org.gridsuite.study.server.service.common.AbstractComputationService; +import org.gridsuite.study.server.service.common.ComputationParameters; import org.springframework.http.*; import org.springframework.lang.Nullable; import org.springframework.stereotype.Service; @@ -37,7 +38,7 @@ * @author Franck Lecuyer */ @Service -public class SensitivityAnalysisService extends AbstractComputationService { +public class SensitivityAnalysisService extends AbstractComputationService implements ComputationParameters { static final String RESULT_UUID = "resultUuid"; private static final String RESULTS = "results"; @@ -279,7 +280,8 @@ public UUID createSensitivityAnalysisParameters(String parameters) { return restTemplate.postForObject(sensitivityAnalysisServerBaseUri + path, httpEntity, UUID.class); } - public UUID duplicateSensitivityAnalysisParameters(UUID sourceParametersUuid) { + @Override + public UUID duplicateParameters(UUID sourceParametersUuid) { Objects.requireNonNull(sourceParametersUuid); @@ -306,8 +308,8 @@ public void updateSensitivityAnalysisParameters(UUID parametersUuid, @Nullable S restTemplate.put(sensitivityAnalysisServerBaseUri + path, httpEntity); } - public void deleteSensitivityAnalysisParameters(UUID uuid) { - + @Override + public void deleteParameters(UUID uuid) { Objects.requireNonNull(uuid); String path = UriComponentsBuilder diff --git a/src/main/java/org/gridsuite/study/server/service/StateEstimationService.java b/src/main/java/org/gridsuite/study/server/service/StateEstimationService.java index 9fe5f5ec86..662f14f32c 100644 --- a/src/main/java/org/gridsuite/study/server/service/StateEstimationService.java +++ b/src/main/java/org/gridsuite/study/server/service/StateEstimationService.java @@ -17,6 +17,7 @@ import org.gridsuite.study.server.dto.StateEstimationStatus; import org.gridsuite.study.server.repository.StudyEntity; import org.gridsuite.study.server.service.common.AbstractComputationService; +import org.gridsuite.study.server.service.common.ComputationParameters; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; @@ -41,7 +42,7 @@ * @author Franck Lecuyer */ @Service -public class StateEstimationService extends AbstractComputationService { +public class StateEstimationService extends AbstractComputationService implements ComputationParameters { static final String RESULT_UUID = "resultUuid"; @@ -202,7 +203,8 @@ public String getStateEstimationParameters(UUID parametersUuid) { return restTemplate.getForObject(stateEstimationServerServerBaseUri + path, String.class); } - public UUID duplicateStateEstimationParameters(UUID sourceParametersUuid) { + @Override + public UUID duplicateParameters(UUID sourceParametersUuid) { Objects.requireNonNull(sourceParametersUuid); String path = UriComponentsBuilder @@ -218,7 +220,8 @@ public UUID duplicateStateEstimationParameters(UUID sourceParametersUuid) { return restTemplate.exchange(stateEstimationServerServerBaseUri + path, HttpMethod.POST, httpEntity, UUID.class).getBody(); } - public void deleteStateEstimationParameters(UUID uuid) { + @Override + public void deleteParameters(UUID uuid) { Objects.requireNonNull(uuid); String path = UriComponentsBuilder diff --git a/src/main/java/org/gridsuite/study/server/service/StudyService.java b/src/main/java/org/gridsuite/study/server/service/StudyService.java index 206498ff7c..69f6a74909 100644 --- a/src/main/java/org/gridsuite/study/server/service/StudyService.java +++ b/src/main/java/org/gridsuite/study/server/service/StudyService.java @@ -20,6 +20,7 @@ import org.gridsuite.study.server.dto.InvalidateNodeTreeParameters.ComputationsInvalidationMode; import org.gridsuite.study.server.dto.InvalidateNodeTreeParameters.InvalidationMode; import org.gridsuite.study.server.dto.caseimport.CaseImportAction; +import org.gridsuite.study.server.dto.computation.ComputationsParameters; import org.gridsuite.study.server.dto.dynamicsimulation.DynamicSimulationStatus; import org.gridsuite.study.server.dto.dynamicsimulation.event.EventInfos; import org.gridsuite.study.server.dto.elasticsearch.EquipmentInfos; @@ -48,6 +49,7 @@ import org.gridsuite.study.server.repository.rootnetwork.RootNetworkEntity; import org.gridsuite.study.server.repository.rootnetwork.RootNetworkRequestEntity; import org.gridsuite.study.server.repository.voltageinit.StudyVoltageInitParametersEntity; +import org.gridsuite.study.server.service.common.ComputationParameters; import org.gridsuite.study.server.service.dynamicmargincalculation.DynamicMarginCalculationService; import org.gridsuite.study.server.service.dynamicsecurityanalysis.DynamicSecurityAnalysisService; import org.gridsuite.study.server.service.dynamicsimulation.DynamicSimulationEventService; @@ -73,7 +75,9 @@ import java.util.concurrent.CompletableFuture; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiConsumer; import java.util.function.BiFunction; +import java.util.function.Consumer; import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -132,6 +136,7 @@ public class StudyService { private final RootNetworkService rootNetworkService; private final RootNetworkNodeInfoService rootNetworkNodeInfoService; private final DirectoryService directoryService; + private final ComputationParametersService computationParametersService; private final ObjectMapper objectMapper; @@ -160,42 +165,43 @@ public enum ReportType { @Autowired public StudyService( - StudyRepository studyRepository, - StudyCreationRequestRepository studyCreationRequestRepository, - NetworkService networkStoreService, - NetworkModificationService networkModificationService, - ReportService reportService, - UserAdminService userAdminService, - StudyInfosService studyInfosService, - EquipmentInfosService equipmentInfosService, - NetworkModificationTreeService networkModificationTreeService, - ObjectMapper objectMapper, - StudyServerExecutionService studyServerExecutionService, - NotificationService notificationService, - LoadFlowService loadflowService, - ShortCircuitService shortCircuitService, - SingleLineDiagramService singleLineDiagramService, - NetworkConversionService networkConversionService, - GeoDataService geoDataService, - NetworkMapService networkMapService, - SecurityAnalysisService securityAnalysisService, - ActionsService actionsService, - CaseService caseService, - SensitivityAnalysisService sensitivityAnalysisService, - DynamicSimulationService dynamicSimulationService, - DynamicSecurityAnalysisService dynamicSecurityAnalysisService, - DynamicMarginCalculationService dynamicMarginCalculationService, - VoltageInitService voltageInitService, - DynamicSimulationEventService dynamicSimulationEventService, - StudyConfigService studyConfigService, - NadConfigService nadConfigService, - FilterService filterService, - StateEstimationService stateEstimationService, - PccMinService pccMinService, - @Lazy StudyService studyService, - RootNetworkService rootNetworkService, - RootNetworkNodeInfoService rootNetworkNodeInfoService, - DirectoryService directoryService) { + StudyRepository studyRepository, + StudyCreationRequestRepository studyCreationRequestRepository, + NetworkService networkStoreService, + NetworkModificationService networkModificationService, + ReportService reportService, + UserAdminService userAdminService, + StudyInfosService studyInfosService, + EquipmentInfosService equipmentInfosService, + NetworkModificationTreeService networkModificationTreeService, + ObjectMapper objectMapper, + StudyServerExecutionService studyServerExecutionService, + NotificationService notificationService, + LoadFlowService loadflowService, + ShortCircuitService shortCircuitService, + SingleLineDiagramService singleLineDiagramService, + NetworkConversionService networkConversionService, + GeoDataService geoDataService, + NetworkMapService networkMapService, + SecurityAnalysisService securityAnalysisService, + ActionsService actionsService, + CaseService caseService, + SensitivityAnalysisService sensitivityAnalysisService, + DynamicSimulationService dynamicSimulationService, + DynamicSecurityAnalysisService dynamicSecurityAnalysisService, + DynamicMarginCalculationService dynamicMarginCalculationService, + VoltageInitService voltageInitService, + DynamicSimulationEventService dynamicSimulationEventService, + StudyConfigService studyConfigService, + NadConfigService nadConfigService, + FilterService filterService, + StateEstimationService stateEstimationService, + PccMinService pccMinService, + @Lazy StudyService studyService, + RootNetworkService rootNetworkService, + RootNetworkNodeInfoService rootNetworkNodeInfoService, + DirectoryService directoryService, + ComputationParametersService computationParametersService) { this.studyRepository = studyRepository; this.studyCreationRequestRepository = studyCreationRequestRepository; this.networkStoreService = networkStoreService; @@ -232,6 +238,7 @@ public StudyService( this.rootNetworkService = rootNetworkService; this.rootNetworkNodeInfoService = rootNetworkNodeInfoService; this.directoryService = directoryService; + this.computationParametersService = computationParametersService; } private CreatedStudyBasicInfos toStudyInfos(UUID studyUuid) { @@ -545,17 +552,21 @@ private Optional doDeleteStudyIfNotCreationInProgress(UUID stu networkModificationTreeService.doDeleteTree(studyUuid); studyRepository.deleteById(studyUuid); studyInfosService.deleteByUuid(studyUuid); - removeLoadFlowParameters(s.getLoadFlowParametersUuid()); - removeSecurityAnalysisParameters(s.getSecurityAnalysisParametersUuid()); - removeVoltageInitParameters(s.getVoltageInitParametersUuid()); - removeSensitivityAnalysisParameters(s.getSensitivityAnalysisParametersUuid()); - removeDynamicSimulationParameters(s.getDynamicSimulationParametersUuid()); - removeDynamicSecurityAnalysisParameters(s.getDynamicSecurityAnalysisParametersUuid()); - removeDynamicMarginCalculationParameters(s.getDynamicMarginCalculationParametersUuid()); + computationParametersService.deleteComputationsParameters( + ComputationsParameters.builder() + .loadFlowParametersUuid(s.getLoadFlowParametersUuid()) + .shortCircuitParametersUuid(s.getShortCircuitParametersUuid()) + .dynamicSimulationParametersUuid(s.getDynamicSimulationParametersUuid()) + .voltageInitParametersUuid(s.getVoltageInitParametersUuid()) + .securityAnalysisParametersUuid(s.getSecurityAnalysisParametersUuid()) + .sensitivityAnalysisParametersUuid(s.getSensitivityAnalysisParametersUuid()) + .dynamicSecurityAnalysisParametersUuid(s.getDynamicSecurityAnalysisParametersUuid()) + .dynamicMarginCalculationParametersUuid(s.getDynamicMarginCalculationParametersUuid()) + .stateEstimationParametersUuid(s.getStateEstimationParametersUuid()) + .pccMinParametersUuid(s.getPccMinParametersUuid()) + .build() + ); removeNetworkVisualizationParameters(s.getNetworkVisualizationParametersUuid()); - removeStateEstimationParameters(s.getStateEstimationParametersUuid()); - removeShortcircuitParameters(s.getShortCircuitParametersUuid()); - removePccMinParameters(s.getPccMinParametersUuid()); removeSpreadsheetConfigCollection(s.getSpreadsheetConfigCollectionUuid()); removeWorkspacesConfig(s.getWorkspacesConfigUuid()); removeNadConfigs(s.getNadConfigsUuids().stream().toList()); @@ -572,26 +583,6 @@ private Optional doDeleteStudyIfNotCreationInProgress(UUID stu } } - private void removeStateEstimationParameters(@Nullable UUID uuid) { - if (uuid != null) { - try { - stateEstimationService.deleteStateEstimationParameters(uuid); - } catch (Exception e) { - LOGGER.error("Could not delete state estimation parameters with uuid:" + uuid, e); - } - } - } - - private void removePccMinParameters(@Nullable UUID uuid) { - if (uuid != null) { - try { - pccMinService.deletePccMinParameters(uuid); - } catch (Exception e) { - LOGGER.error("Could not delete pcc min parameters with uuid:" + uuid, e); - } - } - } - private void removeNetworkVisualizationParameters(@Nullable UUID uuid) { if (uuid != null) { try { @@ -622,12 +613,10 @@ public void deleteStudyIfNotCreationInProgress(UUID studyUuid) { } @Transactional - public CreatedStudyBasicInfos insertStudy(UUID studyUuid, String userId, NetworkInfos networkInfos, CaseInfos caseInfos, UUID loadFlowParametersUuid, - UUID shortCircuitParametersUuid, UUID dynamicSimulationParametersUuid, - UUID voltageInitParametersUuid, UUID securityAnalysisParametersUuid, UUID sensitivityAnalysisParametersUuid, - UUID networkVisualizationParametersUuid, UUID dynamicSecurityAnalysisParametersUuid, UUID dynamicMarginCalculationParametersUuid, - UUID stateEstimationParametersUuid, UUID pccMinParametersUuid, - UUID spreadsheetConfigCollectionUuid, UUID workspacesConfigUuid, Map importParameters, UUID importReportUuid) { + public CreatedStudyBasicInfos insertStudy(UUID studyUuid, String userId, NetworkInfos networkInfos, CaseInfos caseInfos, + ComputationsParameters computationsParameters, UUID networkVisualizationParametersUuid, + UUID spreadsheetConfigCollectionUuid, UUID workspacesConfigUuid, + Map importParameters, UUID importReportUuid) { Objects.requireNonNull(studyUuid); Objects.requireNonNull(userId); Objects.requireNonNull(networkInfos.getNetworkUuid()); @@ -637,11 +626,7 @@ public CreatedStudyBasicInfos insertStudy(UUID studyUuid, String userId, Network Objects.requireNonNull(importParameters); StudyEntity studyEntity = saveStudyThenCreateBasicTree(studyUuid, networkInfos, - caseInfos, loadFlowParametersUuid, - shortCircuitParametersUuid, dynamicSimulationParametersUuid, - voltageInitParametersUuid, securityAnalysisParametersUuid, - sensitivityAnalysisParametersUuid, networkVisualizationParametersUuid, dynamicSecurityAnalysisParametersUuid, dynamicMarginCalculationParametersUuid, - stateEstimationParametersUuid, pccMinParametersUuid, spreadsheetConfigCollectionUuid, workspacesConfigUuid, importParameters, importReportUuid); + caseInfos, computationsParameters, networkVisualizationParametersUuid, spreadsheetConfigCollectionUuid, workspacesConfigUuid, importParameters, importReportUuid); // Need to deal with the study creation (with a default root network ?) CreatedStudyBasicInfos createdStudyBasicInfos = toCreatedStudyBasicInfos(studyEntity); @@ -716,46 +701,6 @@ private StudyEntity duplicateStudy(BasicStudyInfos studyInfos, UUID sourceStudyU } private StudyEntity duplicateStudyEntity(StudyEntity sourceStudyEntity, UUID newStudyId) { - UUID copiedLoadFlowParametersUuid = null; - if (sourceStudyEntity.getLoadFlowParametersUuid() != null) { - copiedLoadFlowParametersUuid = loadflowService.duplicateLoadFlowParameters(sourceStudyEntity.getLoadFlowParametersUuid()); - } - - UUID copiedShortCircuitParametersUuid = null; - if (sourceStudyEntity.getShortCircuitParametersUuid() != null) { - copiedShortCircuitParametersUuid = shortCircuitService.duplicateParameters(sourceStudyEntity.getShortCircuitParametersUuid()); - } - - UUID copiedSecurityAnalysisParametersUuid = null; - if (sourceStudyEntity.getSecurityAnalysisParametersUuid() != null) { - copiedSecurityAnalysisParametersUuid = securityAnalysisService.duplicateSecurityAnalysisParameters(sourceStudyEntity.getSecurityAnalysisParametersUuid()); - } - - UUID copiedDynamicSimulationParametersUuid = null; - if (sourceStudyEntity.getDynamicSimulationParametersUuid() != null) { - copiedDynamicSimulationParametersUuid = dynamicSimulationService.duplicateParameters(sourceStudyEntity.getDynamicSimulationParametersUuid()); - } - - UUID copiedDynamicSecurityAnalysisParametersUuid = null; - if (sourceStudyEntity.getDynamicSecurityAnalysisParametersUuid() != null) { - copiedDynamicSecurityAnalysisParametersUuid = dynamicSecurityAnalysisService.duplicateParameters(sourceStudyEntity.getDynamicSecurityAnalysisParametersUuid()); - } - - UUID copiedDynamicMarginCalculationParametersUuid = null; - if (sourceStudyEntity.getDynamicMarginCalculationParametersUuid() != null) { - copiedDynamicMarginCalculationParametersUuid = dynamicMarginCalculationService.duplicateParameters(sourceStudyEntity.getDynamicMarginCalculationParametersUuid()); - } - - UUID copiedSensitivityAnalysisParametersUuid = null; - if (sourceStudyEntity.getSensitivityAnalysisParametersUuid() != null) { - copiedSensitivityAnalysisParametersUuid = sensitivityAnalysisService.duplicateSensitivityAnalysisParameters(sourceStudyEntity.getSensitivityAnalysisParametersUuid()); - } - - UUID copiedVoltageInitParametersUuid = null; - if (sourceStudyEntity.getVoltageInitParametersUuid() != null) { - copiedVoltageInitParametersUuid = voltageInitService.duplicateVoltageInitParameters(sourceStudyEntity.getVoltageInitParametersUuid()); - } - UUID copiedNetworkVisualizationParametersUuid = null; if (sourceStudyEntity.getNetworkVisualizationParametersUuid() != null) { copiedNetworkVisualizationParametersUuid = studyConfigService.duplicateNetworkVisualizationParameters(sourceStudyEntity.getNetworkVisualizationParametersUuid()); @@ -771,30 +716,22 @@ private StudyEntity duplicateStudyEntity(StudyEntity sourceStudyEntity, UUID new copiedWorkspacesConfigUuid = studyConfigService.duplicateWorkspacesConfig(sourceStudyEntity.getWorkspacesConfigUuid()); } - UUID copiedStateEstimationParametersUuid = null; - if (sourceStudyEntity.getStateEstimationParametersUuid() != null) { - copiedStateEstimationParametersUuid = stateEstimationService.duplicateStateEstimationParameters(sourceStudyEntity.getStateEstimationParametersUuid()); - } - - UUID copiedPccMinParametersUuid = null; - if (sourceStudyEntity.getPccMinParametersUuid() != null) { - copiedPccMinParametersUuid = pccMinService.duplicatePccMinParameters(sourceStudyEntity.getPccMinParametersUuid()); - } + ComputationsParameters duplicatedComputationsParameters = computationParametersService.duplicateParameters(sourceStudyEntity); return studyRepository.save(StudyEntity.builder() .id(newStudyId) - .loadFlowParametersUuid(copiedLoadFlowParametersUuid) - .securityAnalysisParametersUuid(copiedSecurityAnalysisParametersUuid) - .dynamicSimulationParametersUuid(copiedDynamicSimulationParametersUuid) - .dynamicSecurityAnalysisParametersUuid(copiedDynamicSecurityAnalysisParametersUuid) - .dynamicMarginCalculationParametersUuid(copiedDynamicMarginCalculationParametersUuid) - .shortCircuitParametersUuid(copiedShortCircuitParametersUuid) - .voltageInitParametersUuid(copiedVoltageInitParametersUuid) - .sensitivityAnalysisParametersUuid(copiedSensitivityAnalysisParametersUuid) + .loadFlowParametersUuid(duplicatedComputationsParameters.loadFlowParametersUuid()) + .securityAnalysisParametersUuid(duplicatedComputationsParameters.securityAnalysisParametersUuid()) + .dynamicSimulationParametersUuid(duplicatedComputationsParameters.dynamicSimulationParametersUuid()) + .dynamicSecurityAnalysisParametersUuid(duplicatedComputationsParameters.dynamicSecurityAnalysisParametersUuid()) + .dynamicMarginCalculationParametersUuid(duplicatedComputationsParameters.dynamicMarginCalculationParametersUuid()) + .shortCircuitParametersUuid(duplicatedComputationsParameters.shortCircuitParametersUuid()) + .voltageInitParametersUuid(duplicatedComputationsParameters.voltageInitParametersUuid()) + .sensitivityAnalysisParametersUuid(duplicatedComputationsParameters.sensitivityAnalysisParametersUuid()) + .stateEstimationParametersUuid(duplicatedComputationsParameters.stateEstimationParametersUuid()) + .pccMinParametersUuid(duplicatedComputationsParameters.pccMinParametersUuid()) .networkVisualizationParametersUuid(copiedNetworkVisualizationParametersUuid) .spreadsheetConfigCollectionUuid(copiedSpreadsheetConfigCollectionUuid) - .stateEstimationParametersUuid(copiedStateEstimationParametersUuid) - .pccMinParametersUuid(copiedPccMinParametersUuid) .workspacesConfigUuid(copiedWorkspacesConfigUuid) .build()); } @@ -1209,6 +1146,64 @@ public LoadFlowParametersInfos getLoadFlowParametersInfos(StudyEntity studyEntit return loadflowService.getLoadFlowParameters(loadFlowParamsUuid); } + private boolean setComputationParameters(UUID studyUuid, T parameters, String userId, + Function studyParameterGetter, + BiConsumer studyParameterSetter, + Function profileParameterGetter, + ComputationParameters computationParameters, + Function createParameters, + BiConsumer updateParameters, + ComputationType computationType, + List> statusInvalidations, + String... statusUpdateTypes) { + StudyEntity studyEntity = getStudy(studyUuid); + boolean userProfileIssue = computationParametersService.createOrUpdateParameters( + studyEntity, + parameters, + userId, + studyParameterGetter, + studyParameterSetter, + profileParameterGetter, + computationParameters, + createParameters, + updateParameters, + computationType.getLabel() + ); + emitComputationParametersChanged(studyUuid, userId, computationType, statusInvalidations, statusUpdateTypes); + return userProfileIssue; + } + + private void setComputationParameters(UUID studyUuid, T parameters, String userId, + Function studyParameterGetter, + BiConsumer studyParameterSetter, + Function createParameters, + BiConsumer updateParameters, + ComputationType computationType, + List> statusInvalidations, + String... statusUpdateTypes) { + StudyEntity studyEntity = getStudy(studyUuid); + computationParametersService.createOrUpdateParameters( + studyEntity, + parameters, + studyParameterGetter, + studyParameterSetter, + createParameters, + updateParameters + ); + emitComputationParametersChanged(studyUuid, userId, computationType, statusInvalidations, statusUpdateTypes); + } + + private void emitComputationParametersChanged(UUID studyUuid, String userId, + ComputationType computationType, + List> statusInvalidations, + String... statusUpdateTypes) { + statusInvalidations.forEach(invalidate -> invalidate.accept(studyUuid)); + Arrays.stream(statusUpdateTypes) + .forEach(updateType -> notificationService.emitStudyChanged(studyUuid, null, null, updateType)); + notificationService.emitElementUpdated(studyUuid, userId); + notificationService.emitComputationParamsChanged(studyUuid, computationType); + } + @Transactional public String getSecurityAnalysisParametersValues(UUID studyUuid) { StudyEntity studyEntity = getStudy(studyUuid); @@ -1217,13 +1212,20 @@ public String getSecurityAnalysisParametersValues(UUID studyUuid) { @Transactional public boolean setSecurityAnalysisParametersValues(UUID studyUuid, String parameters, String userId) { - StudyEntity studyEntity = getStudy(studyUuid); - boolean userProfileIssue = createOrUpdateSecurityAnalysisParameters(studyEntity, parameters, userId); - invalidateSecurityAnalysisStatusOnAllNodes(studyUuid); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_SECURITY_ANALYSIS_STATUS); - notificationService.emitElementUpdated(studyUuid, userId); - notificationService.emitComputationParamsChanged(studyUuid, SECURITY_ANALYSIS); - return userProfileIssue; + return setComputationParameters( + studyUuid, + parameters, + userId, + StudyEntity::getSecurityAnalysisParametersUuid, + StudyEntity::setSecurityAnalysisParametersUuid, + UserProfileInfos::getSecurityAnalysisParameterId, + securityAnalysisService, + securityAnalysisService::createSecurityAnalysisParameters, + securityAnalysisService::updateSecurityAnalysisParameters, + SECURITY_ANALYSIS, + List.of(this::invalidateSecurityAnalysisStatusOnAllNodes), + NotificationService.UPDATE_TYPE_SECURITY_ANALYSIS_STATUS + ); } @Transactional @@ -1252,23 +1254,32 @@ public void createOrUpdateNetworkVisualizationParameters(StudyEntity studyEntity @Transactional public boolean setLoadFlowParameters(UUID studyUuid, String parameters, String userId) { - StudyEntity studyEntity = getStudy(studyUuid); - boolean userProfileIssue = createOrUpdateLoadFlowParameters(studyEntity, parameters, userId); - invalidateAllStudyLoadFlowStatus(studyUuid); - invalidateSecurityAnalysisStatusOnAllNodes(studyUuid); - invalidateSensitivityAnalysisStatusOnAllNodes(studyUuid); - invalidateDynamicSimulationStatusOnAllNodes(studyUuid); - invalidateDynamicSecurityAnalysisStatusOnAllNodes(studyUuid); - invalidateDynamicMarginCalculationStatusOnAllNodes(studyUuid); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_LOADFLOW_STATUS); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_SECURITY_ANALYSIS_STATUS); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_SENSITIVITY_ANALYSIS_STATUS); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_DYNAMIC_SIMULATION_STATUS); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_DYNAMIC_SECURITY_ANALYSIS_STATUS); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_DYNAMIC_MARGIN_CALCULATION_STATUS); - notificationService.emitElementUpdated(studyUuid, userId); - notificationService.emitComputationParamsChanged(studyUuid, LOAD_FLOW); - return userProfileIssue; + return setComputationParameters( + studyUuid, + parameters, + userId, + StudyEntity::getLoadFlowParametersUuid, + StudyEntity::setLoadFlowParametersUuid, + UserProfileInfos::getLoadFlowParameterId, + loadflowService, + loadflowService::createLoadFlowParameters, + loadflowService::updateLoadFlowParameters, + LOAD_FLOW, + List.of( + this::invalidateAllStudyLoadFlowStatus, + this::invalidateSecurityAnalysisStatusOnAllNodes, + this::invalidateSensitivityAnalysisStatusOnAllNodes, + this::invalidateDynamicSimulationStatusOnAllNodes, + this::invalidateDynamicSecurityAnalysisStatusOnAllNodes, + this::invalidateDynamicMarginCalculationStatusOnAllNodes + ), + NotificationService.UPDATE_TYPE_LOADFLOW_STATUS, + NotificationService.UPDATE_TYPE_SECURITY_ANALYSIS_STATUS, + NotificationService.UPDATE_TYPE_SENSITIVITY_ANALYSIS_STATUS, + NotificationService.UPDATE_TYPE_DYNAMIC_SIMULATION_STATUS, + NotificationService.UPDATE_TYPE_DYNAMIC_SECURITY_ANALYSIS_STATUS, + NotificationService.UPDATE_TYPE_DYNAMIC_MARGIN_CALCULATION_STATUS + ); } public String getDynamicSimulationProvider(UUID studyUuid) { @@ -1298,62 +1309,22 @@ public String getShortCircuitParametersInfo(UUID studyUuid) { @Transactional public boolean setShortCircuitParameters(UUID studyUuid, @Nullable String shortCircuitParametersInfos, String userId) { - StudyEntity studyEntity = getStudy(studyUuid); - boolean userProfileIssue = createOrUpdateShortcircuitParameters(studyEntity, shortCircuitParametersInfos, userId); - invalidateShortCircuitStatusOnAllNodes(studyUuid); - invalidatePccMinStatusOnAllNodes(studyUuid); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_SHORT_CIRCUIT_STATUS); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_ONE_BUS_SHORT_CIRCUIT_STATUS); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_PCC_MIN_STATUS); - notificationService.emitElementUpdated(studyUuid, userId); - notificationService.emitComputationParamsChanged(studyUuid, SHORT_CIRCUIT); - return userProfileIssue; - } - - public boolean createOrUpdateShortcircuitParameters(StudyEntity studyEntity, String parameters, String userId) { - /* +-----------------------+----------------+-----------------------------------------+ - * | entity.parametersUuid | parametersInfo | action | - * | no | no | create default ones | - * | no | yes | create new ones | - * | yes | no | reset existing ones (with default ones) | - * | yes | yes | update existing ones | - * +-----------------------+----------------+-----------------------------------------+ - */ - boolean userProfileIssue = false; - UUID existingShortcircuitParametersUuid = studyEntity.getShortCircuitParametersUuid(); - UserProfileInfos userProfileInfos = parameters == null ? userAdminService.getUserProfile(userId) : null; - if (parameters == null && userProfileInfos.getShortcircuitParameterId() != null) { - // reset case, with existing profile, having default short circuit params - try { - UUID shortcircuitParametersFromProfileUuid = shortCircuitService.duplicateParameters(userProfileInfos.getShortcircuitParameterId()); - studyEntity.setShortCircuitParametersUuid(shortcircuitParametersFromProfileUuid); - removeShortcircuitParameters(existingShortcircuitParametersUuid); - return userProfileIssue; - } catch (Exception e) { - userProfileIssue = true; - LOGGER.error(String.format("Could not duplicate short circuit parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getShortcircuitParameterId(), userId, userProfileInfos.getName()), e); - // in case of duplication error (ex: wrong/dangling uuid in the profile), move on with default params below - } - } - - if (existingShortcircuitParametersUuid == null) { - existingShortcircuitParametersUuid = shortCircuitService.createParameters(parameters); - studyEntity.setShortCircuitParametersUuid(existingShortcircuitParametersUuid); - } else { - shortCircuitService.updateParameters(existingShortcircuitParametersUuid, parameters); - } - return userProfileIssue; - } - - private void removeShortcircuitParameters(@Nullable UUID shortcircuitParametersUuid) { - if (shortcircuitParametersUuid != null) { - try { - shortCircuitService.deleteShortcircuitParameters(shortcircuitParametersUuid); - } catch (Exception e) { - LOGGER.error("Could not remove short circuit parameters with uuid:" + shortcircuitParametersUuid, e); - } - } + return setComputationParameters( + studyUuid, + shortCircuitParametersInfos, + userId, + StudyEntity::getShortCircuitParametersUuid, + StudyEntity::setShortCircuitParametersUuid, + UserProfileInfos::getShortcircuitParameterId, + shortCircuitService, + shortCircuitService::createParameters, + shortCircuitService::updateParameters, + SHORT_CIRCUIT, + List.of(this::invalidateShortCircuitStatusOnAllNodes, this::invalidatePccMinStatusOnAllNodes), + NotificationService.UPDATE_TYPE_SHORT_CIRCUIT_STATUS, + NotificationService.UPDATE_TYPE_ONE_BUS_SHORT_CIRCUIT_STATUS, + NotificationService.UPDATE_TYPE_PCC_MIN_STATUS + ); } @Transactional @@ -1538,27 +1509,24 @@ public StudyEntity updateRootNetworkIndexationStatus(UUID studyUuid, UUID rootNe } private StudyEntity saveStudyThenCreateBasicTree(UUID studyUuid, NetworkInfos networkInfos, - CaseInfos caseInfos, UUID loadFlowParametersUuid, - UUID shortCircuitParametersUuid, UUID dynamicSimulationParametersUuid, - UUID voltageInitParametersUuid, UUID securityAnalysisParametersUuid, UUID sensitivityAnalysisParametersUuid, - UUID networkVisualizationParametersUuid, UUID dynamicSecurityAnalysisParametersUuid, UUID dynamicMarginCalculationParametersUuid, - UUID stateEstimationParametersUuid, UUID pccMinParametersUuid, - UUID spreadsheetConfigCollectionUuid, UUID workspacesConfigUuid, Map importParameters, UUID importReportUuid) { + CaseInfos caseInfos, ComputationsParameters computationsParameters, + UUID networkVisualizationParametersUuid, UUID spreadsheetConfigCollectionUuid, + UUID workspacesConfigUuid, Map importParameters, UUID importReportUuid) { StudyEntity studyEntity = StudyEntity.builder() .id(studyUuid) - .loadFlowParametersUuid(loadFlowParametersUuid) - .shortCircuitParametersUuid(shortCircuitParametersUuid) - .voltageInitParametersUuid(voltageInitParametersUuid) - .securityAnalysisParametersUuid(securityAnalysisParametersUuid) - .sensitivityAnalysisParametersUuid(sensitivityAnalysisParametersUuid) + .loadFlowParametersUuid(computationsParameters.loadFlowParametersUuid()) + .shortCircuitParametersUuid(computationsParameters.shortCircuitParametersUuid()) + .voltageInitParametersUuid(computationsParameters.voltageInitParametersUuid()) + .securityAnalysisParametersUuid(computationsParameters.securityAnalysisParametersUuid()) + .sensitivityAnalysisParametersUuid(computationsParameters.sensitivityAnalysisParametersUuid()) .voltageInitParameters(new StudyVoltageInitParametersEntity()) .networkVisualizationParametersUuid(networkVisualizationParametersUuid) - .dynamicSimulationParametersUuid(dynamicSimulationParametersUuid) - .dynamicSecurityAnalysisParametersUuid(dynamicSecurityAnalysisParametersUuid) - .dynamicMarginCalculationParametersUuid(dynamicMarginCalculationParametersUuid) - .stateEstimationParametersUuid(stateEstimationParametersUuid) - .pccMinParametersUuid(pccMinParametersUuid) + .dynamicSimulationParametersUuid(computationsParameters.dynamicSimulationParametersUuid()) + .dynamicSecurityAnalysisParametersUuid(computationsParameters.dynamicSecurityAnalysisParametersUuid()) + .dynamicMarginCalculationParametersUuid(computationsParameters.dynamicMarginCalculationParametersUuid()) + .stateEstimationParametersUuid(computationsParameters.stateEstimationParametersUuid()) + .pccMinParametersUuid(computationsParameters.pccMinParametersUuid()) .spreadsheetConfigCollectionUuid(spreadsheetConfigCollectionUuid) .workspacesConfigUuid(workspacesConfigUuid) .monoRoot(true) @@ -1604,45 +1572,6 @@ private StudyCreationRequestEntity insertStudyCreationRequestEntity(UUID studyUu return studyCreationRequestRepository.save(studyCreationRequestEntity); } - public boolean createOrUpdateLoadFlowParameters(StudyEntity studyEntity, String parameters, String userId) { - boolean userProfileIssue = false; - UUID existingLoadFlowParametersUuid = studyEntity.getLoadFlowParametersUuid(); - - UserProfileInfos userProfileInfos = parameters == null ? userAdminService.getUserProfile(userId) : null; - if (parameters == null && userProfileInfos.getLoadFlowParameterId() != null) { - // reset case, with existing profile, having default LF params - try { - UUID loadFlowParametersFromProfileUuid = loadflowService.duplicateLoadFlowParameters(userProfileInfos.getLoadFlowParameterId()); - studyEntity.setLoadFlowParametersUuid(loadFlowParametersFromProfileUuid); - removeLoadFlowParameters(existingLoadFlowParametersUuid); - return userProfileIssue; - } catch (Exception e) { - userProfileIssue = true; - LOGGER.error(String.format("Could not duplicate loadflow parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getLoadFlowParameterId(), userId, userProfileInfos.getName()), e); - // in case of duplication error (ex: wrong/dangling uuid in the profile), move on with default params below - } - } - - if (existingLoadFlowParametersUuid == null) { - existingLoadFlowParametersUuid = loadflowService.createLoadFlowParameters(parameters); - studyEntity.setLoadFlowParametersUuid(existingLoadFlowParametersUuid); - } else { - loadflowService.updateLoadFlowParameters(existingLoadFlowParametersUuid, parameters); - } - return userProfileIssue; - } - - private void removeLoadFlowParameters(@Nullable UUID lfParametersUuid) { - if (lfParametersUuid != null) { - try { - loadflowService.deleteLoadFlowParameters(lfParametersUuid); - } catch (Exception e) { - LOGGER.error("Could not remove loadflow Parameters with uuid:" + lfParametersUuid, e); - } - } - } - public boolean createOrUpdateVoltageInitParameters(StudyEntity studyEntity, VoltageInitParametersInfos parameters, String userId) { boolean userProfileIssue = false; UUID existingVoltageInitParametersUuid = studyEntity.getVoltageInitParametersUuid(); @@ -1650,9 +1579,9 @@ public boolean createOrUpdateVoltageInitParameters(StudyEntity studyEntity, Volt if (parameters == null && userProfileInfos.getVoltageInitParameterId() != null) { // reset case, with existing profile, having default voltage init params try { - UUID voltageInitParametersFromProfileUuid = voltageInitService.duplicateVoltageInitParameters(userProfileInfos.getVoltageInitParameterId()); + UUID voltageInitParametersFromProfileUuid = voltageInitService.duplicateParameters(userProfileInfos.getVoltageInitParameterId()); studyEntity.setVoltageInitParametersUuid(voltageInitParametersFromProfileUuid); - removeVoltageInitParameters(existingVoltageInitParametersUuid); + computationParametersService.deleteComputationParameters(existingVoltageInitParametersUuid, voltageInitService, VOLTAGE_INITIALIZATION.getLabel()); return userProfileIssue; } catch (Exception e) { userProfileIssue = true; @@ -1675,55 +1604,6 @@ public boolean createOrUpdateVoltageInitParameters(StudyEntity studyEntity, Volt return userProfileIssue; } - private void removeVoltageInitParameters(@Nullable UUID voltageInitParametersUuid) { - if (voltageInitParametersUuid != null) { - try { - voltageInitService.deleteVoltageInitParameters(voltageInitParametersUuid); - } catch (Exception e) { - LOGGER.error("Could not remove voltage init parameters with uuid:" + voltageInitParametersUuid, e); - } - } - } - - public boolean createOrUpdateSecurityAnalysisParameters(StudyEntity studyEntity, String parameters, String userId) { - boolean userProfileIssue = false; - UUID existingSecurityAnalysisParametersUuid = studyEntity.getSecurityAnalysisParametersUuid(); - UserProfileInfos userProfileInfos = parameters == null ? userAdminService.getUserProfile(userId) : null; - if (parameters == null && userProfileInfos.getSecurityAnalysisParameterId() != null) { - // reset case, with existing profile, having default security analysis params - try { - UUID securityAnalysisParametersFromProfileUuid = securityAnalysisService.duplicateSecurityAnalysisParameters(userProfileInfos.getSecurityAnalysisParameterId()); - studyEntity.setSecurityAnalysisParametersUuid(securityAnalysisParametersFromProfileUuid); - removeSecurityAnalysisParameters(existingSecurityAnalysisParametersUuid); - return userProfileIssue; - } catch (Exception e) { - userProfileIssue = true; - LOGGER.error(String.format("Could not duplicate security analysis parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getSecurityAnalysisParameterId(), userId, userProfileInfos.getName()), e); - // in case of duplication error (ex: wrong/dangling uuid in the profile), move on with default params below - } - } - - if (existingSecurityAnalysisParametersUuid == null) { - existingSecurityAnalysisParametersUuid = securityAnalysisService.createSecurityAnalysisParameters(parameters); - studyEntity.setSecurityAnalysisParametersUuid(existingSecurityAnalysisParametersUuid); - } else { - securityAnalysisService.updateSecurityAnalysisParameters(existingSecurityAnalysisParametersUuid, parameters); - } - - return userProfileIssue; - } - - private void removeSecurityAnalysisParameters(@Nullable UUID securityAnalysisParametersUuid) { - if (securityAnalysisParametersUuid != null) { - try { - securityAnalysisService.deleteSecurityAnalysisParameters(securityAnalysisParametersUuid); - } catch (Exception e) { - LOGGER.error("Could not remove security analysis parameters with uuid:" + securityAnalysisParametersUuid, e); - } - } - } - @Transactional public void createNetworkModification(UUID studyUuid, UUID nodeUuid, String createModificationAttributes, String userId) { List childrenUuids = networkModificationTreeService.getChildrenUuids(nodeUuid); @@ -2729,7 +2609,6 @@ private UUID handleShortCircuitRequest(StudyEntity studyEntity, UUID nodeUuid, U updateComputationResultUuid(nodeUuid, rootNetworkUuid, result, computationType); notificationService.emitStudyChanged(studyEntity.getId(), nodeUuid, rootNetworkUuid, busId.isEmpty() ? NotificationService.UPDATE_TYPE_SHORT_CIRCUIT_STATUS : NotificationService.UPDATE_TYPE_ONE_BUS_SHORT_CIRCUIT_STATUS); - notificationService.emitElementUpdated(studyEntity.getId(), userId); return result; } @@ -2777,10 +2656,13 @@ public boolean setVoltageInitParameters(UUID studyUuid, StudyVoltageInitParamete voltageInitParameters.setApplyModifications(parameters.isApplyModifications()); } boolean userProfileIssue = createOrUpdateVoltageInitParameters(studyEntity, parameters.getComputationParameters(), userId); - invalidateVoltageInitStatusOnAllNodes(studyEntity.getId()); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_VOLTAGE_INIT_STATUS); - notificationService.emitElementUpdated(studyUuid, userId); - notificationService.emitComputationParamsChanged(studyUuid, VOLTAGE_INITIALIZATION); + emitComputationParametersChanged( + studyUuid, + userId, + VOLTAGE_INITIALIZATION, + List.of(this::invalidateVoltageInitStatusOnAllNodes), + NotificationService.UPDATE_TYPE_VOLTAGE_INIT_STATUS + ); return userProfileIssue; } @@ -2945,57 +2827,21 @@ public String getDynamicSimulationParameters(UUID studyUuid) { @Transactional public boolean setDynamicSimulationParameters(UUID studyUuid, String dsParameter, String userId) { - StudyEntity studyEntity = getStudy(studyUuid); - boolean userProfileIssue = createOrUpdateDynamicSimulationParameters(studyEntity, dsParameter, userId); - invalidateDynamicSimulationStatusOnAllNodes(studyUuid); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_DYNAMIC_SIMULATION_STATUS); - - // Dynamic security analysis depends on dynamic simulation => must invalidate - invalidateDynamicSecurityAnalysisStatusOnAllNodes(studyUuid); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_DYNAMIC_SECURITY_ANALYSIS_STATUS); - - notificationService.emitElementUpdated(studyUuid, userId); - notificationService.emitComputationParamsChanged(studyUuid, DYNAMIC_SIMULATION); - return userProfileIssue; - } - - public boolean createOrUpdateDynamicSimulationParameters(StudyEntity studyEntity, String parameters, String userId) { - boolean userProfileIssue = false; - UUID existingDynamicSimulationParametersUuid = studyEntity.getDynamicSimulationParametersUuid(); - UserProfileInfos userProfileInfos = parameters == null ? userAdminService.getUserProfile(userId) : null; - if (parameters == null && userProfileInfos.getDynamicSimulationParameterId() != null) { - // reset case, with existing profile, having default dynamic simulation params - try { - UUID dynamicSimulationParametersFromProfileUuid = dynamicSimulationService.duplicateParameters(userProfileInfos.getDynamicSimulationParameterId()); - studyEntity.setDynamicSimulationParametersUuid(dynamicSimulationParametersFromProfileUuid); - removeDynamicSimulationParameters(existingDynamicSimulationParametersUuid); - return userProfileIssue; - } catch (Exception e) { - userProfileIssue = true; - LOGGER.error(String.format("Could not duplicate dynamic simulation parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getDynamicSimulationParameterId(), userId, userProfileInfos.getName()), e); - // in case of duplication error (ex: wrong/dangling uuid in the profile), move on with default params below - } - } - - if (existingDynamicSimulationParametersUuid == null) { - UUID newDynamicSimulationParametersUuid = dynamicSimulationService.createParameters(parameters); - studyEntity.setDynamicSimulationParametersUuid(newDynamicSimulationParametersUuid); - } else { - dynamicSimulationService.updateParameters(existingDynamicSimulationParametersUuid, parameters); - } - - return userProfileIssue; - } - - private void removeDynamicSimulationParameters(@Nullable UUID dynamicSimulationParametersUuid) { - if (dynamicSimulationParametersUuid != null) { - try { - dynamicSimulationService.deleteParameters(dynamicSimulationParametersUuid); - } catch (Exception e) { - LOGGER.error("Could not remove dynamic simulation parameters with uuid:" + dynamicSimulationParametersUuid, e); - } - } + return setComputationParameters( + studyUuid, + dsParameter, + userId, + StudyEntity::getDynamicSimulationParametersUuid, + StudyEntity::setDynamicSimulationParametersUuid, + UserProfileInfos::getDynamicSimulationParameterId, + dynamicSimulationService, + dynamicSimulationService::createParameters, + dynamicSimulationService::updateParameters, + DYNAMIC_SIMULATION, + List.of(this::invalidateDynamicSimulationStatusOnAllNodes, this::invalidateDynamicSecurityAnalysisStatusOnAllNodes), + NotificationService.UPDATE_TYPE_DYNAMIC_SIMULATION_STATUS, + NotificationService.UPDATE_TYPE_DYNAMIC_SECURITY_ANALYSIS_STATUS + ); } @Transactional(readOnly = true) @@ -3109,52 +2955,20 @@ public String getDynamicSecurityAnalysisParameters(UUID studyUuid) { @Transactional public boolean setDynamicSecurityAnalysisParameters(UUID studyUuid, String dsaParameter, String userId) { - StudyEntity studyEntity = getStudy(studyUuid); - boolean userProfileIssue = createOrUpdateDynamicSecurityAnalysisParameters(studyEntity, dsaParameter, userId); - invalidateDynamicSecurityAnalysisStatusOnAllNodes(studyUuid); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_DYNAMIC_SECURITY_ANALYSIS_STATUS); - notificationService.emitElementUpdated(studyUuid, userId); - notificationService.emitComputationParamsChanged(studyUuid, DYNAMIC_SECURITY_ANALYSIS); - return userProfileIssue; - } - - public boolean createOrUpdateDynamicSecurityAnalysisParameters(StudyEntity studyEntity, String parameters, String userId) { - boolean userProfileIssue = false; - UUID existingDynamicSecurityAnalysisParametersUuid = studyEntity.getDynamicSecurityAnalysisParametersUuid(); - UserProfileInfos userProfileInfos = parameters == null ? userAdminService.getUserProfile(userId) : null; - if (parameters == null && userProfileInfos.getDynamicSecurityAnalysisParameterId() != null) { - // reset case, with existing profile, having default dynamic security analysis params - try { - UUID dynamicSecurityAnalysisParametersFromProfileUuid = dynamicSecurityAnalysisService.duplicateParameters(userProfileInfos.getDynamicSecurityAnalysisParameterId()); - studyEntity.setDynamicSecurityAnalysisParametersUuid(dynamicSecurityAnalysisParametersFromProfileUuid); - removeDynamicSecurityAnalysisParameters(existingDynamicSecurityAnalysisParametersUuid); - return userProfileIssue; - } catch (Exception e) { - userProfileIssue = true; - LOGGER.error(String.format("Could not duplicate dynamic security analysis parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getDynamicSecurityAnalysisParameterId(), userId, userProfileInfos.getName()), e); - // in case of duplication error (ex: wrong/dangling uuid in the profile), move on with default params below - } - } - - if (existingDynamicSecurityAnalysisParametersUuid == null) { - UUID newDynamicSecurityAnalysisParametersUuid = dynamicSecurityAnalysisService.createParameters(parameters); - studyEntity.setDynamicSecurityAnalysisParametersUuid(newDynamicSecurityAnalysisParametersUuid); - } else { - dynamicSecurityAnalysisService.updateParameters(existingDynamicSecurityAnalysisParametersUuid, parameters); - } - - return userProfileIssue; - } - - private void removeDynamicSecurityAnalysisParameters(@Nullable UUID dynamicSecurityAnalysisParametersUuid) { - if (dynamicSecurityAnalysisParametersUuid != null) { - try { - dynamicSecurityAnalysisService.deleteParameters(dynamicSecurityAnalysisParametersUuid); - } catch (Exception e) { - LOGGER.error("Could not remove dynamic security analysis parameters with uuid:" + dynamicSecurityAnalysisParametersUuid, e); - } - } + return setComputationParameters( + studyUuid, + dsaParameter, + userId, + StudyEntity::getDynamicSecurityAnalysisParametersUuid, + StudyEntity::setDynamicSecurityAnalysisParametersUuid, + UserProfileInfos::getDynamicSecurityAnalysisParameterId, + dynamicSecurityAnalysisService, + dynamicSecurityAnalysisService::createParameters, + dynamicSecurityAnalysisService::updateParameters, + DYNAMIC_SECURITY_ANALYSIS, + List.of(this::invalidateDynamicSecurityAnalysisStatusOnAllNodes), + NotificationService.UPDATE_TYPE_DYNAMIC_SECURITY_ANALYSIS_STATUS + ); } @Transactional @@ -3220,52 +3034,20 @@ public String getDynamicMarginCalculationParameters(UUID studyUuid, String userI @Transactional public boolean setDynamicMarginCalculationParameters(UUID studyUuid, String dmcParameter, String userId) { - StudyEntity studyEntity = getStudy(studyUuid); - boolean userProfileIssue = createOrUpdateDynamicMarginCalculationParameters(studyEntity, dmcParameter, userId); - invalidateDynamicMarginCalculationStatusOnAllNodes(studyUuid); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_DYNAMIC_MARGIN_CALCULATION_STATUS); - notificationService.emitElementUpdated(studyUuid, userId); - notificationService.emitComputationParamsChanged(studyUuid, DYNAMIC_MARGIN_CALCULATION); - return userProfileIssue; - } - - public boolean createOrUpdateDynamicMarginCalculationParameters(StudyEntity studyEntity, String parameters, String userId) { - boolean userProfileIssue = false; - UUID existingDynamicMarginCalculationParametersUuid = studyEntity.getDynamicMarginCalculationParametersUuid(); - UserProfileInfos userProfileInfos = parameters == null ? userAdminService.getUserProfile(userId) : null; - if (parameters == null && userProfileInfos.getDynamicMarginCalculationParameterId() != null) { - // reset case, with existing profile, having default dynamic margin calculation params - try { - UUID dynamicMarginCalculationParametersFromProfileUuid = dynamicMarginCalculationService.duplicateParameters(userProfileInfos.getDynamicMarginCalculationParameterId()); - studyEntity.setDynamicMarginCalculationParametersUuid(dynamicMarginCalculationParametersFromProfileUuid); - removeDynamicMarginCalculationParameters(existingDynamicMarginCalculationParametersUuid); - return userProfileIssue; - } catch (Exception e) { - userProfileIssue = true; - LOGGER.error(String.format("Could not duplicate dynamic margin calculation parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getDynamicMarginCalculationParameterId(), userId, userProfileInfos.getName()), e); - // in case of duplication error (ex: wrong/dangling uuid in the profile), move on with default params below - } - } - - if (existingDynamicMarginCalculationParametersUuid == null) { - UUID newDynamicMarginCalculationParametersUuid = dynamicMarginCalculationService.createParameters(parameters); - studyEntity.setDynamicMarginCalculationParametersUuid(newDynamicMarginCalculationParametersUuid); - } else { - dynamicMarginCalculationService.updateParameters(existingDynamicMarginCalculationParametersUuid, parameters); - } - - return userProfileIssue; - } - - private void removeDynamicMarginCalculationParameters(@Nullable UUID dynamicMarginCalculationParametersUuid) { - if (dynamicMarginCalculationParametersUuid != null) { - try { - dynamicMarginCalculationService.deleteParameters(dynamicMarginCalculationParametersUuid); - } catch (Exception e) { - LOGGER.error("Could not remove dynamic margin calculation parameters with uuid:" + dynamicMarginCalculationParametersUuid, e); - } - } + return setComputationParameters( + studyUuid, + dmcParameter, + userId, + StudyEntity::getDynamicMarginCalculationParametersUuid, + StudyEntity::setDynamicMarginCalculationParametersUuid, + UserProfileInfos::getDynamicMarginCalculationParameterId, + dynamicMarginCalculationService, + dynamicMarginCalculationService::createParameters, + dynamicMarginCalculationService::updateParameters, + DYNAMIC_MARGIN_CALCULATION, + List.of(this::invalidateDynamicMarginCalculationStatusOnAllNodes), + NotificationService.UPDATE_TYPE_DYNAMIC_MARGIN_CALCULATION_STATUS + ); } @Transactional @@ -3397,52 +3179,20 @@ public String getSensitivityAnalysisParameters(UUID studyUuid) { @Transactional public boolean setSensitivityAnalysisParameters(UUID studyUuid, String parameters, String userId) { - StudyEntity studyEntity = getStudy(studyUuid); - boolean userProfileIssue = createOrUpdateSensitivityAnalysisParameters(studyEntity, parameters, userId); - invalidateSensitivityAnalysisStatusOnAllNodes(studyUuid); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_SENSITIVITY_ANALYSIS_STATUS); - notificationService.emitElementUpdated(studyUuid, userId); - notificationService.emitComputationParamsChanged(studyUuid, SENSITIVITY_ANALYSIS); - return userProfileIssue; - } - - public boolean createOrUpdateSensitivityAnalysisParameters(StudyEntity studyEntity, String parameters, String userId) { - boolean userProfileIssue = false; - UUID existingSensitivityAnalysisParametersUuid = studyEntity.getSensitivityAnalysisParametersUuid(); - UserProfileInfos userProfileInfos = parameters == null ? userAdminService.getUserProfile(userId) : null; - if (parameters == null && userProfileInfos.getSensitivityAnalysisParameterId() != null) { - // reset case, with existing profile, having default sensitivity analysis params - try { - UUID sensitivityAnalysisParametersFromProfileUuid = sensitivityAnalysisService.duplicateSensitivityAnalysisParameters(userProfileInfos.getSensitivityAnalysisParameterId()); - studyEntity.setSensitivityAnalysisParametersUuid(sensitivityAnalysisParametersFromProfileUuid); - removeSensitivityAnalysisParameters(existingSensitivityAnalysisParametersUuid); - return userProfileIssue; - } catch (Exception e) { - userProfileIssue = true; - LOGGER.error(String.format("Could not duplicate sensitivity analysis parameters with id '%s' from user/profile '%s/%s'. Using default parameters", - userProfileInfos.getSensitivityAnalysisParameterId(), userId, userProfileInfos.getName()), e); - // in case of duplication error (ex: wrong/dangling uuid in the profile), move on with default params below - } - } - - if (existingSensitivityAnalysisParametersUuid == null) { - existingSensitivityAnalysisParametersUuid = sensitivityAnalysisService.createSensitivityAnalysisParameters(parameters); - studyEntity.setSensitivityAnalysisParametersUuid(existingSensitivityAnalysisParametersUuid); - } else { - sensitivityAnalysisService.updateSensitivityAnalysisParameters(existingSensitivityAnalysisParametersUuid, parameters); - } - - return userProfileIssue; - } - - private void removeSensitivityAnalysisParameters(@Nullable UUID sensitivityAnalysisParametersUuid) { - if (sensitivityAnalysisParametersUuid != null) { - try { - sensitivityAnalysisService.deleteSensitivityAnalysisParameters(sensitivityAnalysisParametersUuid); - } catch (Exception e) { - LOGGER.error("Could not remove sensitivity analysis parameters with uuid:" + sensitivityAnalysisParametersUuid, e); - } - } + return setComputationParameters( + studyUuid, + parameters, + userId, + StudyEntity::getSensitivityAnalysisParametersUuid, + StudyEntity::setSensitivityAnalysisParametersUuid, + UserProfileInfos::getSensitivityAnalysisParameterId, + sensitivityAnalysisService, + sensitivityAnalysisService::createSensitivityAnalysisParameters, + sensitivityAnalysisService::updateSensitivityAnalysisParameters, + SENSITIVITY_ANALYSIS, + List.of(this::invalidateSensitivityAnalysisStatusOnAllNodes), + NotificationService.UPDATE_TYPE_SENSITIVITY_ANALYSIS_STATUS + ); } public void invalidateShortCircuitStatusOnAllNodes(UUID studyUuid) { @@ -3590,7 +3340,6 @@ private UUID handlePccMinRequest(StudyEntity studyEntity, UUID nodeUuid, UUID ro UUID result = pccMinService.runPccMin(networkUuid, variantId, runPccMinParametersInfos, new ReportInfos(reportUuid, nodeUuid), receiver, userId); updateComputationResultUuid(nodeUuid, rootNetworkUuid, result, PCC_MIN); notificationService.emitStudyChanged(studyEntity.getId(), nodeUuid, rootNetworkUuid, NotificationService.UPDATE_TYPE_PCC_MIN_STATUS); - notificationService.emitElementUpdated(studyEntity.getId(), userId); return result; } @@ -3602,22 +3351,18 @@ public String getStateEstimationParameters(UUID studyUuid) { @Transactional public void setStateEstimationParametersValues(UUID studyUuid, String parameters, String userId) { - StudyEntity studyEntity = getStudy(studyUuid); - createOrUpdateStateEstimationParameters(studyEntity, parameters); - invalidateStateEstimationStatusOnAllNodes(studyEntity.getId()); - notificationService.emitStudyChanged(studyUuid, null, null, NotificationService.UPDATE_TYPE_STATE_ESTIMATION_STATUS); - notificationService.emitElementUpdated(studyUuid, userId); - notificationService.emitComputationParamsChanged(studyUuid, STATE_ESTIMATION); - } - - public void createOrUpdateStateEstimationParameters(StudyEntity studyEntity, String parameters) { - UUID existingStateEstimationParametersUuid = studyEntity.getStateEstimationParametersUuid(); - if (existingStateEstimationParametersUuid == null) { - existingStateEstimationParametersUuid = stateEstimationService.createStateEstimationParameters(parameters); - studyEntity.setStateEstimationParametersUuid(existingStateEstimationParametersUuid); - } else { - stateEstimationService.updateStateEstimationParameters(existingStateEstimationParametersUuid, parameters); - } + setComputationParameters( + studyUuid, + parameters, + userId, + StudyEntity::getStateEstimationParametersUuid, + StudyEntity::setStateEstimationParametersUuid, + stateEstimationService::createStateEstimationParameters, + stateEstimationService::updateStateEstimationParameters, + STATE_ESTIMATION, + List.of(this::invalidateStateEstimationStatusOnAllNodes), + NotificationService.UPDATE_TYPE_STATE_ESTIMATION_STATUS + ); } @Transactional @@ -3646,7 +3391,7 @@ public boolean createOrUpdatePccMinParameters(StudyEntity studyEntity, String pa if (parameters == null && userProfileInfos.getPccMinParameterId() != null) { // reset case, with existing profile, having default pcc min params try { - UUID pccMinParametersFromProfileUuid = pccMinService.duplicatePccMinParameters(userProfileInfos.getPccMinParameterId()); + UUID pccMinParametersFromProfileUuid = pccMinService.duplicateParameters(userProfileInfos.getPccMinParameterId()); studyEntity.setPccMinParametersUuid(pccMinParametersFromProfileUuid); removePccMinParameters(existingPccMinParametersUuid); return userProfileIssue; @@ -3666,6 +3411,16 @@ public boolean createOrUpdatePccMinParameters(StudyEntity studyEntity, String pa return userProfileIssue; } + private void removePccMinParameters(@Nullable UUID uuid) { + if (uuid != null) { + try { + pccMinService.deleteParameters(uuid); + } catch (Exception e) { + LOGGER.error("Could not delete pcc min parameters with uuid:" + uuid, e); + } + } + } + @Transactional public NetworkModificationNode createNode(UUID studyUuid, UUID nodeId, NetworkModificationNode nodeInfo, InsertMode insertMode, String userId) { StudyEntity study = getStudy(studyUuid); diff --git a/src/main/java/org/gridsuite/study/server/service/VoltageInitService.java b/src/main/java/org/gridsuite/study/server/service/VoltageInitService.java index a2fb4275d9..da3127ee9c 100644 --- a/src/main/java/org/gridsuite/study/server/service/VoltageInitService.java +++ b/src/main/java/org/gridsuite/study/server/service/VoltageInitService.java @@ -19,6 +19,7 @@ import org.gridsuite.study.server.dto.VoltageInitStatus; import org.gridsuite.study.server.dto.voltageinit.parameters.VoltageInitParametersInfos; import org.gridsuite.study.server.service.common.AbstractComputationService; +import org.gridsuite.study.server.service.common.ComputationParameters; import org.springframework.http.*; import org.springframework.lang.Nullable; import org.springframework.stereotype.Service; @@ -39,7 +40,7 @@ * @author Etienne Homer */ @Service -public class VoltageInitService extends AbstractComputationService { +public class VoltageInitService extends AbstractComputationService implements ComputationParameters { static final String RESULT_UUID = "resultUuid"; static final String PARAMETERS_URI = "/parameters/{parametersUuid}"; @@ -159,8 +160,8 @@ public void updateVoltageInitParameters(UUID parametersUuid, @Nullable VoltageIn restTemplate.exchange(voltageInitServerBaseUri + path, HttpMethod.PUT, httpEntity, UUID.class); } - public UUID duplicateVoltageInitParameters(UUID sourceParametersUuid) { - + @Override + public UUID duplicateParameters(UUID sourceParametersUuid) { Objects.requireNonNull(sourceParametersUuid); String path = UriComponentsBuilder @@ -176,7 +177,8 @@ public UUID duplicateVoltageInitParameters(UUID sourceParametersUuid) { return restTemplate.exchange(voltageInitServerBaseUri + path, HttpMethod.POST, httpEntity, UUID.class).getBody(); } - public void deleteVoltageInitParameters(UUID parametersUuid) { + @Override + public void deleteParameters(UUID parametersUuid) { String path = UriComponentsBuilder.fromPath(DELIMITER + VOLTAGE_INIT_API_VERSION + PARAMETERS_URI) .buildAndExpand(parametersUuid).toUriString(); diff --git a/src/main/java/org/gridsuite/study/server/service/common/ComputationParameters.java b/src/main/java/org/gridsuite/study/server/service/common/ComputationParameters.java new file mode 100644 index 0000000000..8a1f7dd01c --- /dev/null +++ b/src/main/java/org/gridsuite/study/server/service/common/ComputationParameters.java @@ -0,0 +1,20 @@ +/** + * Copyright (c) 2026, 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.study.server.service.common; + +import java.util.UUID; + +/** + * @author Abdelsalem HEDHILI + */ +public interface ComputationParameters { + + UUID duplicateParameters(UUID parametersUuid); + + void deleteParameters(UUID parametersUuid); + +} diff --git a/src/main/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationService.java b/src/main/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationService.java index 5595c57401..804d1e7384 100644 --- a/src/main/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationService.java +++ b/src/main/java/org/gridsuite/study/server/service/dynamicmargincalculation/DynamicMarginCalculationService.java @@ -16,6 +16,7 @@ import org.gridsuite.study.server.error.StudyException; import org.gridsuite.study.server.repository.StudyEntity; import org.gridsuite.study.server.service.client.dynamicmargincalculation.DynamicMarginCalculationClient; +import org.gridsuite.study.server.service.common.ComputationParameters; import org.springframework.stereotype.Service; import java.io.UncheckedIOException; @@ -30,7 +31,7 @@ * @author Thang PHAM */ @Service -public class DynamicMarginCalculationService { +public class DynamicMarginCalculationService implements ComputationParameters { private final ObjectMapper objectMapper; @@ -58,6 +59,7 @@ public void updateParameters(UUID parametersUuid, String parametersInfos) { dynamicMarginCalculationClient.updateParameters(parametersUuid, parametersInfos); } + @Override public UUID duplicateParameters(UUID sourceParameterId) { return dynamicMarginCalculationClient.duplicateParameters(sourceParameterId); } diff --git a/src/main/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisService.java b/src/main/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisService.java index 56b84d6353..e094272a19 100644 --- a/src/main/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisService.java +++ b/src/main/java/org/gridsuite/study/server/service/dynamicsecurityanalysis/DynamicSecurityAnalysisService.java @@ -16,6 +16,7 @@ import org.gridsuite.study.server.error.StudyException; import org.gridsuite.study.server.repository.StudyEntity; import org.gridsuite.study.server.service.client.dynamicsecurityanalysis.DynamicSecurityAnalysisClient; +import org.gridsuite.study.server.service.common.ComputationParameters; import org.springframework.stereotype.Service; import java.io.UncheckedIOException; @@ -30,7 +31,7 @@ * @author Thang PHAM */ @Service -public class DynamicSecurityAnalysisService { +public class DynamicSecurityAnalysisService implements ComputationParameters { private final ObjectMapper objectMapper; @@ -58,6 +59,7 @@ public void updateParameters(UUID parametersUuid, String parametersInfos) { dynamicSecurityAnalysisClient.updateParameters(parametersUuid, parametersInfos); } + @Override public UUID duplicateParameters(UUID sourceParameterId) { return dynamicSecurityAnalysisClient.duplicateParameters(sourceParameterId); } diff --git a/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationService.java b/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationService.java index 3360a4066b..615d29feed 100644 --- a/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationService.java +++ b/src/main/java/org/gridsuite/study/server/service/dynamicsimulation/DynamicSimulationService.java @@ -14,6 +14,7 @@ import org.gridsuite.study.server.dto.timeseries.TimelineEventInfos; import org.gridsuite.study.server.error.StudyException; import org.gridsuite.study.server.repository.StudyEntity; +import org.gridsuite.study.server.service.common.ComputationParameters; import java.util.List; import java.util.UUID; @@ -21,7 +22,7 @@ /** * @author Thang PHAM */ -public interface DynamicSimulationService { +public interface DynamicSimulationService extends ComputationParameters { // --- Parameters related methods --- // diff --git a/src/main/java/org/gridsuite/study/server/service/shortcircuit/ShortCircuitService.java b/src/main/java/org/gridsuite/study/server/service/shortcircuit/ShortCircuitService.java index eed14a8c38..8a51d27f98 100644 --- a/src/main/java/org/gridsuite/study/server/service/shortcircuit/ShortCircuitService.java +++ b/src/main/java/org/gridsuite/study/server/service/shortcircuit/ShortCircuitService.java @@ -20,6 +20,7 @@ import org.gridsuite.study.server.dto.VariantInfos; import org.gridsuite.study.server.service.StudyService; import org.gridsuite.study.server.service.common.AbstractComputationService; +import org.gridsuite.study.server.service.common.ComputationParameters; import org.gridsuite.study.server.utils.ResultParameters; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.core.ParameterizedTypeReference; @@ -49,7 +50,7 @@ * @author Abdelsalem Hedhili */ @Service -public class ShortCircuitService extends AbstractComputationService { +public class ShortCircuitService extends AbstractComputationService implements ComputationParameters { static final String RESULT_UUID = "resultUuid"; @@ -305,6 +306,7 @@ public String getParameters(UUID parametersUuid) { .toUri(), HttpMethod.GET, new HttpEntity<>(headers), String.class).getBody(); } + @Override public UUID duplicateParameters(UUID parametersUuid) { HttpHeaders headers = new HttpHeaders(); headers.setAccept(List.of(MediaType.APPLICATION_JSON)); @@ -314,7 +316,8 @@ public UUID duplicateParameters(UUID parametersUuid) { .toUri(), new HttpEntity<>(headers), UUID.class); } - public void deleteShortcircuitParameters(UUID uuid) { + @Override + public void deleteParameters(UUID uuid) { Objects.requireNonNull(uuid); String path = UriComponentsBuilder.fromPath(DELIMITER + SHORT_CIRCUIT_API_VERSION + PARAMETERS_URI) .buildAndExpand(uuid)