Refactor NEE and Sensi parameters

src/components/dialogs/parameters/non-evacuated-energy/non-evacuated-energy-parameters.jsx

@@ -5,11 +5,10 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-import { CustomFormProvider, MuiSelectInput, SubmitButton, useSnackMessage } from '@gridsuite/commons-ui';
+import { CustomFormProvider, MuiSelectInput, SubmitButton } from '@gridsuite/commons-ui';
 import { Button, DialogActions, Grid } from '@mui/material';
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useMemo } from 'react';
 import { FormattedMessage } from 'react-intl';
-import { useSelector } from 'react-redux';
 import { styles } from '../parameters';
 import { yupResolver } from '@hookform/resolvers/yup';
 import { useForm } from 'react-hook-form';
@@ -46,10 +45,6 @@ import {
     STAGES_SELECTION,
 } from '../../../utils/field-constants';
 import yup from '../../../utils/yup-config';
-import {
-    getNonEvacuatedEnergyParameters,
-    setNonEvacuatedEnergyParameters,
-} from '../../../../services/study/non-evacuated-energy';
 import NonEvacuatedEnergyParametersSelector from './non-evacuated-energy-parameters-selector';
 import { LineSeparator } from '../../dialogUtils';
 import {
@@ -65,55 +60,6 @@ import {
     getMonitoredBranchesParams,
 } from './utils';
 import { mergeSx } from 'components/utils/functions';
-import ComputingType from '../../../computing-status/computing-type';
-import { isComputationParametersUpdated } from '../common/computation-parameters-util';
-import { OptionalServicesNames, OptionalServicesStatus } from 'components/utils/optional-services';
-import { useOptionalServiceStatus } from 'hooks/use-optional-service-status';
-
-export const useGetNonEvacuatedEnergyParameters = () => {
-    const studyUuid = useSelector((state) => state.studyUuid);
-    const studyUpdated = useSelector((state) => state.studyUpdated);
-
-    const { snackError } = useSnackMessage();
-    const [nonEvacuatedEnergyParams, setNonEvacuatedEnergyParams] = useState(null);
-
-    const nonEvacuatedEnergyAvailability = useOptionalServiceStatus(OptionalServicesNames.SensitivityAnalysis);
-    const nonEvacuatedEnergyAvailabilityRef = useRef(nonEvacuatedEnergyAvailability);
-    nonEvacuatedEnergyAvailabilityRef.current = nonEvacuatedEnergyAvailability;
-
-    const fetchNonEvacuatedEnergyParameters = useCallback(
-        (studyUuid) => {
-            getNonEvacuatedEnergyParameters(studyUuid)
-                .then((params) => setNonEvacuatedEnergyParams(params))
-                .catch((error) => {
-                    snackError({
-                        messageTxt: error.message,
-                        headerId: 'paramsRetrievingError',
-                    });
-                });
-        },
-        [snackError]
-    );
-
-    useEffect(() => {
-        if (studyUuid && nonEvacuatedEnergyAvailability === OptionalServicesStatus.Up) {
-            fetchNonEvacuatedEnergyParameters(studyUuid);
-        }
-    }, [nonEvacuatedEnergyAvailability, studyUuid, fetchNonEvacuatedEnergyParameters]);
-
-    // fetch the parameter if NON_EVACUATED_ENERGY_ANALYSIS  notification type is received.
-    useEffect(() => {
-        if (
-            studyUuid &&
-            nonEvacuatedEnergyAvailabilityRef.current === OptionalServicesStatus.Up &&
-            isComputationParametersUpdated(ComputingType.NON_EVACUATED_ENERGY_ANALYSIS, studyUpdated)
-        ) {
-            fetchNonEvacuatedEnergyParameters(studyUuid);
-        }
-    }, [studyUuid, fetchNonEvacuatedEnergyParameters, studyUpdated]);
-
-    return [nonEvacuatedEnergyParams, setNonEvacuatedEnergyParams];
-};
 
 const formSchema = yup
     .object()
@@ -127,10 +73,16 @@ const formSchema = yup
     })
     .required();
 
