@topconsultnpm/sdkui-react-beta 6.12.36 → 6.12.38

package/lib/helper/SDKUI_Localizator.js

@@ -8,6 +8,16 @@ export class SDKUI_Localizator {
     static setLanguage(cultureID) {
         this._cultureID = cultureID;
     }
+    static get Active() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Aktive";
+            case CultureIDs.En_US: return "Active";
+            case CultureIDs.Es_ES: return "Activos";
+            case CultureIDs.Fr_FR: return "Actifs";
+            case CultureIDs.Pt_PT: return "Ativos";
+            default: return "Attivi";
+        }
+    }
     static get Abort() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Stoppen";
@@ -238,6 +248,16 @@ export class SDKUI_Localizator {
             default: return "Consenti solo archiviazioni di metadati";
         }
     }
+    static get ArchivedDocuments() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Archivierte Dokumente";
+            case CultureIDs.En_US: return "Archived Documents";
+            case CultureIDs.Es_ES: return "Documentos Archivados";
+            case CultureIDs.Fr_FR: return "Documents Archivés";
+            case CultureIDs.Pt_PT: return "Documentos Arquivados";
+            default: return "Documenti Archiviati";
+        }
+    }
     static get ArchiveID() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Dokumentarisches Archiv";
@@ -248,6 +268,26 @@ export class SDKUI_Localizator {
             default: return "Archivio documentale";
         }
     }
+    static get Attachment() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Anhang";
+            case CultureIDs.En_US: return "Attachment";
+            case CultureIDs.Es_ES: return "Adjunto";
+            case CultureIDs.Fr_FR: return "Pièce jointe";
+            case CultureIDs.Pt_PT: return "Anexo";
+            default: return "Allegato";
+        }
+    }
+    static get Attachments() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Anhänge";
+            case CultureIDs.En_US: return "Attachments";
+            case CultureIDs.Es_ES: return "Adjuntos";
+            case CultureIDs.Fr_FR: return "Pièces jointes";
+            case CultureIDs.Pt_PT: return "Anexos";
+            default: return "Allegati";
+        }
+    }
     static get Attention() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Aufmerksamkeit";
@@ -519,6 +559,16 @@ export class SDKUI_Localizator {
             default: return "Visualizza tutte le colonne";
         }
     }
+    static get Comment() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Kommentieren";
+            case CultureIDs.En_US: return "Comment";
+            case CultureIDs.Es_ES: return "Comentar";
+            case CultureIDs.Fr_FR: return "Commenter";
+            case CultureIDs.Pt_PT: return "Comentar";
+            default: return "Commenta";
+        }
+    }
     static get CompleteError() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Kompletter Fehler";
@@ -609,6 +659,16 @@ export class SDKUI_Localizator {
             default: return "Crea";
         }
     }
+    static get CreateContextualTask() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Kontextbezogene Aufgabe erstellen";
+            case CultureIDs.En_US: return "Create contextual task";
+            case CultureIDs.Es_ES: return "Crear tarea contextual";
+            case CultureIDs.Fr_FR: return "Créer une tâche contextuelle";
+            case CultureIDs.Pt_PT: return "Criar tarefa contextual";
+            default: return "Crea attività contestuale";
+        }
+    }
     static get CreationTime() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Erstellungsdatum";
@@ -769,6 +829,16 @@ export class SDKUI_Localizator {
             default: return "{{0}} oggetti selezionati. Eliminarli tutti?";
         }
     }
+    static get DeleteComment() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Kommentar löschen?";
+            case CultureIDs.En_US: return "Delete the comment?";
+            case CultureIDs.Es_ES: return "¿Eliminar el comentario?";
+            case CultureIDs.Fr_FR: return "Supprimer le commentaire ?";
+            case CultureIDs.Pt_PT: return "Eliminar o comentário?";
+            default: return "Eliminare il commento?";
+        }
+    }
     static get DeletionCompletedSuccessfully() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Löschung erfolgreich abgeschlossen";
@@ -779,6 +849,16 @@ export class SDKUI_Localizator {
             default: return "Eliminazione completata con successo";
         }
     }
