@topconsultnpm/sdkui-react 6.20.0-dev1.15 → 6.20.0-dev1.16

package/lib/components/features/search/TMSearch.js

@@ -0,0 +1,253 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { SavedQueryCacheService, DcmtTypeListCacheService, SDK_Localizator, LayoutModes } from '@topconsultnpm/sdk-ts';
+import TMSavedQuerySelector from './TMSavedQuerySelector';
+import TMTreeSelector from './TMTreeSelector';
+import { TabPanel, Item } from 'devextreme-react/tab-panel';
+import TMSearchQueryPanel, { refreshLastSearch } from './TMSearchQueryPanel';
+import { getSysAllDcmtsSQD, IconFilter, IconRecentlyViewed, IconSavedQuery, IconTree, removeMruTid, SDKUI_Globals, SDKUI_Localizator, updateMruTids } from '../../../helper';
+import TMSearchResult from './TMSearchResult';
+import TMRecentsManager from '../../grids/TMRecentsManager';
+import { SearchResultContext } from '../../../ts';
+import { useDeviceType, DeviceType } from '../../base/TMDeviceProvider';
+import { StyledMultiViewPanel } from '../../base/Styled';
+import { TMPanelManagerProvider, useTMPanelManagerContext } from '../../layout/panelManager/TMPanelManagerContext';
+import TMPanelManagerContainer from '../../layout/panelManager/TMPanelManagerContainer';
+var TMSearchViews;
+(function (TMSearchViews) {
+    TMSearchViews[TMSearchViews["Search"] = 0] = "Search";
+    TMSearchViews[TMSearchViews["Result"] = 1] = "Result";
+})(TMSearchViews || (TMSearchViews = {}));
+const TMSearch = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTaskCallback, editTaskCallback, handleNavigateToWGs, handleNavigateToDossiers, openInOffice, isVisible, inputTID, inputSqdID, inputMids, isExpertMode = SDKUI_Globals.userSettings.advancedSettings.expertMode === 1, floatingActionConfig, onFileOpened, onRefreshAfterAddDcmtToFavs, onTaskCreateRequest, openWGsCopyMoveForm, openEditPdf, openS4TViewer, onOpenS4TViewerRequest, showTodoDcmtForm, passToArchiveCallback, onCurrentTIDChangedCallback, onlyShowSearchQueryPanel, onReferenceClick }) => {
+    const [allSQDs, setAllSQDs] = useState([]);
+    const [filteredByTIDSQDs, setFilteredByTIDSQDs] = useState([]);
+    const [currentSQD, setCurrentSQD] = useState();
+    const [currentTID, setCurrentTID] = useState(0);
+    const [currentMruTID, setCurrentMruTID] = useState(0);
+    const [fromDTD, setFromDTD] = useState();
+    const [searchResult, setSearchResult] = useState([]);
+    const [mruTIDs, setMruTIDs] = useState([]);
+    const [currentSearchView, setCurrentSearchView] = useState(TMSearchViews.Search);
+    const [currentSQDMode, setCurrentSQDMode] = useState(1);
+    const [lastQdSearched, setLastQdSearched] = useState();
+    const [showSearchResults, setShowSearchResults] = useState(true);
+    const deviceType = useDeviceType();
+    useEffect(() => {
+        if (onCurrentTIDChangedCallback) {
+            onCurrentTIDChangedCallback(currentTID);
+        }
+    }, [currentTID, onCurrentTIDChangedCallback]);
+    useEffect(() => {
+        setMruTIDs(SDKUI_Globals.userSettings.searchSettings.mruTIDs);
+        loadDataSQDsAsync(false);
+    }, []);
+    useEffect(() => {
+        if (!inputTID)
+            return;
+        setCurrentTID(inputTID);
+        setCurrentSearchView(TMSearchViews.Search);
+    }, [inputTID]);
+    useEffect(() => {
+        if (inputSqdID) {
+            SavedQueryCacheService.GetAsync(inputSqdID).then(async (resultSqd) => {
+                await setSQDAsync(resultSqd);
+            });
+        }
+    }, [inputSqdID]);
+    useEffect(() => {
+        setSearchResult([]);
+        if (!currentTID || currentTID <= 0) {
+            return;
+        }
+        DcmtTypeListCacheService.GetAsync(currentTID).then(async (dtd) => {
+            setFromDTD(dtd);
+            let sqds = await getSQDsByTIDAsync(currentTID, allSQDs) ?? [];
+            setFilteredByTIDSQDs(sqds);
+            setCurrentSQDMode(0);
+            await setDefaultSQDAsync(sqds);
+        });
+    }, [currentTID]);
+    useEffect(() => {
+        if (currentSQD && currentSQD.masterTID != currentTID) {
+            DcmtTypeListCacheService.GetAsync(currentSQD.masterTID).then(async (dtd) => {
+                setFromDTD(dtd);
+                let sqds = await getSQDsByTIDAsync(currentSQD.masterTID, allSQDs) ?? [];
+                setFilteredByTIDSQDs(sqds);
+                setCurrentSQDMode(0);
+            });
+        }
+    }, [currentSQD]);
+    useEffect(() => {
+        if (onlyShowSearchQueryPanel === undefined)
+            return;
+        if (onlyShowSearchQueryPanel) {
+            setShowSearchResults(false);
+        }
+    }, [onlyShowSearchQueryPanel]);
+    const loadDataSQDsAsync = async (refreshCache, curTID) => {
+        if (refreshCache) {
+            SavedQueryCacheService.RemoveAll();
+            SavedQueryCacheService.Remove();
+        }
+        let sqdCache = await SavedQueryCacheService.GetAllAsync() ?? [];
+        setAllSQDs(sqdCache);
+        let sqds = await getSQDsByTIDAsync(curTID ?? currentTID, sqdCache) ?? [];
+        setFilteredByTIDSQDs(sqds);
+        setCurrentSQDMode(0);
+    };
+    const getSQDsByTIDAsync = async (tid, allSQDList) => {
+        if (!tid)
+            return;
+        let sqds = allSQDList ? allSQDList.slice() : allSQDs.slice();
+        sqds = sqds.filter(o => o.masterTID == tid);
+        sqds.unshift(await getSysAllDcmtsSQD(tid, false));
+        return sqds;
+    };
+    const setDefaultSQDAsync = async (sqds) => {
+        let defaultSQD = sqds.find(o => o.isDefault == 1);
+        defaultSQD ??= sqds.find(o => o.id == 1);
+        if (defaultSQD)
+            defaultSQD.isDefault = 1;
+        if (defaultSQD) {
+            await setSQDAsync(defaultSQD);
+        }
+    };
+    const setSQDAsync = async (sqd) => {
+        let newSqd = (sqd?.id == 1) ? sqd : await SavedQueryCacheService.GetAsync(sqd?.id);
+        setCurrentSQD(newSqd);
+        if (!newSqd?.masterTID)
+            return;
+        if (newSqd?.masterTID !== currentTID)
+            setCurrentTID(0);
+        if (mruTIDs.includes(newSqd.masterTID))
+            setCurrentMruTID(newSqd.masterTID);
+        else
+            setCurrentMruTID(0);
+    };
+    const onSQDItemClick = useCallback(async (sqd, setSqdAsync) => {
+        await setSqdAsync(sqd);
+    }, []);
+    const onSQDDeleted = useCallback(async (sqd, sqdToBeSet, setSqdAsync) => {
+        await loadDataSQDsAsync(true, sqd.masterTID);
+        if (sqdToBeSet)
+            await setSqdAsync?.(sqdToBeSet);
+    }, []);
+    const onRefreshSearchAsync = async () => {
+        try {
+            const newResult = (await refreshLastSearch(lastQdSearched)) ?? [];
+            setSearchResult(newResult);
+        }
+        catch (error) {
+            console.error("Error refreshing search:", error);
+        }
+    };
+    const isMobile = deviceType === DeviceType.TABLET || deviceType === DeviceType.MOBILE;
+    // --- JSX WRAPPERS ---
+    const tmTreeSelectorElement = useMemo(() => _jsx(TMTreeSelectorWrapper, { isMobile: isMobile, onSelectedTIDChanged: (tid) => {
+            setCurrentTID(tid);
+            if (tid && mruTIDs.includes(tid))
+                setCurrentMruTID(tid);
+            else
+                setCurrentMruTID(0);
+        } }), [isMobile, mruTIDs]);
+    const tmRecentsManagerElement = useMemo(() => _jsx(TMRecentsManagerWrapper, { mruTIDs: mruTIDs, currentMruTID: currentMruTID, deviceType: deviceType, onSelectedTID: (tid) => {
+            setCurrentMruTID(tid);
+            setCurrentTID(tid);
+        }, onDeletedTID: (tid) => {
+            let newMruTIDS = removeMruTid(SDKUI_Globals.userSettings.searchSettings.mruTIDs, tid);
+            SDKUI_Globals.userSettings.searchSettings.mruTIDs = newMruTIDS;
+            setMruTIDs(newMruTIDS);
+        } }), [mruTIDs, currentMruTID, deviceType]);
+    const tmSearchQueryPanelElement = useMemo(() => _jsx(TMSearchQueryPanelWrapper, { passToArchiveCallback: passToArchiveCallback, isExpertMode: isExpertMode, showBackToResultButton: searchResult.length > 0, fromDTD: fromDTD, SQD: currentSQD, inputMids: inputMids, onBackToResult: () => { setCurrentSearchView(TMSearchViews.Result); }, onSearchCompleted: (searchResult, qd) => {
+            setSearchResult(searchResult);
+            if (searchResult.length <= 0)
+                return;
+            setLastQdSearched(qd);
+            setCurrentSearchView(TMSearchViews.Result);
+            // Salvataggio ultimi 10 TIDs 
+            let fromTID = searchResult?.[0].fromTID;
+            let newMruTIDS = updateMruTids(SDKUI_Globals.userSettings.searchSettings.mruTIDs, fromTID);
+            SDKUI_Globals.userSettings.searchSettings.mruTIDs = newMruTIDS;
+            setMruTIDs(newMruTIDS);
+            setCurrentMruTID(fromTID);
+            setShowSearchResults(true);
+        }, onSqdSaved: async (newSqd) => {
+            await loadDataSQDsAsync(true, newSqd.masterTID);
+            await setSQDAsync(newSqd);
+        } }), [fromDTD, showSearchResults, setShowSearchResults, currentSQD, isExpertMode, mruTIDs, searchResult, passToArchiveCallback, inputMids]);
+    const tmSavedQuerySelectorElement = useMemo(() => _jsxs(TabPanel, { width: "100%", height: "100%", showNavButtons: true, repaintChangesOnly: true, selectedIndex: currentSQDMode, onSelectedIndexChange: (index) => setCurrentSQDMode(index), children: [(currentTID || currentSQD) ? _jsx(Item, { title: fromDTD?.nameLoc, children: _jsx(TMSavedQuerySelectorWrapper, { allowShowSearch: false, items: filteredByTIDSQDs, selectedId: currentSQD?.id, onRefreshData: () => { loadDataSQDsAsync(true); }, onItemClick: (sqd) => {
+                        onSQDItemClick(sqd, setSQDAsync);
+                    }, onDeleted: (sqd) => onSQDDeleted(sqd, sqd.id == currentSQD?.id ? filteredByTIDSQDs.find(o => o.id == 1) : currentSQD, setSQDAsync) }) }) : _jsx(_Fragment, {}), _jsx(Item, { title: SDKUI_Localizator.AllFemale, children: _jsx(TMSavedQuerySelectorWrapper, { allowShowSearch: true, items: allSQDs, manageDefault: false, onItemClick: (sqd) => {
+                        onSQDItemClick(sqd, setSQDAsync);
+                    }, onDeleted: (sqd) => onSQDDeleted(sqd, sqd.id == currentSQD?.id ? undefined : currentSQD, setSQDAsync) }) })] }), [currentSQDMode, currentTID, currentSQD, fromDTD, filteredByTIDSQDs, allSQDs]);
+    // --- PANEL DEFINITIONS ---
+    const allInitialPanelVisibility = {
+        'TMTreeSelector': true,
+        'TMRecentsManager': true,
+        'TMSearchQueryPanel': true,
+        'TMSavedQuerySelector': true,
+    };
+    const initialPanelDimensions = {
+        'TMTreeSelector': { width: '20%', height: '100%' },
+        'TMRecentsManager': { width: '20%', height: '100%' },
+        'TMSearchQueryPanel': { width: '40%', height: '100%' },
+        'TMSavedQuerySelector': { width: '20%', height: '100%' },
+    };
+    const initialPanels = useMemo(() => [
+        {
+            id: 'TMTreeSelector',
+            name: SDK_Localizator.Trees,
+            contentOptions: { component: tmTreeSelectorElement },
+            toolbarOptions: { icon: _jsx(IconTree, { fontSize: 24 }), visible: true, orderNumber: 1, isActive: allInitialPanelVisibility['TMTreeSelector'] }
+        },
+        {
+            id: 'TMRecentsManager',
+            name: SDKUI_Localizator.Shortcuts,
+            contentOptions: { component: tmRecentsManagerElement, panelContainer: { title: SDKUI_Localizator.Shortcuts, totalItems: mruTIDs.length } },
+            toolbarOptions: { icon: _jsx(IconRecentlyViewed, { fontSize: 24 }), visible: true, orderNumber: 2, isActive: allInitialPanelVisibility['TMRecentsManager'] }
+        },
+        {
+            id: 'TMSearchQueryPanel',
+            name: fromDTD?.nameLoc ?? SDKUI_Localizator.Search_Metadata,
+            contentOptions: { component: tmSearchQueryPanelElement },
+            toolbarOptions: { icon: _jsx(IconFilter, { fontSize: 24 }), visible: true, orderNumber: 3, isActive: allInitialPanelVisibility['TMSearchQueryPanel'] }
+        },
+        {
+            id: 'TMSavedQuerySelector',
+            name: SDK_Localizator.SavedQueries,
+            contentOptions: { component: tmSavedQuerySelectorElement, panelContainer: { title: SDK_Localizator.SavedQueries } },
+            toolbarOptions: { icon: _jsx(IconSavedQuery, { fontSize: 24 }), visible: true, orderNumber: 4, isActive: allInitialPanelVisibility['TMSavedQuerySelector'] }
+        }
+    ], [tmTreeSelectorElement, showSearchResults, tmRecentsManagerElement, tmSearchQueryPanelElement, tmSavedQuerySelectorElement, fromDTD, mruTIDs]);
+    return (_jsxs(_Fragment, { children: [showSearchResults ? _jsx(StyledMultiViewPanel, { "$isVisible": currentSearchView === TMSearchViews.Search, children: _jsx(TMPanelManagerProvider, { panels: initialPanels, initialVisibility: allInitialPanelVisibility, defaultDimensions: initialPanelDimensions, initialDimensions: initialPanelDimensions, initialMobilePanelId: 'TMRecentsManager', children: _jsx(TMPanelManagerContainer, { panels: initialPanels, direction: "horizontal", showToolbar: true, minPanelSizePx: !isMobile ? 250 : 150 }) }) }) : tmSearchQueryPanelElement, showSearchResults && _jsx(TMSearchResult, { isVisible: isVisible && currentSearchView === TMSearchViews.Result, context: SearchResultContext.METADATA_SEARCH, searchResults: searchResult, floatingActionConfig: floatingActionConfig, onRefreshAfterAddDcmtToFavs: onRefreshAfterAddDcmtToFavs, openInOffice: openInOffice, onRefreshSearchAsync: onRefreshSearchAsync, onClose: () => { onlyShowSearchQueryPanel ? setShowSearchResults(false) : setCurrentSearchView(TMSearchViews.Search); }, onFileOpened: onFileOpened, onTaskCreateRequest: onTaskCreateRequest, openWGsCopyMoveForm: openWGsCopyMoveForm, openEditPdf: openEditPdf, openS4TViewer: openS4TViewer, onOpenS4TViewerRequest: onOpenS4TViewerRequest, passToArchiveCallback: passToArchiveCallback, onSelectedTIDChanged: onCurrentTIDChangedCallback, showTodoDcmtForm: showTodoDcmtForm, onReferenceClick: onReferenceClick, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers })] }));
+};
+export default TMSearch;
+const TMTreeSelectorWrapper = ({ isMobile, onSelectedTIDChanged }) => {
+    const { setPanelVisibilityById, toggleMaximize, countVisibleLeafPanels } = useTMPanelManagerContext();
+    return (_jsx(TMTreeSelector, { layoutMode: LayoutModes.Update, onClosePanel: !isMobile && countVisibleLeafPanels() > 1 ? () => setPanelVisibilityById('TMTreeSelector', false) : undefined, allowMaximize: !isMobile && countVisibleLeafPanels() > 1, onMaximizePanel: !isMobile && countVisibleLeafPanels() > 1 ? () => toggleMaximize("TMTreeSelector") : undefined, onSelectedTIDChanged: (tid) => {
+            onSelectedTIDChanged?.(tid);
+            isMobile && setPanelVisibilityById('TMSearchQueryPanel', true);
+        } }));
+};
+const TMRecentsManagerWrapper = ({ mruTIDs, currentMruTID, deviceType, onSelectedTID, onDeletedTID }) => {
+    const { setPanelVisibilityById } = useTMPanelManagerContext();
+    return (_jsx(TMRecentsManager, { accessFilter: 'canSearch', mruTIDs: mruTIDs, currentMruTID: currentMruTID, deviceType: deviceType, onSelectedTID: (tid) => {
+            onSelectedTID?.(tid);
+            deviceType === DeviceType.MOBILE && setPanelVisibilityById('TMSearchQueryPanel', true);
+        }, onDeletedTID: (tid) => {
+            onDeletedTID?.(tid);
+        } }));
+};
+const TMSearchQueryPanelWrapper = ({ fromDTD, SQD, isExpertMode, showBackToResultButton, onSearchCompleted, onSqdSaved, onBackToResult, passToArchiveCallback, inputMids }) => {
+    const { setPanelVisibilityById, toggleMaximize, countVisibleLeafPanels } = useTMPanelManagerContext();
+    const deviceType = useDeviceType();
+    const isMobile = deviceType === DeviceType.MOBILE;
+    return (_jsx(TMSearchQueryPanel, { onClosePanel: (!isMobile && countVisibleLeafPanels() > 1) ? () => setPanelVisibilityById('TMSearchQueryPanel', false) : undefined, allowMaximize: !isMobile && countVisibleLeafPanels() > 1, onMaximizePanel: (!isMobile && countVisibleLeafPanels() > 1) ? () => toggleMaximize("TMSearchQueryPanel") : undefined, isExpertMode: isExpertMode, fromDTD: fromDTD, SQD: SQD, inputMids: inputMids, onSearchCompleted: onSearchCompleted, onSqdSaved: onSqdSaved, showBackToResultButton: showBackToResultButton, onBackToResult: onBackToResult, passToArchiveCallback: passToArchiveCallback }));
+};
+const TMSavedQuerySelectorWrapper = ({ items, selectedId, allowShowSearch, manageDefault, onRefreshData, onItemClick, onDeleted }) => {
+    const { setPanelVisibilityById } = useTMPanelManagerContext();
+    return (_jsx(TMSavedQuerySelector, { allowShowSearch: allowShowSearch, manageDefault: manageDefault, items: items, selectedId: selectedId, onRefreshData: onRefreshData, onItemClick: (sqd) => {
+            onItemClick?.(sqd);
+            setPanelVisibilityById('TMSearchQueryPanel', true);
+        }, onDeleted: onDeleted }));
+};

package/lib/components/features/search/TMSearchQueryEditor.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { DcmtTypeDescriptor, QueryDescriptor } from '@topconsultnpm/sdk-ts';
+import { TID_MID } from '../../../ts';
+import { AdvancedMenuClickEventArgs } from '../../editors/TMMetadataValues';
+interface ITMSearchQueryEditorProps {
+    qd: QueryDescriptor | undefined;
+    dcmtTypesList?: DcmtTypeDescriptor[];
+    isExpertMode?: boolean;
+    showAllMdWhere?: boolean;
+    onQdChanged?: (qd: QueryDescriptor) => void;
+    onAdvancedMenuClick?: (e: AdvancedMenuClickEventArgs) => void;
+    onFocusedMetadataChanged?: (tid_mid: TID_MID | undefined) => void;
+}
+declare const _default: React.NamedExoticComponent<ITMSearchQueryEditorProps>;
+export default _default;