@topconsultnpm/sdkui-react 6.21.0-t2 → 6.21.0-t4

package/lib/helper/certificateImportHelper.js

@@ -0,0 +1,403 @@
+import { MetadataDataTypes, DcmtTypeListCacheService, SDK_Globals, QueryDescriptor, FromItem, SelectItem, SystemMIDsAsNumber, WhereItem, QueryOperators, ArchiveEngineByID, ResultTypes, DataListCacheService } from '@topconsultnpm/sdk-ts';
+import { SDKUI_Localizator } from './SDKUI_Localizator';
+// Costanti DTD usate nell'importazione certificati
+export const S4T_USER_REGISTRY_MASTER = 'S4T_UserRegistry'.toLowerCase();
+export const S4T_CERTIFICATE_REGISTRY_DETAIL = 'S4T_CertificateRegistry'.toLowerCase();
+/**
+ * Formatta il valore di LoginAuth con la descrizione testuale
+ * 0 = PIN senza OTP, 2 = PIN con OTP, 4 = Implicit PIN con OTP, 5 = Implicit PIN senza OTP
+ */
+const formatLoginAuth = (value) => {
+    if (value === undefined || value === null)
+        return undefined;
+    switch (value) {
+        case 0: return SDKUI_Localizator.LoginAuth_PINWithoutOTP;
+        case 2: return SDKUI_Localizator.LoginAuth_PINWithOTP;
+        case 4: return SDKUI_Localizator.LoginAuth_ImplicitPINWithOTP;
+        case 5: return SDKUI_Localizator.LoginAuth_ImplicitPINWithoutOTP;
+        default: return `${SDKUI_Localizator.LoginAuth_Unknown} (${value})`;
+    }
+};
+/**
+ * Mapping tra nome metadato (lowercase) e proprietà di IntesiCertificateData
+ */
+const getCredentialValue = (cert, fieldName) => {
+    switch (fieldName) {
+        case 'ig_cid': return cert.cid;
+        case 'ig_alias': return cert.alias;
+        case 'ig_label': return cert.label;
+        case 'ig_description': return cert.description;
+        case 'ig_domain': return cert.domain;
+        case 'ig_providername': return cert.providerName;
+        case 'ig_providerdescription': return cert.providerDescription;
+        case 'ig_loginauth': return formatLoginAuth(cert.loginAuth);
+        case 'ig_creationdate': return cert.creationDate;
+        case 'ig_validfrom': return cert.validFrom;
+        case 'ig_validto': return cert.validTo;
+        case 'ig_certificatestatus': return cert.certificateStatus;
+        case 'ig_revokedate': return cert.revokeDate;
+        default: return undefined;
+    }
+};
+/**
+ * Popola i metadati dell'engine (Archive o Update) dal certificato
+ */
+const setEngineMetadataFromCertificate = (engine, metadata, cert, email) => {
+    for (const md of metadata) {
+        const mdNameLower = md.name?.toLowerCase();
+        const value = getCredentialValue(cert, mdNameLower ?? '');
+        if (value !== undefined && value !== null) {
+            switch (md.dataType) {
+                case MetadataDataTypes.DateTime:
+                    // I valori arrivano sempre come timestamp in millisecondi
+                    engine.Metadata_AddDateTime(md.id, new Date(value));
+                    break;
+                case MetadataDataTypes.Number:
+                    engine.Metadata_AddNumber(md.id, typeof value === 'number' ? value : parseFloat(value));
+                    break;
+                case MetadataDataTypes.Varchar:
+                default:
+                    engine.Metadata_AddString(md.id, String(value));
+                    break;
+            }
+        }
+    }
+    // Aggiungi il riferimento all'email del documento principale (email) se specificato
+    if (email !== undefined) {
+        const emailMetadata = metadata.find(md => md.name?.toLowerCase() === 'email');
+        if (emailMetadata) {
+            engine.Metadata_AddString(emailMetadata.id, email);
+        }
+    }
+};
+/**
+ * Recupera il contesto necessario per l'importazione certificati.
+ * Legge i metadati freschi dal backend per ottenere l'email corrente.
+ */
+const getCertificateImportContext = async (dcmtInfo) => {
+    const dtdMaster = await DcmtTypeListCacheService.GetAsync(dcmtInfo.TID);
+    const emailDescriptor = dtdMaster?.metadata?.find(md => md.name?.toLowerCase() === 'email');
+    // Legge i metadati freschi dal backend per ottenere l'email aggiornata
+    let email;
+    if (emailDescriptor) {
+        const metadataResult = await SDK_Globals.tmSession?.NewSearchEngine().GetMetadataAsync(dcmtInfo.TID, dcmtInfo.DID, true);
+        if (metadataResult?.selectMIDs && metadataResult?.dtdResult?.rows?.[0]) {
+            const midIndex = metadataResult.selectMIDs.indexOf(emailDescriptor.id);
+            if (midIndex >= 0) {
+                email = metadataResult.dtdResult.rows[0][midIndex];
+            }
+        }
+    }
+    const allDtds = await DcmtTypeListCacheService.GetAllWithoutMetadataAsync();
+    const dtdDetailWithoutMetadata = allDtds.find(d => d.name?.toLowerCase() === S4T_CERTIFICATE_REGISTRY_DETAIL);
+    const dtdDetail = dtdDetailWithoutMetadata ? await DcmtTypeListCacheService.GetAsync(dtdDetailWithoutMetadata.id) : undefined;
+    if (!email || !dtdMaster || !dtdDetail) {
+        const missingItems = [];
+        if (!email)
+            missingItems.push('email');
+        if (!dtdMaster)
+            missingItems.push('dtdMaster');
+        if (!dtdDetail)
+            missingItems.push('dtdDetail');
+        return { missingItems };
+    }
+    return { email, dtdMaster, dtdDetail };
+};
+/**
+ * Costruisce la query per cercare certificati esistenti.
+ */
+const buildCertificateSearchQuery = (certificateTid, emailMid, cidMid, email, certificateCid) => {
+    const query = new QueryDescriptor();
+    query.from = new FromItem();
+    query.from.tid = certificateTid;
+    query.select = [];
+    const didSelectField = new SelectItem();
+    didSelectField.tid = query.from.tid;
+    didSelectField.mid = SystemMIDsAsNumber.DID;
+    query.select.push(didSelectField);
+    query.where = [];
+    // Condizione: email = email del documento padre
+    const emailCondition = new WhereItem();
+    emailCondition.tid = query.from.tid;
+    emailCondition.mid = emailMid;
+    emailCondition.value1 = email.toString();
+    emailCondition.or = false;
+    emailCondition.operator = QueryOperators.Equal;
+    query.where.push(emailCondition);
+    // Condizione: cid = CID del certificato remoto
+    const cidCondition = new WhereItem();
+    cidCondition.tid = query.from.tid;
+    cidCondition.mid = cidMid;
+    cidCondition.value1 = certificateCid.toString();
+    cidCondition.or = false;
+    cidCondition.operator = QueryOperators.Equal;
+    query.where.push(cidCondition);
+    return query;
+};
+/**
+ * Crea un nuovo documento certificato nel sistema.
+ */
+const createNewCertificateDocument = async (dtdDetail, remoteCertificate, email, abortSignal) => {
+    if (!dtdDetail)
+        throw new Error("DTD Detail non disponibile");
+    const ae = new ArchiveEngineByID(SDK_Globals.tmSession);
+    ae.TID = dtdDetail.id;
+    ae.Metadata_ClearAll();
+    setEngineMetadataFromCertificate(ae, dtdDetail.metadata ?? [], remoteCertificate, email);
+    await ae.ArchiveAsync(abortSignal);
+};
+/**
+ * Aggiorna i certificati esistenti con i dati del certificato remoto.
+ */
+const updateExistingCertificates = async (rows, dtdDetail, remoteCertificate, email) => {
+    if (!dtdDetail)
+        throw new Error("DTD Detail non disponibile");
+    await Promise.all(rows.map(async (row) => {
+        const did = row?.[0];
+        if (did === undefined)
+            return;
+        const ue = SDK_Globals.tmSession?.NewUpdateEngineByID();
+        if (!ue)
+            throw new Error("Update Engine not available");
+        ue.DID = Number(did);
+        ue.TID = dtdDetail.id;
+        ue.Metadata_ClearAll();
+        setEngineMetadataFromCertificate(ue, dtdDetail.metadata ?? [], remoteCertificate, email);
+        await ue.UpdateAsync();
+    }));
+};
+/**
+ * Risultato dell'importazione certificati per determinare come aggiornare il master.
+ * Valori corrispondenti alla datalist "SYSTEM - Flusso base":
+ * - 2: Elaborato con successo
+ * - 3: Elaborato con warning (es. nessun certificato trovato)
+ * - 4: Elaborato con errori
+ */
+var ProcessingResult;
+(function (ProcessingResult) {
+    ProcessingResult[ProcessingResult["SUCCESS"] = 2] = "SUCCESS";
+    ProcessingResult[ProcessingResult["WARNING"] = 3] = "WARNING";
+    ProcessingResult[ProcessingResult["ERROR"] = 4] = "ERROR";
+})(ProcessingResult || (ProcessingResult = {}));
+/** Lunghezza massima del campo processingResultDescription */
+const MAX_PROCESSING_RESULT_DESCRIPTION_LENGTH = 500;
+/** Tronca una stringa alla lunghezza massima consentita per processingResultDescription */
+const truncateProcessingResultDescription = (message) => {
+    if (message.length <= MAX_PROCESSING_RESULT_DESCRIPTION_LENGTH)
+        return message;
+    return message.substring(0, MAX_PROCESSING_RESULT_DESCRIPTION_LENGTH - 3) + '...';
+};
+/**
+ * Aggiorna il documento master con i metadati di elaborazione.
+ * - processingdate: data/ora corrente (solo se certificati trovati)
+ * - processingdatedescription: descrizione esito
+ * - guid: resettato (svuotato)
+ */
+const updateMasterDocument = async (dcmtInfo, dtdMaster, outcome, certificatesCount = 0, errorMessage) => {
+    const ue = SDK_Globals.tmSession?.NewUpdateEngineByID();
+    if (!ue)
+        throw new Error("Update Engine not available");
+    ue.DID = dcmtInfo.DID;
+    ue.TID = dcmtInfo.TID;
+    ue.Metadata_ClearAll();
+    const metadata = dtdMaster?.metadata ?? [];
+    // Trova i descrittori dei metadati (sempre in lowercase)
+    const processingDateDescriptor = metadata.find(md => md.name?.toLowerCase() === 'processingdate');
+    const processingResultDescriptor = metadata.find(md => md.name?.toLowerCase() === 'processingresult');
+    const processingResultDescriptionDescriptor = metadata.find(md => md.name?.toLowerCase() === 'processingresultdescription');
+    const guidDescriptor = metadata.find(md => md.name?.toLowerCase() === 'guid');
+    // Resetta sempre il metadato guid
+    if (guidDescriptor) {
+        ue.Metadata_AddString(guidDescriptor.id, '');
+    }
+    // Salva il risultato dell'elaborazione
+    if (processingResultDescriptor) {
+        if (processingResultDescriptor.dataListID) {
+            // Se esiste una datalist associata, usa il valore numerico
+            const dataList = await DataListCacheService.GetAsync(processingResultDescriptor.dataListID);
+            if (dataList && dataList.items) {
+                const itemExists = dataList.items.some((item) => Number(item.value) === outcome);
+                if (itemExists) {
+                    ue.Metadata_AddNumber(processingResultDescriptor.id, outcome);
+                }
+            }
+        }
+        else {
+            // Se non c'è datalist, salva come stringa
+            const outcomeString = ProcessingResult[outcome]; // "SUCCESS", "WARNING", "ERROR"
+            ue.Metadata_AddString(processingResultDescriptor.id, outcomeString);
+        }
+    }
+    // Aggiorna sempre la data di elaborazione
+    if (processingDateDescriptor) {
+        ue.Metadata_AddDateTime(processingDateDescriptor.id, new Date());
+    }
+    switch (outcome) {
+        case ProcessingResult.SUCCESS:
+            // ═══════════════════════════════════════════════════════════════════════════
+            // CASO 1: CERTIFICATI TROVATI
+            // ═══════════════════════════════════════════════════════════════════════════
+            // I certificati remoti sono stati trovati e importati con successo.
+            // ═══════════════════════════════════════════════════════════════════════════
+            if (processingResultDescriptionDescriptor) {
+                const message = certificatesCount === 1
+                    ? 'Importazione completata con successo: 1 certificato elaborato'
+                    : `Importazione completata con successo: ${certificatesCount} certificati elaborati`;
+                ue.Metadata_AddString(processingResultDescriptionDescriptor.id, truncateProcessingResultDescription(message));
+            }
+            break;
+        case ProcessingResult.WARNING:
+            // ═══════════════════════════════════════════════════════════════════════════
+            // CASO 2: NESSUN CERTIFICATO TROVATO (WARNING)
+            // ═══════════════════════════════════════════════════════════════════════════
+            // La chiamata al servizio remoto è andata a buon fine, ma non sono stati
+            // restituiti certificati per l'email associata al documento.
+            // ═══════════════════════════════════════════════════════════════════════════
+            if (processingResultDescriptionDescriptor) {
+                ue.Metadata_AddString(processingResultDescriptionDescriptor.id, truncateProcessingResultDescription('Nessun certificato trovato'));
+            }
+            break;
+        case ProcessingResult.ERROR:
+            // ═══════════════════════════════════════════════════════════════════════════
+            // CASO 3: ERRORE DI COMUNICAZIONE O RISPOSTA NON VALIDA
+            // ═══════════════════════════════════════════════════════════════════════════
+            // Si è verificato un errore durante la comunicazione con il servizio remoto
+            // (es: timeout chiamata API, errore 500, risposta malformata, ecc.)
+            // ═══════════════════════════════════════════════════════════════════════════
+            if (processingResultDescriptionDescriptor) {
+                ue.Metadata_AddString(processingResultDescriptionDescriptor.id, truncateProcessingResultDescription(errorMessage ?? 'Errore durante l\'importazione dei certificati'));
+            }
+            break;
+    }
+    await ue.UpdateAsync();
+};
+/**
+ * Importa i certificati remoti per il documento corrente.
+ * Verifica se esistono già certificati nel sistema e li aggiorna o crea nuovi.
+ * Aggiorna il documento master con i metadati di elaborazione.
+ *
+ * @returns Array di ImportResultInfo con eventuali warning, o undefined se tutto ok
+ */
+export const importCertificatesAsync = async (inputDcmt, rowIndex, fetchRemoteCertificates, abortSignal) => {
+    const warnings = [];
+    // Recupera il contesto di importazione (email e DTD del certificato)
+    const importContext = await getCertificateImportContext(inputDcmt);
+    if ('missingItems' in importContext) {
+        return [{ rowIndex, id1: inputDcmt.TID, id2: inputDcmt.DID, resultType: ResultTypes.WARNING, description: `Impossibile importare i certificati. Valori mancanti: ${importContext.missingItems.join(', ')}` }];
+    }
+    if (!fetchRemoteCertificates) {
+        return [{ rowIndex, id1: inputDcmt.TID, id2: inputDcmt.DID, resultType: ResultTypes.WARNING, description: 'Callback fetchRemoteCertificates non definita. Impossibile importare i certificati.' }];
+    }
+    const { email, dtdMaster, dtdDetail } = importContext;
+    // Recupera i certificati remoti con gestione errori
+    let remoteCertificates;
+    try {
+        remoteCertificates = await fetchRemoteCertificates(email);
+    }
+    catch (error) {
+        // Caso 3: errore di comunicazione o risposta non valida
+        const errorMessage = error instanceof Error ? error.message : 'Errore sconosciuto durante il recupero dei certificati';
+        await updateMasterDocument(inputDcmt, dtdMaster, ProcessingResult.ERROR, 0, errorMessage);
+        return [{ rowIndex, id1: inputDcmt.TID, id2: inputDcmt.DID, resultType: ResultTypes.WARNING, description: errorMessage }];
+    }
+    // Recupera i descrittori dei metadati necessari dal DTD
+    const dtd = await DcmtTypeListCacheService.GetAsync(dtdDetail?.id);
+    const emailDescriptor = dtd?.metadata?.find(md => md.name?.toLowerCase() === 'email');
+    const cidDescriptor = dtd?.metadata?.find(md => md.name?.toLowerCase() === 'ig_cid');
+    if (!emailDescriptor || !cidDescriptor) {
+        await updateMasterDocument(inputDcmt, dtdMaster, ProcessingResult.ERROR, 0, 'Metadati necessari per l\'importazione dei certificati non trovati nel DTD.');
+        return [{ rowIndex, id1: inputDcmt.TID, id2: inputDcmt.DID, resultType: ResultTypes.WARNING, description: 'Metadati necessari per l\'importazione dei certificati non trovati nel DTD.' }];
+    }
+    if (!remoteCertificates || remoteCertificates.length === 0) {
+        // Caso 2: nessun certificato trovato (warning)
+        await updateMasterDocument(inputDcmt, dtdMaster, ProcessingResult.WARNING);
+        return [{ rowIndex, id1: inputDcmt.TID, id2: inputDcmt.DID, resultType: ResultTypes.WARNING, description: 'Nessun certificato remoto trovato per questo documento.' }];
+    }
+    // Itera su ogni certificato remoto per verificare se esiste già nel sistema
+    // Conta i certificati effettivamente elaborati con successo
+    let successfullyProcessedCount = 0;
+    try {
+        await Promise.all(remoteCertificates.map(async (remoteCertificate) => {
+            // Validazione: il certificato deve avere un CID valido
+            if (remoteCertificate.cid === undefined) {
+                warnings.push({ rowIndex, id1: inputDcmt.TID, id2: inputDcmt.DID, resultType: ResultTypes.WARNING, description: 'Certificato remoto con informazioni incomplete (cid mancante). Impossibile importare questo certificato.' });
+                return;
+            }
+            // Costruisce la query per verificare se esiste già un documento certificato
+            const certificateSearchQuery = buildCertificateSearchQuery(dtdDetail?.id, emailDescriptor.id, cidDescriptor.id, email, remoteCertificate.cid);
+            // Esegue la ricerca
+            const searchEngine = SDK_Globals.tmSession?.NewSearchEngine();
+            if (!searchEngine)
+                throw new Error("Search Engine not available");
+            const existingCertificateResult = await searchEngine.SearchByIDAsync(certificateSearchQuery);
+            if (existingCertificateResult === undefined) {
+                warnings.push({ rowIndex, id1: inputDcmt.TID, id2: inputDcmt.DID, resultType: ResultTypes.WARNING, description: 'Errore durante la verifica dei certificati esistenti. Impossibile importare questo certificato.' });
+                return;
+            }
+            const dcmtsFound = existingCertificateResult.dcmtsFound ?? 0;
+            if (dcmtsFound === 0) {
+                // Crea nuovo certificato
+                await createNewCertificateDocument(dtdDetail, remoteCertificate, email, abortSignal);
+            }
+            else {
+                // Aggiorna certificati esistenti
+                await updateExistingCertificates(existingCertificateResult.dtdResult?.rows ?? [], dtdDetail, remoteCertificate, email);
+            }
+            // Incrementa il conteggio solo se l'elaborazione è andata a buon fine
+            successfullyProcessedCount++;
+        }));
+        // Determina l'esito in base ai certificati effettivamente elaborati
+        if (successfullyProcessedCount === 0) {
+            // Nessun certificato elaborato con successo (tutti senza CID o con errori)
+            await updateMasterDocument(inputDcmt, dtdMaster, ProcessingResult.ERROR, 0, 'Errore durante l\'importazione dei certificati: nessun certificato valido trovato');
+        }
+        else {
+            // Almeno un certificato elaborato con successo
+            await updateMasterDocument(inputDcmt, dtdMaster, ProcessingResult.SUCCESS, successfullyProcessedCount);
+        }
+    }
+    catch (error) {
+        // Caso 3: errore durante l'importazione
+        const errorMessage = error instanceof Error ? error.message : 'Errore durante l\'importazione dei certificati';
+        await updateMasterDocument(inputDcmt, dtdMaster, ProcessingResult.ERROR, 0, errorMessage);
+        warnings.push({ rowIndex, id1: inputDcmt.TID, id2: inputDcmt.DID, resultType: ResultTypes.WARNING, description: errorMessage });
+    }
+    return warnings.length > 0 ? warnings : undefined;
+};
+export const archiveUserRegistryDocument = async (abortSignal, params) => {
+    try {
+        const allDtds = await DcmtTypeListCacheService.GetAllWithoutMetadataAsync();
+        const dtdMasterWithoutMetadata = allDtds.find(d => d.name?.toLowerCase() === S4T_USER_REGISTRY_MASTER);
+        const dtdMaster = dtdMasterWithoutMetadata ? await DcmtTypeListCacheService.GetAsync(dtdMasterWithoutMetadata.id) : undefined;
+        if (!dtdMaster) {
+            throw new Error(`DTD Master "${S4T_USER_REGISTRY_MASTER}" non trovato`);
+        }
+        const ae = new ArchiveEngineByID(SDK_Globals.tmSession);
+        ae.TID = dtdMaster.id;
+        ae.Metadata_ClearAll();
+        // Aggiunge i metadati dall'oggetto params
+        const metadata = dtdMaster.metadata ?? [];
+        const emailDescriptor = metadata.find(md => md.name?.toLowerCase() === 'email');
+        if (emailDescriptor)
+            ae.Metadata_AddString(emailDescriptor.id, params.email);
+        const fiscalCodeDescriptor = metadata.find(md => md.name?.toLowerCase() === 'fiscalcode');
+        if (fiscalCodeDescriptor)
+            ae.Metadata_AddString(fiscalCodeDescriptor.id, params.fiscalCode);
+        const phoneNumberDescriptor = metadata.find(md => md.name?.toLowerCase() === 'phonenumber');
+        if (phoneNumberDescriptor)
+            ae.Metadata_AddString(phoneNumberDescriptor.id, params.phoneNumber);
+        const nameDescriptor = metadata.find(md => md.name?.toLowerCase() === 'name');
+        if (nameDescriptor)
+            ae.Metadata_AddString(nameDescriptor.id, params.name);
+        const surnameDescriptor = metadata.find(md => md.name?.toLowerCase() === 'surname');
+        if (surnameDescriptor)
+            ae.Metadata_AddString(surnameDescriptor.id, params.surname);
+        const typeDescriptor = metadata.find(md => md.name?.toLowerCase() === 'certificatemethod');
+        if (typeDescriptor)
+            ae.Metadata_AddString(typeDescriptor.id, params.type);
+        await ae.ArchiveAsync(abortSignal);
+    }
+    catch (error) {
+        throw error;
+    }
+};