+    static get Deleted() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Gelöscht";
+            case CultureIDs.En_US: return "Deleted";
+            case CultureIDs.Es_ES: return "Eliminados";
+            case CultureIDs.Fr_FR: return "Supprimés";
+            case CultureIDs.Pt_PT: return "Excluídos";
+            default: return "Eliminati";
+        }
+    }
     static get DeletionOperationInterrupted() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Löschvorgang abgebrochen";
@@ -839,6 +919,16 @@ export class SDKUI_Localizator {
             default: return "Valori distinti";
         }
     }
+    static get DocumentNotAvailable() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Dokument nicht verfügbar";
+            case CultureIDs.En_US: return "Document not available";
+            case CultureIDs.Es_ES: return "Documento no disponible";
+            case CultureIDs.Fr_FR: return "Document non disponible";
+            case CultureIDs.Pt_PT: return "Documento não disponível";
+            default: return "Documento non disponibile";
+        }
+    }
     static get Domain() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Domäne";
@@ -1500,6 +1590,16 @@ export class SDKUI_Localizator {
             default: return "Nascondi nome completo";
         }
     }
+    static get HideFilters() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Filter ausblenden";
+            case CultureIDs.En_US: return "Hide filters";
+            case CultureIDs.Es_ES: return "Ocultar filtros";
+            case CultureIDs.Fr_FR: return "Masquer les filtres";
+            case CultureIDs.Pt_PT: return "Ocultar filtros";
+            default: return "Nascondi filtri";
+        }
+    }
     static get HideLeftPanel() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Linkes Panel ausblenden";
@@ -1650,6 +1750,26 @@ export class SDKUI_Localizator {
             default: return "Ultima modifica";
         }
     }
+    static get LastVersion() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Letzte Version";
+            case CultureIDs.En_US: return "Last version";
+            case CultureIDs.Es_ES: return "Última versión";
+            case CultureIDs.Fr_FR: return "Dernière version";
+            case CultureIDs.Pt_PT: return "Última versão";
+            default: return "Ultima versione";
+        }
+    }
+    static get Latest() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Letzte";
+            case CultureIDs.En_US: return "Latest";
+            case CultureIDs.Es_ES: return "Últimos";
+            case CultureIDs.Fr_FR: return "Derniers";
+            case CultureIDs.Pt_PT: return "Últimos";
+            default: return "Ultimi";
+        }
+    }
     static get LexProt() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Lex-Schutz";
@@ -2101,6 +2221,26 @@ export class SDKUI_Localizator {
             default: return "Nessun documento trovato";
         }
     }
+    static get NoMessages() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Keine Nachrichten vorhanden";
+            case CultureIDs.En_US: return "No Messages Present";
+            case CultureIDs.Es_ES: return "Ningún mensaje presente";
+            case CultureIDs.Fr_FR: return "Aucun message présent";
+            case CultureIDs.Pt_PT: return "Nenhuma mensagem presente";
+            default: return "Nessun messaggio presente in Bacheca";
+        }
+    }
+    static get NoMessagesFound() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Keine Nachricht gefunden";
+            case CultureIDs.En_US: return "No messages found";
+            case CultureIDs.Es_ES: return "No se encontraron mensajes";
+            case CultureIDs.Fr_FR: return "Aucun message trouvé";
+            case CultureIDs.Pt_PT: return "Nenhuma mensagem encontrada";
+            default: return "Nessun messaggio trovato";
+        }
+    }
     static get NoneSelection() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Keine Auswahl";
@@ -2111,6 +2251,16 @@ export class SDKUI_Localizator {
             default: return "Nessuna selezione";
         }
     }
+    static get OfSystem() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Des Systems";
+            case CultureIDs.En_US: return "Of system";
+            case CultureIDs.Es_ES: return "Del sistema";
+            case CultureIDs.Fr_FR: return "Du système";
+            case CultureIDs.Pt_PT: return "Do sistema";
+            default: return "Di sistema";
+        }
+    }
     static get OldPassword() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Altes Kennwort";
@@ -2281,6 +2431,16 @@ export class SDKUI_Localizator {
             default: return "Non proprietario";
         }
     }
