@topconsultnpm/sdkui-react 6.22.0-t1 → 6.22.0-t3

package/lib/hooks/usePreventFileDrop.js

@@ -2,7 +2,12 @@ import { useEffect } from "react";
 const usePreventFileDrop = (allowedDropZones) => {
     useEffect(() => {
         const isOverAllowedZone = (event) => allowedDropZones.some((ref) => ref.current?.contains(event.target));
+        // Il blocco vale solo per i file trascinati da fuori: i drag interni all'applicazione
+        // (riordino di metadati, colonne, tab, ...) devono restare liberi di completarsi
+        const isFileDrag = (event) => event.dataTransfer?.types?.includes("Files") === true;
         const handleDragOver = (event) => {
+            if (!isFileDrag(event))
+                return;
             if (isOverAllowedZone(event)) {
                 // Riafferma "copy" ad ogni dragover: altrimenti un "none"
                 // impostato mentre si era fuori zona resta e mostra "not-allowed"
@@ -17,6 +22,8 @@ const usePreventFileDrop = (allowedDropZones) => {
             }
         };
         const handleDragEnter = (event) => {
+            if (!isFileDrag(event))
+                return;
             if (isOverAllowedZone(event)) {
                 document.body.style.cursor = "default";
             }
@@ -28,6 +35,8 @@ const usePreventFileDrop = (allowedDropZones) => {
             document.body.style.cursor = "default";
         };
         const handleDrop = (event) => {
+            if (!isFileDrag(event))
+                return;
             if (!isOverAllowedZone(event)) {
                 event.preventDefault();
                 document.body.style.cursor = "default";

package/lib/hooks/useQueryParametersDialog.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
 import { QueryParameterDescriptor } from '@topconsultnpm/sdk-ts';
 import { TMModal, TMTextBox, TMButton, TMCard, StyledDivHorizontal } from "../components";

package/lib/hooks/useRelatedDocuments.d.ts

@@ -67,6 +67,7 @@ export interface UseRelatedDocumentsReturn {
     checkManyToManyCapability: () => Promise<void>;
     archiveRelatedDcmtHandler: (relation: RelationDescriptor, type: 'detail' | 'master') => Promise<void>;
     executeManyToManyPairing: (relation: RelationDescriptor, isPairing: boolean) => Promise<void>;
+    backToPairSearchModal: (() => void) | undefined;
 }
 export declare const useRelatedDocuments: ({ selectedSearchResult, focusedItem, currentSearchResults }: UseRelatedDocumentsProps) => UseRelatedDocumentsReturn;
 export {};

package/lib/hooks/useRelatedDocuments.js

@@ -2,7 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useState, useCallback, useMemo, useEffect } from 'react';
 import { SDKUI_Localizator } from '../helper/SDKUI_Localizator';
 import { IconPair, IconUnpair } from '../helper/TMIcons';
-import { hasDetailRelations, hasMasterRelations } from '../helper/dcmtsHelper';
+import { hasDetailRelations, hasMasterRelations, mapRelationAssociationsToMids } from '../helper/dcmtsHelper';
 import { SDK_Globals, SearchEngine, RelationCacheService, RelationTypes, DcmtTypeListCacheService, SystemMIDsAsNumber, AccessLevelsEx } from '@topconsultnpm/sdk-ts';
 import { TMSpinner, TMExceptionBoxManager, ShowAlert } from '../components';
 export const useRelatedDocuments = ({ selectedSearchResult, focusedItem, currentSearchResults }) => {
@@ -28,6 +28,7 @@ export const useRelatedDocuments = ({ selectedSearchResult, focusedItem, current
     const [pairSearchModalParentDID, setPairSearchModalParentDID] = useState(undefined);
     const [pairSearchModalRelation, setPairSearchModalRelation] = useState(undefined);
     const [pairSearchModalInputMids, setPairSearchModalInputMids] = useState(undefined);
+    const [pairSearchContext, setPairSearchContext] = useState(undefined);
     const [currentTIDHasDetailRelations, setCurrentTIDHasDetailRelations] = useState();
     const [currentTIDHasMasterRelations, setCurrentTIDHasMasterRelations] = useState();
     const [canArchiveMasterRelation, setCanArchiveMasterRelation] = useState(false);
@@ -86,6 +87,7 @@ export const useRelatedDocuments = ({ selectedSearchResult, focusedItem, current
             if (!tms)
                 return;
             const se = new SearchEngine(tms);
+            const operationTitle = isPairing ? SDKUI_Localizator.MatchManyDocumentsManyToMany : SDKUI_Localizator.UnmatchManyDocumentsManyToMany;
             try {
                 TMSpinner.show({ description: isPairing ? 'Abbinamento in corso...' : 'Disabbinamento in corso...' });
                 for (const doc of selected) {
@@ -115,10 +117,16 @@ export const useRelatedDocuments = ({ selectedSearchResult, focusedItem, current
                     }
                 }
                 onCloseModal();
+                ShowAlert({
+                    message: SDKUI_Localizator.OperationSuccess,
+                    mode: 'success',
+                    title: operationTitle,
+                    duration: 3000
+                });
             }
             catch (error) {
                 console.error('Error in onClick:', error);
-                TMExceptionBoxManager.show({ exception: error });
+                TMExceptionBoxManager.show({ title: operationTitle, exception: error });
             }
             finally {
                 TMSpinner.hide();
@@ -129,6 +137,14 @@ export const useRelatedDocuments = ({ selectedSearchResult, focusedItem, current
     }), []);
     const pairFloatingActionConfig = useMemo(() => createPairFloatingActionConfig(selectedManyToManyRelation, focusedItem?.TID ? Number(focusedItem.TID) : undefined, focusedItem?.DID ? Number(focusedItem.DID) : undefined, isPairingManyToMany, () => setShowPairDcmtsModal(false)), [createPairFloatingActionConfig, selectedManyToManyRelation, focusedItem, isPairingManyToMany]);
     const pairSearchModalFloatingActionConfig = useMemo(() => createPairFloatingActionConfig(pairSearchModalRelation, pairSearchModalParentTID, pairSearchModalParentDID, true, () => setShowPairSearchModal(false)), [createPairFloatingActionConfig, pairSearchModalRelation, pairSearchModalParentTID, pairSearchModalParentDID]);
+    const backToPairSearchModal = useMemo(() => {
+        if (!pairSearchContext)
+            return undefined;
+        return () => {
+            setShowPairDcmtsModal(false);
+            openPairSearchModal(pairSearchContext.relation, pairSearchContext.targetTID, pairSearchContext.qd);
+        };
+    }, [pairSearchContext, openPairSearchModal]);
     const getAllRelationsAsync = async () => {
         const tmSession = SDK_Globals.tmSession;
         try {
@@ -224,31 +240,7 @@ export const useRelatedDocuments = ({ selectedSearchResult, focusedItem, current
     };
     //This ensures archive master/detail works correctly regardless of output metadata configuration.
     const mapAssociationsToMidsAsync = useCallback(async (relation, type) => {
-        if (!relation.associations || relation.associations.length === 0)
-            return [];
-        if (!focusedItem?.TID || !focusedItem?.DID)
-            return [];
-        const searchEngine = SDK_Globals.tmSession?.NewSearchEngine();
-        if (!searchEngine)
-            return [];
-        const allMetadata = await searchEngine.GetMetadataAsync(focusedItem.TID, focusedItem.DID, false);
-        if (!allMetadata?.dtdResult?.rows?.[0] || !allMetadata.selectMIDs)
-            return [];
-        const row = allMetadata.dtdResult.rows[0];
-        const mids = allMetadata.selectMIDs;
-        const metadataMap = new Map();
-        mids.forEach((mid, index) => {
-            const value = row[index];
-            if (value !== undefined && value !== null) {
-                metadataMap.set(mid, value.toString());
-            }
-        });
-        return relation.associations.map(assoc => {
-            const sourceMid = type === 'detail' ? (assoc.item1 ?? 0) : (assoc.item2 ?? 0);
-            const targetMid = type === 'detail' ? (assoc.item2 ?? 0) : (assoc.item1 ?? 0);
-            const value = metadataMap.get(sourceMid) ?? '';
-            return { mid: targetMid, value };
-        });
+        return mapRelationAssociationsToMids(relation, type, focusedItem);
     }, [focusedItem]);
     const archiveRelatedDcmtHandler = useCallback(async (relation, type) => {
         const targetTID = type === 'detail' ? relation.detailTID : relation.masterTID;
@@ -537,6 +529,7 @@ export const useRelatedDocuments = ({ selectedSearchResult, focusedItem, current
                 dcmtsReturned: pairedDocumentsResult.dtdResult.rows.length,
                 dcmtsFound: pairedDocumentsResult.dtdResult.rows.length
             };
+            setPairSearchContext(undefined);
             setPairedSearchResults([pairedSq]);
             setIsPairingManyToMany(isPairing);
             setShowPairDcmtsModal(true);
@@ -578,6 +571,7 @@ export const useRelatedDocuments = ({ selectedSearchResult, focusedItem, current
             openPairSearchModal(relation, targetTID, qd);
             return;
         }
+        setPairSearchContext({ relation, targetTID, qd });
         setPairedSearchResults([filteredSq]);
         setIsPairingManyToMany(isPairing);
         setShowPairDcmtsModal(true);
@@ -652,6 +646,7 @@ export const useRelatedDocuments = ({ selectedSearchResult, focusedItem, current
         selectedManyToManyRelation,
         showManyToManyChooser,
         manyToManyChooserDataSource,
+        backToPairSearchModal,
         showPairSearchModal,
         pairSearchModalTargetTID,
         pairSearchModalParentTID,

package/lib/hooks/useShowDossiersV5.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Impostazione avanzata "Mostra pratiche V5": le pratiche (i dossier) sono
+ * sostituite dal CaseFlow e restano nascoste finché l'utente non le riattiva.
+ *
+ * Il valore vive in `SDKUI_Globals.userSettings.advancedSettings`, quindi la
+ * persistenza è quella delle altre impostazioni utente (per archivio e utente).
+ */
+export declare const SHOW_DOSSIERS_V5_CHANGED_EVENT = "showDossiersV5Changed";
+export declare const getShowDossiersV5: () => boolean;
+export declare const setShowDossiersV5: (value: boolean) => void;
+/** Legge l'impostazione e si aggiorna quando cambia. */
+export declare const useShowDossiersV5: () => boolean;

package/lib/hooks/useShowDossiersV5.js

@@ -0,0 +1,37 @@
+import { useEffect, useState } from 'react';
+import { SDK_Globals } from '@topconsultnpm/sdk-ts';
+import { SDKUI_Globals } from '../helper';
+/**
+ * Impostazione avanzata "Mostra pratiche V5": le pratiche (i dossier) sono
+ * sostituite dal CaseFlow e restano nascoste finché l'utente non le riattiva.
+ *
+ * Il valore vive in `SDKUI_Globals.userSettings.advancedSettings`, quindi la
+ * persistenza è quella delle altre impostazioni utente (per archivio e utente).
+ */
+export const SHOW_DOSSIERS_V5_CHANGED_EVENT = 'showDossiersV5Changed';
+export const getShowDossiersV5 = () => {
+    return SDKUI_Globals.userSettings.advancedSettings?.showDossiersV5 === 1;
+};
+export const setShowDossiersV5 = (value) => {
+    SDKUI_Globals.userSettings.advancedSettings.showDossiersV5 = value ? 1 : 0;
+    // Il setter di AdvancedSettings emette l'evento, ma dopo un ricaricamento
+    // della pagina `advancedSettings` torna da localStorage come oggetto
+    // semplice e non lo emette più: lo lanciamo anche qui, così i consumatori
+    // non dipendono da quale delle due forme è in memoria.
+    globalThis.dispatchEvent(new CustomEvent(SHOW_DOSSIERS_V5_CHANGED_EVENT, { detail: value }));
+};
+/** Legge l'impostazione e si aggiorna quando cambia. */
+export const useShowDossiersV5 = () => {
+    const sessionDescr = SDK_Globals.tmSession?.SessionDescr;
+    const archiveId = sessionDescr?.archiveID;
+    const userId = sessionDescr?.userID;
+    const [showDossiersV5, setValue] = useState(getShowDossiersV5);
+    // Le impostazioni sono per utente e archivio: al cambio sessione va riletto.
+    useEffect(() => { setValue(getShowDossiersV5()); }, [archiveId, userId]);
+    useEffect(() => {
+        const onChanged = () => setValue(getShowDossiersV5());
+        globalThis.addEventListener(SHOW_DOSSIERS_V5_CHANGED_EVENT, onChanged);
+        return () => globalThis.removeEventListener(SHOW_DOSSIERS_V5_CHANGED_EVENT, onChanged);
+    }, []);
+    return showDossiersV5;
+};

package/lib/hooks/useTMDistinctValuesMetadataDisplay.d.ts

@@ -0,0 +1,18 @@
+import { MetadataDescriptor } from '@topconsultnpm/sdk-ts';
+import { IColumnProps } from 'devextreme-react/data-grid';
+export declare const needsDisplayValue: (columnMd: MetadataDescriptor | undefined) => boolean;
+/**
+ * Resa dei valori nelle griglie di TMDistinctValues: al posto della chiave archiviata mostra la descrizione
+ * presa dalle cache di liste dati e utenti, tenendole allineate alle colonne effettivamente visualizzate.
+ *
+ * Vale per entrambe le sorgenti del pannello (valori distinti e ricerca rapida, che può essere su un altro
+ * tipo documento): le chiavi delle due sorgenti vengono accumulate e ricaricate sempre insieme, altrimenti
+ * un caricamento farebbe perdere le descrizioni dell'altra sorgente.
+ */
+export declare const useTMDistinctValuesMetadataDisplay: () => {
+    loadDisplayCachesAsync: (columnsMd: Array<MetadataDescriptor | undefined>, rows: string[][] | undefined) => Promise<void>;
+    getMetadataDisplayValue: (columnMd: MetadataDescriptor | undefined, value: any) => any;
+    displayValueColumnProps: (columnMd: MetadataDescriptor | undefined, dataField: string) => Partial<IColumnProps>;
+};
+/** Tipo di ritorno dell'hook: le sorgenti di TMDistinctValues lo ricevono come dipendenza */
+export type TMDistinctValuesMetadataDisplay = ReturnType<typeof useTMDistinctValuesMetadataDisplay>;

package/lib/hooks/useTMDistinctValuesMetadataDisplay.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useRef } from 'react';
+import { DataListViewModes, MetadataDataDomains } from '@topconsultnpm/sdk-ts';
+import { SDKUI_Localizator, stringIsNullOrEmpty } from '../helper';
+import { useDataListItem } from './useDataListItem';
+import { useDataUserIdItem } from './useDataUserIdItem';
+// Le griglie di TMDistinctValues mostrano la descrizione, non la chiave archiviata (es. TD01 -> FATTURA)
+export const needsDisplayValue = (columnMd) => columnMd?.dataDomain === MetadataDataDomains.DataList || columnMd?.dataDomain === MetadataDataDomains.UserID;
+const getCellDataListViewMode = (columnMd) => columnMd?.dataListViewMode === DataListViewModes.Description
+    ? DataListViewModes.Description
+    : DataListViewModes.ImageAndDescription;
+/**
+ * Resa dei valori nelle griglie di TMDistinctValues: al posto della chiave archiviata mostra la descrizione
+ * presa dalle cache di liste dati e utenti, tenendole allineate alle colonne effettivamente visualizzate.
+ *
+ * Vale per entrambe le sorgenti del pannello (valori distinti e ricerca rapida, che può essere su un altro
+ * tipo documento): le chiavi delle due sorgenti vengono accumulate e ricaricate sempre insieme, altrimenti
+ * un caricamento farebbe perdere le descrizioni dell'altra sorgente.
+ */
+export const useTMDistinctValuesMetadataDisplay = () => {
+    const { loadDataListsAsync, renderDataListCell, getDataListItem, hasDataList } = useDataListItem();
+    const { loadUsersAsync, renderUserIdViewer, getUserItem, getCompleteUserName, hasUser } = useDataUserIdItem();
+    // Le cache vengono sostituite con le sole chiavi richieste a ogni caricamento: qui si accumula l'insieme completo
+    const requestedDataListIDsRef = useRef(new Set());
+    const requestedUserIDsRef = useRef(new Set());
+    // I caricamenti delle due sorgenti possono sovrapporsi: la coda garantisce che l'ultimo a scrivere nelle cache sia quello con l'insieme completo di chiavi
+    const displayCachesQueueRef = useRef(Promise.resolve());
+    /** Le descrizioni vengono dalle cache di liste dati e utenti: vanno caricate prima di mostrare le righe */
+    const loadDisplayCachesAsync = useCallback(async (columnsMd, rows) => {
+        const dataListIDs = new Set();
+        const userIDs = new Set();
+        columnsMd.forEach((columnMd, index) => {
+            if (columnMd?.dataDomain === MetadataDataDomains.DataList && columnMd.dataListID) {
+                dataListIDs.add(columnMd.dataListID);
+                return;
+            }
+            if (columnMd?.dataDomain !== MetadataDataDomains.UserID)
+                return;
+            // Della cache utenti serve solo chi compare effettivamente nelle righe
+            rows?.forEach((row) => {
+                const userId = Number(row[index]);
+                if (userId && userId > 0)
+                    userIDs.add(userId);
+            });
+        });
+        if (dataListIDs.size <= 0 && userIDs.size <= 0)
+            return;
+        // In coda al caricamento precedente: l'insieme delle chiavi va calcolato quando è il turno di questa richiesta
+        const load = displayCachesQueueRef.current.then(async () => {
+            // Se tutte le chiavi richieste sono già in cache non c'è nulla da ricaricare
+            const isCacheComplete = Array.from(dataListIDs).every(id => hasDataList(id)) && Array.from(userIDs).every(id => hasUser(id));
+            if (isCacheComplete)
+                return;
+            dataListIDs.forEach(id => requestedDataListIDsRef.current.add(id));
+            userIDs.forEach(id => requestedUserIDsRef.current.add(id));
+            // Ricaricate tutte insieme: il caricamento sostituisce il contenuto delle cache
+            if (requestedDataListIDsRef.current.size > 0)
+                await loadDataListsAsync(new Set(requestedDataListIDsRef.current));
+            if (requestedUserIDsRef.current.size > 0)
+                await loadUsersAsync(new Set(requestedUserIDsRef.current));
+        });
+        // La coda non deve interrompersi per un caricamento fallito
+        displayCachesQueueRef.current = load.catch(() => { });
+        await load;
+    }, [loadDataListsAsync, loadUsersAsync, hasDataList, hasUser]);
+    const renderMetadataCell = useCallback((columnMd, cellData) => {
+        if (!cellData || cellData.value === undefined)
+            return null;
+        if (columnMd?.dataDomain === MetadataDataDomains.DataList && columnMd.dataListID) {
+            return renderDataListCell(cellData.value, columnMd.dataListID, getCellDataListViewMode(columnMd));
+        }
+        if (columnMd?.dataDomain === MetadataDataDomains.UserID) {
+            return renderUserIdViewer(Number(cellData.value), true);
+        }
+        return _jsx("div", { children: cellData.text });
+    }, [renderDataListCell, renderUserIdViewer]);
+    /** Descrizione da mostrare al posto della chiave archiviata, fuori dal contesto di una cella di griglia */
+    const getMetadataDisplayValue = useCallback((columnMd, value) => {
+        if (stringIsNullOrEmpty(value))
+            return value;
+        if (columnMd?.dataDomain === MetadataDataDomains.DataList && columnMd.dataListID) {
+            return getDataListItem(columnMd.dataListID, value)?.name ?? value;
+        }
+        if (columnMd?.dataDomain === MetadataDataDomains.UserID) {
+            const userId = Number(value);
+            if (userId === 0)
+                return SDKUI_Localizator.SystemUser;
+            const ud = getUserItem(userId);
+            return ud ? getCompleteUserName(ud.domain, ud.name) ?? value : value;
+        }
+        return value;
+    }, [getDataListItem, getUserItem, getCompleteUserName]);
+    /** Proprietà con cui una colonna mostra la descrizione al posto della chiave archiviata: vuote per i domini che non ne hanno bisogno */
+    const displayValueColumnProps = useCallback((columnMd, dataField) => {
+        if (!needsDisplayValue(columnMd))
+            return {};
+        return {
+            cellRender: (cellData) => renderMetadataCell(columnMd, cellData),
+            calculateDisplayValue: (rowData) => getMetadataDisplayValue(columnMd, rowData?.[dataField]),
+        };
+    }, [renderMetadataCell, getMetadataDisplayValue]);
+    return { loadDisplayCachesAsync, getMetadataDisplayValue, displayValueColumnProps };
+};

package/lib/hooks/useTMDistinctValuesQuickSearch.d.ts

@@ -0,0 +1,49 @@
+import { MetadataDescriptor } from '@topconsultnpm/sdk-ts';
+import { IColumnProps } from 'devextreme-react/data-grid';
+import { DistinctValuesQuickSearchSettings } from '../helper';
+import { TMDistinctValuesCounts } from './useTMDistinctValuesSource';
+import { TMDistinctValuesMetadataDisplay } from './useTMDistinctValuesMetadataDisplay';
+/** Le due sorgenti da cui TMDistinctValues può prelevare il valore del campo */
+export declare enum DistinctValuesModes {
+    DistinctValues = 0,
+    QuickSearch = 1
+}
+/** Classe applicata alla colonna del metadato configurato nella ricerca rapida: è quella da cui si prende il valore */
+export declare const QUICK_SEARCH_VALUE_COLUMN_CLASS = "tm-quick-search-value-column";
+interface ITMDistinctValuesQuickSearchParams {
+    tid: number | undefined;
+    mid: number | undefined;
+    /** Metadato del campo, dalla sorgente dei valori distinti: è il ripiego quando la ricerca rapida non è attiva */
+    md: MetadataDescriptor | undefined;
+    display: TMDistinctValuesMetadataDisplay;
+}
+/**
+ * Sorgente "ricerca rapida" di TMDistinctValues, con il selettore di modalità del pannello: la modalità esiste
+ * solo perché esiste questa sorgente, quindi le due cose vivono insieme.
+ *
+ * La ricerca rapida non filtra i valori distinti: è una sorgente alternativa da cui prelevare il valore del
+ * metadato configurato nelle impostazioni, che restano associate alla coppia (tid, mid).
+ */
+export declare const useTMDistinctValuesQuickSearch: ({ tid, mid, md, display }: ITMDistinctValuesQuickSearchParams) => {
+    mode: DistinctValuesModes;
+    isQuickSearchMode: boolean;
+    isQuickSearchGridVisible: boolean;
+    isFirstSearchPending: boolean;
+    settings: DistinctValuesQuickSearchSettings | undefined;
+    columns: IColumnProps[];
+    dataSource: any[];
+    counts: TMDistinctValuesCounts;
+    customizeColumns: (columns: Array<any>) => void;
+    valueField: string | undefined;
+    selectedValueMd: MetadataDescriptor | undefined;
+    showSettingsForm: boolean;
+    setShowSettingsForm: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    onModeChanged: (newMode: DistinctValuesModes) => void;
+    onSaveSettings: (newSettings: DistinctValuesQuickSearchSettings) => void;
+    onDeleteSettings: () => void;
+    onDeleteSettingsClick: () => void;
+    onSettingsFormClose: () => void;
+    refreshAsync: () => Promise<void>;
+    ConfirmQueryParamsDialog: () => JSX.Element;
+};
+export {};