package/lib/helper/checkinCheckoutManager.d.ts

@@ -1,7 +1,8 @@
 import React from "react";
-import { AccessLevels, DcmtTypeDescriptor, FileDescriptor, UserDescriptor } from "@topconsultnpm/sdk-ts";
-import { DcmtInfo, DownloadModes, DownloadTypes } from "../ts/types";
+import { AccessLevels, DcmtTypeDescriptor, UserDescriptor } from "@topconsultnpm/sdk-ts";
+import { DcmtInfo } from "../ts/types";
 import { FileItem } from "../components";
+import { DownloadDcmtsAsyncParams } from "../hooks/useDcmtOperations";
 /**
  * Check-in/Check-out Manager
  * Questo modulo gestisce tutte le operazioni di check-in e check-out
@@ -42,7 +43,7 @@ export type DownloadSource = {
     originalFileName: string;
 };
 export declare const getCicoDownloadFileName: (source: DownloadSource, checkout: boolean, withTimestampAndExt: boolean) => string;
-export declare const cicoDownloadFilesCallback: (sources: Array<DownloadSource>, checkout: boolean, downloadDcmtsAsync: (inputDcmts: Array<DcmtInfo> | undefined, downloadType?: DownloadTypes, downloadMode?: DownloadModes, onFileDownloaded?: (dcmtFile: File) => void, confirmAttachments?: (list: FileDescriptor[]) => Promise<string[] | undefined>, skipConfirmation?: boolean) => Promise<void>) => Promise<void>;
+export declare const cicoDownloadFilesCallback: (sources: Array<DownloadSource>, checkout: boolean, downloadDcmtsAsync: (params: DownloadDcmtsAsyncParams) => Promise<void>) => Promise<void>;
 export declare const updateCicoCheckoutStorageItem: (item: CheckoutInfo, type: "fileItem" | "dcmtInfo", action?: "addOrUpdate" | "remove") => void;
 export declare const validateCicoFileName: (source: DownloadSource, fileName: string, checkoutDate?: string | null) => FileNameValidation;
 type ValidationResult = {

package/lib/helper/checkinCheckoutManager.js

@@ -2,6 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { AccessLevels, CICO_MetadataNames, SDK_Globals, SystemMIDsAsNumber } from "@topconsultnpm/sdk-ts";
 import TMTooltip from "../components/base/TMTooltip";
 import { dcmtsFileCachePreview, Globalization, removeDcmtsFileCache, SDKUI_Globals, SDKUI_Localizator } from "./index";
+import { getBaseExtension, getFullFileExtension } from "./TMUtils";
 import { DownloadTypes } from "../ts/types";
 const findCheckOutUserName = (users, checkoutUserId) => {
     let checkOutUser = users.find(user => user.id === checkoutUserId);
@@ -74,7 +75,7 @@ export const cicoDownloadFilesCallback = async (sources, checkout, downloadDcmts
         }
     });
     if (files.length > 0) {
-        await downloadDcmtsAsync(files, DownloadTypes.Dcmt, "download");
+        await downloadDcmtsAsync({ inputDcmts: files, downloadType: DownloadTypes.Dcmt, downloadMode: "download", skipConfirmation: true, useInputFileName: true });
     }
 };
 export const updateCicoCheckoutStorageItem = (item, type, action = "addOrUpdate") => {
@@ -128,13 +129,22 @@ export const validateCicoFileName = (source, fileName, checkoutDate) => {
         did = DID;
         ext = FILEEXT;
     }
-    // Ensure originalName has the extension
-    const normalizedExt = ext?.toLowerCase() ?? '';
-    const name = baseName.toLowerCase().endsWith(`.${normalizedExt}`) ? baseName : `${baseName}.${normalizedExt}`;
+    // Ensure originalName has the extension (use base extension for comparison)
+    const sourceBaseExt = getBaseExtension(ext ?? '');
+    const name = baseName.toLowerCase().endsWith(`.${sourceBaseExt}`) ? baseName : `${baseName}.${sourceBaseExt}`;
     let fileNameToValidate = fileName;
-    const fileExtensionCheck = fileNameToValidate.split('.').pop() ?? '';
-    // Remove extension part
-    fileNameToValidate = fileNameToValidate.slice(0, -fileExtensionCheck.length - 1);
+    // Estrai l'estensione completa (incluse eventuali firme digitali ricorsive es. pdf.p7m.tsd)
+    const fullExtension = getFullFileExtension(fileNameToValidate);
+    let fileExtensionCheck;
+    if (fullExtension) {
+        // Rimuovi l'estensione completa dal nome
+        fileNameToValidate = fileNameToValidate.slice(0, -fullExtension.length);
+        // L'estensione base è la prima parte (es. da ".pdf.p7m.tsd" prendi "pdf")
+        fileExtensionCheck = fullExtension.substring(1).split('.')[0];
+    }
+    else {
+        fileExtensionCheck = '';
+    }
     // Check and remove 'checkout~' prefix if present
     const hasCheckoutPrefix = fileNameToValidate.startsWith('checkout~');
     if (hasCheckoutPrefix) {
@@ -159,7 +169,7 @@ export const validateCicoFileName = (source, fileName, checkoutDate) => {
     const isValidDid = didCheck ? did.toString() === parseInt(didCheck, 10).toString() : false;
     const isValidTid = tidCheck ? tid.toString() === parseInt(tidCheck, 10).toString() : false;
     const isValidArchive = archiveCheck ? archiveCheck === archiveID : false;
-    const isValidExt = ext ? ext.toLowerCase() === fileExtensionCheck.toLowerCase() : false;
+    const isValidExt = sourceBaseExt ? sourceBaseExt === fileExtensionCheck.toLowerCase() : false;
     // First phase validation result
     const isFirstPhaseValid = !!(isValidName && isValidArchive && isValidDid && isValidTid && isValidExt);
     // Second phase: validate checkoutDate timestamp (only if first phase passed and checkoutDate is a valid string)
@@ -177,11 +187,11 @@ export const validateCicoFileName = (source, fileName, checkoutDate) => {
             else {
                 const pad = (n) => n.toString().padStart(2, '0');
                 const expectedTimestamp = `${dt.getFullYear()}${pad(dt.getMonth() + 1)}${pad(dt.getDate())}${pad(dt.getHours())}${pad(dt.getMinutes())}${pad(dt.getSeconds())}`;
-                isSecondPhaseValid = timestampCheck === expectedTimestamp;
                 // Format dates for display: readable date + (raw timestamp)
                 const expectedDisplayDate = Globalization.getDateTimeDisplayValue(dt);
                 // Parse timestampCheck to readable format (YYYYMMDDHHmmss -> Date)
                 let currentDisplayDate = timestampCheck;
+                let parsedDate = null;
                 if (timestampCheck && timestampCheck.length === 14) {
                     const year = parseInt(timestampCheck.substring(0, 4), 10);
                     const month = parseInt(timestampCheck.substring(4, 6), 10) - 1;
@@ -189,9 +199,17 @@ export const validateCicoFileName = (source, fileName, checkoutDate) => {
                     const hours = parseInt(timestampCheck.substring(8, 10), 10);
                     const minutes = parseInt(timestampCheck.substring(10, 12), 10);
                     const seconds = parseInt(timestampCheck.substring(12, 14), 10);
-                    const parsedDate = new Date(year, month, day, hours, minutes, seconds);
+                    parsedDate = new Date(year, month, day, hours, minutes, seconds);
                     currentDisplayDate = Globalization.getDateTimeDisplayValue(parsedDate);
                 }
+                // Validate with ±10 seconds tolerance
+                if (parsedDate && !isNaN(parsedDate.getTime())) {
+                    const diffInSeconds = Math.abs((dt.getTime() - parsedDate.getTime()) / 1000);
+                    isSecondPhaseValid = diffInSeconds <= 10;
+                }
+                else {
+                    isSecondPhaseValid = timestampCheck === expectedTimestamp;
+                }
                 checkoutDateValidation = {
                     expected: `${expectedDisplayDate} (${expectedTimestamp})`,
                     current: `${currentDisplayDate} (${timestampCheck})`,
@@ -229,7 +247,7 @@ export const validateCicoFileName = (source, fileName, checkoutDate) => {
                 isValid: isValidTid
             },
             fileExtension: {
-                expected: ext?.toLowerCase(),
+                expected: sourceBaseExt,
                 current: fileExtensionCheck.toLowerCase(),
                 isValid: isValidExt
             },

package/lib/helper/helpers.d.ts

@@ -52,7 +52,7 @@ export { openApps, calcResponsiveDirection, calcResponsiveSizes, taskModalSizes,
 export declare function moduleVersion(module: moduleTypes): string;
 export declare function buildtype(module: moduleTypes): string;
 export declare const highlightText: (text: string, searchValue: string) => JSX.Element;
-export declare const renderHighlightedText: (text: string, searchText: string, isSelected: boolean) => string | (string | import("react/jsx-runtime").JSX.Element)[];
+export declare const renderHighlightedText: (text: string, searchText: string, isSelected: boolean) => string | (string | import("react").JSX.Element)[];
 export declare function versionAndBuildtypeInfo(module: moduleTypes): string;
 export declare const getListMaxItems: (deviceType: DeviceType | undefined) => number;
 export declare const svgToString: (icon: React.ReactElement) => string;
@@ -72,7 +72,8 @@ export declare enum LandingPages {
     AREA_MANAGER = "areaManager",
     NOTIFICATIONS = "notifications",
     ACTIVITIES = "activities",
-    WORKFLOW_CTRL = "workflowCtrl"
+    WORKFLOW_CTRL = "workflowCtrl",
+    CASEFLOW = "caseflow"
 }
 export declare function getExceptionMessage(ex: any): string;
 export declare function getContrastColor(inputColor: string): {

package/lib/helper/helpers.js

@@ -461,6 +461,15 @@ export const extensionHandler = (fileExt) => {
         case 'docx':
         case 'docx.p7m':
         case 'docx.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'dotm':
+        case 'dotm.p7m':
+        case 'dotm.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'docm':
+        case 'docm.p7m':
+        case 'docm.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
+        case 'dotx':
+        case 'dotx.p7m':
+        case 'dotx.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
         case 'xls':
         case 'xls.p7m':
         case 'xls.p7m.ts': return FileExtensionHandler.CONVERTIBLE;
@@ -747,6 +756,7 @@ export var LandingPages;
     LandingPages["NOTIFICATIONS"] = "notifications";
     LandingPages["ACTIVITIES"] = "activities";
     LandingPages["WORKFLOW_CTRL"] = "workflowCtrl";
+    LandingPages["CASEFLOW"] = "caseflow";
 })(LandingPages || (LandingPages = {}));
 // #endregion
 // #region Exception

package/lib/helper/index.d.ts

@@ -16,3 +16,4 @@ export * from './checkinCheckoutManager';
 export * from './workItemsHelper';
 export * from './devextremeCustomMessages';
 export * from './ZipManager';
+export * from './certificateImportHelper';

package/lib/helper/index.js

@@ -16,3 +16,4 @@ export * from './checkinCheckoutManager';
 export * from './workItemsHelper';
 export * from './devextremeCustomMessages';
 export * from './ZipManager';
+export * from './certificateImportHelper';

package/lib/hooks/useCheckInOutOperations.d.ts

@@ -1,5 +1,6 @@
-import { DcmtInfo, DownloadModes, DownloadTypes } from '../ts';
-import { FileDescriptor, SearchResultDescriptor } from '@topconsultnpm/sdk-ts';
+import { DcmtInfo } from '../ts';
+import { SearchResultDescriptor } from '@topconsultnpm/sdk-ts';
+import { DownloadDcmtsAsyncParams } from './useDcmtOperations';
 export interface UseCheckInOutOperationsProps {
     onRefreshPreview: () => Promise<void>;
 }
@@ -17,7 +18,7 @@ export interface UseCheckInOutOperationsReturn {
     };
     hideCommentFormCallback: () => void;
     copyCheckoutPathToClipboardCallback: (dcmt: DcmtInfo, filename: string) => void;
-    handleCheckOutCallback: (dcmt: DcmtInfo, checkout: boolean, filename: string, downloadDcmtsAsync: (inputDcmts: Array<DcmtInfo> | undefined, downloadType?: DownloadTypes, downloadMode?: DownloadModes, onFileDownloaded?: (dcmtFile: File) => void, confirmAttachments?: (list: FileDescriptor[]) => Promise<string[] | undefined>, skipConfirmation?: boolean) => Promise<void>, onRefreshAsync?: (tid: number | undefined, did: number | undefined, refreshUI?: boolean, metadataResult?: SearchResultDescriptor | null) => Promise<void>) => Promise<void>;
+    handleCheckOutCallback: (dcmt: DcmtInfo, checkout: boolean, filename: string, downloadDcmtsAsync: (params: DownloadDcmtsAsyncParams) => Promise<void>, onRefreshAsync?: (tid: number | undefined, did: number | undefined, refreshUI?: boolean, metadataResult?: SearchResultDescriptor | null) => Promise<void>) => Promise<void>;
     handleCheckInCallback: (dcmt: DcmtInfo, checkoutDate?: string | null, onRefreshAsync?: (tid: number | undefined, did: number | undefined, refreshUI?: boolean, metadataResult?: SearchResultDescriptor | null) => Promise<void>) => Promise<void>;
     showCicoWaitPanel: boolean;
     cicoWaitPanelTitle: string;

package/lib/hooks/useDataUserIdItem.js

@@ -74,7 +74,7 @@ export const useDataUserIdItem = () => {
         const getIcon = () => {
             if (!showIcon)
                 return null;
-            if (userId === undefined)
+            if (userId === undefined || userId === null)
                 return null;
             return ud ? _jsx(TMUserIcon, { ud: ud }) : _jsx("span", { title: showTitile ? SDKUI_Localizator.ValueNotPresent : undefined, style: { display: 'inline-flex', alignItems: 'center' }, children: _jsx(IconWarning, { color: TMColors.warning }) });
         };