+    static get Path() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Dateipfad";
+            case CultureIDs.En_US: return "File Path";
+            case CultureIDs.Es_ES: return "Ruta de archivo";
+            case CultureIDs.Fr_FR: return "Chemin de fichier";
+            case CultureIDs.Pt_PT: return "Caminho de arquivo";
+            default: return "Percorso";
+        }
+    }
     static get ParametricFilter() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Parametrischer Filter";
@@ -2521,6 +2681,16 @@ export class SDKUI_Localizator {
             default: return "Cancellazione fisica";
         }
     }
+    static get Practice() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Praxis";
+            case CultureIDs.En_US: return "Practice";
+            case CultureIDs.Es_ES: return "Práctica";
+            case CultureIDs.Fr_FR: return "Pratique";
+            case CultureIDs.Pt_PT: return "Prática";
+            default: return "Pratica";
+        }
+    }
     static get PreviewView() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Vorschauansicht";
@@ -2641,6 +2811,36 @@ export class SDKUI_Localizator {
             default: return "Documenti recenti";
         }
     }
+    static get RefersTo() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Bezieht sich auf";
+            case CultureIDs.En_US: return "Refers to";
+            case CultureIDs.Es_ES: return "Se refiere a";
+            case CultureIDs.Fr_FR: return "Fait référence à";
+            case CultureIDs.Pt_PT: return "Refere-se a";
+            default: return "Riferito a";
+        }
+    }
+    static get RecentDocs_Archived() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Zuletzt archivierte Dokumente";
+            case CultureIDs.En_US: return "Last archived documents";
+            case CultureIDs.Es_ES: return "Últimos documentos archivados";
+            case CultureIDs.Fr_FR: return "Derniers documents archivés";
+            case CultureIDs.Pt_PT: return "Últimos documentos arquivados";
+            default: return "Ultimi documenti archiviati";
+        }
+    }
+    static get RecentDocs_Visualized() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Zuletzt visualisierte Dokumente";
+            case CultureIDs.En_US: return "Last seen documents";
+            case CultureIDs.Es_ES: return "Últimos documentos visualizados";
+            case CultureIDs.Fr_FR: return "Derniers documents visualisés";
+            case CultureIDs.Pt_PT: return "Últimos documentos visualizados";
+            default: return "Ultimi documenti visualizzati";
+        }
+    }
     static get Reject() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Ablehnen";
@@ -2808,6 +3008,16 @@ export class SDKUI_Localizator {
             default: return "Ripristina";
         }
     }
+    static get RestoreComment() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Kommentar wiederherstellen?";
+            case CultureIDs.En_US: return "Restore the comment?";
+            case CultureIDs.Es_ES: return "¿Restaurar el comentario?";
+            case CultureIDs.Fr_FR: return "Restaurer le commentaire ?";
+            case CultureIDs.Pt_PT: return "Restaurar o comentário?";
+            default: return "Ripristinare il commento?";
+        }
+    }
     static get RetrieveFile() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Dateiwiederherstellung";
@@ -3088,6 +3298,16 @@ export class SDKUI_Localizator {
             default: return "Mostra dettagli";
         }
     }
+    static get ShowFilters() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Filter anzeigen";
+            case CultureIDs.En_US: return "Show filters";
+            case CultureIDs.Es_ES: return "Mostrar filtros";
+            case CultureIDs.Fr_FR: return "Afficher les filtres";
+            case CultureIDs.Pt_PT: return "Mostrar filtros";
+            default: return "Mostra filtri";
+        }
+    }
     static get ShowHideMetadataSystemDesc() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Anzeigen oder Verbergen von Methadaten des Dokumententypsystems";
@@ -3218,6 +3438,16 @@ export class SDKUI_Localizator {
             default: return "Modello";
         }
     }
+    static get Today() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Heute";
+            case CultureIDs.En_US: return "Today";
+            case CultureIDs.Es_ES: return "Hoy";
+            case CultureIDs.Fr_FR: return "Aujourd'hui";
+            case CultureIDs.Pt_PT: return "Hoje";
+            default: return "Oggi";
+        }
+    }
     static get ToTime() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "zu";
@@ -3628,6 +3858,16 @@ export class SDKUI_Localizator {
             default: return "Approvazione workflow";
         }
     }
