@topconsultnpm/sdkui-react 6.22.0-dev2.3 → 6.22.0-dev2.30

package/lib/helper/SDKUI_Localizator.js

@@ -444,6 +444,16 @@ export class SDKUI_Localizator {
             default: return "Consenti solo archiviazioni di metadati";
         }
     }
+    static get ArchivedDetails() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Bereits archivierte Details";
+            case CultureIDs.En_US: return "Already archived details";
+            case CultureIDs.Es_ES: return "Detalles ya archivados";
+            case CultureIDs.Fr_FR: return "Détails déjà archivés";
+            case CultureIDs.Pt_PT: return "Detalhes já arquivados";
+            default: return "Dettagli già archiviati";
+        }
+    }
     static get ArchivedDocuments() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Archivierte Dokumente";
@@ -484,6 +494,46 @@ export class SDKUI_Localizator {
             default: return "Archivia documento master";
         }
     }
+    static get ArchiveMultipleDetailDocuments() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Mehrere Details archivieren";
+            case CultureIDs.En_US: return "Archive multiple details";
+            case CultureIDs.Es_ES: return "Archivar múltiples detalles";
+            case CultureIDs.Fr_FR: return "Archiver plusieurs détails";
+            case CultureIDs.Pt_PT: return "Arquivar múltiplos detalhes";
+            default: return "Archivia dettagli multipli";
+        }
+    }
+    static get ArchiveMasterAndMultipleDetailDocuments() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Master mit mehreren Details archivieren";
+            case CultureIDs.En_US: return "Archive master with multiple details";
+            case CultureIDs.Es_ES: return "Archivar maestro con múltiples detalles";
+            case CultureIDs.Fr_FR: return "Archiver le maître avec plusieurs détails";
+            case CultureIDs.Pt_PT: return "Arquivar mestre com múltiplos detalhes";
+            default: return "Archivia master con dettagli multipli";
+        }
+    }
+    static get ArchiveMasterAndDetails_Confirm() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Master archivieren und mit den Details fortfahren?";
+            case CultureIDs.En_US: return "Archive the master and proceed with the details?";
+            case CultureIDs.Es_ES: return "¿Archivar el maestro y continuar con los detalles?";
+            case CultureIDs.Fr_FR: return "Archiver le maître et poursuivre avec les détails ?";
+            case CultureIDs.Pt_PT: return "Arquivar o mestre e prosseguir com os detalhes?";
+            default: return "Archiviare il master e proseguire con i dettagli?";
+        }
+    }
+    static get ExitWithoutArchiving_Confirm() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Möchten Sie wirklich beenden? Die eingegebenen Dokumente werden nicht archiviert. Fortfahren?";
+            case CultureIDs.En_US: return "Are you sure you want to exit? The entered documents will not be archived. Continue?";
+            case CultureIDs.Es_ES: return "¿Está seguro de que desea salir? Los documentos introducidos no se archivarán. ¿Continuar?";
+            case CultureIDs.Fr_FR: return "Êtes-vous sûr de vouloir quitter ? Les documents saisis ne seront pas archivés. Continuer ?";
+            case CultureIDs.Pt_PT: return "Tem a certeza de que pretende sair? Os documentos introduzidos não serão arquivados. Continuar?";
+            default: return "Sei sicuro di voler uscire? I documenti inseriti non verranno archiviati. Continuare?";
+        }
+    }
     static get Archiving() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Archivierung";
@@ -715,6 +765,16 @@ export class SDKUI_Localizator {
             default: return "Indietro";
         }
     }
+    static get BackToResult() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Zum Ergebnis";
+            case CultureIDs.En_US: return "Go to result";
+            case CultureIDs.Es_ES: return "Ir al resultado";
+            case CultureIDs.Fr_FR: return "Aller au résultat";
+            case CultureIDs.Pt_PT: return "Ir para o resultado";
+            default: return "Vai a risultato";
+        }
+    }
     static get BatchUpdate() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Mehrfachbearbeitung";
@@ -1662,6 +1722,16 @@ export class SDKUI_Localizator {
             default: return "Dettagli";
         }
     }
+    static get DetailsToArchive() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Zu archivierende Details";
+            case CultureIDs.En_US: return "Details to archive";
+            case CultureIDs.Es_ES: return "Detalles a archivar";
+            case CultureIDs.Fr_FR: return "Détails à archiver";
+            case CultureIDs.Pt_PT: return "Detalhes a arquivar";
+            default: return "Dettagli da archiviare";
+        }
+    }
     static get Delete() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Löschen";
