@gridsuite/commons-ui 0.214.0 → 0.215.0

package/dist/components/composite/filter/expert/expertFilterUtils.js

@@ -0,0 +1,374 @@
+import { defaultOperators, getParentPath, findPath, remove } from "react-querybuilder";
+import { validate } from "uuid";
+import { DataType } from "./expertFilter.type.js";
+import { OPERATOR_OPTIONS, RULES, FIELDS_OPTIONS } from "./expertFilterConstants.js";
+import { isBlankOrEmpty, convertOutputValue, convertInputValue } from "../../../../utils/conversionUtils.js";
+import { FieldType } from "../../../../utils/types/fieldType.js";
+import "../../../../utils/types/equipmentType.js";
+import { isEmpty } from "../../../../utils/functions.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import "../../../../utils/yupConfig.js";
+const searchTree = (tree, key, value) => {
+  const stack = Object.values(tree);
+  while (stack.length) {
+    const node = stack.shift();
+    if (node?.[key] === value) {
+      return node;
+    }
+    if (node?.children) {
+      stack.push(...Object.values(node.children));
+    }
+  }
+  return null;
+};
+const getFieldData = (fieldName) => {
+  return searchTree(FIELDS_OPTIONS, "name", fieldName);
+};
+const getDataType = (fieldName, operator) => {
+  if (operator === OPERATOR_OPTIONS.IS_PART_OF.name || operator === OPERATOR_OPTIONS.IS_NOT_PART_OF.name) {
+    return DataType.FILTER_UUID;
+  }
+  if (fieldName === FieldType.REMOTE_REGULATED_TERMINAL && (operator === OPERATOR_OPTIONS.EXISTS.name || operator === OPERATOR_OPTIONS.NOT_EXISTS.name)) {
+    return DataType.BOOLEAN;
+  }
+  const fieldData = getFieldData(fieldName);
+  return fieldData?.dataType;
+};
+const getOperators = (fieldName, intl) => {
+  const field = Object.values(FIELDS_OPTIONS).find((fieldOption) => fieldOption.name === fieldName);
+  switch (field?.dataType) {
+    case DataType.STRING: {
+      let stringOperators = [
+        OPERATOR_OPTIONS.CONTAINS,
+        OPERATOR_OPTIONS.IS,
+        OPERATOR_OPTIONS.BEGINS_WITH,
+        OPERATOR_OPTIONS.ENDS_WITH,
+        OPERATOR_OPTIONS.IN,
+        OPERATOR_OPTIONS.EXISTS,
+        OPERATOR_OPTIONS.NOT_EXISTS
+      ];
+      if (field.name === FieldType.ID || field.name === FieldType.VOLTAGE_LEVEL_ID || field.name === FieldType.VOLTAGE_LEVEL_ID_1 || field.name === FieldType.VOLTAGE_LEVEL_ID_2 || field.name === FieldType.VOLTAGE_LEVEL_ID_3 || field.name === FieldType.SUBSTATION_ID || field.name === FieldType.SUBSTATION_ID_1 || field.name === FieldType.SUBSTATION_ID_2) {
+        stringOperators.push(OPERATOR_OPTIONS.IS_PART_OF);
+        stringOperators.push(OPERATOR_OPTIONS.IS_NOT_PART_OF);
+      }
+      if (field.name === FieldType.ID) {
+        stringOperators = stringOperators.filter(
+          (operator) => operator !== OPERATOR_OPTIONS.EXISTS && operator !== OPERATOR_OPTIONS.NOT_EXISTS
+        );
+      }
+      return stringOperators.map((operator) => ({
+        name: operator.name,
+        label: intl.formatMessage({ id: operator.label })
+      }));
+    }
+    case DataType.NUMBER: {
+      const numberOperators = [
+        OPERATOR_OPTIONS.EQUALS,
+        OPERATOR_OPTIONS.GREATER,
+        OPERATOR_OPTIONS.GREATER_OR_EQUALS,
+        OPERATOR_OPTIONS.LOWER,
+        OPERATOR_OPTIONS.LOWER_OR_EQUALS,
+        OPERATOR_OPTIONS.BETWEEN,
+        OPERATOR_OPTIONS.EXISTS,
+        OPERATOR_OPTIONS.NOT_EXISTS
+      ];
+      return numberOperators.map((operator) => ({
+        name: operator.name,
+        label: intl.formatMessage({ id: operator.label })
+      }));
+    }
+    case DataType.BOOLEAN: {
+      let booleanOperators = [OPERATOR_OPTIONS.EQUALS];
+      if (field.name === FieldType.AUTOMATE) {
+        booleanOperators = [OPERATOR_OPTIONS.EXISTS, OPERATOR_OPTIONS.NOT_EXISTS];
+      }
+      return booleanOperators.map((operator) => ({
+        name: operator.name,
+        label: intl.formatMessage({ id: operator.label })
+      }));
+    }
+    case DataType.ENUM: {
+      let enumOperators = [
+        OPERATOR_OPTIONS.EQUALS,
+        OPERATOR_OPTIONS.NOT_EQUALS,
+        OPERATOR_OPTIONS.IN
+      ];
+      if (field.name === FieldType.SHUNT_COMPENSATOR_TYPE || field.name === FieldType.REGULATION_TYPE || field.name === FieldType.SVAR_REGULATION_MODE) {
+        enumOperators = enumOperators.filter((operator) => operator !== OPERATOR_OPTIONS.IN);
+      }
+      return enumOperators.map((operator) => ({
+        name: operator.name,
+        label: intl.formatMessage({ id: operator.label })
+      }));
+    }
+    case DataType.PROPERTY: {
+      return [];
+    }
+    case DataType.COMBINATOR: {
+      const combinatorOperators = [OPERATOR_OPTIONS.IS];
+      if (field.name === FieldType.REMOTE_REGULATED_TERMINAL) {
+        combinatorOperators.push(OPERATOR_OPTIONS.EXISTS);
+        combinatorOperators.push(OPERATOR_OPTIONS.NOT_EXISTS);
+      }
+      return combinatorOperators.map((operator) => ({
+        name: operator.name,
+        label: intl.formatMessage({ id: operator.label })
+      }));
+    }
+    default:
+      return defaultOperators;
+  }
+};
+function exportExpertRules(query) {
+  function transformRule(rule) {
+    const isValueAnArray = Array.isArray(rule.value);
+    const dataType = getDataType(rule.field, rule.operator);
+    if (dataType === DataType.COMBINATOR) {
+      return transformCompositeRule(rule);
+    }
+    return {
+      id: rule.id,
+      field: rule.field,
+      operator: dataType !== DataType.PROPERTY ? Object.values(OPERATOR_OPTIONS).find((operator) => operator.name === rule.operator)?.customName : rule.value.propertyOperator,
+      value: !isValueAnArray && rule.operator !== OPERATOR_OPTIONS.EXISTS.name && rule.operator !== OPERATOR_OPTIONS.NOT_EXISTS.name && dataType !== DataType.PROPERTY ? convertOutputValue(rule.field, rule.value) : void 0,
+      values: isValueAnArray && dataType !== DataType.PROPERTY ? convertOutputValue(rule.field, rule.value) : void 0,
+      dataType,
+      propertyName: dataType === DataType.PROPERTY ? rule.value.propertyName : void 0,
+      propertyValues: dataType === DataType.PROPERTY ? rule.value.propertyValues : void 0
+    };
+  }
+  function transformCompositeRule(compositeRule) {
+    const compositeGroup = compositeRule.value;
+    const transformedRules = Object.entries(compositeGroup.rules).map(
+      ([field, rule]) => transformRule({
+        ...rule,
+        field,
+        operator: rule.operator,
+        value: rule.value
+      })
+    );
+    return {
+      id: compositeGroup.id,
+      combinator: compositeGroup.combinator,
+      dataType: DataType.COMBINATOR,
+      rules: transformedRules,
+      // two additional attributes to distinct a composite rule from a normal rule group
+      operator: Object.values(OPERATOR_OPTIONS).find((operator) => operator.name === compositeRule.operator)?.customName,
+      field: compositeRule.field
+    };
+  }
+  function transformGroup(group) {
+    const transformedRules = group.rules.map((ruleOrGroup) => {
+      if ("rules" in ruleOrGroup) {
+        return transformGroup(ruleOrGroup);
+      }
+      return transformRule(ruleOrGroup);
+    });
+    return {
+      id: group.id,
+      combinator: group.combinator,
+      dataType: DataType.COMBINATOR,
+      rules: transformedRules
+    };
+  }
+  return transformGroup(query);
+}
+function importExpertRules(query) {
+  function parseValue(rule) {
+    if (rule.propertyName) {
+      return {
+        propertyName: rule.propertyName,
+        propertyValues: rule.propertyValues,
+        propertyOperator: rule.operator
+      };
+    }
+    if (rule.values) {
+      if (rule.dataType === DataType.NUMBER) {
+        return rule.values.map((value) => parseFloat(value)).map((numberValue) => convertInputValue(rule.field, numberValue)).sort((a, b) => a - b);
+      }
+      return rule.values.sort();
+    }
+    if (rule.dataType === DataType.NUMBER) {
+      return convertInputValue(rule.field, rule.value);
+    }
+    return rule.value;
+  }
+  function transformRule(rule) {
+    return {
+      id: rule.id,
+      field: rule.field,
+      operator: rule.dataType !== DataType.PROPERTY ? Object.values(OPERATOR_OPTIONS).find((operator) => operator.customName === rule.operator)?.name : OPERATOR_OPTIONS.IS.name,
+      value: parseValue(rule)
+    };
+  }
+  function transformCompositeGroup(group) {
+    const transformedRules = group.rules.map((rule) => transformRule(rule)).reduce(
+      (obj, transformedRule) => ({
+        ...obj,
+        [transformedRule.field]: {
+          operator: transformedRule.operator,
+          value: transformedRule.value
+        }
+      }),
+      {}
+    );
+    return {
+      id: group.id,
+      field: group.field,
+      operator: Object.values(OPERATOR_OPTIONS).find((operator) => operator.customName === group.operator)?.name,
+      value: {
+        combinator: group.combinator,
+        rules: transformedRules
+      }
+    };
+  }
+  function transformGroup(group) {
+    const transformedRules = group.rules.map((ruleOrGroup) => {
+      if ("rules" in ruleOrGroup) {
+        if ("field" in ruleOrGroup && "operator" in ruleOrGroup) {
+          return transformCompositeGroup(ruleOrGroup);
+        }
+        return transformGroup(ruleOrGroup);
+      }
+      return transformRule(ruleOrGroup);
+    });
+    return {
+      id: group.id,
+      combinator: group.combinator,
+      rules: transformedRules
+    };
+  }
+  return transformGroup(query);
+}
+function countRules(query) {
+  if (!query) {
+    return 0;
+  }
+  if ("rules" in query) {
+    const group = query;
+    return group.rules.reduce((sum, ruleOrGroup) => sum + countRules(ruleOrGroup), 0);
+  }
+  return 1;
+}
+const queryValidator = (query) => {
+  const result = {};
+  if (!query) {
+    return result;
+  }
+  const validateRule = (rule) => {
+    const isValueAnArray = Array.isArray(rule.value);
+    const dataType = getDataType(rule.field, rule.operator);
+    const isNumberInput = dataType === DataType.NUMBER && !isValueAnArray;
+    const isStringInput = (dataType === DataType.STRING || dataType === DataType.ENUM) && !isValueAnArray;
+    if (rule.id && (rule.operator === OPERATOR_OPTIONS.EXISTS.name || rule.operator === OPERATOR_OPTIONS.NOT_EXISTS.name)) {
+      result[rule.id] = {
+        valid: true,
+        reasons: void 0
+      };
+    } else if (rule.id && rule.operator === OPERATOR_OPTIONS.BETWEEN.name) {
+      if (isEmpty(rule.value?.[0]) || isEmpty(rule.value?.[1])) {
+        result[rule.id] = {
+          valid: false,
+          reasons: [RULES.EMPTY_RULE]
+        };
+      } else if (Number.isNaN(parseFloat(rule.value[0])) || Number.isNaN(parseFloat(rule.value[1]))) {
+        result[rule.id] = {
+          valid: false,
+          reasons: [RULES.INCORRECT_RULE]
+        };
+      } else if (parseFloat(rule.value[0]) >= parseFloat(rule.value[1])) {
+        result[rule.id] = {
+          valid: false,
+          reasons: [RULES.BETWEEN_RULE]
+        };
+      }
+    } else if (rule.id && rule.operator === OPERATOR_OPTIONS.IN.name && !rule.value?.length) {
+      result[rule.id] = {
+        valid: false,
+        reasons: [RULES.EMPTY_RULE]
+      };
+    } else if (rule.id && isStringInput && (rule.value || "").trim() === "") {
+      result[rule.id] = {
+        valid: false,
+        reasons: [RULES.EMPTY_RULE]
+      };
+    } else if (rule.id && isNumberInput && Number.isNaN(parseFloat(rule.value))) {
+      result[rule.id] = {
+        valid: false,
+        reasons: [RULES.INCORRECT_RULE]
+      };
+    } else if (rule.id && dataType === DataType.FILTER_UUID && (!rule.value?.length || !validate(rule.value[0]))) {
+      result[rule.id] = {
+        valid: false,
+        reasons: [RULES.EMPTY_RULE]
+      };
+    } else if (rule.id && dataType === DataType.PROPERTY && (isBlankOrEmpty(rule.value?.propertyName) || isBlankOrEmpty(rule.value?.propertyOperator) || isBlankOrEmpty(rule.value?.propertyValues) || !rule.value?.propertyValues?.length)) {
+      result[rule.id] = {
+        valid: false,
+        reasons: [RULES.EMPTY_RULE]
+      };
+    } else if (rule.id && dataType === DataType.COMBINATOR) {
+      const childrenFields = Object.keys(getFieldData(rule.field).children ?? {});
+      const compositeGroup = rule.value;
+      childrenFields.forEach((field) => {
+        validateRule({
+          ...rule,
+          field,
+          operator: compositeGroup?.rules?.[field]?.operator,
+          value: compositeGroup?.rules?.[field]?.value
+        });
+      });
+    }
+  };
+  const validateGroup = (ruleGroup) => {
+    const reasons = [];
+    if (ruleGroup.id) {
+      if (reasons.length) {
+        result[ruleGroup.id] = { valid: false, reasons };
+      } else {
+        result[ruleGroup.id] = true;
+      }
+    }
+    ruleGroup.rules.forEach((rule) => {
+      if (typeof rule === "string") ;
+      else if ("rules" in rule) {
+        validateGroup(rule);
+      } else {
+        validateRule(rule);
+      }
+    });
+  };
+  validateGroup(query);
+  return result;
+};
+const testQuery = (check, query) => {
+  const queryValidatorResult = queryValidator(query);
+  return !Object.values(queryValidatorResult).some((ruleValidation) => {
+    if (typeof ruleValidation !== "boolean" && ruleValidation.reasons) {
+      return ruleValidation.reasons.includes(check);
+    }
+    return false;
+  });
+};
+function getNumberOfSiblings(path, query) {
+  const parentPath = getParentPath(path);
+  const parentGroup = findPath(parentPath, query);
+  return parentGroup?.rules?.length;
+}
+function recursiveRemove(query, path) {
+  if (getNumberOfSiblings(path, query) === 1 && path.toString() !== [0].toString()) {
+    return recursiveRemove(query, getParentPath(path));
+  }
+  return remove(query, path);
+}
+export {
+  countRules,
+  exportExpertRules,
+  getNumberOfSiblings,
+  getOperators,
+  importExpertRules,
+  queryValidator,
+  recursiveRemove,
+  testQuery
+};