+    static get WorkGroup() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Arbeitsgruppe";
+            case CultureIDs.En_US: return "Work Group";
+            case CultureIDs.Es_ES: return "Grupo de Trabajo";
+            case CultureIDs.Fr_FR: return "Groupe de travail";
+            case CultureIDs.Pt_PT: return "Grupo de Trabalho";
+            default: return "Gruppo di lavoro";
+        }
+    }
     static get Yes() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Ja";

package/lib/helper/dcmtsHelper.d.ts

@@ -0,0 +1,4 @@
+/** 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>;

package/lib/helper/dcmtsHelper.js

@@ -0,0 +1,15 @@
+import { RelationCacheService, RelationTypes } from "@topconsultnpm/sdk-ts-beta";
+/** Check if dcmtType (mTID) has configured Detail or Many-to-Many relations */
+export const hasDetailRelations = async (mTID) => {
+    let allRelations = await RelationCacheService.GetAllAsync();
+    let rdlOneToMany = allRelations?.filter(o => o.masterTID == mTID && o.relationType == RelationTypes.OneToMany) ?? [];
+    let rdlManyToMany = allRelations?.filter(o => o.relationType == RelationTypes.ManyToMany && (o.masterTID == mTID || o.detailTID == mTID)) ?? [];
+    return rdlManyToMany.length > 0 || rdlOneToMany.length > 0;
+};
+/** Check if dcmtType (mTID) has configured Master or Many-to-Many relations */
+export const hasMasterRelations = async (mTID) => {
+    let allRelations = await RelationCacheService.GetAllAsync();
+    let rdlOneToMany = allRelations?.filter(o => o.detailTID == mTID && o.relationType == RelationTypes.OneToMany) ?? [];
+    let rdlManyToMany = allRelations?.filter(o => o.relationType == RelationTypes.ManyToMany && (o.masterTID == mTID || o.detailTID == mTID)) ?? [];
+    return rdlManyToMany.length > 0 || rdlOneToMany.length > 0;
+};

package/lib/helper/helpers.d.ts

@@ -1,7 +1,7 @@
 import { Colors as ColorsType } from "../components/base/TMEditorBase";
 import { DeviceType } from "../components";
 import { AppModules, DataColumnDescriptor, ITopMediaSession, MetadataDescriptor, QueryDescriptor, SearchResultDescriptor } from "@topconsultnpm/sdk-ts-beta";
-import { FormModes, moduleTypes } from "../ts";
+import { FileExtensionHandler, FormModes, moduleTypes } from "../ts";
 declare const TABLET_WIDTH = 1024;
 declare const MOBILE_WIDTH = 640;
 declare const calcResponsiveDirection: (deviceType: DeviceType, desktopDir: "horizontal" | "vertical", tabletDir: "horizontal" | "vertical", mobileDir: "horizontal" | "vertical") => "horizontal" | "vertical";
@@ -20,6 +20,7 @@ export declare const getQueryCountAsync: (qd: QueryDescriptor, showSpinner: bool
 export declare function getTIDByMID(mid: number | undefined, defaultTid?: number): number;
 export declare const getSystemMetadata: (withPerm?: boolean) => MetadataDescriptor[];
 export declare function deepCompare(obj1: any, obj2: any): boolean;
+export declare const extensionHandler: (fileExt: string | undefined) => FileExtensionHandler;
 export declare const canNext: (visibleItems: any[], selectedItems: any[]) => boolean;
 export declare const getNext: (visibleItems: any[], selectedItems: any[]) => any;
 export declare const canPrev: (visibleItems: any[], selectedItems: any[]) => boolean;

package/lib/helper/helpers.js

@@ -3,7 +3,7 @@ import { Colors } from "../utils/theme";
 import { ButtonNames, DeviceType, TMExceptionBoxManager, TMMessageBoxManager, TMSpinner } from "../components";
 import { AccessLevels, MetadataDataDomains, MetadataDataTypes, MetadataDescriptor, MetadataFormatDescriptor, MetadataFormats, MetadataPermission, SDK_Globals, SystemMIDs, SystemMIDsAsNumber, TopMediaServer } from "@topconsultnpm/sdk-ts-beta";
 import { Buffer } from 'buffer';
-import { buildTypes, FormModes, moduleTypes } from "../ts";
+import { buildTypes, FileExtensionHandler, FormModes, moduleTypes } from "../ts";
 import { SDKUI_Localizator } from "./SDKUI_Localizator";
 import ReactDOMServer from "react-dom/server";
 //#region Responsive Helpers
@@ -400,6 +400,79 @@ export function deepCompare(obj1, obj2) {
     }
     return true;
 }