@@ -1702,6 +1772,16 @@ export class SDKUI_Localizator {
             default: return "Eliminare il commento?";
         }
     }
+    static get DeleteAllRowsToChangeDcmtType() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Löschen Sie alle Zeilen, um den Dokumenttyp zu ändern";
+            case CultureIDs.En_US: return "Delete all rows to change the document type";
+            case CultureIDs.Es_ES: return "Elimine todas las filas para poder cambiar el tipo de documento";
+            case CultureIDs.Fr_FR: return "Supprimez toutes les lignes pour pouvoir changer le type de document";
+            case CultureIDs.Pt_PT: return "Elimine todas as linhas para poder alterar o tipo de documento";
+            default: return "Elimina tutte le righe per poter cambiare tipo documento";
+        }
+    }
     static get DeleteDeletedMessages() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Gelöschte Nachrichten löschen";
@@ -4008,6 +4088,36 @@ export class SDKUI_Localizator {
             default: return "Nascondi tutti";
         }
     }
+    static get HideArchivedDetails() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Bereits archivierte Details ausblenden";
+            case CultureIDs.En_US: return "Hide already archived details";
+            case CultureIDs.Es_ES: return "Ocultar los detalles ya archivados";
+            case CultureIDs.Fr_FR: return "Masquer les détails déjà archivés";
+            case CultureIDs.Pt_PT: return "Ocultar os detalhes já arquivados";
+            default: return "Nascondi i dettagli già archiviati";
+        }
+    }
+    static get HideDcmtTypes() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Dokumenttypen ausblenden";
+            case CultureIDs.En_US: return "Hide document types";
+            case CultureIDs.Es_ES: return "Ocultar tipos de documento";
+            case CultureIDs.Fr_FR: return "Masquer les types de document";
+            case CultureIDs.Pt_PT: return "Ocultar tipos de documento";
+            default: return "Nascondi tipi documento";
+        }
+    }
+    static get HideDetailsToArchive() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Zu archivierende Details ausblenden";
+            case CultureIDs.En_US: return "Hide details to archive";
+            case CultureIDs.Es_ES: return "Ocultar los detalles a archivar";
+            case CultureIDs.Fr_FR: return "Masquer les détails à archiver";
+            case CultureIDs.Pt_PT: return "Ocultar os detalhes a arquivar";
+            default: return "Nascondi i dettagli da archiviare";
+        }
+    }
     static get HideDetailsWithZeroDocs() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Details mit 0 Dokumenten ausblenden";
@@ -4058,6 +4168,16 @@ export class SDKUI_Localizator {
             default: return "Nascondi opzioni di formattazione";
         }
     }
+    static get HideMasterInfo() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Master-Informationen ausblenden";
+            case CultureIDs.En_US: return "Hide master information";
+            case CultureIDs.Es_ES: return "Ocultar la información del maestro";
+            case CultureIDs.Fr_FR: return "Masquer les informations du maître";
+            case CultureIDs.Pt_PT: return "Ocultar as informações do mestre";
+            default: return "Nascondi le informazioni del master";
+        }
+    }
     static get HideMetadata() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Metadaten ausblenden";
@@ -6522,6 +6642,16 @@ export class SDKUI_Localizator {
             default: return "Valorizza parametri query";
         }
     }
+    static get QuickSearchSettings_DeleteConfirmFor1() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Schnellsuche-Konfiguration für '{{0}}' löschen?";
+            case CultureIDs.En_US: return "Delete the quick search setup for '{{0}}'?";
+            case CultureIDs.Es_ES: return "¿Eliminar la configuración de la búsqueda rápida de '{{0}}'?";
+            case CultureIDs.Fr_FR: return "Supprimer la configuration de la recherche rapide de '{{0}}' ?";
+            case CultureIDs.Pt_PT: return "Eliminar a configuração da pesquisa rápida de '{{0}}'?";
+            default: return "Eliminare la configurazione della ricerca rapida di '{{0}}'?";
+        }
+    }
     static get ReadOnly() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Nur Lesen";
@@ -6623,6 +6753,26 @@ export class SDKUI_Localizator {
             default: return "Nessuna correlazione trovata";
         }
     }
