@gridsuite/commons-ui 0.112.0 → 0.113.0

package/dist/components/parameters/sensi/use-sensitivity-analysis-parameters.js

@@ -0,0 +1,413 @@
+import { useForm } from "react-hook-form";
+import { yupResolver } from "@hookform/resolvers/yup";
+import { useState, useMemo, useCallback, useEffect } from "react";
+import { PROVIDER } from "../common/constant.js";
+import "react/jsx-runtime";
+import "@mui/material";
+import "react-intl";
+import "../../../utils/types/equipmentType.js";
+import { updateParameter } from "../../../services/explore.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import { useSnackMessage } from "../../../hooks/useSnackMessage.js";
+import { PARAMETER_SENSI_NODES, PARAMETER_SENSI_PST, PARAMETER_SENSI_HVDC, PARAMETER_SENSI_INJECTION, PARAMETER_SENSI_INJECTIONS_SET, FLOW_VOLTAGE_SENSITIVITY_VALUE_THRESHOLD, ANGLE_FLOW_SENSITIVITY_VALUE_THRESHOLD, FLOW_FLOW_SENSITIVITY_VALUE_THRESHOLD, ACTIVATED, MONITORED_BRANCHES, INJECTIONS, PSTS, HVDC_LINES, COUNT, SENSI_INJECTIONS_SET, CONTINGENCIES, CONTAINER_NAME, CONTAINER_ID, EQUIPMENTS_IN_VOLTAGE_REGULATION, SUPERVISED_VOLTAGE_LEVELS, SENSITIVITY_TYPE, DISTRIBUTION_TYPE } from "./constants.js";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "../../dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../../dialogs/elementSaveDialog/ElementSaveDialog.js";
+import "@mui/icons-material";
+import { FieldConstants } from "../../../utils/constants/fieldConstants.js";
+import { ElementType } from "../../../utils/types/elementType.js";
+import "../../treeViewFinder/TreeViewFinder.js";
+import "yup";
+import "../../overflowableText/OverflowableText.js";
+import "../../inputs/reactHookForm/agGridTable/BottomRightButtons.js";
+import "../../customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import "../../inputs/reactHookForm/numbers/RangeInput.js";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/yupConfig.js";
+import "@react-querybuilder/material";
+import "../../filter/expert/expertFilterConstants.js";
+import "../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "uuid";
+import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
+import "react-querybuilder";
+import "../common/widget/parameter-line-slider.js";
+import "../common/limitreductions/columns-definitions.js";
+import { getFormSchema, getSensiNodesformatNewParams, getSensiPstformatNewParams, getSensiHvdcformatNewParams, getSensiInjectionsformatNewParams, getSensiInjectionsSetformatNewParams, getGenericRowNewParams } from "./utils.js";
+import { getSensitivityAnalysisFactorsCount, setSensitivityAnalysisParameters } from "../../../services/sensitivity-analysis.js";
+import "../../filter/HeaderFilterForm.js";
+import { getNameElementEditorEmptyFormData } from "../common/name-element-editor/name-element-editor-utils.js";
+const numberMax = 5e5;
+const useSensitivityAnalysisParametersForm = ({
+  studyUuid,
+  currentNodeUuid,
+  currentRootNetworkUuid,
+  parametersBackend,
+  parametersUuid,
+  name,
+  description
+}) => {
+  const [providers, , , , , params, , updateParameters] = parametersBackend;
+  const [sensitivityAnalysisParams, setSensitivityAnalysisParams] = useState(params);
+  const [analysisComputeComplexity, setAnalysisComputeComplexity] = useState(0);
+  const [launchLoader, setLaunchLoader] = useState(false);
+  const [isSubmitAction, setIsSubmitAction] = useState(false);
+  const { snackError } = useSnackMessage();
+  const emptyFormData = useMemo(() => {
+    return {
+      ...getNameElementEditorEmptyFormData(name, description),
+      [PROVIDER]: "",
+      [FLOW_FLOW_SENSITIVITY_VALUE_THRESHOLD]: 0,
+      [ANGLE_FLOW_SENSITIVITY_VALUE_THRESHOLD]: 0,
+      [FLOW_VOLTAGE_SENSITIVITY_VALUE_THRESHOLD]: 0,
+      [PARAMETER_SENSI_INJECTIONS_SET]: [],
+      [PARAMETER_SENSI_INJECTION]: [],
+      [PARAMETER_SENSI_HVDC]: [],
+      [PARAMETER_SENSI_PST]: [],
+      [PARAMETER_SENSI_NODES]: []
+    };
+  }, [description, name]);
+  const isStudyLinked = useMemo(() => {
+    return studyUuid !== null && currentNodeUuid !== null && currentRootNetworkUuid !== null;
+  }, [currentNodeUuid, currentRootNetworkUuid, studyUuid]);
+  const formSchema = useMemo(() => {
+    return getFormSchema(name);
+  }, [name]);
+  const formMethods = useForm({
+    defaultValues: emptyFormData,
+    resolver: yupResolver(formSchema)
+  });
+  const { reset, getValues, setValue } = formMethods;
+  const formattedProviders = Object.keys(providers).map((key) => ({
+    id: key,
+    label: providers[key]
+  }));
+  const formatNewParams = useCallback((newParams) => {
+    return {
+      [PROVIDER]: newParams[PROVIDER],
+      [FLOW_FLOW_SENSITIVITY_VALUE_THRESHOLD]: newParams[FLOW_FLOW_SENSITIVITY_VALUE_THRESHOLD],
+      [ANGLE_FLOW_SENSITIVITY_VALUE_THRESHOLD]: newParams[ANGLE_FLOW_SENSITIVITY_VALUE_THRESHOLD],
+      [FLOW_VOLTAGE_SENSITIVITY_VALUE_THRESHOLD]: newParams[FLOW_VOLTAGE_SENSITIVITY_VALUE_THRESHOLD],
+      ...getSensiInjectionsSetformatNewParams(newParams),
+      ...getSensiInjectionsformatNewParams(newParams),
+      ...getSensiHvdcformatNewParams(newParams),
+      ...getSensiPstformatNewParams(newParams),
+      ...getSensiNodesformatNewParams(newParams)
+    };
+  }, []);
+  const formatFilteredParams = useCallback((row) => {
+    return getGenericRowNewParams(row);
+  }, []);
+  const getResultCount = useCallback(() => {
+    const values = getValues();
+    let totalResultCount = 0;
+    const tabsToCheck = [
+      "sensitivityInjectionsSet",
+      "sensitivityInjection",
+      "sensitivityHVDC",
+      "sensitivityPST"
+    ];
+    tabsToCheck.forEach((tab) => {
+      const tabToCheck = values[tab];
+      if (tabToCheck) {
+        const count = tabToCheck.filter((entry) => entry[ACTIVATED]).filter((entry) => entry[MONITORED_BRANCHES].length > 0).filter(
+          (entry) => {
+            var _a, _b, _c;
+            return ((_a = entry[INJECTIONS]) == null ? void 0 : _a.length) > 0 || ((_b = entry[PSTS]) == null ? void 0 : _b.length) > 0 || ((_c = entry[HVDC_LINES]) == null ? void 0 : _c.length) > 0;
+          }
+        ).map((entry) => entry[COUNT]).reduce((a, b) => a + b, 0);
+        totalResultCount += count;
+      }
+    });
+    setAnalysisComputeComplexity(totalResultCount);
+    const timeoutId = setTimeout(() => {
+      setLaunchLoader(false);
+    }, 500);
+    return () => clearTimeout(timeoutId);
+  }, [getValues]);
+  const onFormChanged = useCallback(
+    (formChanged) => {
+      if (formChanged) {
+        setLaunchLoader(true);
+        getResultCount();
+      }
+    },
+    [getResultCount]
+  );
+  const onChangeParams = useCallback(
+    (row, arrayFormName, index) => {
+      if (!currentNodeUuid || !currentRootNetworkUuid) {
+        return;
+      }
+      setLaunchLoader(true);
+      getSensitivityAnalysisFactorsCount(
+        studyUuid,
+        currentNodeUuid,
+        currentRootNetworkUuid,
+        arrayFormName === SENSI_INJECTIONS_SET,
+        formatFilteredParams(row)
+      ).then((response) => {
+        response.text().then((value) => {
+          setValue(
+            `${arrayFormName}.${index}.${COUNT}`,
+            !Number.isNaN(Number(value)) ? parseInt(value, 10) : 0
+          );
+          getResultCount();
+        });
+      }).catch((error) => {
+        setLaunchLoader(false);
+        snackError({
+          messageTxt: error.message,
+          headerId: "getSensitivityAnalysisFactorsCountError"
+        });
+      });
+    },
+    [snackError, studyUuid, currentRootNetworkUuid, formatFilteredParams, setValue, getResultCount, currentNodeUuid]
+  );
+  const fromSensitivityAnalysisParamsDataToFormValues = useCallback(
+    (parameters) => {
+      var _a, _b, _c, _d, _e;
+      const values = {
+        [PROVIDER]: parameters[PROVIDER],
+        [FLOW_FLOW_SENSITIVITY_VALUE_THRESHOLD]: parameters.flowFlowSensitivityValueThreshold,
+        [ANGLE_FLOW_SENSITIVITY_VALUE_THRESHOLD]: parameters.angleFlowSensitivityValueThreshold,
+        [FLOW_VOLTAGE_SENSITIVITY_VALUE_THRESHOLD]: parameters.flowVoltageSensitivityValueThreshold,
+        [PARAMETER_SENSI_INJECTIONS_SET]: ((_a = parameters.sensitivityInjectionsSet) == null ? void 0 : _a.map((sensiInjectionsSet) => {
+          var _a2, _b2, _c2;
+          return {
+            [MONITORED_BRANCHES]: ((_a2 = sensiInjectionsSet[MONITORED_BRANCHES]) == null ? void 0 : _a2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [INJECTIONS]: ((_b2 = sensiInjectionsSet[INJECTIONS]) == null ? void 0 : _b2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [DISTRIBUTION_TYPE]: sensiInjectionsSet[DISTRIBUTION_TYPE],
+            [CONTINGENCIES]: ((_c2 = sensiInjectionsSet[CONTINGENCIES]) == null ? void 0 : _c2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [ACTIVATED]: sensiInjectionsSet[ACTIVATED] ?? false,
+            [COUNT]: 0
+          };
+        })) ?? [],
+        [PARAMETER_SENSI_INJECTION]: ((_b = parameters.sensitivityInjection) == null ? void 0 : _b.map((sensiInjections) => {
+          var _a2, _b2, _c2;
+          return {
+            [MONITORED_BRANCHES]: ((_a2 = sensiInjections[MONITORED_BRANCHES]) == null ? void 0 : _a2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [INJECTIONS]: ((_b2 = sensiInjections[INJECTIONS]) == null ? void 0 : _b2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [CONTINGENCIES]: ((_c2 = sensiInjections[CONTINGENCIES]) == null ? void 0 : _c2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [ACTIVATED]: sensiInjections[ACTIVATED] ?? false,
+            [COUNT]: 0
+          };
+        })) ?? [],
+        [PARAMETER_SENSI_HVDC]: ((_c = parameters.sensitivityHVDC) == null ? void 0 : _c.map((sensiInjectionsSet) => {
+          var _a2, _b2, _c2;
+          return {
+            [MONITORED_BRANCHES]: ((_a2 = sensiInjectionsSet[MONITORED_BRANCHES]) == null ? void 0 : _a2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [HVDC_LINES]: ((_b2 = sensiInjectionsSet[HVDC_LINES]) == null ? void 0 : _b2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [SENSITIVITY_TYPE]: sensiInjectionsSet[SENSITIVITY_TYPE],
+            [CONTINGENCIES]: ((_c2 = sensiInjectionsSet[CONTINGENCIES]) == null ? void 0 : _c2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [ACTIVATED]: sensiInjectionsSet[ACTIVATED] ?? false,
+            [COUNT]: 0
+          };
+        })) ?? [],
+        [PARAMETER_SENSI_PST]: ((_d = parameters.sensitivityPST) == null ? void 0 : _d.map((sensiInjectionsSet) => {
+          var _a2, _b2, _c2;
+          return {
+            [MONITORED_BRANCHES]: ((_a2 = sensiInjectionsSet[MONITORED_BRANCHES]) == null ? void 0 : _a2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [PSTS]: ((_b2 = sensiInjectionsSet[PSTS]) == null ? void 0 : _b2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [SENSITIVITY_TYPE]: sensiInjectionsSet[SENSITIVITY_TYPE],
+            [CONTINGENCIES]: ((_c2 = sensiInjectionsSet[CONTINGENCIES]) == null ? void 0 : _c2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [ACTIVATED]: sensiInjectionsSet[ACTIVATED] ?? false,
+            [COUNT]: 0
+          };
+        })) ?? [],
+        [PARAMETER_SENSI_NODES]: ((_e = parameters.sensitivityNodes) == null ? void 0 : _e.map((sensiInjectionsSet) => {
+          var _a2, _b2, _c2;
+          return {
+            [SUPERVISED_VOLTAGE_LEVELS]: ((_a2 = sensiInjectionsSet[SUPERVISED_VOLTAGE_LEVELS]) == null ? void 0 : _a2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [EQUIPMENTS_IN_VOLTAGE_REGULATION]: ((_b2 = sensiInjectionsSet[EQUIPMENTS_IN_VOLTAGE_REGULATION]) == null ? void 0 : _b2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [CONTINGENCIES]: ((_c2 = sensiInjectionsSet[CONTINGENCIES]) == null ? void 0 : _c2.map((sensiInjection) => {
+              return {
+                [FieldConstants.ID]: sensiInjection[CONTAINER_ID],
+                [FieldConstants.NAME]: sensiInjection[CONTAINER_NAME]
+              };
+            })) ?? [],
+            [ACTIVATED]: sensiInjectionsSet[ACTIVATED] ?? false,
+            [COUNT]: 0
+          };
+        })) ?? []
+      };
+      return values;
+    },
+    []
+  );
+  const initRowsCount = useCallback(() => {
+    const handleEntries = (entries, parameter) => {
+      if (!entries) {
+        return;
+      }
+      const entriesWithIndices = entries.map((entry, index) => ({
+        entry,
+        index
+      }));
+      const filteredInitEntries = entries.filter(
+        (entry) => {
+          var _a, _b, _c;
+          return entry[ACTIVATED] && entry[MONITORED_BRANCHES].length > 0 && (((_a = entry[INJECTIONS]) == null ? void 0 : _a.length) > 0 || ((_b = entry[PSTS]) == null ? void 0 : _b.length) > 0 || ((_c = entry[HVDC_LINES]) == null ? void 0 : _c.length) > 0);
+        }
+      );
+      filteredInitEntries.forEach((entry) => {
+        const originalIndex = entriesWithIndices.findIndex((obj) => obj.entry === entry);
+        onChangeParams(entry, parameter, originalIndex);
+      });
+    };
+    const values = getValues();
+    handleEntries(values[PARAMETER_SENSI_INJECTIONS_SET], PARAMETER_SENSI_INJECTIONS_SET);
+    handleEntries(values[PARAMETER_SENSI_INJECTION], PARAMETER_SENSI_INJECTION);
+    handleEntries(values[PARAMETER_SENSI_HVDC], PARAMETER_SENSI_HVDC);
+    handleEntries(values[PARAMETER_SENSI_PST], PARAMETER_SENSI_PST);
+  }, [onChangeParams, getValues]);
+  const onSaveInline = useCallback(
+    (newParams) => {
+      setIsSubmitAction(true);
+      setSensitivityAnalysisParameters(studyUuid, formatNewParams(newParams)).then(() => {
+        const formattedParams = formatNewParams(newParams);
+        setSensitivityAnalysisParams(formattedParams);
+        updateParameters(formattedParams);
+        initRowsCount();
+      }).catch((error) => {
+        snackError({
+          messageTxt: error.message,
+          headerId: "updateSensitivityAnalysisParametersError"
+        });
+      });
+    },
+    [setSensitivityAnalysisParams, snackError, studyUuid, formatNewParams, initRowsCount, updateParameters]
+  );
+  const onSaveDialog = useCallback(
+    (formData) => {
+      if (parametersUuid) {
+        updateParameter(
+          parametersUuid,
+          formatNewParams(formData),
+          formData[FieldConstants.NAME],
+          ElementType.SENSITIVITY_PARAMETERS,
+          formData[FieldConstants.DESCRIPTION] ?? ""
+        );
+      }
+    },
+    [parametersUuid, formatNewParams]
+  );
+  useEffect(() => {
+    if (sensitivityAnalysisParams) {
+      reset(fromSensitivityAnalysisParamsDataToFormValues(sensitivityAnalysisParams));
+      if (!isSubmitAction) {
+        initRowsCount();
+      }
+    }
+  }, [
+    fromSensitivityAnalysisParamsDataToFormValues,
+    sensitivityAnalysisParams,
+    initRowsCount,
+    isSubmitAction,
+    reset
+  ]);
+  useEffect(() => {
+    if (params) {
+      reset(fromSensitivityAnalysisParamsDataToFormValues(params));
+    }
+  }, [params, reset, fromSensitivityAnalysisParamsDataToFormValues]);
+  const isMaxReached = useMemo(() => analysisComputeComplexity > numberMax, [analysisComputeComplexity]);
+  const paramsLoaded = useMemo(() => !!params, [params]);
+  return {
+    formMethods,
+    formSchema,
+    formattedProviders,
+    fromSensitivityAnalysisParamsDataToFormValues,
+    formatNewParams,
+    params,
+    paramsLoaded,
+    isStudyLinked,
+    onSaveInline,
+    onSaveDialog,
+    isMaxReached,
+    launchLoader,
+    initRowsCount,
+    onFormChanged,
+    onChangeParams,
+    emptyFormData,
+    analysisComputeComplexity,
+    setAnalysisComputeComplexity
+  };
+};
+export {
+  useSensitivityAnalysisParametersForm
+};