Add new contingency list by filter

src/components/dialogs/contingency-list/contingency-list-utils.ts

@@ -16,6 +16,7 @@
 import type { SetRequired } from 'type-fest';
 import { prepareContingencyListForBackend } from '../contingency-list-helper';
 import { ContingencyListType } from '../../../utils/elementType';
+import { FilterAttributes } from '../../../utils/contingency-list.type';
 
 export interface Identifier {
     type: 'ID_BASED';
@@ -71,6 +72,15 @@
     ...getCriteriaBasedFormData(response),
 });
 
+export const getFilterBasedFormDataFromFetchedElement = (response: any, name: string, description: string) => ({
+    [FieldConstants.NAME]: name,
+    [FieldConstants.DESCRIPTION]: description,
+    [FieldConstants.CONTINGENCY_LIST_TYPE]: ContingencyListType.FILTERS.id,
+    [FieldConstants.FILTERS]: response.filters.map((filter: FilterAttributes) => {
+        return { id: filter.id, name: filter.name, specificMetadata: { equipmentType: filter.equipmentType } };
+    }),
+});
+
 export const getExplicitNamingFormDataFromFetchedElement = (response: any, name: string, description: string) => {
     let result;
     if (response.identifierContingencyList?.identifiers?.length) {

src/components/dialogs/contingency-list/creation/contingency-list-creation-form.tsx

@@ -42,7 +42,7 @@ export default function ContingencyListCreationForm() {
     const contingencyListTypeField = (
         <RadioInput
             name={FieldConstants.CONTINGENCY_LIST_TYPE}
-            options={Object.values(ContingencyListType)}
+            options={[ContingencyListType.CRITERIA_BASED, ContingencyListType.EXPLICIT_NAMING]}
             formProps={{ onChange: handleChange }} // need to override this in order to do not activate the validate button when changing the filter type
         />
     );

src/components/dialogs/contingency-list/filter-based/contingency-list-filter-based-dialog.tsx

@@ -0,0 +1,180 @@
+/**
+ * Copyright (c) 2025, 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/.
+ */
+
+import {
+    CustomMuiDialog,
+    FieldConstants,
+    MAX_CHAR_DESCRIPTION,
+    TreeViewFinderNodeProps,
+    useSnackMessage,
+    yupConfig as yup,
+} from '@gridsuite/commons-ui';
+import { useForm } from 'react-hook-form';
+import { yupResolver } from '@hookform/resolvers/yup';
+import { useSelector } from 'react-redux';
+import { useCallback, useEffect, useState } from 'react';
+import { UUID } from 'crypto';
+import { ObjectSchema } from 'yup';
+import ContingencyListFilterBasedForm from './contingency-list-filter-based-form';
+import { AppState } from '../../../../redux/types';
+import {
+    createFilterBasedContingency,
+    getContingencyList,
+    saveFilterBasedContingencyList,
+} from '../../../../utils/rest-api';
+import { handleNotAllowedError } from '../../../utils/rest-errors';
+import { ContingencyListType } from '../../../../utils/elementType';
+import { getFilterBasedFormDataFromFetchedElement } from '../contingency-list-utils';
+import { FilterBasedContingencyList } from '../../../../utils/contingency-list.type';
+
+const schema: ObjectSchema<ContingencyListFilterBasedFormData> = yup.object().shape({
+    [FieldConstants.NAME]: yup.string().required(),
+    [FieldConstants.DESCRIPTION]: yup.string().max(MAX_CHAR_DESCRIPTION),
+    [FieldConstants.FILTERS]: yup.array().required(),
+});
+
+export interface ContingencyListFilterBasedFormData {
+    [FieldConstants.NAME]: string;
+    [FieldConstants.DESCRIPTION]?: string;
+    [FieldConstants.FILTERS]: TreeViewFinderNodeProps[];
+}
+
+const getContingencyListEmptyFormData = (name = '') => ({
+    [FieldConstants.NAME]: name,
+    [FieldConstants.DESCRIPTION]: '',
+    [FieldConstants.FILTERS]: [],
+});
+
+const emptyFormData = (name?: string) => getContingencyListEmptyFormData(name);
+
+export interface FilterBasedContingencyListProps {
+    titleId: string;
+    open: boolean;
+    onClose: () => void;
+    name?: string;
+    description?: string;
+    id?: UUID;
+}
+
+export default function FilterBasedContingencyListDialog({
+    titleId,
+    open,
+    onClose,
+    name,
+    description,
+    id,
+}: Readonly<FilterBasedContingencyListProps>) {
+    const activeDirectory = useSelector((state: AppState) => state.activeDirectory);
+    const { snackError } = useSnackMessage();
+    const [isFetching, setIsFetching] = useState(!!id);
+
+    const methods = useForm<ContingencyListFilterBasedFormData>({
+        defaultValues: emptyFormData(),
+        resolver: yupResolver(schema),
+    });
+    const {
+        reset,
+        formState: { errors },
+    } = methods;
+
+    useEffect(() => {
+        if (id) {
+            setIsFetching(true);
+            getContingencyList(ContingencyListType.FILTERS.id, id?.toString())
+                .then((response) => {
+                    const formData: ContingencyListFilterBasedFormData = getFilterBasedFormDataFromFetchedElement(
+                        response,
+                        name ?? '',
+                        description ?? ''
+                    );
+                    reset({ ...formData });
+                })
+                .catch((error) => {
+                    snackError({
+                        messageTxt: error.message,
+                        headerId: 'cannotRetrieveContingencyList',
+                    });
+                })
+                .finally(() => setIsFetching(false));
+        }
+    }, [id, name, reset, snackError, description]);
+
+    const closeAndClear = useCallback(() => {
+        reset(emptyFormData());
+        onClose();
+    }, [onClose, reset]);
+
+    const onSubmit = useCallback(
+        (data: ContingencyListFilterBasedFormData) => {
+            const filterBaseContingencyList: FilterBasedContingencyList = {
+                filters: data[FieldConstants.FILTERS]?.map((item: TreeViewFinderNodeProps) => {
+                    return {
+                        id: item.id,
+                    };
+                }),
+            };
+
+            if (id) {
+                saveFilterBasedContingencyList(
+                    id,
+                    data[FieldConstants.NAME],
+                    data[FieldConstants.DESCRIPTION] ?? '',
+                    filterBaseContingencyList
+                )
+                    .then(() => closeAndClear())
+                    .catch((error) => {
+                        if (handleNotAllowedError(error, snackError)) {
+                            return;
+                        }
+                        snackError({
+                            messageTxt: error.message,
+                            headerId: 'contingencyListEditingError',
+                            headerValues: { name: data[FieldConstants.NAME] },
+                        });
+                    });
+            } else {
+                createFilterBasedContingency(
+                    data[FieldConstants.NAME],
+                    data[FieldConstants.DESCRIPTION] ?? '',
+                    filterBaseContingencyList,
+                    activeDirectory
+                )
+                    .then(() => closeAndClear())
+                    .catch((error) => {
+                        if (handleNotAllowedError(error, snackError)) {
+                            return;
+                        }
+                        snackError({
+                            messageTxt: error.message,
+                            headerId: 'contingencyListCreationError',
+                            headerValues: { name: data[FieldConstants.NAME] },
+                        });
+                    });
+            }
+        },
+        [activeDirectory, closeAndClear, id, snackError]
+    );
+
+    const nameError = errors[FieldConstants.NAME];
+    const isValidating = errors.root?.isValidating;
+
+    return (
+        <CustomMuiDialog
+            titleId={titleId}
+            open={open}
+            onClose={closeAndClear}
+            onSave={onSubmit}
+            formSchema={schema}
+            formMethods={methods}
+            unscrollableFullHeight
+            disabledSave={Boolean(!!nameError || isValidating)}
+            isDataFetching={isFetching}
+        >
+            <ContingencyListFilterBasedForm />
+        </CustomMuiDialog>
+    );
+}