+export const extensionHandler = (fileExt) => {
+    if (!fileExt || fileExt.length === 0) {
+        return FileExtensionHandler.NONE;
+    }
+    switch (fileExt.toLowerCase()) {
+        case 'pdf.p7m':
+        case 'pdf.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'doc':
+        case 'doc.p7m':
+        case 'doc.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'docx':
+        case 'docx.p7m':
+        case 'docx.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'xls':
+        case 'xls.p7m':
+        case 'xls.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'xlsx':
+        case 'xlsx.p7m':
+        case 'xlsx.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'ppt':
+        case 'ppt.p7m':
+        case 'ppt.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'pptx':
+        case 'pptx.p7m':
+        case 'pptx.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'pptm':
+        case 'pptm.p7m':
+        case 'pptm.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'pps':
+        case 'pps.p7m':
+        case 'pps.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'ppsx':
+        case 'ppsx.p7m':
+        case 'ppsx.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'tif':
+        case 'tif.p7m':
+        case 'tif.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'tiff':
+        case 'tiff.p7m':
+        case 'tiff.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'eml':
+        case 'eml.p7m':
+        case 'eml.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'msg':
+        case 'msg.p7m':
+        case 'msg.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'htm.p7m':
+        case 'htm.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'html.p7m':
+        case 'html.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'txt.p7m':
+        case 'txt.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'csv': return FileExtensionHandler.CONVERTIBLE;
+        // case 'xml.p7m': case 'xml.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'jpg':
+        case 'jpeg':
+        case 'png':
+        case 'bmp':
+        case 'gif':
+        case 'svg': return FileExtensionHandler.READY_TO_SHOW;
+        case 'htm':
+        case 'html': return FileExtensionHandler.READY_TO_SHOW;
+        case 'mp4':
+        case 'webm': return FileExtensionHandler.READY_TO_SHOW;
+        case 'xml': return FileExtensionHandler.READY_TO_SHOW;
+        case 'xml.p7m':
+        case 'xml.p7m.ts':
+        case 'xml.p7m.tsd': return FileExtensionHandler.READY_TO_SHOW;
+        case 'pdf': return FileExtensionHandler.READY_TO_SHOW;
+        case 'txt': return FileExtensionHandler.READY_TO_SHOW;
+        default: return FileExtensionHandler.NONE;
+    }
+};
 //#region Form, Page Helpers
 export const canNext = (visibleItems, selectedItems) => {
     if (!visibleItems)

package/lib/helper/queryHelper.d.ts

@@ -1,4 +1,5 @@
-import { MetadataDescriptor, SystemMIDsAsNumber, QueryDescriptor, SelectItem } from '@topconsultnpm/sdk-ts-beta';
+import { MetadataDescriptor, MetadataDataDomains, SystemMIDsAsNumber, MetadataDataTypes, QueryDescriptor, SelectItem, DataTableDescriptor, LayoutModes, QueryOperators, SavedQueryDescriptor } from '@topconsultnpm/sdk-ts-beta';
+import { MetadataValueDescriptorEx } from '../ts';
 export type TID_Alias = {
     tid: number;
     alias: string | undefined;
@@ -9,3 +10,8 @@ export declare const displayMetadataValue: (md: MetadataDescriptor | undefined,
 export declare const IsParametricQuery: (qd: QueryDescriptor | undefined) => boolean;
 export declare const addHiddenSelectItem: (select: SelectItem[], tid: number | undefined, mid: SystemMIDsAsNumber) => void;
 export declare const prepareQdForSearchAsync: (qdInput?: QueryDescriptor) => Promise<QueryDescriptor>;
+export declare function getDefaultOperator(dataDomain: MetadataDataDomains | undefined, dataType: MetadataDataTypes | undefined): QueryOperators.Equal | QueryOperators.Contain | QueryOperators.In;
+export declare const getQD: (tid: number | undefined, easyOr: boolean) => Promise<QueryDescriptor | undefined>;
+export declare const getSysAllDcmtsSQD: (tid: number | undefined, easyOr: boolean) => Promise<SavedQueryDescriptor>;
+export declare const searchResultToMetadataValues: (tid: number | undefined, dtd: DataTableDescriptor | undefined, rows: string[], mids: number[], metadata: MetadataDescriptor[], layoutMode: LayoutModes) => MetadataValueDescriptorEx[];
+export declare const handleArchiveVisibility: (md: MetadataDescriptor) => boolean;

package/lib/helper/queryHelper.js

@@ -1,5 +1,6 @@
-import { AccessLevels, MetadataDataDomains, DcmtTypeListCacheService, SystemMIDsAsNumber, MetadataDataTypes, QueryDescriptor, QueryFunctions, SelectItem, SelectItemVisibilities } from '@topconsultnpm/sdk-ts-beta';
+import { AccessLevels, MetadataDataDomains, DcmtTypeListCacheService, SystemMIDsAsNumber, MetadataDataTypes, QueryDescriptor, QueryFunctions, SelectItem, SelectItemVisibilities, FromItem, LayoutModes, QueryOperators, SavedQueryDescriptor, SearchEngine, WhereItem } from '@topconsultnpm/sdk-ts-beta';
 import { DateDisplayTypes, Globalization } from './Globalization';
+import { MetadataValueDescriptorEx } from '../ts';
 export const getTIDsByQd = (qd) => {
     let tids = [];
     qd?.from?.tid && tids.push({ tid: qd.from?.tid, alias: undefined });
@@ -96,3 +97,106 @@ export const prepareQdForSearchAsync = async (qdInput) => {
     qd.isLexProt = 1;
     return qd;
 };
+export function getDefaultOperator(dataDomain, dataType) {
+    if (dataDomain == MetadataDataDomains.DataList)
+        return QueryOperators.In;
+    return dataType == MetadataDataTypes.Varchar ? QueryOperators.Contain : QueryOperators.Equal;
+}
+export const getQD = async (tid, easyOr) => {
+    let dtd = await DcmtTypeListCacheService.GetAsync(tid);
+    if (!dtd?.metadata)
+        return;
+    let qd = SearchEngine.NewQueryDescriptor();
+    qd.isDistinct = false;
+    qd.id = 1;
+    qd.maxDcmtsToBeReturned = 1000;
+    qd.from = new FromItem();
+    qd.from.tid = tid;
+    qd.select = [];
+    for (const md of dtd.metadata) {
+        if ((md?.perm?.canView == AccessLevels.No) && (md?.perm?.canUpdate == AccessLevels.No))
+            continue;
+        if (md.isSystem == 1)
+            continue;
+        let si = new SelectItem();
+        si.visibility = SelectItemVisibilities.Visible;
+        si.tid = dtd.id;
+        si.mid = md.id;
+        qd.select.push(si);
+    }
+    qd.where = [];
+    for (const md of dtd.metadata) {
+        if ((md?.perm?.canView == AccessLevels.No) && (md?.perm?.canSearch == AccessLevels.No))
+            continue;
+        if (md.isSystem == 1)
+            continue;
+        let wi = new WhereItem();
+        wi.or = easyOr;
+        wi.leftBrackets = "(";
+        wi.tid = dtd.id;
+        wi.mid = md.id;
+        wi.operator = getDefaultOperator(md.dataDomain, md.dataType);
+        wi.rightBrackets = ")";
+        qd.where.push(wi);
+    }
+    return qd;
+};
+export const getSysAllDcmtsSQD = async (tid, easyOr) => {
+    let sqd = new SavedQueryDescriptor();
+    sqd.id = 1;
+    sqd.masterTID = tid;
+    sqd.isEasyWhere = 1;
+    sqd.name = "Tutti i documenti";
+    sqd.description = "Restituisce tutti i documenti";
+    sqd.qd = await getQD(tid, easyOr);
+    return sqd;
+};
+export const searchResultToMetadataValues = (tid, dtd, rows, mids, metadata, layoutMode) => {
+    if (!metadata || metadata.length === 0) {
+        return [];
+    }
+    const outputMetadataList = [];
+    const isLexProtIndex = dtd?.columns?.findIndex(col => col.caption === 'IsLexProt') !== -1 ? dtd?.columns?.findIndex(col => col.caption === 'IsLexProt') : 0;
+    const createMetadataProps = (tid, md, value, isLexProt) => {
+        const isNumeratorInArk = md.dataDomain === MetadataDataDomains.Numerator && layoutMode === LayoutModes.Ark;
+        const hasDefaultValue = md.defaultValue !== undefined;
+        let mvd = new MetadataValueDescriptorEx();
+        mvd.tid = tid;
+        mvd.mid = md.id;
+        mvd.md = md;
+        mvd.value = (md.dataDomain === MetadataDataDomains.Numerator && layoutMode === LayoutModes.Ark) ? undefined : value;
+        mvd.isRequired = isNumeratorInArk || hasDefaultValue ? '0' : md.isRequired?.toString();
+        mvd.isLexProt = isLexProt;
+        return mvd;
+    };
+    metadata.forEach(md => {
+        if (!md.id)
+            return;
+        if (layoutMode === LayoutModes.Ark && !handleArchiveVisibility(md))
+            return;
+        if (!rows)
+            return;
+        if (mids.length > 0) {
+            const index = mids.indexOf(md.id);
+            if (index >= 0) {
+                const isLexProt = (isLexProtIndex !== undefined && rows[isLexProtIndex]) ? (parseInt(rows[isLexProtIndex]) || undefined) : undefined;
+                outputMetadataList.push(createMetadataProps(tid, md, rows[index], isLexProt));
+            }
+        }
+        else {
+            let defaultValue;
+            if (layoutMode === LayoutModes.Ark && (md.dataDomain === MetadataDataDomains.DataList || md.dataDomain === MetadataDataDomains.DynamicDataList || md.dataDomain === MetadataDataDomains.UserID))
+                defaultValue = md.defaultValue;
+            outputMetadataList.push(createMetadataProps(tid, md, defaultValue, undefined));
+        }
+    });
+    return outputMetadataList;
+};
+export const handleArchiveVisibility = (md) => {
+    if (md.dataDomain === MetadataDataDomains.Computed ||
+        md.perm?.canArchive !== AccessLevels.Yes ||
+        md.isSystem === 1 ||
+        md.isRootMID !== 1)
+        return false;
+    return true;
+};

package/lib/hooks/useDcmtOperations.d.ts

@@ -0,0 +1,24 @@
+import { RetrieveFileOptions } from '@topconsultnpm/sdk-ts-beta';
+import { DcmtInfo, DcmtOperationTypes } from '../ts';
+export declare function useDcmtOperations(): {
+    abortController: AbortController;
+    showWaitPanel: boolean;
+    showPrimary: boolean;
+    waitPanelTitle: string;
+    waitPanelTextPrimary: string;
+    waitPanelValuePrimary: number;
+    waitPanelMaxValuePrimary: number;
+    showSecondary: boolean;
+    waitPanelTextSecondary: string;
+    waitPanelValueSecondary: number;
+    waitPanelMaxValueSecondary: number;
+    downloadDcmtsAsync: (inputDcmts: DcmtInfo[] | undefined) => Promise<void>;
+    getDcmtFileAsync: (inputDcmt: DcmtInfo | undefined, rfo: RetrieveFileOptions, operationTitle: string, keepWaitPanelPrimary: boolean) => Promise<{
+        file: File | undefined;
+        isFromCache: boolean;
+    } | undefined>;
+    clearDcmtsFileCache: () => void;
+    removeDcmtsFileCache: (key: string) => boolean;
+    isDcmtFileInCache: (key: string) => boolean;
+    runOperationAsync: (inputDcmts: DcmtInfo[] | undefined, dcmtOperationType: DcmtOperationTypes, actionAfterOperationAsync?: () => Promise<void>) => Promise<void>;
+};