Implement last selected directory functionality (#814)

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

Author: achour94

src/components/dialogs/elementSaveDialog/ElementSaveDialog.tsx

@@ -18,7 +18,7 @@ import { DirectoryItemSelector } from '../../directoryItemSelector';
 import { CustomMuiDialog } from '../customMuiDialog/CustomMuiDialog';
 import { ElementAttributes, ElementType, FieldConstants, MAX_CHAR_DESCRIPTION } from '../../../utils';
 import { useSnackMessage } from '../../../hooks';
-import { fetchDirectoryElementPath } from '../../../services';
+import { DirectoryInitConfig, initializeDirectory } from './utils';
 
 // Define operation types
 enum OperationType {
@@ -131,6 +131,7 @@ export function ElementSaveDialog({
     const [selectedItem, setSelectedItem] = useState<
         TreeViewFinderNodeProps & { parentFolderId: UUID; fullPath: string }
     >();
+    const [expanded, setExpanded] = useState<UUID[]>([]);
 
     // Form handling with conditional defaultValues
     const formMethods = useForm({
@@ -155,9 +156,42 @@ export function ElementSaveDialog({
     const disableSave =
         Object.keys(errors).length > 0 || (isCreateMode && !destinationFolder) || (!isCreateMode && !selectedItem);
 
+    const setDestinationFolderWithPath = useCallback(
+        (elementUuid: UUID, elementName: string, path?: ElementAttributes[]) => {
+            setDestinationFolder({
+                id: elementUuid,
+                name: elementName,
+            });
+
+            if (path && path.length > 0) {
+                // Set expanded path to show the selected directory
+                const expandPath = path.map((element) => element.elementUuid);
+                setExpanded(expandPath);
+            }
+        },
+        []
+    );
+
+    const initializeDestinationFolder = useCallback(async () => {
+        const config: DirectoryInitConfig = {
+            studyUuid,
+            initDirectory,
+            onError: (messageTxt, headerId) => {
+                snackError({ messageTxt, headerId });
+            },
+        };
+
+        const result = await initializeDirectory(config);
+
+        if (result) {
+            setDestinationFolderWithPath(result.element.elementUuid, result.element.elementName, result.path);
+        }
+    }, [studyUuid, initDirectory, snackError, setDestinationFolderWithPath]);
+
     // Handle cancellation
     const onCancel = useCallback(() => {
         reset({ ...emptyFormData, [FieldConstants.OPERATION_TYPE]: initialOperation });
+        setExpanded([]);
         onClose();
     }, [onClose, reset, initialOperation]);
 
@@ -179,36 +213,14 @@ export function ElementSaveDialog({
         }
     }, [prefixIdForGeneratedName, intl, reset, isCreateMode]);
 
-    // Fetch study directory for creation if needed
+    // Destination folder initialization for create mode
     useEffect(() => {
-        if (open && isCreateMode && studyUuid) {
-            fetchDirectoryElementPath(studyUuid).then((res) => {
-                if (!res || res.length < 2) {
-                    snackError({
-                        messageTxt: 'unknown study directory',
-                        headerId: 'studyDirectoryFetchingError',
-                    });
-                    return;
-                }
-                const parentFolderIndex = res.length - 2;
-                const { elementUuid, elementName } = res[parentFolderIndex];
-                setDestinationFolder({
-                    id: elementUuid,
-                    name: elementName,
-                });
-            });
+        if (!open || !isCreateMode) {
+            return;
         }
-    }, [studyUuid, open, snackError, isCreateMode]);
 
-    // Set initial directory for creation if provided
-    useEffect(() => {
-        if (open && isCreateMode && initDirectory) {
-            setDestinationFolder({
-                id: initDirectory.elementUuid,
-                name: initDirectory.elementName,
-            });
-        }
-    }, [initDirectory, open, isCreateMode]);
+        initializeDestinationFolder();
+    }, [open, isCreateMode, initializeDestinationFolder]);
 
     // Open selector dialog
     const handleChangeFolder = useCallback(() => {
@@ -223,6 +235,7 @@ export function ElementSaveDialog({
                 if (items?.length > 0 && items[0].id !== destinationFolder?.id) {
                     const { id, name } = items[0];
                     setDestinationFolder({ id, name });
+                    setExpanded([]);
                 }
             } else if (items?.length > 0 && items[0].id !== selectedItem?.id) {
                 // Handle item selection for update
@@ -357,6 +370,7 @@ export function ElementSaveDialog({
                 types={isCreateMode ? [ElementType.DIRECTORY] : [type]}
                 onlyLeaves={isCreateMode ? false : undefined}
                 multiSelect={false}
+                expanded={isCreateMode ? expanded : []}
                 validationButtonText={intl.formatMessage({
                     id: 'validate',
                 })}

src/components/dialogs/elementSaveDialog/utils.ts

@@ -0,0 +1,72 @@
+/**
+ * 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 { UUID } from 'crypto';
+import { ElementAttributes } from '../../../utils';
+import {
+    clearLastSelectedDirectory,
+    fetchDirectoryPathSafe,
+    getLastSelectedDirectoryId,
+} from '../../directoryItemSelector/utils';
+
+/**
+ * Generic directory initialization configuration
+ */
+export interface DirectoryInitConfig {
+    studyUuid?: UUID;
+    initDirectory?: ElementAttributes;
+    onError?: (message: string, headerId: string) => void;
+}
+
+/**
+ * Generic destination directory initialization that follows the standard priority:
+ * 1. Last selected directory from localStorage
+ * 2. Study UUID (if provided)
+ * 3. Initial directory (if provided)
+ *
+ * @param config Configuration object
+ * @returns Promise resolving to { element, path } or null if all methods fail
+ */
+export async function initializeDirectory(
+    config: DirectoryInitConfig
+): Promise<{ element: ElementAttributes; path?: ElementAttributes[] } | null> {
+    const { studyUuid, initDirectory, onError } = config;
+
+    // Priority 1: Try last selected directory from localStorage
+    const lastSelectedDirId = getLastSelectedDirectoryId();
+    if (lastSelectedDirId) {
+        const path = await fetchDirectoryPathSafe(lastSelectedDirId);
+        if (path && path.length > 0) {
+            const targetElement = path[path.length - 1];
+            return { element: targetElement, path };
+        }
+        // Clear invalid last selected directory
+        await clearLastSelectedDirectory();
+    }
+
+    // Priority 2: Try study UUID
+    if (studyUuid) {
+        const path = await fetchDirectoryPathSafe(studyUuid);
+        if (path && path.length >= 2) {
+            const parentFolderIndex = path.length - 2;
+            const parentElement = path[parentFolderIndex];
+            return {
+                element: parentElement,
+                path: path.slice(0, parentFolderIndex + 1),
+            };
+        }
+        onError?.('unknown study directory', 'studyDirectoryFetchingError');
+        return null;
+    }
+
+    // Priority 3: Try initial directory
+    if (initDirectory) {
+        return { element: initDirectory };
+    }
+
+    return null;
+}

src/components/directoryItemSelector/DirectoryItemSelector.tsx

@@ -14,6 +14,12 @@ import { TreeViewFinder, TreeViewFinderNodeProps, TreeViewFinderProps } from '..
 import { useSnackMessage } from '../../hooks/useSnackMessage';
 import { fetchDirectoryContent, fetchElementsInfos, fetchRootFolders } from '../../services';
 import { ElementAttributes } from '../../utils';
+import {
+    fetchChildrenForExpandedNodes,
+    getExpansionPathsForSelected,
+    initializeFromLastSelected,
+    saveLastSelectedDirectoryFromNode,
+} from './utils';
 
 const styles = {
     icon: (theme: Theme) => ({
@@ -173,10 +179,13 @@ export function DirectoryItemSelector({
     itemFilter,
     expanded,
     selected,
+    onClose,
     ...otherTreeViewFinderProps
 }: Readonly<DirectoryItemSelectorProps>) {
     const [data, setData] = useState<TreeViewFinderNodeProps[]>([]);
     const [rootDirectories, setRootDirectories] = useState<ElementAttributes[]>([]);
+    const [isRootsLoaded, setIsRootsLoaded] = useState(false);
+    const [autoExpandedNodes, setAutoExpandedNodes] = useState<UUID[]>([]);
     const nodeMap = useRef<Record<UUID, ElementAttributes>>({});
     const dataRef = useRef<TreeViewFinderNodeProps[]>([]);
     dataRef.current = data;
@@ -231,6 +240,7 @@ export function DirectoryItemSelector({
     );
 
     const updateRootDirectories = useCallback(() => {
+        setIsRootsLoaded(false);
         fetchRootFolders(types)
             .then((newData) => {
                 const [nrs, mdr] = updatedTree(rootsRef.current, nodeMap.current, null, newData);
@@ -243,6 +253,9 @@ export function DirectoryItemSelector({
                     messageTxt: error.message,
                     headerId: 'DirectoryItemSelector',
                 });
+            })
+            .finally(() => {
+                setIsRootsLoaded(true);
             });
     }, [convertRoots, types, snackError]);
 
@@ -286,39 +299,113 @@ export function DirectoryItemSelector({
         [types, equipmentTypes, itemFilter, contentFilter, addToDirectory]
     );
 
-    // In this useEffect, we fetch the path (expanded array) of every selected node
-    useEffect(() => {
-        if (open && expanded && selected) {
-            // we check if every selected item is already fetched
-            const isSelectedItemFetched = selected.every((id) => nodeMap.current[id]);
-            if (!isSelectedItemFetched) {
-                expanded.forEach((nodeId) => {
-                    const node = nodeMap.current[nodeId];
-                    // we check that the node exist before fetching the children
-                    // And we check if there is already children (Because we are trying to reach a selected element, we know every node has at least one child)
-                    if (node?.children && node.children.length === 0) {
-                        fetchDirectoryChildren(nodeId);
-                    }
-                });
-            }
+    // Helper function to fetch children for a node if not already loaded
+    const fetchNodeChildrenIfNeeded = useCallback(
+        (nodeId: UUID, delay: number = 0) => {
+            setTimeout(() => {
+                const node = nodeMap.current[nodeId];
+                if (node && (!node.children || node.children.length === 0) && node.type === ElementType.DIRECTORY) {
+                    fetchDirectoryChildren(nodeId);
+                }
+            }, delay);
+        },
+        [fetchDirectoryChildren]
+    );
+
+    // Handle expansion from selected items
+    const handleSelectedExpansion = useCallback(async (): Promise<boolean> => {
+        if (!selected || selected.length === 0) {
+            return false;
         }
-    }, [open, expanded, fetchDirectoryChildren, selected, data]);
 
+        const expandedArray = await getExpansionPathsForSelected(selected, expanded);
+        setAutoExpandedNodes(expandedArray);
+        fetchChildrenForExpandedNodes(expandedArray, fetchNodeChildrenIfNeeded);
+        return true;
+    }, [selected, expanded, fetchNodeChildrenIfNeeded]);
+
+    // Handle expansion from provided expanded prop
+    const handleProvidedExpansion = useCallback((): boolean => {
+        if (!expanded || expanded.length === 0) {
+            return false;
+        }
+
+        setAutoExpandedNodes(expanded);
+        fetchChildrenForExpandedNodes(expanded, fetchNodeChildrenIfNeeded);
+
+        return true;
+    }, [expanded, fetchNodeChildrenIfNeeded]);
+
+    // Handle expansion from last selected directory
+    const handleLastSelectedExpansion = useCallback(async (): Promise<boolean> => {
+        const expandPath = await initializeFromLastSelected();
+
+        if (!expandPath) {
+            return false;
+        }
+
+        setAutoExpandedNodes(expandPath);
+        fetchChildrenForExpandedNodes(expandPath, fetchNodeChildrenIfNeeded);
+
+        return true;
+    }, [fetchNodeChildrenIfNeeded]);
+
+    // Main expansion orchestrator
+    const initializeExpansion = useCallback(async () => {
+        // Priority 1: Handle selected items
+        const selectedSuccess = await handleSelectedExpansion();
+        if (selectedSuccess) return;
+
+        // Priority 2: Handle provided expanded items
+        const expandedSuccess = handleProvidedExpansion();
+        if (expandedSuccess) return;
+
+        // Priority 3: Fall back to last selected directory
+        await handleLastSelectedExpansion();
+    }, [handleSelectedExpansion, handleProvidedExpansion, handleLastSelectedExpansion]);
+
+    // Handle root loading and expansion initialization
     useEffect(() => {
-        if (open) {
+        if (!open) {
+            setIsRootsLoaded(false);
+            setAutoExpandedNodes([]);
+            return;
+        }
+
+        // Phase 1: Load root directories if not already loaded
+        if (!isRootsLoaded) {
             updateRootDirectories();
+            return;
         }
-    }, [open, updateRootDirectories]);
+
+        // Phase 2: Initialize expansion once roots are loaded
+        initializeExpansion();
+    }, [open, isRootsLoaded, updateRootDirectories, initializeExpansion]);
+
+    const handleClose = useCallback(
+        (nodes: TreeViewFinderNodeProps[]) => {
+            if (nodes && nodes.length > 0) {
+                const lastSelectedNode = nodes[0];
+                saveLastSelectedDirectoryFromNode(lastSelectedNode);
+            }
+
+            setAutoExpandedNodes([]);
+
+            onClose(nodes);
+        },
+        [onClose]
+    );
 
     return (
         <TreeViewFinder
             onTreeBrowse={fetchDirectoryChildren as (NodeId: string) => void}
             sortMethod={sortHandlingDirectories}
             multiSelect // defaulted to true
             open={open}
-            expanded={expanded as string[]}
+            expanded={autoExpandedNodes}
             onlyLeaves // defaulted to true
             selected={selected}
+            onClose={handleClose}
             {...otherTreeViewFinderProps}
             data={data}
         />