+    static get StopRelationsCalculation() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Berechnung unterbrechen und die bereits berechneten Korrelationen anzeigen";
+            case CultureIDs.En_US: return "Stop the calculation and show the already calculated correlations";
+            case CultureIDs.Es_ES: return "Interrumpir el cálculo y mostrar las correlaciones ya calculadas";
+            case CultureIDs.Fr_FR: return "Interrompre le calcul et afficher les corrélations déjà calculées";
+            case CultureIDs.Pt_PT: return "Interromper o cálculo e mostrar as correlações já calculadas";
+            default: return "Interrompi il calcolo e mostra le correlazioni già calcolate";
+        }
+    }
+    static get RelationsCalculationStopped() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Berechnung der Korrelationen unterbrochen: Es werden nur die bereits berechneten Korrelationen angezeigt.";
+            case CultureIDs.En_US: return "Correlations calculation stopped: only the already calculated correlations are shown.";
+            case CultureIDs.Es_ES: return "Cálculo de correlaciones interrumpido: solo se muestran las correlaciones ya calculadas.";
+            case CultureIDs.Fr_FR: return "Calcul des corrélations interrompu : seules les corrélations déjà calculées sont affichées.";
+            case CultureIDs.Pt_PT: return "Cálculo das correlações interrompido: são mostradas apenas as correlações já calculadas.";
+            default: return "Calcolo delle correlazioni interrotto: vengono mostrate solo le correlazioni già calcolate.";
+        }
+    }
     static get RelatedDcmtsNotFound() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Für das ausgewählte Dokument wurden keine zugehörigen Dokumente gefunden.";
@@ -6663,6 +6813,16 @@ export class SDKUI_Localizator {
             default: return "Rimuovi filtro contestuale";
         }
     }
+    static get RemoveDetailFromSummary_Confirm() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Detail entfernen? Es wird nicht archiviert.";
+            case CultureIDs.En_US: return "Remove this detail? It won't be archived.";
+            case CultureIDs.Es_ES: return "¿Eliminar este detalle? No se archivará.";
+            case CultureIDs.Fr_FR: return "Supprimer ce détail ? Il ne sera pas archivé.";
+            case CultureIDs.Pt_PT: return "Remover este detalhe? Não será arquivado.";
+            default: return "Rimuovere questo dettaglio? Non verrà archiviato.";
+        }
+    }
     static get RemoveFromCache() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Element aus Cache entfernen";
@@ -7149,6 +7309,16 @@ export class SDKUI_Localizator {
             default: return "Cerca";
         }
     }
+    static get SearchAndAppend() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Suchen und anhängen";
+            case CultureIDs.En_US: return "Search and append";
+            case CultureIDs.Es_ES: return "Buscar y añadir";
+            case CultureIDs.Fr_FR: return "Rechercher et ajouter";
+            case CultureIDs.Pt_PT: return "Pesquisar e acrescentar";
+            default: return "Ricerca e accoda";
+        }
+    }
     static get Search_Advanced() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Erweiterte Suche";
@@ -7259,6 +7429,16 @@ export class SDKUI_Localizator {
             default: return "Seleziona un documento per visualizzare i dettagli";
         }
     }
+    static get SelectDcmtTypeForDetailArchiving() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Dokumenttyp auswählen, für den die Details archiviert werden sollen";
+            case CultureIDs.En_US: return "Select the document type for which to archive the details";
+            case CultureIDs.Es_ES: return "Seleccionar el tipo de documento sobre el cual archivar los detalles";
+            case CultureIDs.Fr_FR: return "Sélectionner le type de document sur lequel archiver les détails";
+            case CultureIDs.Pt_PT: return "Selecionar o tipo de documento no qual arquivar os detalhes";
+            default: return "Selezionare il tipo documento sul quale effettuare l'archiviazione dei dettagli";
+        }
+    }
     static get SelectArchiveToStart() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Klicken Sie auf Archivieren, um zu beginnen.";
@@ -7590,6 +7770,16 @@ export class SDKUI_Localizator {
             default: return "Mostra tutti";
         }
     }
+    static get ShowArchivedDetails() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Bereits archivierte Details anzeigen";
+            case CultureIDs.En_US: return "Show already archived details";
+            case CultureIDs.Es_ES: return "Mostrar los detalles ya archivados";
+            case CultureIDs.Fr_FR: return "Afficher les détails déjà archivés";
+            case CultureIDs.Pt_PT: return "Mostrar os detalhes já arquivados";
+            default: return "Mostra i dettagli già archiviati";
+        }
+    }
     static get ShowColumnSelection() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Spaltenauswahl anzeigen";
@@ -7600,6 +7790,16 @@ export class SDKUI_Localizator {
             default: return "Mostra selezione colonne";
         }
     }
