@topconsultnpm/sdkui-react 6.19.0-dev1.20 → 6.19.0-dev1.22

package/lib/hooks/useRelatedDocuments.js

@@ -0,0 +1,629 @@
+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 { SDK_Globals, SearchEngine, RelationCacheService, RelationTypes, DcmtTypeListCacheService, SystemMIDsAsNumber } from '@topconsultnpm/sdk-ts';
+import { TMSpinner, TMExceptionBoxManager, ShowAlert } from '../components';
+export const useRelatedDocuments = ({ selectedSearchResult, focusedItem, currentSearchResults }) => {
+    const [relatedDcmts, setRelatedDcmts] = useState(undefined);
+    const [showRelatedDcmtsChooser, setShowRelatedDcmtsChooser] = useState(false);
+    const [archiveType, setArchiveType] = useState(undefined);
+    const [isOpenDetails, setIsOpenDetails] = useState(false);
+    const [isOpenMaster, setIsOpenMaster] = useState(false);
+    const [isOpenArchiveRelationForm, setIsOpenArchiveRelationForm] = useState(false);
+    const [archiveRelatedDcmtFormTID, setArchiveRelatedDcmtFormTID] = useState(undefined);
+    const [archiveRelatedDcmtFormMids, setArchiveRelatedDcmtFormMids] = useState([]);
+    const [relatedDcmtsChooserDataSource, setRelatedDcmtsChooserDataSource] = useState(undefined);
+    const [showPairDcmtsModal, setShowPairDcmtsModal] = useState(false);
+    const [isPairingManyToMany, setIsPairingManyToMany] = useState(false);
+    const [pairedSearchResults, setPairedSearchResults] = useState([]);
+    const [manyToManyRelations, setManyToManyRelations] = useState(undefined);
+    const [selectedManyToManyRelation, setSelectedManyToManyRelation] = useState(undefined);
+    const [showManyToManyChooser, setShowManyToManyChooser] = useState(false);
+    const [manyToManyChooserDataSource, setManyToManyChooserDataSource] = useState(undefined);
+    const [showPairSearchModal, setShowPairSearchModal] = useState(false);
+    const [pairSearchModalTargetTID, setPairSearchModalTargetTID] = useState(undefined);
+    const [pairSearchModalParentTID, setPairSearchModalParentTID] = useState(undefined);
+    const [pairSearchModalParentDID, setPairSearchModalParentDID] = useState(undefined);
+    const [pairSearchModalRelation, setPairSearchModalRelation] = useState(undefined);
+    const [pairSearchModalInputMids, setPairSearchModalInputMids] = useState(undefined);
+    const [currentTIDHasDetailRelations, setCurrentTIDHasDetailRelations] = useState();
+    const [currentTIDHasMasterRelations, setCurrentTIDHasMasterRelations] = useState();
+    const [canArchiveMasterRelation, setCanArchiveMasterRelation] = useState(false);
+    const [canArchiveDetailRelation, setCanArchiveDetailRelation] = useState(false);
+    const [hasManyToManyRelation, setHasManyToManyRelation] = useState(false);
+    useEffect(() => {
+        const updateRelationStates = async () => {
+            if (selectedSearchResult?.fromTID) {
+                const [hasDetail, hasMaster] = await Promise.all([
+                    hasDetailRelations(selectedSearchResult.fromTID),
+                    hasMasterRelations(selectedSearchResult.fromTID)
+                ]);
+                setCurrentTIDHasDetailRelations(hasDetail);
+                setCurrentTIDHasMasterRelations(hasMaster);
+            }
+            else {
+                setCurrentTIDHasDetailRelations(undefined);
+                setCurrentTIDHasMasterRelations(undefined);
+            }
+        };
+        updateRelationStates();
+    }, [selectedSearchResult?.fromTID]);
+    const openPairSearchModal = useCallback((relation, targetTID, qd) => {
+        if (!targetTID)
+            return;
+        const inputMidsFromQd = [];
+        if (qd?.where) {
+            for (const whereItem of qd.where) {
+                if (whereItem.mid && whereItem.value1) {
+                    inputMidsFromQd.push({
+                        mid: whereItem.mid,
+                        value: whereItem.value1
+                    });
+                }
+            }
+        }
+        setIsPairingManyToMany(true);
+        setPairSearchModalTargetTID(targetTID);
+        setPairSearchModalParentTID(Number(focusedItem.TID));
+        setPairSearchModalParentDID(Number(focusedItem.DID));
+        setPairSearchModalRelation(relation);
+        setPairSearchModalInputMids(inputMidsFromQd.length > 0 ? inputMidsFromQd : undefined);
+        setShowPairSearchModal(true);
+    }, [focusedItem]);
+    const createPairFloatingActionConfig = useCallback((relation, parentTID, parentDID, isPairing, onCloseModal) => ({
+        isVisible: true,
+        type: 'multi',
+        onClick: async (selected) => {
+            if (!relation || !parentTID || !parentDID)
+                return;
+            const parentIsMaster = parentTID === relation.masterTID;
+            const parentIsDetail = parentTID === relation.detailTID;
+            if (!parentIsMaster && !parentIsDetail)
+                return;
+            const tms = SDK_Globals.tmSession;
+            if (!tms)
+                return;
+            const se = new SearchEngine(tms);
+            try {
+                TMSpinner.show({ description: isPairing ? 'Abbinamento in corso...' : 'Disabbinamento in corso...' });
+                for (const doc of selected) {
+                    if (!doc?.TID || !doc?.DID)
+                        continue;
+                    let masterTID;
+                    let masterDID;
+                    let detailTID;
+                    let detailDID;
+                    if (parentIsMaster) {
+                        masterTID = parentTID;
+                        masterDID = parentDID;
+                        detailTID = doc.TID;
+                        detailDID = doc.DID;
+                    }
+                    else {
+                        masterTID = doc.TID;
+                        masterDID = doc.DID;
+                        detailTID = parentTID;
+                        detailDID = parentDID;
+                    }
+                    if (isPairing) {
+                        await se.ManyToManyRelateAsync(masterTID, masterDID, detailTID, detailDID);
+                    }
+                    else {
+                        await se.ManyToManyUnrelateAsync(masterTID, masterDID, detailTID, detailDID);
+                    }
+                }
+                onCloseModal();
+            }
+            catch (error) {
+                console.error('Error in onClick:', error);
+                TMExceptionBoxManager.show({ exception: error });
+            }
+            finally {
+                TMSpinner.hide();
+            }
+        },
+        iconElement: isPairing ? _jsx(IconPair, { fontSize: 26 }) : _jsx(IconUnpair, { fontSize: 26 }),
+        tooltip: isPairing ? 'Abbina' : 'Disabbina',
+    }), []);
+    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 getAllRelationsAsync = async () => {
+        const tmSession = SDK_Globals.tmSession;
+        try {
+            TMSpinner.show({ description: SDKUI_Localizator.Loading });
+            let relations = await RelationCacheService.GetAllAsync(tmSession);
+            if (!relations)
+                throw new Error("Impossibile caricare le relazioni.");
+            return relations;
+        }
+        catch (error) {
+            TMExceptionBoxManager.show({ exception: error });
+            return undefined;
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    };
+    const checkRelatedDcmtsArchiveCapability = useCallback(async () => {
+        const tid = selectedSearchResult?.fromTID;
+        if (!tid) {
+            setCanArchiveMasterRelation(false);
+            setCanArchiveDetailRelation(false);
+            return;
+        }
+        try {
+            const relations = await getAllRelationsAsync();
+            if (!relations) {
+                setCanArchiveMasterRelation(false);
+                setCanArchiveDetailRelation(false);
+                return;
+            }
+            const detailRelations = relations.filter(r => r.detailTID === tid);
+            const hasMasterWithAssociations = detailRelations.some(rel => rel.associations && rel.associations.length > 0);
+            setCanArchiveMasterRelation(hasMasterWithAssociations);
+            const masterRelations = relations.filter(r => r.masterTID === tid);
+            const hasDetailWithAssociations = masterRelations.some(rel => rel.associations && rel.associations.length > 0);
+            setCanArchiveDetailRelation(hasDetailWithAssociations);
+        }
+        catch (error) {
+            console.error("Error checking archive capability:", error);
+            setCanArchiveMasterRelation(false);
+            setCanArchiveDetailRelation(false);
+        }
+    }, [selectedSearchResult?.fromTID]);
+    const checkManyToManyCapability = useCallback(async () => {
+        const tid = selectedSearchResult?.fromTID;
+        if (!tid) {
+            setHasManyToManyRelation(false);
+            return;
+        }
+        try {
+            const relations = await getAllRelationsAsync();
+            if (!relations) {
+                setHasManyToManyRelation(false);
+                return;
+            }
+            const manyToManyRels = relations.filter(r => r.relationType === RelationTypes.ManyToMany &&
+                (r.masterTID === tid || r.detailTID === tid));
+            setHasManyToManyRelation(manyToManyRels.length > 0);
+        }
+        catch (error) {
+            console.error("Error checking many-to-many capability:", error);
+            setHasManyToManyRelation(false);
+        }
+    }, [selectedSearchResult?.fromTID]);
+    const getFocusedItem = useCallback(() => {
+        if (!focusedItem || currentSearchResults.length !== 1)
+            return undefined;
+        return { mdList: currentSearchResults[0].dtdResult?.rows?.[focusedItem?.rowIndex ?? 0], mids: currentSearchResults[0].selectMIDs ?? [] };
+    }, [focusedItem, currentSearchResults]);
+    const fetchAssociatedValues = useCallback((mid) => {
+        let mdList = getFocusedItem();
+        if (!mdList)
+            return;
+        let index = mdList.mids.findIndex(m => m == mid);
+        if (index === -1)
+            return;
+        return mdList.mdList?.[index];
+    }, [getFocusedItem]);
+    const filterRelationsByType = (relations, tid, type) => {
+        return type === 'detail'
+            ? relations.filter(r => r.masterTID == tid)
+            : relations.filter(r => r.detailTID == tid);
+    };
+    const filterRelationsWithAssociations = (relations) => {
+        return relations.filter(rel => rel.associations && rel.associations.length > 0);
+    };
+    const getRelatedDcmt = async (relation, type) => {
+        return await DcmtTypeListCacheService.GetAsync(type === 'detail' ? relation.detailTID : relation.masterTID);
+    };
+    const showNoRelationsAlert = (type) => {
+        ShowAlert({
+            message: type === 'detail'
+                ? "Nessun documento di dettaglio trovato per l'archiviazione."
+                : "Nessun documento di master trovato per l'archiviazione.",
+            mode: 'info',
+            title: type === 'detail' ? SDKUI_Localizator.DcmtsDetail : SDKUI_Localizator.DcmtsMaster,
+            duration: 5000
+        });
+    };
+    const showNoAssociationsAlert = (type) => {
+        ShowAlert({
+            message: type === 'detail'
+                ? "Nessuna associazione trovata per i documenti di dettaglio."
+                : "Nessuna associazione trovata per i documenti di master.",
+            mode: 'info',
+            title: type === 'detail' ? SDKUI_Localizator.DcmtsDetail : SDKUI_Localizator.DcmtsMaster,
+            duration: 5000
+        });
+    };
+    const mapAssociationsToMids = useCallback((relation, type) => {
+        return relation.associations?.map(assoc => ({
+            mid: type === 'detail' ? (assoc.item2 ?? 0) : (assoc.item1 ?? 0),
+            value: fetchAssociatedValues(type === 'detail' ? (assoc.item1 ?? 0) : (assoc.item2 ?? 0)) ?? ''
+        })) ?? [];
+    }, [fetchAssociatedValues]);
+    const archiveRelatedDcmtHandler = useCallback((relation, type) => {
+        const targetTID = type === 'detail' ? relation.detailTID : relation.masterTID;
+        if (!targetTID)
+            return;
+        const mids = mapAssociationsToMids(relation, type);
+        setArchiveType(type);
+        setArchiveRelatedDcmtFormTID(targetTID);
+        setArchiveRelatedDcmtFormMids(mids);
+        setIsOpenArchiveRelationForm(true);
+    }, [mapAssociationsToMids]);
+    const archiveRelatedDocuments = useCallback(async (tid, type) => {
+        try {
+            TMSpinner.show({ description: SDKUI_Localizator.Loading });
+            const relations = await getAllRelationsAsync();
+            if (!relations || !tid)
+                return;
+            const filteredRelations = filterRelationsByType(relations, tid, type);
+            if (!filteredRelations || filteredRelations.length === 0) {
+                showNoRelationsAlert(type);
+                return;
+            }
+            const withAssociations = filterRelationsWithAssociations(filteredRelations);
+            if (withAssociations.length === 0) {
+                showNoAssociationsAlert(type);
+                return;
+            }
+            setRelatedDcmts(withAssociations);
+            if (withAssociations.length > 1) {
+                const dataSourcePromises = withAssociations.map(async (rel) => {
+                    const relatedDcmt = await getRelatedDcmt(rel, type);
+                    return { id: rel?.id, name: relatedDcmt?.name };
+                });
+                const dataSource = await Promise.all(dataSourcePromises);
+                setRelatedDcmtsChooserDataSource(dataSource);
+                setArchiveType(type);
+                setShowRelatedDcmtsChooser(true);
+            }
+            else {
+                archiveRelatedDcmtHandler(withAssociations[0], type);
+            }
+        }
+        catch (error) {
+            TMExceptionBoxManager.show({ exception: error });
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    }, [archiveRelatedDcmtHandler]);
+    const archiveDetailDocuments = useCallback(async (tid) => {
+        await archiveRelatedDocuments(tid, 'detail');
+    }, [archiveRelatedDocuments]);
+    const archiveMasterDocuments = useCallback(async (tid) => {
+        await archiveRelatedDocuments(tid, 'master');
+    }, [archiveRelatedDocuments]);
+    const getPairedDocuments = async (relation, currentTID, currentDID, searchEngine) => {
+        if (!relation || !currentDID)
+            return null;
+        try {
+            const isMaster = currentTID === relation.masterTID;
+            const pairedResults = isMaster
+                ? await searchEngine.GetAllDetailDcmtsAsync(currentTID, currentDID)
+                : await searchEngine.GetAllMasterDcmtsAsync(currentTID, currentDID);
+            if (!pairedResults || pairedResults.length === 0)
+                return null;
+            const relationResult = pairedResults.find(r => r.relationID === relation.id);
+            if (!relationResult?.dtdResult)
+                return null;
+            return relationResult;
+        }
+        catch (error) {
+            console.error('getPairedDocuments - Error:', error);
+            return null;
+        }
+    };
+    const extractPairedDIDs = (relationResult) => {
+        const pairedDIDs = [];
+        const rows = relationResult.dtdResult?.rows ?? [];
+        const columns = relationResult.dtdResult?.columns ?? [];
+        const didColumnIndex = columns.findIndex(col => {
+            const caption = col.caption?.toUpperCase();
+            const mid = col.extendedProperties?.["MID"];
+            const midNum = typeof mid === 'string' ? Number.parseInt(mid, 10) : mid;
+            return caption === 'DID' || midNum === 5;
+        });
+        if (didColumnIndex === -1)
+            return [];
+        for (const row of rows) {
+            const did = row[didColumnIndex];
+            if (did) {
+                const didNumber = typeof did === 'string' ? Number.parseInt(did, 10) : did;
+                if (!Number.isNaN(didNumber)) {
+                    pairedDIDs.push(didNumber);
+                }
+            }
+        }
+        return pairedDIDs;
+    };
+    const executeManyToManyPairing = useCallback(async (relation, isPairing) => {
+        const searchEngine = SDK_Globals.tmSession?.NewSearchEngine();
+        if (!focusedItem?.TID || !focusedItem?.DID) {
+            ShowAlert({
+                message: "Nessun documento selezionato per l'operazione molti-a-molti.",
+                mode: 'warning',
+                title: 'Operazione molti-a-molti',
+                duration: 5000
+            });
+            return;
+        }
+        setSelectedManyToManyRelation(relation);
+        let qd;
+        if (relation.detailTID === selectedSearchResult?.fromTID) {
+            qd = relation.retrieveMastersQuery;
+        }
+        if (relation.masterTID === selectedSearchResult?.fromTID) {
+            qd = relation.retrieveDetailsQuery;
+        }
+        if (!qd) {
+            ShowAlert({
+                message: "Nessuna query di recupero associata alla relazione molti-a-molti.",
+                mode: 'warning',
+                title: 'Operazione molti-a-molti',
+                duration: 5000
+            });
+            return;
+        }
+        qd = structuredClone(qd);
+        if (qd.select) {
+            for (const s of qd.select) {
+                s.visibility = 1;
+            }
+        }
+        const qdRetrieveParamsValue = {
+            from: { tid: focusedItem.TID },
+            select: [],
+            where: [
+                {
+                    tid: focusedItem.TID,
+                    mid: 5,
+                    leftBrackets: "(",
+                    rightBrackets: ")",
+                    operator: 0,
+                    value1: focusedItem.DID.toString()
+                }
+            ]
+        };
+        let notMappedMIDs = false;
+        if (qd.params && qd.params.length > 0) {
+            for (const param of qd.params) {
+                if (!param.mappedMID)
+                    continue;
+                qdRetrieveParamsValue.select.push({
+                    tid: param.mappedTID ?? focusedItem.TID,
+                    mid: param.mappedMID,
+                    visibility: 1
+                });
+                const currentRowValue = currentSearchResults[0]?.dtdResult?.rows?.[focusedItem.rowIndex];
+                const midIndex = currentSearchResults[0]?.selectMIDs?.indexOf(param.mappedMID);
+                if (currentRowValue && midIndex !== undefined && midIndex >= 0) {
+                    const value = currentRowValue[midIndex];
+                    param.value = value ?? '';
+                    if (param.value === null || param.value === '')
+                        notMappedMIDs = true;
+                }
+                else {
+                    notMappedMIDs = true;
+                }
+            }
+            if (notMappedMIDs && qdRetrieveParamsValue.select && qdRetrieveParamsValue.select.length > 0) {
+                const paramMetadata = await searchEngine.SearchByIDAsync(qdRetrieveParamsValue);
+                if (paramMetadata?.dtdResult?.rows?.[0]) {
+                    for (const param of qd.params) {
+                        if (!param.mappedMID)
+                            continue;
+                        const colIndex = paramMetadata.selectMIDs?.indexOf(param.mappedMID);
+                        if (colIndex !== undefined && colIndex >= 0) {
+                            const value = paramMetadata.dtdResult.rows[0][colIndex];
+                            param.value = value ?? '';
+                        }
+                    }
+                }
+            }
+            if (qd.where && qd.where.length > 0) {
+                for (const whereItem of qd.where) {
+                    for (const param of qd.params) {
+                        if (!param.name)
+                            continue;
+                        param.value ??= '';
+                        const paramValue = param.value.toString();
+                        if (whereItem.value1) {
+                            whereItem.value1 = whereItem.value1.replace(param.name, paramValue);
+                        }
+                        if (whereItem.value2) {
+                            whereItem.value2 = whereItem.value2.replace(param.name, paramValue);
+                        }
+                    }
+                }
+            }
+        }
+        const targetTID = relation.detailTID === selectedSearchResult?.fromTID
+            ? relation.masterTID
+            : relation.detailTID;
+        const systemSelects = [
+            { tid: targetTID, mid: SystemMIDsAsNumber.DID, visibility: 0 },
+            { tid: targetTID, mid: SystemMIDsAsNumber.TID, visibility: 0 },
+            { tid: targetTID, mid: SystemMIDsAsNumber.OwnerID, visibility: 0 },
+            { tid: targetTID, mid: SystemMIDsAsNumber.UpdaterID, visibility: 0 },
+            { tid: targetTID, mid: SystemMIDsAsNumber.FileExt, visibility: 0 },
+            { tid: targetTID, mid: SystemMIDsAsNumber.CreationTime, visibility: 0 },
+            { tid: targetTID, mid: SystemMIDsAsNumber.LastUpdateTime, visibility: 0 },
+            { tid: targetTID, mid: SystemMIDsAsNumber.FileCount, visibility: 0 },
+            { tid: targetTID, mid: SystemMIDsAsNumber.FileSize, visibility: 0 },
+            { tid: targetTID, mid: SystemMIDsAsNumber.PageCount, visibility: 0 },
+        ];
+        if (qd.select) {
+            qd.select = [...systemSelects, ...qd.select];
+        }
+        else {
+            qd.select = systemSelects;
+        }
+        const pairedDocumentsResult = await getPairedDocuments(relation, focusedItem.TID, focusedItem.DID, searchEngine);
+        if (!isPairing) {
+            if (!pairedDocumentsResult?.dtdResult?.rows || pairedDocumentsResult.dtdResult.rows.length === 0) {
+                ShowAlert({
+                    message: "Nessun documento abbinato trovato.",
+                    mode: 'warning',
+                    title: 'Operazione molti-a-molti',
+                    duration: 5000
+                });
+                return;
+            }
+            const pairedSq = {
+                fromTID: targetTID,
+                fromName: await DcmtTypeListCacheService.GetAsync(targetTID).then(d => d?.name ?? ''),
+                dtdResult: pairedDocumentsResult.dtdResult,
+                selectMIDs: pairedDocumentsResult.selectMIDs,
+                relationID: relation.id,
+                dcmtsReturned: pairedDocumentsResult.dtdResult.rows.length,
+                dcmtsFound: pairedDocumentsResult.dtdResult.rows.length
+            };
+            setPairedSearchResults([pairedSq]);
+            setIsPairingManyToMany(isPairing);
+            setShowPairDcmtsModal(true);
+            return;
+        }
+        const sq = await searchEngine.SearchByIDAsync(qd);
+        if (!sq?.dtdResult?.rows || sq.dtdResult.rows.length === 0) {
+            ShowAlert({
+                message: "Nessun documento trovato.",
+                mode: 'warning',
+                title: 'Operazione molti-a-molti',
+                duration: 5000
+            });
+            openPairSearchModal(relation, targetTID, qd);
+            return;
+        }
+        const pairedDIDs = pairedDocumentsResult ? extractPairedDIDs(pairedDocumentsResult) : [];
+        const filteredRows = sq.dtdResult.rows.filter(row => {
+            const did = row[0];
+            const didNum = typeof did === 'string' ? Number.parseInt(did, 10) : did;
+            return !pairedDIDs.includes(didNum);
+        });
+        const filteredSq = {
+            ...sq,
+            dtdResult: {
+                ...sq.dtdResult,
+                rows: filteredRows
+            },
+            dcmtsReturned: filteredRows.length,
+            dcmtsFound: filteredRows.length
+        };
+        if (filteredRows.length === 0) {
+            ShowAlert({
+                message: "Nessun documento da abbinare. Tutti i documenti risultanti sono già abbinati.",
+                mode: 'warning',
+                title: 'Operazione molti-a-molti',
+                duration: 5000
+            });
+            openPairSearchModal(relation, targetTID, qd);
+            return;
+        }
+        setPairedSearchResults([filteredSq]);
+        setIsPairingManyToMany(isPairing);
+        setShowPairDcmtsModal(true);
+    }, [focusedItem, selectedSearchResult, currentSearchResults, openPairSearchModal]);
+    const pairManyToMany = useCallback(async (isPairing) => {
+        try {
+            TMSpinner.show({ description: SDKUI_Localizator.Loading });
+            const relations = await getAllRelationsAsync();
+            if (!relations)
+                return;
+            if (!relations.some(r => r.relationType === RelationTypes.ManyToMany)) {
+                ShowAlert({
+                    message: "Nessuna relazione molti-a-molti definita nel sistema.",
+                    mode: 'warning',
+                    title: 'Operazione molti-a-molti',
+                    duration: 5000
+                });
+                return;
+            }
+            const manyToManyRels = relations.filter(r => r.relationType === RelationTypes.ManyToMany);
+            if (!manyToManyRels.some(r => r.masterTID === selectedSearchResult?.fromTID || r.detailTID === selectedSearchResult?.fromTID)) {
+                ShowAlert({
+                    message: "Nessuna relazione molti-a-molti definita per il tipo di documento selezionato.",
+                    mode: 'warning',
+                    title: 'Operazione molti-a-molti',
+                    duration: 5000
+                });
+                return;
+            }
+            const relsManyToMany = manyToManyRels.filter(r => r.masterTID === selectedSearchResult?.fromTID || r.detailTID === selectedSearchResult?.fromTID);
+            setManyToManyRelations(relsManyToMany);
+            if (relsManyToMany.length > 1) {
+                const dataSourcePromises = relsManyToMany.map(async (rel) => {
+                    const targetTID = rel.masterTID === selectedSearchResult?.fromTID ? rel.detailTID : rel.masterTID;
+                    const relatedDcmt = await DcmtTypeListCacheService.GetAsync(targetTID);
+                    return { id: rel?.id, name: relatedDcmt?.name };
+                });
+                const dataSource = await Promise.all(dataSourcePromises);
+                setManyToManyChooserDataSource(dataSource);
+                setIsPairingManyToMany(isPairing);
+                setShowManyToManyChooser(true);
+            }
+            else {
+                await executeManyToManyPairing(relsManyToMany[0], isPairing);
+            }
+        }
+        catch (error) {
+            TMExceptionBoxManager.show({ exception: error });
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    }, [selectedSearchResult, executeManyToManyPairing]);
+    return {
+        relatedDcmts,
+        showRelatedDcmtsChooser,
+        archiveType,
+        isOpenDetails,
+        isOpenMaster,
+        isOpenArchiveRelationForm,
+        archiveRelatedDcmtFormTID,
+        archiveRelatedDcmtFormMids,
+        relatedDcmtsChooserDataSource,
+        showPairDcmtsModal,
+        isPairingManyToMany,
+        pairedSearchResults,
+        manyToManyRelations,
+        selectedManyToManyRelation,
+        showManyToManyChooser,
+        manyToManyChooserDataSource,
+        showPairSearchModal,
+        pairSearchModalTargetTID,
+        pairSearchModalParentTID,
+        pairSearchModalParentDID,
+        pairSearchModalRelation,
+        pairSearchModalInputMids,
+        currentTIDHasDetailRelations,
+        currentTIDHasMasterRelations,
+        canArchiveMasterRelation,
+        canArchiveDetailRelation,
+        hasManyToManyRelation,
+        setIsOpenDetails,
+        setIsOpenMaster,
+        setShowRelatedDcmtsChooser,
+        setShowManyToManyChooser,
+        setShowPairDcmtsModal,
+        setShowPairSearchModal,
+        setIsOpenArchiveRelationForm,
+        setArchiveType,
+        setArchiveRelatedDcmtFormTID,
+        setArchiveRelatedDcmtFormMids,
+        pairFloatingActionConfig,
+        pairSearchModalFloatingActionConfig,
+        archiveMasterDocuments,
+        archiveDetailDocuments,
+        pairManyToMany,
+        checkRelatedDcmtsArchiveCapability,
+        checkManyToManyCapability,
+        archiveRelatedDcmtHandler,
+        executeManyToManyPairing,
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@topconsultnpm/sdkui-react",
-    "version": "6.19.0-dev1.20",
+    "version": "6.19.0-dev1.22",
     "description": "",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1",