Fix sonar issues "Do not nest functions more than 4 levels deep" (#3033)

* fix(App): add parameter to `updateParams` to fill empty params with defaultValues if given.
* fix(App): create a `computeRetrieveOptionalServices` function in 'src/components/utils/optional-services.ts' and use it in App component
* fix(ExportNetworkDialog): create a completeDefaultValuesForExtensionsParameters
* fix(TabularDialog): create a `convertCreations` function
* fix(CheckboxTreeview): create `getSelectedItems` function outside the `useImperativeHandle` scope
* fix(CurvePreview): create `isCurveAlreadyAdded` and `isRowSelected` helper functions
* fix(ModelFilter): create `getSelectedVariables` func outside of the `useImperativeHandle` scope
* fix(getReactiveCapabilityCurveValidationSchema): create `hasAtLeastOneNegativeP` and `hasAtLeastOnePositiveP` helper functions
* fix(RootNetworkChipCellRenderer): create a helper function `getUpdatedExcludedModifications`
* fix(useDiagramModel): create `handleFetchSuccess` `handleFetchError` and `handleFetchFinally` to remove some code depth
* fix(PlutlySeriesChart): move the `seriesToData` helper function outside the component
* fix(ColumnsConfig) : Create `DraggableColumnItem` and `DroppableColumnsList` separated components.
* fix Node.js built-in modules should be imported using the "node:" protocol typescript:S7772 introduced here
* fix Use ".some()" instead of ".filter().length" checks or ".find()" for existence testing typescript:S7754
* fix Use "for...of" loops instead of "forEach" method calls typescript:S7728

Signed-off-by: sBouzols <[email protected]>

Author: sBouzols

src/components/app.jsx

@@ -7,11 +7,7 @@
 
 import { useCallback, useEffect, useState } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
-import {
-    getOptionalServiceByServerName,
-    OptionalServicesNames,
-    OptionalServicesStatus,
-} from './utils/optional-services';
+import { retrieveOptionalServices } from './utils/optional-services';
 import { Navigate, Route, Routes, useLocation, useMatch, useNavigate } from 'react-router';
 import {
     AnnouncementNotification,
@@ -106,8 +102,22 @@ const App = () => {
     );
 
     const updateParams = useCallback(
-        (params) => {
+        (params, defaultValues = null) => {
             console.debug('received UI parameters : ', params);
+            if (defaultValues) {
+                // Browsing defaultParametersValues entries
+                Object.entries(defaultValues).forEach(([key, defaultValue]) => {
+                    // Checking if keys defined in defaultParametersValues file are already defined in config server
+                    // If they are not defined, values are taken from default values file
+                    if (!params.find((param) => param.name === key)) {
+                        params.push({
+                            name: key,
+                            value: defaultValue,
+                        });
+                    }
+                });
+                console.debug('UI parameters filled with default values when undefined : ', params);
+            }
             params.forEach((param) => {
                 switch (param.name) {
                     case PARAM_THEME:
@@ -306,18 +316,7 @@ const App = () => {
 
             const fetchAppConfigPromise = fetchConfigParameters(APP_NAME).then((params) => {
                 fetchDefaultParametersValues().then((defaultValues) => {
-                    // Browsing defaultParametersValues entries
-                    Object.entries(defaultValues).forEach(([key, defaultValue]) => {
-                        // Checking if keys defined in defaultParametersValues file are already defined in config server
-                        // If they are not defined, values are taken from default values file
-                        if (!params.find((param) => param.name === key)) {
-                            params.push({
-                                name: key,
-                                value: defaultValue,
-                            });
-                        }
-                    });
-                    updateParams(params);
+                    updateParams(params, defaultValues);
                 });
             });
 
@@ -327,29 +326,7 @@ const App = () => {
 
             const fetchOptionalServices = getOptionalServices()
                 .then((services) => {
-                    const retrieveOptionalServices = services.map((service) => {
-                        return {
-                            ...service,
-                            name: getOptionalServiceByServerName(service.name),
-                        };
-                    });
-                    // get all potentially optional services
-                    const optionalServicesNames = Object.keys(OptionalServicesNames);
-
-                    // if one of those services was not returned by "getOptionalServices", it means it was defined as "not optional"
-                    // in that case, we consider it is UP
-                    optionalServicesNames
-                        .filter(
-                            (serviceName) =>
-                                !retrieveOptionalServices.map((service) => service.name).includes(serviceName)
-                        )
-                        .forEach((serviceName) =>
-                            retrieveOptionalServices.push({
-                                name: serviceName,
-                                status: OptionalServicesStatus.Up,
-                            })
-                        );
-                    dispatch(setOptionalServices(retrieveOptionalServices));
+                    dispatch(setOptionalServices(retrieveOptionalServices(services)));
                 })
                 .catch((error) => {
                     snackError({

src/components/dialogs/export-network-dialog.tsx

@@ -25,7 +25,13 @@ import DialogContent from '@mui/material/DialogContent';
 import DialogActions from '@mui/material/DialogActions';
 import Button from '@mui/material/Button';
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { CancelButton, FlatParameters, fetchDirectoryElementPath, useSnackMessage } from '@gridsuite/commons-ui';
+import {
+    CancelButton,
+    FlatParameters,
+    Parameter,
+    fetchDirectoryElementPath,
+    useSnackMessage,
+} from '@gridsuite/commons-ui';
 import { ExportFormatProperties, getAvailableExportFormats } from '../../services/study';
 import { getExportUrl } from '../../services/study/network';
 import { isBlankOrEmpty } from 'components/utils/validation-functions';
@@ -57,6 +63,18 @@ interface ExportNetworkDialogProps {
     rootNetworkUuid: UUID;
 }
 
+// we check if the param is for extension, if it is, we select all possible values by default.
+// the only way for the moment to check if the param is for extension, is by checking his type is name.
+// TODO to be removed when extensions param default value corrected in backend to include all possible values
+function getDefaultValuesForExtensionsParameter(parameters: Parameter[]): Parameter[] {
+    return parameters.map((parameter) => {
+        if (parameter.type === STRING_LIST && parameter.name?.endsWith('extensions')) {
+            parameter.defaultValue = parameter.possibleValues;
+        }
+        return parameter;
+    });
+}
+
 export function ExportNetworkDialog({
     open,
     onClose,
@@ -102,16 +120,9 @@ export function ExportNetworkDialog({
                 const availableFormats = enableDeveloperMode
                     ? formats
                     : Object.fromEntries(Object.entries(formats).filter(([key]) => key === XIIDM_FORMAT));
-                // we check if the param is for extension, if it is, we select all possible values by default.
-                // the only way for the moment to check if the param is for extension, is by checking his type is name.
-                //TODO to be removed when extensions param default value corrected in backend to include all possible values
+
                 Object.values(availableFormats).forEach((format) => {
-                    format.parameters = format.parameters.map((parameter) => {
-                        if (parameter.type === STRING_LIST && parameter.name?.endsWith('extensions')) {
-                            parameter.defaultValue = parameter.possibleValues;
-                        }
-                        return parameter;
-                    });
+                    format.parameters = getDefaultValuesForExtensionsParameter(format.parameters);
                 });
                 setFormatsWithParameters(availableFormats);
             });

src/components/dialogs/network-modifications/tabular/tabular-dialog.tsx

@@ -48,6 +48,20 @@ import {
 } from './tabular-creation-utils';
 import { NetworkModificationDialogProps } from '../../../graph/menus/network-modifications/network-modification-menu.type';
 
+function convertCreations(creations: Modification[]): Modification[] {
+    return creations.map((creat: Modification) => {
+        let creation: Modification = {};
+        Object.keys(formatModification(creat)).forEach((key) => {
+            const entry = convertCreationFieldFromBackToFront(key, creat[key]);
+            (Array.isArray(entry) ? entry : [entry]).forEach((item) => {
+                creation[item.key] = item.value;
+            });
+        });
+        creation = addPropertiesFromBack(creation, creat?.[TABULAR_PROPERTIES]);
+        return creation;
+    });
+}
+
 type TabularDialogProps = NetworkModificationDialogProps & {
     editData: TabularModificationEditDataType;
     dialogMode: TabularModificationType;
@@ -114,17 +128,7 @@ export function TabularDialog({
     const initTabularCreationData = useCallback(
         (editData: TabularModificationCreationType) => {
             const equipmentType = getEquipmentTypeFromCreationType(editData?.creationType);
-            const creations = editData?.creations.map((creat: Modification) => {
-                let creation: Modification = {};
-                Object.keys(formatModification(creat)).forEach((key) => {
-                    const entry = convertCreationFieldFromBackToFront(key, creat[key]);
-                    (Array.isArray(entry) ? entry : [entry]).forEach((item) => {
-                        creation[item.key] = item.value;
-                    });
-                });
-                creation = addPropertiesFromBack(creation, creat?.[TABULAR_PROPERTIES]);
-                return creation;
-            });
+            const creations = convertCreations(editData?.creations);
             reset({
                 [TYPE]: equipmentType,
                 [MODIFICATIONS_TABLE]: creations,

src/components/dialogs/parameters/dynamicsimulation/curve/common/checkbox-treeview.tsx

@@ -175,20 +175,21 @@ const CheckboxTreeview = forwardRef<GetSelectedItemsHandle, CheckBoxTreeViewProp
             [itemStates]
         );
 
+        const getSelectedItems = useCallback(() => {
+            return items.filter(
+                (item) => getState(item.id) === CheckState.CHECKED && !items.some((elem) => elem.parentId === item.id) // no children
+            );
+        }, [items, getState]);
+
         // expose some api for the component by using ref
         useImperativeHandle(
             ref,
             () => ({
                 api: {
-                    getSelectedItems: () =>
-                        items.filter(
-                            (item) =>
-                                getState(item.id) === CheckState.CHECKED &&
-                                !items.find((elem) => elem.parentId === item.id) // no children
-                        ),
+                    getSelectedItems,
                 },
             }),
-            [items, getState]
+            [getSelectedItems]
         );
 
         // render functions (recursive rendering)

src/components/dialogs/parameters/dynamicsimulation/curve/dialog/curve-preview.tsx

@@ -38,6 +38,16 @@ export interface CurveHandler {
     };
 }
 
+function isCurveAlreadyAdded(curves: Curve[], curve: Curve): boolean {
+    return curves.some((elem) => elem.equipmentId === curve.equipmentId && elem.variableId === curve.variableId);
+}
+
+function isRowSelected(elem: Curve, selectedRows: Curve[]): boolean {
+    return selectedRows.some(
+        (selectedElem) => elem.equipmentId === selectedElem.equipmentId && elem.variableId === selectedElem.variableId
+    );
+}
+
 const CurvePreview = forwardRef<CurveHandler>((props, ref) => {
     const intl = useIntl();
     const gridRef = useRef<AgGridReact<any>>(null);
@@ -88,50 +98,41 @@ const CurvePreview = forwardRef<CurveHandler>((props, ref) => {
         setSelectedRowsLength(selectedRows.length);
     }, []);
 
+    const addCurves = useCallback((curves: Curve[]) => {
+        setRowData((prev) => {
+            const notYetAddedCurves = curves.filter((curve) => !isCurveAlreadyAdded(prev, curve));
+            return [...prev, ...notYetAddedCurves];
+        });
+    }, []);
+
+    const removeCurves = useCallback(() => {
+        if (!gridRef.current) {
+            return;
+        }
+        const selectedRows = gridRef.current.api.getSelectedRows();
+
+        // reset selected rows length
+        setSelectedRowsLength(0);
+
+        setRowData((prev) => {
+            const remainingRows = prev.filter((elem) => !isRowSelected(elem, selectedRows));
+            return remainingRows;
+        });
+    }, []);
+
     // expose some api for the component by using ref
     useImperativeHandle(
         ref,
         () => ({
             api: {
-                addCurves: (curves) => {
-                    setRowData((prev) => {
-                        const notYetAddedCurves = curves.filter(
-                            (curve) =>
-                                !prev.find(
-                                    (elem) =>
-                                        elem.equipmentId === curve.equipmentId && elem.variableId === curve.variableId
-                                )
-                        );
-                        return [...prev, ...notYetAddedCurves];
-                    });
-                },
-                removeCurves: () => {
-                    if (!gridRef.current) {
-                        return;
-                    }
-                    const selectedRows = gridRef.current.api.getSelectedRows();
-
-                    // reset selected rows length
-                    setSelectedRowsLength(0);
-
-                    setRowData((prev) => {
-                        const remainingRows = prev.filter(
-                            (elem) =>
-                                !selectedRows.find(
-                                    (selectedElem) =>
-                                        elem.equipmentId === selectedElem.equipmentId &&
-                                        elem.variableId === selectedElem.variableId
-                                )
-                        );
-                        return remainingRows;
-                    });
-                },
+                addCurves,
+                removeCurves,
                 getCurves: () => {
                     return rowData;
                 },
             },
         }),
-        [rowData]
+        [addCurves, removeCurves, rowData]
     );
 
     return (

src/components/dialogs/parameters/dynamicsimulation/curve/dialog/model-filter.tsx

@@ -226,25 +226,26 @@ const ModelFilter = forwardRef<GetSelectedVariablesHandle, ModelFilterProps>(
             });
         }, [studyUuid]);
 
+        const getSelectedVariables = useCallback((): ModelVariable[] => {
+            return (
+                variablesRef.current?.api
+                    .getSelectedItems()
+                    .filter((item) => item.variableId) // filter to keep only variable item
+                    .filter(
+                        (item, index, arr) => arr.findIndex((elem) => elem.variableId === item.variableId) === index
+                    ) ?? []
+            ); // remove duplicated by variableId
+        }, []);
+
         // expose some api for the component by using ref
         useImperativeHandle(
             ref,
             () => ({
                 api: {
-                    getSelectedVariables: () => {
-                        return (
-                            variablesRef.current?.api
-                                .getSelectedItems()
-                                .filter((item) => item.variableId) // filter to keep only variable item
-                                .filter(
-                                    (item, index, arr) =>
-                                        arr.findIndex((elem) => elem.variableId === item.variableId) === index
-                                ) ?? []
-                        ); // remove duplicated by variableId
-                    },
+                    getSelectedVariables,
                 },
             }),
-            []
+            [getSelectedVariables]
         );
 
         const getModelLabel = useMemo(() => {