+    static get ShowDcmtTypes() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Dokumenttypen anzeigen";
+            case CultureIDs.En_US: return "Show document types";
+            case CultureIDs.Es_ES: return "Mostrar tipos de documento";
+            case CultureIDs.Fr_FR: return "Afficher les types de document";
+            case CultureIDs.Pt_PT: return "Mostrar tipos de documento";
+            default: return "Mostra tipi documento";
+        }
+    }
     static get ShowFloatingBar() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Floating-Leiste anzeigen";
@@ -7640,6 +7840,16 @@ export class SDKUI_Localizator {
             default: return "Mostra dettagli";
         }
     }
+    static get ShowDetailsToArchive() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Zu archivierende Details anzeigen";
+            case CultureIDs.En_US: return "Show details to archive";
+            case CultureIDs.Es_ES: return "Mostrar los detalles a archivar";
+            case CultureIDs.Fr_FR: return "Afficher les détails à archiver";
+            case CultureIDs.Pt_PT: return "Mostrar os detalhes a arquivar";
+            default: return "Mostra i dettagli da archiviare";
+        }
+    }
     static get ShowDetailsWithZeroDocs() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Details mit 0 Dokumenten anzeigen";
@@ -7690,6 +7900,26 @@ export class SDKUI_Localizator {
             default: return "Mostra il pannello sinistro";
         }
     }
+    static get ShowMasterInfo() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Master-Informationen anzeigen";
+            case CultureIDs.En_US: return "Show master information";
+            case CultureIDs.Es_ES: return "Mostrar la información del maestro";
+            case CultureIDs.Fr_FR: return "Afficher les informations du maître";
+            case CultureIDs.Pt_PT: return "Mostrar as informações do mestre";
+            default: return "Mostra le informazioni del master";
+        }
+    }
+    static get ShowPartialResults() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Teilergebnisse anzeigen";
+            case CultureIDs.En_US: return "Show partial results";
+            case CultureIDs.Es_ES: return "Mostrar resultados parciales";
+            case CultureIDs.Fr_FR: return "Afficher les résultats partiels";
+            case CultureIDs.Pt_PT: return "Mostrar resultados parciais";
+            default: return "Mostra risultati parziali";
+        }
+    }
     static get ShowSearch() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Suche anzeigen";
@@ -7950,6 +8180,16 @@ export class SDKUI_Localizator {
             default: return "Stato e risposta";
         }
     }
+    static get StopOnFirstError() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Beim ersten Fehler abbrechen";
+            case CultureIDs.En_US: return "Stop at the first error";
+            case CultureIDs.Es_ES: return "Detener en el primer error";
+            case CultureIDs.Fr_FR: return "Arrêter à la première erreur";
+            case CultureIDs.Pt_PT: return "Parar no primeiro erro";
+            default: return "Interrompi al primo errore";
+        }
+    }
     static get Subject() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Betreff";

package/lib/helper/TMIcons.d.ts