package/dist/components/composite/filter/explicitNaming/ExplicitNamingFilterEditionDialog.js

@@ -0,0 +1,123 @@
+import { jsx } from "react/jsx-runtime";
+import { yupResolver } from "@hookform/resolvers/yup";
+import PropTypes from "prop-types";
+import { useState, useEffect, useCallback } from "react";
+import { useForm } from "react-hook-form";
+import { v4 } from "uuid";
+import { useSnackMessage } from "../../../../hooks/useSnackMessage.js";
+import { FieldConstants } from "../../../../utils/constants/fieldConstants.js";
+import "../../../../utils/yupConfig.js";
+import { CustomMuiDialog } from "../../../ui/dialogs/customMuiDialog/CustomMuiDialog.js";
+import { saveExplicitNamingFilter } from "../utils/filterApi.js";
+import { explicitNamingFilterSchema } from "./ExplicitNamingFilterForm.js";
+import { FetchStatus } from "../../../../utils/constants/fetchStatus.js";
+import { FilterForm } from "../FilterForm.js";
+import { FilterType } from "../constants/FilterConstants.js";
+import { NO_ITEM_SELECTION_FOR_COPY } from "../../../../utils/directory-utils.js";
+import { HeaderFilterSchema } from "../HeaderFilterForm.js";
+import { FILTER_EQUIPMENTS_ATTRIBUTES } from "./ExplicitNamingFilterConstants.js";
+import { snackWithFallback } from "../../../../utils/error.js";
+import * as yup from "yup";
+const formSchema = yup.object().shape({
+  ...HeaderFilterSchema,
+  ...explicitNamingFilterSchema
+}).required();
+function ExplicitNamingFilterEditionDialog({
+  id,
+  name,
+  titleId,
+  open,
+  onClose,
+  broadcastChannel,
+  itemSelectionForCopy,
+  setItemSelectionForCopy,
+  getFilterById,
+  activeDirectory,
+  language,
+  description,
+  isDeveloperMode
+}) {
+  const { snackError } = useSnackMessage();
+  const [dataFetchStatus, setDataFetchStatus] = useState(FetchStatus.IDLE);
+  const formMethods = useForm({
+    resolver: yupResolver(formSchema)
+  });
+  const {
+    reset,
+    formState: { errors }
+  } = formMethods;
+  const nameError = errors[FieldConstants.NAME];
+  const isValidating = errors.root?.isValidating;
+  useEffect(() => {
+    if (id && open) {
+      setDataFetchStatus(FetchStatus.FETCHING);
+      getFilterById(id).then((response) => {
+        setDataFetchStatus(FetchStatus.FETCH_SUCCESS);
+        reset({
+          [FieldConstants.NAME]: name,
+          [FieldConstants.DESCRIPTION]: description,
+          [FieldConstants.EQUIPMENT_TYPE]: response[FieldConstants.EQUIPMENT_TYPE],
+          [FILTER_EQUIPMENTS_ATTRIBUTES]: response[FILTER_EQUIPMENTS_ATTRIBUTES]?.map((row) => ({
+            [FieldConstants.AG_GRID_ROW_UUID]: v4(),
+            ...row
+          }))
+        });
+      }).catch((error) => {
+        setDataFetchStatus(FetchStatus.FETCH_ERROR);
+        snackWithFallback(snackError, error, { headerId: "cannotRetrieveFilter" });
+      });
+    }
+  }, [id, name, open, reset, snackError, getFilterById, description]);
+  const onSubmit = useCallback(
+    (filterForm) => {
+      saveExplicitNamingFilter(
+        filterForm[FILTER_EQUIPMENTS_ATTRIBUTES] ?? [],
+        false,
+        filterForm[FieldConstants.EQUIPMENT_TYPE],
+        filterForm[FieldConstants.NAME],
+        filterForm[FieldConstants.DESCRIPTION] ?? "",
+        id,
+        (error) => {
+          snackWithFallback(snackError, error);
+        },
+        onClose
+      );
+      if (itemSelectionForCopy.sourceItemUuid === id) {
+        setItemSelectionForCopy(NO_ITEM_SELECTION_FOR_COPY);
+        broadcastChannel.postMessage({ NO_SELECTION_FOR_COPY: NO_ITEM_SELECTION_FOR_COPY });
+      }
+    },
+    [broadcastChannel, id, itemSelectionForCopy, onClose, snackError, setItemSelectionForCopy]
+  );
+  const isDataReady = dataFetchStatus === FetchStatus.FETCH_SUCCESS;
+  return /* @__PURE__ */ jsx(
+    CustomMuiDialog,
+    {
+      open,
+      onClose,
+      onSave: onSubmit,
+      formContext: {
+        ...formMethods,
+        validationSchema: formSchema,
+        removeOptional: true,
+        language,
+        isDeveloperMode
+      },
+      titleId,
+      disabledSave: !!nameError || !!isValidating,
+      isDataFetching: dataFetchStatus === FetchStatus.FETCHING,
+      unscrollableFullHeight: true,
+      children: isDataReady && /* @__PURE__ */ jsx(FilterForm, { activeDirectory, filterType: FilterType.EXPLICIT_NAMING, isEditing: true })
+    }
+  );
+}
+ExplicitNamingFilterEditionDialog.prototype = {
+  id: PropTypes.string,
+  name: PropTypes.string,
+  titleId: PropTypes.string.isRequired,
+  open: PropTypes.bool,
+  onClose: PropTypes.func.isRequired
+};
+export {
+  ExplicitNamingFilterEditionDialog
+};