-export const NonEvacuatedEnergyParameters = ({ parametersBackend, useNonEvacuatedEnergyParameters }) => {
-    const { snackError } = useSnackMessage();
-
-    const [providers, provider, updateProvider, resetProvider] = parametersBackend;
+export const NonEvacuatedEnergyParameters = ({ parametersBackend }) => {
+    const [
+        providers,
+        provider,
+        updateProvider,
+        resetProvider,
+        nonEvacuatedEnergyParams,
+        updateNonEvacuatedEnergyParams,
+        resetNonEvacuatedEnergyParams,
+    ] = parametersBackend;
 
     const emptyFormData = useMemo(() => {
         return {
@@ -195,18 +147,6 @@ export const NonEvacuatedEnergyParameters = ({ parametersBackend, useNonEvacuate
     });
 
     const { reset, handleSubmit, setValue, getValues, watch } = formMethods;
-    const studyUuid = useSelector((state) => state.studyUuid);
-
-    const [nonEvacuatedEnergyParams, setNonEvacuatedEnergyParams] = useNonEvacuatedEnergyParameters;
-
-    const resetNonEvacuatedEnergyParameters = useCallback(() => {
-        setNonEvacuatedEnergyParameters(studyUuid, emptyFormData).catch((error) => {
-            snackError({
-                messageTxt: error.message,
-                headerId: 'paramsChangingError',
-            });
-        });
-    }, [studyUuid, emptyFormData, snackError]);
 
     const formatNewParams = useCallback((newParams, withProvider = true) => {
         let params = {
@@ -226,19 +166,10 @@ export const NonEvacuatedEnergyParameters = ({ parametersBackend, useNonEvacuate
 
     const onSubmit = useCallback(
         (newParams) => {
-            setNonEvacuatedEnergyParameters(studyUuid, formatNewParams(newParams, true))
-                .then(() => {
-                    setNonEvacuatedEnergyParams(formatNewParams(newParams, false));
-                    updateProvider(newParams[PROVIDER]);
-                })
-                .catch((error) => {
-                    snackError({
-                        messageTxt: error.message,
-                        headerId: 'NonEvacuatedEnergyParametersError',
-                    });
-                });
+            updateNonEvacuatedEnergyParams(formatNewParams(newParams, false));
+            updateProvider(newParams[PROVIDER]);
         },
-        [setNonEvacuatedEnergyParams, snackError, studyUuid, formatNewParams, updateProvider]
+        [updateNonEvacuatedEnergyParams, formatNewParams, updateProvider]
     );
 
     const fromNonEvacuatedEnergyParamsDataToFormValues = useCallback(
@@ -387,7 +318,7 @@ export const NonEvacuatedEnergyParameters = ({ parametersBackend, useNonEvacuate
                 ? nonEvacuatedEnergyParams
                 : emptyFormData;
         fromNonEvacuatedEnergyParamsDataToFormValues(params);
-    }, [fromNonEvacuatedEnergyParamsDataToFormValues, nonEvacuatedEnergyParams, parametersBackend, emptyFormData]);
+    }, [fromNonEvacuatedEnergyParamsDataToFormValues, nonEvacuatedEnergyParams, emptyFormData]);
 
     useEffect(() => {
         const subscription = watch((value, { name, type }) => {
@@ -403,8 +334,8 @@ export const NonEvacuatedEnergyParameters = ({ parametersBackend, useNonEvacuate
     const clear = useCallback(() => {
         reset(emptyFormData);
         resetProvider();
-        resetNonEvacuatedEnergyParameters();
-    }, [emptyFormData, reset, resetProvider, resetNonEvacuatedEnergyParameters]);
+        resetNonEvacuatedEnergyParams();
+    }, [emptyFormData, reset, resetProvider, resetNonEvacuatedEnergyParams]);
 
     const onFormChanged = () => {};
     const onChangeParams = () => {};

src/components/dialogs/parameters/sensi/sensitivity-analysis-parameters.jsx

@@ -51,7 +51,6 @@ import yup from '../../../utils/yup-config';
 import {
     fetchSensitivityAnalysisParameters,
     getSensitivityAnalysisFactorsCount,
-    setSensitivityAnalysisParameters,
 } from '../../../../services/study/sensitivity-analysis';
 import SensitivityAnalysisFields from './sensitivity-Flow-parameters';
 import SensitivityParametersSelector from './sensitivity-parameters-selector';
@@ -93,9 +92,8 @@ export const SensitivityAnalysisParameters = ({ parametersBackend, setHaveDirtyF
     const { snackError } = useSnackMessage();
 
     const [launchLoader, setLaunchLoader] = useState(false);
-    const [isSubmitAction, setIsSubmitAction] = useState(false);
     const [analysisComputeComplexity, setAnalysisComputeComplexity] = useState(0);
-    const [providers, , , , params, updateParameters] = parametersBackend;
+    const [providers, , , , params, updateParameters, resetSensitivityAnalysisParameters] = parametersBackend;
     const [openCreateParameterDialog, setOpenCreateParameterDialog] = useState(false);
     const [openSelectParameterDialog, setOpenSelectParameterDialog] = useState(false);
 
@@ -126,16 +124,6 @@ export const SensitivityAnalysisParameters = ({ parametersBackend, setHaveDirtyF
     const { reset, handleSubmit, formState, getValues, setValue } = formMethods;
     const studyUuid = useSelector((state) => state.studyUuid);
     const currentNode = useSelector((state) => state.currentTreeNode);
-    const [sensitivityAnalysisParams, setSensitivityAnalysisParams] = useState(params);
-
-    const resetSensitivityAnalysisParameters = useCallback(() => {
-        setSensitivityAnalysisParameters(studyUuid, null).catch((error) => {
-            snackError({
-                messageTxt: error.message,
-                headerId: 'paramsChangingError',
-            });
-        });
-    }, [studyUuid, snackError]);
 
     const formatNewParams = useCallback((newParams) => {
         return {
@@ -382,24 +370,13 @@ export const SensitivityAnalysisParameters = ({ parametersBackend, setHaveDirtyF
         handleEntries(values[PARAMETER_SENSI_HVDC], PARAMETER_SENSI_HVDC);
         handleEntries(values[PARAMETER_SENSI_PST], PARAMETER_SENSI_PST);
     }, [onChangeParams, getValues]);
+
     const onSubmit = useCallback(
         (newParams) => {
-            setIsSubmitAction(true);
-            setSensitivityAnalysisParameters(studyUuid, formatNewParams(newParams))
-                .then(() => {
-                    let formattedParams = formatNewParams(newParams);
-                    setSensitivityAnalysisParams(formattedParams);
-                    updateParameters(formattedParams);
-                    initRowsCount();
-                })
-                .catch((error) => {
-                    snackError({
-                        messageTxt: error.message,
-                        headerId: 'SensitivityAnalysisParametersError',
-                    });
-                });
+            updateParameters(formatNewParams(newParams));
+            initRowsCount();
         },
-        [setSensitivityAnalysisParams, snackError, studyUuid, formatNewParams, initRowsCount, updateParameters]
+        [formatNewParams, initRowsCount, updateParameters]
     );
 
     const handleSensibilityParameter = useCallback(
@@ -427,23 +404,13 @@ export const SensitivityAnalysisParameters = ({ parametersBackend, setHaveDirtyF
         [snackError, fromSensitivityAnalysisParamsDataToFormValues, reset, initRowsCount]
     );
 
-    useEffect(() => {
-        if (sensitivityAnalysisParams) {
-            reset(fromSensitivityAnalysisParamsDataToFormValues(sensitivityAnalysisParams));
-            !isSubmitAction && initRowsCount();
-        }
-    }, [
-        fromSensitivityAnalysisParamsDataToFormValues,
-        sensitivityAnalysisParams,
-        initRowsCount,
-        isSubmitAction,
-        reset,
-    ]);
     useEffect(() => {
         if (params) {
             reset(fromSensitivityAnalysisParamsDataToFormValues(params));
+            initRowsCount();
+            setAnalysisComputeComplexity(0);
         }
-    }, [params, reset, fromSensitivityAnalysisParamsDataToFormValues]);
+    }, [params, reset, fromSensitivityAnalysisParamsDataToFormValues, initRowsCount]);
 
     const clear = useCallback(() => {
         reset(emptyFormData);

src/components/parameters-tabs.tsx

@@ -32,6 +32,7 @@ import {
 import {
     fetchDefaultSensitivityAnalysisProvider,
     getSensitivityAnalysisParameters,
+    setSensitivityAnalysisParameters,
 } from 'services/study/sensitivity-analysis';
 import { fetchSensitivityAnalysisProviders } from 'services/sensitivity-analysis';
 import { SensitivityAnalysisParameters } from './dialogs/parameters/sensi/sensitivity-analysis-parameters';
@@ -50,12 +51,10 @@ import {
     fetchDefaultNonEvacuatedEnergyProvider,
     fetchNonEvacuatedEnergyProvider,
     getNonEvacuatedEnergyParameters,
+    setNonEvacuatedEnergyParameters,
     updateNonEvacuatedEnergyProvider,
 } from 'services/study/non-evacuated-energy';
-import {
-    NonEvacuatedEnergyParameters,
-    useGetNonEvacuatedEnergyParameters,
-} from './dialogs/parameters/non-evacuated-energy/non-evacuated-energy-parameters';
+import { NonEvacuatedEnergyParameters } from './dialogs/parameters/non-evacuated-energy/non-evacuated-energy-parameters';
 import ComputingType from './computing-status/computing-type';
 import RunningStatus from './utils/running-status';
 import GlassPane from './results/common/glass-pane';
@@ -205,7 +204,8 @@ const ParametersTabs: FunctionComponent<OwnProps> = (props) => {
         null,
         fetchDefaultSensitivityAnalysisProvider,
         null,
-        getSensitivityAnalysisParameters
+        getSensitivityAnalysisParameters,
+        setSensitivityAnalysisParameters
     );
 
     const nonEvacuatedEnergyBackend = useParametersBackend(
@@ -216,11 +216,10 @@ const ParametersTabs: FunctionComponent<OwnProps> = (props) => {
         fetchNonEvacuatedEnergyProvider,
         fetchDefaultNonEvacuatedEnergyProvider,
         updateNonEvacuatedEnergyProvider,
-        getNonEvacuatedEnergyParameters
+        getNonEvacuatedEnergyParameters,
+        setNonEvacuatedEnergyParameters
     );
 
-    const useNonEvacuatedEnergyParameters = useGetNonEvacuatedEnergyParameters();
-
     const useShortCircuitParameters = useGetShortCircuitParameters();
 
     const componentLibraries = useGetAvailableComponentLibraries(user);
@@ -288,12 +287,7 @@ const ParametersTabs: FunctionComponent<OwnProps> = (props) => {
                     />
                 );
             case TAB_VALUES.nonEvacuatedEnergyParamsTabValue:
-                return (
-                    <NonEvacuatedEnergyParameters
-                        parametersBackend={nonEvacuatedEnergyBackend}
-                        useNonEvacuatedEnergyParameters={useNonEvacuatedEnergyParameters}
-                    />
-                );
+                return <NonEvacuatedEnergyParameters parametersBackend={nonEvacuatedEnergyBackend} />;
             case TAB_VALUES.shortCircuitParamsTabValue:
                 return (
                     <ShortCircuitParameters
@@ -315,7 +309,6 @@ const ParametersTabs: FunctionComponent<OwnProps> = (props) => {
         sensitivityAnalysisBackend,
         nonEvacuatedEnergyBackend,
         tabValue,
-        useNonEvacuatedEnergyParameters,
         useShortCircuitParameters,
         user,
     ]);