@@ -271,6 +271,7 @@ export declare function IconWizard4(props: React.SVGProps<SVGSVGElement>): impor
 export declare function IconNew(props: React.SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;
 export declare function IconFileOpenOutline(props: Readonly<React.SVGProps<SVGSVGElement>>): import("react/jsx-runtime").JSX.Element;
 export declare function IconArchiveDetail(props: React.SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;
+export declare function IconArchiveMultipleDetailDocuments(props: React.SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;
 export declare function IconArchiveMaster(props: React.SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;
 export declare function IconPair(props: React.SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;
 export declare function IconUnpair(props: React.SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;

package/lib/helper/TMIcons.js

@@ -673,6 +673,9 @@ export function IconFileOpenOutline(props) {
 export function IconArchiveDetail(props) {
     return (_jsxs("svg", { fontSize: props.fontSize ?? FONTSIZE, xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", width: "1em", height: "1em", ...props, children: [" ", _jsx("path", { fill: "currentColor", d: "m20.54 5.23l-1.39-1.68C18.88 3.21 18.47 3 18 3H6c-.47 0-.88.21-1.16.55L3.46 5.23C3.17 5.57 3 6.02 3 6.5V19c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6.5c0-.48-.17-.93-.46-1.27M12 17.5L6.5 12H10v-2h4v2h3.5zM5.12 5l.81-1h12l.94 1z" }), " "] }));
 }
+export function IconArchiveMultipleDetailDocuments(props) {
+    return (_jsxs("svg", { fontSize: props.fontSize ?? FONTSIZE, xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 48 48", width: "1em", height: "1em", ...props, children: [_jsx("path", { fill: "currentColor", d: "M40,35v5H8v-5H4v5c0,2.2,1.8,4,4,4h32c2.2,0,4-1.8,4-4v-5H40z" }), _jsxs("g", { fill: "currentColor", children: [_jsx("polygon", { points: "24,23.4 17,15 31,15" }), _jsx("rect", { x: "22", y: "4", width: "4", height: "14" }), _jsx("path", { d: "M31.5,26.9L30.8,28l3.5,1.9l0.6-1.2c1.6-3,2.6-4.7,3.5-5.2C39.3,23,41,23,44,23v-4C36.3,19,35.6,19.4,31.5,26.9z" }), _jsx("polygon", { points: "38.4,31 29.4,35 28,25" }), _jsx("path", { d: "M16.5,26.9l0.6,1.2L13.6,30L13,28.8c-1.6-3-2.6-4.7-3.5-5.2C8.7,23,7,23,4,23v-4C11.7,19,12.4,19.4,16.5,26.9z" }), _jsx("polygon", { points: "20,25 18.6,35 9.6,31" })] })] }));
+}
 export function IconArchiveMaster(props) {
     return (_jsxs("svg", { fontSize: props.fontSize ?? FONTSIZE, xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", width: "1em", height: "1em", ...props, children: [" ", _jsx("path", { fill: "currentColor", d: "m20.55 5.22l-1.39-1.68A1.51 1.51 0 0 0 18 3H6c-.47 0-.88.21-1.15.55L3.46 5.22C3.17 5.57 3 6.01 3 6.5V19a2 2 0 0 0 2 2h14c1.1 0 2-.9 2-2V6.5c0-.49-.17-.93-.45-1.28M12 9.5l5.5 5.5H14v2h-4v-2H6.5zM5.12 5l.82-1h12l.93 1z" }), " "] }));
 }

package/lib/helper/dataGridSearchHelper.d.ts

@@ -0,0 +1,28 @@
+import { MetadataFormats } from '@topconsultnpm/sdk-ts';
+/** Testo mostrato in una colonna per una riga: è quello su cui va cercato ciò che l'utente digita */
+export type SearchTextGetter = (rowData: any) => string;
+/** Testo con cui una data viene mostrata nella griglia: è quello che l'utente vede e quindi quello che cerca */
+export declare const getDateDisplayText: (value: any, format: MetadataFormats | undefined, formatCulture: string | undefined | null) => string;
+/** Testo con cui un numero viene mostrato nella griglia (separatore delle migliaia, valuta, decimali) */
+export declare const getNumberDisplayText: (value: any, format: MetadataFormats | undefined, formatCulture: string) => string;
+/**
+ * Dirotta la ricerca della griglia sul testo mostrato, per le colonne indicate (chiave: il `dataField`).
+ *
+ * La ricerca di DevExtreme lavora sul valore archiviato, quindi non trova nulla dove il testo mostrato è
+ * diverso:
+ * - **date**, che nei dati sono stringhe ISO: DevExtreme prova a interpretare il testo digitato con il
+ *   formato della colonna, non riesce (il formato è un formatter personalizzato, non un pattern) e scarta
+ *   la colonna dalla ricerca — cercando `29/01/2023` non trova nulla;
+ * - **numeri formattati**, per lo stesso motivo (separatore delle migliaia, simbolo di valuta);
+ * - **liste dati e utenti**, dove viene confrontata la chiave archiviata invece della descrizione
+ *   visualizzata — cercando `FATTURA` non trova nulla, cercando `TD01` sì.
+ *
+ * Da passare a `customizeColumns` della griglia. Va fatto lì perché solo lì è disponibile la
+ * `calculateFilterExpression` predefinita di DevExtreme, che resta in uso per il filtro di intestazione e
+ * per il generatore di filtri: quelli funzionano già correttamente e vanno lasciati intatti.
+ *
+ * @example
+ * const searchTextGetters = useMemo(() => new Map([['TM_1_2', (row) => getDateDisplayText(row?.TM_1_2, format, culture)]]), [...]);
+ * const customizeColumns = useMemo(() => customizeSearchByDisplayText(searchTextGetters), [searchTextGetters]);
+ */
+export declare const customizeSearchByDisplayText: (searchTextGetters: Map<string, SearchTextGetter>) => (columns: Array<any>) => void;

package/lib/helper/dataGridSearchHelper.js

@@ -0,0 +1,51 @@
+import { formatDateTimeByMetadataFormat, formatNumberByMetadataFormat } from './TMUtils';
+/** Testo con cui una data viene mostrata nella griglia: è quello che l'utente vede e quindi quello che cerca */
+export const getDateDisplayText = (value, format, formatCulture) => {
+    if (value === undefined || value === null || value === '')
+        return '';
+    const date = value instanceof Date ? value : new Date(value);
+    return Number.isNaN(date.getTime()) ? '' : formatDateTimeByMetadataFormat(date, format, formatCulture);
+};
+/** Testo con cui un numero viene mostrato nella griglia (separatore delle migliaia, valuta, decimali) */
+export const getNumberDisplayText = (value, format, formatCulture) => {
+    if (value === undefined || value === null || value === '')
+        return '';
+    return formatNumberByMetadataFormat(value, format, formatCulture);
+};
+/**
+ * Dirotta la ricerca della griglia sul testo mostrato, per le colonne indicate (chiave: il `dataField`).
+ *
+ * La ricerca di DevExtreme lavora sul valore archiviato, quindi non trova nulla dove il testo mostrato è
+ * diverso:
+ * - **date**, che nei dati sono stringhe ISO: DevExtreme prova a interpretare il testo digitato con il
+ *   formato della colonna, non riesce (il formato è un formatter personalizzato, non un pattern) e scarta
+ *   la colonna dalla ricerca — cercando `29/01/2023` non trova nulla;
+ * - **numeri formattati**, per lo stesso motivo (separatore delle migliaia, simbolo di valuta);
+ * - **liste dati e utenti**, dove viene confrontata la chiave archiviata invece della descrizione
+ *   visualizzata — cercando `FATTURA` non trova nulla, cercando `TD01` sì.
+ *
+ * Da passare a `customizeColumns` della griglia. Va fatto lì perché solo lì è disponibile la
+ * `calculateFilterExpression` predefinita di DevExtreme, che resta in uso per il filtro di intestazione e
+ * per il generatore di filtri: quelli funzionano già correttamente e vanno lasciati intatti.
+ *
+ * @example
+ * const searchTextGetters = useMemo(() => new Map([['TM_1_2', (row) => getDateDisplayText(row?.TM_1_2, format, culture)]]), [...]);
+ * const customizeColumns = useMemo(() => customizeSearchByDisplayText(searchTextGetters), [searchTextGetters]);
+ */
+export const customizeSearchByDisplayText = (searchTextGetters) => (columns) => {
+    columns.forEach((column) => {
+        const getSearchText = column?.dataField ? searchTextGetters.get(column.dataField) : undefined;
+        // customizeColumns viene richiamata a ogni aggiornamento delle colonne: senza il marcatore i wrapper si anniderebbero
+        if (!getSearchText || column.tmSearchByDisplayText)
+            return;
+        const defaultCalculateFilterExpression = column.calculateFilterExpression;
+        // Senza questo DevExtreme prova a convertire il testo digitato nel tipo della colonna e, non riuscendo, la scarta
+        column.parseValue = (text) => text;
+        column.calculateFilterExpression = function (filterValue, selectedFilterOperation, target) {
+            if (target === 'search')
+                return [getSearchText, 'contains', filterValue];
+            return defaultCalculateFilterExpression?.apply(this, arguments);
+        };
+        column.tmSearchByDisplayText = true;
+    });
+};

package/lib/helper/dcmtsHelper.d.ts

@@ -1,8 +1,28 @@
+import { DcmtTypeDescriptor, MetadataDataTypes, MetadataDescriptor, MetadataFormats, RelationDescriptor } from "@topconsultnpm/sdk-ts";
 import { MetadataValueDescriptorEx } from "../ts";
+/** Metadati utente (esclusi quelli di sistema) del tipo documento, in ordine di visualizzazione */
+export declare const getUserMetadataSorted: (dtd: DcmtTypeDescriptor | undefined) => Array<MetadataDescriptor>;
+/** Formatta un valore scalare (non lista dati): date e numeri rispettano Format e FormatCulture del metadato */
+export declare const formatScalarValue: (value: any, dataType: MetadataDataTypes | undefined, format: MetadataFormats | undefined, formatCulture: string | undefined) => string;
 /** Check if dcmtType (mTID) has configured Detail or Many-to-Many relations */
 export declare const hasDetailRelations: (mTID: number | undefined) => Promise<boolean>;
 /** Check if dcmtType (mTID) has configured Master or Many-to-Many relations */
 export declare const hasMasterRelations: (mTID: number | undefined) => Promise<boolean>;
+export declare const getDcmtMetadataByMid: (dcmt: {
+    TID?: number;
+    DID?: number;
+} | undefined) => Promise<Map<number, any>>;
+export declare const mapAssociationsFromMetadata: (relation: RelationDescriptor, type: "detail" | "master", metadataByMid: Map<number, any>) => Array<{
+    mid: number;
+    value: string;
+}>;
+export declare const mapRelationAssociationsToMids: (relation: RelationDescriptor, type: "detail" | "master", dcmt: {
+    TID?: number;
+    DID?: number;
+} | undefined) => Promise<Array<{
+    mid: number;
+    value: string;
+}>>;
 export declare const isXMLFileExt: (fileExt: string | undefined) => boolean;
 export declare const getButtonAttributes: (args: string | undefined, formData: MetadataValueDescriptorEx[] | undefined, selectedItems: Array<any> | undefined) => Record<string, any> | undefined;
 export declare const getSelectedItem: (args: string | undefined, formData: MetadataValueDescriptorEx[] | undefined, item: any) => Record<string, any> | undefined;

package/lib/helper/dcmtsHelper.js

@@ -1,4 +1,21 @@
-import { RelationCacheService, RelationTypes, SDK_Globals } from "@topconsultnpm/sdk-ts";
+import { MetadataDataTypes, RelationCacheService, RelationTypes, SDK_Globals } from "@topconsultnpm/sdk-ts";
+import { formatDateTimeByMetadataFormat, formatNumberByMetadataFormat } from "./TMUtils";
+/** Metadati utente (esclusi quelli di sistema) del tipo documento, in ordine di visualizzazione */
+export const getUserMetadataSorted = (dtd) => {
+    return (dtd?.metadata ?? [])
+        .filter(md => md.id !== undefined && md.id > 100 && md.isSystem !== 1)
+        .sort((a, b) => (a.ordinalPosition ?? 0) - (b.ordinalPosition ?? 0));
+};
+/** Formatta un valore scalare (non lista dati): date e numeri rispettano Format e FormatCulture del metadato */
+export const formatScalarValue = (value, dataType, format, formatCulture) => {
+    if (value === undefined || value === null || value === '')
+        return '';
+    switch (dataType) {
+        case MetadataDataTypes.DateTime: return formatDateTimeByMetadataFormat(value instanceof Date ? value : new Date(value), format, formatCulture);
+        case MetadataDataTypes.Number: return formatNumberByMetadataFormat(value, format, formatCulture ?? window.navigator.language);
+        default: return String(value);
+    }
+};
 /** Check if dcmtType (mTID) has configured Detail or Many-to-Many relations */
 export const hasDetailRelations = async (mTID) => {
     let allRelations = await RelationCacheService.GetAllAsync();
@@ -13,6 +30,46 @@ export const hasMasterRelations = async (mTID) => {
     let rdlManyToMany = allRelations?.filter(o => o.relationType == RelationTypes.ManyToMany && (o.masterTID == mTID || o.detailTID == mTID)) ?? [];
     return rdlManyToMany.length > 0 || rdlOneToMany.length > 0;
 };
+// Legge i metadati di un documento
+export const getDcmtMetadataByMid = async (dcmt) => {
+    const metadataMap = new Map();
+    if (!dcmt?.TID || !dcmt?.DID)
+        return metadataMap; // Documento non identificabile: mappa vuota
+    const searchEngine = SDK_Globals.tmSession?.NewSearchEngine();
+    if (!searchEngine)
+        return metadataMap; // Nessuna sessione attiva: mappa vuota
+    const allMetadata = await searchEngine.GetMetadataAsync(dcmt.TID, dcmt.DID, false);
+    const row = allMetadata?.dtdResult?.rows?.[0]; // Prima (e unica) riga = il documento richiesto
+    const mids = allMetadata?.selectMIDs; // MID nello stesso ordine dei valori di riga
+    if (row && mids)
+        mids.forEach((mid, index) => metadataMap.set(mid, row[index])); // Accoppia mid -> valore per posizione
+    return metadataMap;
+};
+// Mappa le associazioni della relazione nei MID di destinazione, usando i metadati sorgente già letti.
+// 'detail' = archivio dettagli dal master (sorgente item1 -> destinazione item2); 'master' = archivio master dal dettaglio (item2 -> item1).
+// Emette una voce per ogni associazione, anche vuota, per coprire tutti i collegamenti.
+export const mapAssociationsFromMetadata = (relation, type, metadataByMid) => {
+    if (!relation.associations || relation.associations.length === 0)
+        return []; // Relazione senza collegamenti
+    return relation.associations.map(assoc => {
+        const sourceMid = type === 'detail' ? (assoc.item1 ?? 0) : (assoc.item2 ?? 0); // MID da cui leggere il valore
+        const targetMid = type === 'detail' ? (assoc.item2 ?? 0) : (assoc.item1 ?? 0); // MID da valorizzare
+        const value = metadataByMid.get(sourceMid); // Valore sorgente (può mancare)
+        return { mid: targetMid, value: value !== undefined && value !== null ? value.toString() : '' }; // Assente/null -> stringa vuota
+    });
+};
+// Legge il documento sorgente (master per 'detail', dettaglio per 'master') e mappa le associazioni nei MID di destinazione.
+// Per letture ripetute dello stesso documento, riusare la mappa e chiamare direttamente `mapAssociationsFromMetadata`.
+export const mapRelationAssociationsToMids = async (relation, type, dcmt) => {
+    if (!relation.associations || relation.associations.length === 0)
+        return []; // Relazione senza collegamenti
+    if (!dcmt?.TID || !dcmt?.DID)
+        return []; // Documento sorgente non identificabile
+    const metadataByMid = await getDcmtMetadataByMid(dcmt);
+    if (metadataByMid.size === 0)
+        return []; // Nessun metadato leggibile: [] come nel flusso originale (niente collegamenti a vuoto)
+    return mapAssociationsFromMetadata(relation, type, metadataByMid);
+};
 export const isXMLFileExt = (fileExt) => {
     const fileExtension = fileExt?.toLowerCase() ?? '';
     switch (fileExtension) {

package/lib/helper/helpers.d.ts

@@ -2,6 +2,15 @@ import { Colors as ColorsType } from "../components/base/TMEditorBase";
 import { DeviceType } from "../components";
 import { AppModules, DataColumnDescriptor, DcmtTypeDescriptor, ITopMediaSession, MetadataDescriptor, QueryDescriptor, SearchResultDescriptor, TaskDescriptor } from "@topconsultnpm/sdk-ts";
 import { FileExtensionHandler, FormModes, moduleTypes } from "../ts";
+import React from "react";
+/**
+ * Handler di hover per elementi con stili inline: applica `over` all'ingresso del mouse e `out` all'uscita.
+ * Da spandere sull'elemento: `{...hoverStyle({ background: 'red' }, { background: 'transparent' })}`
+ */
+export declare const hoverStyle: (over: React.CSSProperties, out: React.CSSProperties) => {
+    onMouseEnter: (e: React.MouseEvent<HTMLElement>) => CSSStyleDeclaration & React.CSSProperties;
+    onMouseLeave: (e: React.MouseEvent<HTMLElement>) => CSSStyleDeclaration & React.CSSProperties;
+};
 declare const calcResponsiveSizes: (deviceType: DeviceType | undefined, desktopSize: string, tabletSize: string, mobileSize: string) => string;
 declare const taskModalSizes: (deviceType: DeviceType | undefined, formMode: FormModes) => {
     width: string;
@@ -35,6 +44,17 @@ export declare const getDataColumnName: (fromTID: number | undefined, dtColumn:
  */
 export declare const generateUniqueColumnKeys: (columns: DataColumnDescriptor[] | undefined, fromTID: number | undefined) => string[];
 export declare const searchResultDescriptorToSimpleArray: (searchResult: SearchResultDescriptor | undefined) => any[] | undefined;
+/**
+ * Unisce ("accoda") il risultato di una nuova ricerca a quello precedente, sullo stesso tipo documento.
+ * - Le righe della nuova ricerca vengono messe in cima (più recenti in alto)
+ * - Le righe duplicate sono accettate: lo stesso documento può comparire più volte
+ * - Aggiorna i contatori globali (dcmtsFound / dcmtsReturned) sul totale unito
+ *
+ * @param previous Risultato attualmente in memoria (può essere undefined al primo giro)
+ * @param next Nuovo risultato appena ottenuto
+ * @returns Un nuovo SearchResultDescriptor con le righe unite, oppure il singolo risultato disponibile
+ */
+export declare const mergeSearchResultsAppend: (previous: SearchResultDescriptor | undefined, next: SearchResultDescriptor | undefined) => SearchResultDescriptor | undefined;
 export declare const getCompleteMetadataName: (dcmtTypeName: string | undefined, metadataName: string | undefined) => string;
 export declare const getQueryCountAsync: (qd: QueryDescriptor, showSpinner: boolean) => Promise<void>;
 export declare function getTIDByMID(mid: number | undefined, defaultTid?: number): number;