package/dist/components/composite/filter/explicitNaming/ExplicitNamingFilterForm.d.ts

@@ -0,0 +1,28 @@
+import { UUID } from 'node:crypto';
+import { FieldConstants } from '../../../../utils/constants/fieldConstants';
+import { default as yup } from '../../../../utils/yupConfig';
+import { DISTRIBUTION_KEY } from '../constants/FilterConstants';
+export declare const explicitNamingFilterSchema: {
+    filterEquipmentsAttributes: yup.ArraySchema<{
+        distributionKey?: number | null | undefined;
+        equipmentID?: string | null | undefined;
+    }[] | undefined, yup.AnyObject, "", "">;
+};
+interface FilterTableRow {
+    [FieldConstants.AG_GRID_ROW_UUID]: string;
+    [FieldConstants.EQUIPMENT_ID]: string;
+    [DISTRIBUTION_KEY]: number | null;
+}
+export declare function getExplicitNamingFilterEmptyFormData(): {
+    filterEquipmentsAttributes: FilterTableRow[];
+};
+export interface FilterForExplicitConversionProps {
+    id: UUID;
+    equipmentType: string;
+}
+interface ExplicitNamingFilterFormProps {
+    sourceFilterForExplicitNamingConversion?: FilterForExplicitConversionProps;
+    isEditing: boolean;
+}
+export declare function ExplicitNamingFilterForm({ sourceFilterForExplicitNamingConversion, isEditing, }: Readonly<ExplicitNamingFilterFormProps>): import("react/jsx-runtime").JSX.Element;
+export {};