@topconsultnpm/sdkui-react 6.20.0-dev1.15 → 6.20.0-dev1.16

package/lib/helper/TMUtils.js

@@ -0,0 +1,435 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import styled from "styled-components";
+import { TMTooltip } from '../components';
+import { IconCADossier, IconKey, IconMenuCAWorkingGroups } from './TMIcons';
+import { DataListCacheService, MetadataDataDomains, PdGs } from '@topconsultnpm/sdk-ts';
+import { SDKUI_Localizator } from './SDKUI_Localizator';
+const StyledIconFileContainer = styled.div ` 
+    height: 22px;
+    width: 18px;
+    border-radius: 5px;
+    background-color: #d2dae2;
+    position: relative;
+`;
+const StyledIconFileExt = styled.div ` 
+    top: 25%;
+    width: 30px;
+    left: -6px;
+    border-radius: 5px;
+    background-color: ${props => props.$backgroundColor};
+    color: ${props => props.$color};
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 0.7rem;
+    position: absolute;
+    height: 12px;
+`;
+export const getFileIcon = (fileExtension, fileCount, tooltipContent) => {
+    if (!fileExtension)
+        fileExtension = "";
+    if (fileExtension.startsWith("."))
+        fileExtension = fileExtension.substring(1).toUpperCase();
+    let fileExtOri = fileExtension;
+    fileExtension = fileExtension.replace(".P7M", "").replace(".M7M", "").replace(".TSR", "").replace(".TSD", "").replace(".TS", "");
+    let fileBgColor;
+    let fileColor = "#FFFFFF";
+    switch (fileExtension) {
+        case "PDF":
+            fileBgColor = '#F15642';
+            break;
+        case "XLS":
+        case "XLSX":
+        case "CSV":
+            fileBgColor = '#1d6f42';
+            break;
+        case "PEC":
+            fileBgColor = '#F15642';
+            break;
+        case "MSG":
+        case "EML":
+        case "RTF":
+        case "DOC":
+        case "DOTX":
+        case "DOCX":
+            fileBgColor = '#205ccc';
+            break;
+        case 'PPT':
+        case 'PPTX':
+            fileBgColor = '#c45a1c';
+            break;
+        case 'PNG':
+        case 'JPG':
+        case 'JPEG':
+        case 'SVG':
+        case 'TIFF':
+        case 'TIF':
+        case 'ICO':
+        case 'GIF':
+        case 'DWG':
+        case 'DCM':
+        case 'SLDDRW':
+        case 'WEBP':
+            fileBgColor = '#A066AA';
+            break;
+        case 'HTM':
+        case 'HTML':
+        case 'TXT':
+        case 'XML':
+            fileBgColor = '#576D7E';
+            break;
+        default:
+            fileBgColor = '#576D7E';
+            break;
+    }
+    return (_jsx(StyledIconFileContainer, { children: _jsx(StyledIconFileExt, { "$backgroundColor": (fileCount === 0 || !fileExtension) ? "#424040" : fileBgColor, "$color": fileColor, children: (fileCount === 0 || !fileExtOri)
+                ? _jsxs(TMTooltip, { content: SDKUI_Localizator.MetadataOnlyDocument, children: [" ", _jsx(IconKey, { fontSize: 17, color: '#f8d775' }), " "] })
+                : _jsx(TMTooltip, { content: tooltipContent ?? fileExtOri, children: fileExtension.toUpperCase() }) }) }));
+};
+export function formatBytes(bytes, decimalPlaces = 2) {
+    if (!bytes)
+        return '0 B';
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    const value = parseFloat((bytes / Math.pow(k, i)).toFixed(decimalPlaces));
+    return `${value} ${units[i]}`;
+}
+// Function to associate columns to rows and return an array of RowData objects
+export const associateColumnsToRows = (columns, rows) => {
+    if (columns === undefined || rows === undefined)
+        return [];
+    // Map over each row and associate each value with the corresponding column's caption
+    return rows.map(row => {
+        // Create an empty object to hold the key-value pairs for each row
+        const rowObject = {};
+        // Loop through each cell in the row and map its value to the corresponding column's caption
+        row.forEach((value, index) => {
+            const column = columns[index]; // Get the column corresponding to the current index
+            // If a column exists at this index, add the value to the rowObject with the column's caption as the key
+            if (column && column.caption) {
+                rowObject[column.caption] = value;
+            }
+        });
+        // Return the populated rowObject, which represents the row with columns as keys
+        return rowObject;
+    });
+};
+export const buildValueToLabelMapFromDataColumns = async (columns) => {
+    const valueToNameMap = new Map();
+    const dataListColumns = columns.filter(col => {
+        const dataDomainRaw = col.extendedProperties?.["DataDomain"];
+        const dataDomain = MetadataDataDomains[(dataDomainRaw ?? "None")];
+        return dataDomain === MetadataDataDomains.DataList;
+    });
+    for (const col of dataListColumns) {
+        const tid = Number(col.extendedProperties?.["TID"]);
+        const mid = Number(col.extendedProperties?.["MID"]);
+        const dataListID = Number(col.extendedProperties?.["DataListID"]);
+        if (tid && mid && dataListID) {
+            const tid_mid = `${tid}_${mid}`;
+            valueToNameMap.set(tid_mid, new Map());
+            const dl = await DataListCacheService.GetAsync(dataListID);
+            dl?.items?.forEach((item) => {
+                if (item?.name !== undefined && item?.value !== undefined) {
+                    valueToNameMap.get(tid_mid)?.set(item.value, item.name);
+                }
+            });
+        }
+    }
+    return valueToNameMap;
+};
+export const getAvatarColor = (name) => {
+    const colors = [
+        '#6264A7', '#8C6BAD', '#C239B3', '#E33B9A', '#F2707C',
+        '#FF8C00', '#CA5010', '#8E562E', '#498205', '#107C10',
+        '#0078D4', '#038387', '#8764B8', '#881798', '#C50E20'
+    ];
+    const hash = name.split('').reduce((acc, char) => char.charCodeAt(0) + acc, 0);
+    return colors[hash % colors.length];
+};
+export const extractInitialsFromName = (name) => {
+    if (!name)
+        return '';
+    const lettersOnly = name.replace(/[^a-zA-Z]/g, '');
+    if (lettersOnly.length === 0) {
+        return name[0]?.toUpperCase() || '';
+    }
+    if (lettersOnly.toLowerCase() === 'sysadmin') {
+        return 'SYS';
+    }
+    return lettersOnly.substring(0, 2).toUpperCase();
+};
+export const SIGN4_TOP_WIDGET_ID = "60003";
+export const CREATE_CERTIFICATE_WIDGET_ID = "60003_1";
+export const PDF_EDITOR_ID = "60007";
+export const isWidgetEnabled = (widgetId, widgetsString) => {
+    const widgets = widgetsString.split(";").filter(Boolean);
+    return widgets.includes(widgetId);
+};
+export const isSign4TopEnabled = (widgetsString) => {
+    return isWidgetEnabled(SIGN4_TOP_WIDGET_ID, widgetsString);
+};
+export const isCreateCertificateEnabled = (widgetsString) => {
+    return isWidgetEnabled(CREATE_CERTIFICATE_WIDGET_ID, widgetsString);
+};
+export const isPdfEditorEnabled = (widgetsString) => {
+    return isWidgetEnabled(PDF_EDITOR_ID, widgetsString);
+};
+export const StyledTabItem = styled.div `
+  display: flex;
+  align-items: center;
+  padding: 6px 12px;
+  border-radius: 8px;
+  font-weight: ${({ $isSelected }) => ($isSelected ? 'bold' : 'normal')};
+  color: ${({ $isSelected }) => ($isSelected ? '#fff' : '#000')};
+  background: ${({ $isSelected }) => $isSelected
+    ? 'linear-gradient(270deg, #46B5A2 16%, #3BAABC 34%, #3BAABC 34%, #3681AD 54%, #3368A5 72%, #2F549D 88%, #304F99 100%)'
+    : 'transparent'};
+  transition: background-color 0.2s ease;
+  font-size: 1rem;
+  &:hover {
+    background: ${({ $isSelected }) => ($isSelected ? null : 'rgba(0, 0, 0, 0.05)')};
+  }
+`;
+export const StyledTabIcon = styled.i `
+  cursor: pointer;
+  font-size: 16px;
+  color: ${({ $isSelected }) => ($isSelected ? '#fff !important' : '#000 !important')};
+  transition: color 0.2s ease;
+`;
+export const TMCountBadge = styled.div ` background-color: #ff5252; color: white; border-radius: 999px; margin-left: 8px; font-size: 0.7rem; line-height: 1; min-height: 20px; min-width: 20px; display: flex ; align-items: center; justify-content: center; `;
+export const getPdgsIconMap = (fontSize = 20) => {
+    return new Map([
+        [PdGs.None, _jsx("span", {}, "PdGs-None")],
+        [PdGs.CF, _jsx(IconCADossier, { color: "#e65b00", fontSize: 28 }, "PdGs-CF")],
+        [PdGs.DT, _jsx("i", { style: { fontSize, color: '#b38600' }, className: "dx-icon-file" }, "PdGs-DT")],
+        [PdGs.WF, _jsx("i", { style: { fontSize }, className: "dx-icon-box" }, "PdGs-WF")],
+        [PdGs.WG, _jsx(IconMenuCAWorkingGroups, { color: "#009700", fontSize: 28 }, "PdGs-WG")],
+    ]);
+};
+/**
+ * Analizza e configura i parametri delle informazioni di firma per un documento.
+ *
+ * @param did - ID del documento
+ * @param informationSign - Stringa di configurazione della firma
+ * @param firstName - Nome del firmatario
+ * @param lastName - Cognome del firmatario
+ * @param title - Titolo del documento (per messaggi di errore)
+ *
+ * @returns Oggetto contenente le configurazioni dei campi della firma
+ *
+ * @example
+ * // Formati supportati:
+ *
+ * // 1. Configurazione predefinita (vuoto o undefined): solo data attiva
+ * parseSignatureConfiguration(1, undefined, "Mario", "Rossi", "Doc1")
+ *
+ * // 2. "All" - Tutti i campi attivi con valori di default
+ * parseSignatureConfiguration(1, "All", "Mario", "Rossi", "Doc1")
+ *
+ * // 3. "None" - Nessun campo attivo
+ * parseSignatureConfiguration(1, "None", "Mario", "Rossi", "Doc1")
+ *
+ * // 4. Formato con valori espliciti: Key=Value
+ * parseSignatureConfiguration(1, "Date=Yes,SignerBy=Mario,Location=Milano,Copyright=TopConsult", ...)
+ *
+ * // 5. Formato chiavi semplici (attiva i default): key1,key2,key3
+ * parseSignatureConfiguration(1, "date,signerby,location", "Mario", "Rossi", "Doc1")
+ *
+ * // 6. Formato misto
+ * parseSignatureConfiguration(1, "date,SignerBy=Yes,Location=Roma", "Mario", "Rossi", "Doc1")
+ */
+export const parseSignatureConfiguration = (did, informationSign, firstName, lastName, title) => {
+    try {
+        // Rimuove spazi dalla stringa di input mantenendo il case originale
+        const signatureSign = informationSign?.trim();
+        // Definisce i valori di default per ciascun campo
+        const defaultLocationValue = SDKUI_Localizator.Torino;
+        const defaultCopyrightValue = "Sign4Top";
+        const defaultSignerByValue = `${firstName ?? ''} ${lastName ?? ''}`.trim() || '';
+        // Configurazione di default: solo data attiva
+        const defaultInfo = {
+            allowDate: true,
+            allowSignerBy: false,
+            signerByValue: defaultSignerByValue,
+            allowLocation: false,
+            locationValue: defaultLocationValue,
+            allowCopyright: false,
+            copyrightValue: defaultCopyrightValue
+        };
+        // Se la stringa è vuota o non definita, ritorna la configurazione di default
+        if (!signatureSign || signatureSign.length === 0) {
+            return defaultInfo;
+        }
+        // Caso speciale: "all" attiva tutti i campi con valori di default
+        if (signatureSign.toLowerCase() === "all") {
+            return {
+                allowDate: true,
+                allowSignerBy: true,
+                signerByValue: defaultSignerByValue,
+                allowLocation: true,
+                locationValue: defaultLocationValue,
+                allowCopyright: true,
+                copyrightValue: defaultCopyrightValue
+            };
+        }
+        // Caso speciale: "none" disattiva tutti i campi
+        if (signatureSign.toLowerCase() === "none") {
+            return {
+                allowDate: false,
+                allowSignerBy: false,
+                signerByValue: defaultSignerByValue,
+                allowLocation: false,
+                locationValue: defaultLocationValue,
+                allowCopyright: false,
+                copyrightValue: defaultCopyrightValue
+            };
+        }
+        // Chiavi ammesse per la configurazione
+        const allowedKeys = ["date", "signerby", "location", "copyright"];
+        // Suddivisione della stringa in parti separate da virgola
+        const infoParts = signatureSign.split(',').map(part => part.trim()).filter(Boolean);
+        // Validazione preventiva di tutte le chiavi
+        const invalidKeys = [];
+        for (const part of infoParts) {
+            const [key] = part.split("=");
+            const currentKey = key.trim().toLowerCase();
+            if (!allowedKeys.includes(currentKey)) {
+                invalidKeys.push(key.trim());
+            }
+        }
+        // Se ci sono chiavi non valide, lancia un errore unico
+        if (invalidKeys.length > 0) {
+            throw new Error(`${invalidKeys.length > 1 ? 'I parametri' : 'Il parametro'} "${invalidKeys.join('", "')}" non ${invalidKeys.length > 1 ? 'sono riconosciuti' : 'è riconosciuto'} nel campo "informationSign" per il documento "${title || did}". ` +
+                `I parametri ammessi sono: ${allowedKeys.join(", ")}. ` +
+                `Il valore attuale del campo è "${informationSign}"`);
+        }
+        // Clone della configurazione di default per la modifica
+        const info = { ...defaultInfo };
+        // Itera su ogni parte della configurazione
+        for (const part of infoParts) {
+            const [key, ...valueParts] = part.split("=");
+            const currentKey = key.trim().toLowerCase();
+            // Ricostruisce il valore nel caso contenga "=" al suo interno
+            const rawValue = valueParts.join("=").trim();
+            // Rimuove le virgolette dall'inizio e dalla fine del valore
+            const currentValue = rawValue.replace(/^["']|["']$/g, "");
+            // Helper per gestire i valori booleani e custom
+            const parseBooleanOrValue = (value) => {
+                const valueLower = value.toLowerCase();
+                if (valueLower === "no" || valueLower === "false")
+                    return { enabled: false };
+                if (valueLower === "yes" || valueLower === "true" || !value)
+                    return { enabled: true };
+                return { enabled: true, customValue: value };
+            };
+            // Processa ciascuna chiave in base al tipo
+            if (part.includes("=")) {
+                // Formato: Key=Value
+                switch (currentKey) {
+                    case "date":
+                        // Data supporta solo Yes/No/True/False
+                        const dateLower = currentValue.toLowerCase();
+                        info.allowDate = dateLower === "yes" || dateLower === "true";
+                        break;
+                    case "signerby": {
+                        const parsed = parseBooleanOrValue(currentValue);
+                        info.allowSignerBy = parsed.enabled;
+                        info.signerByValue = parsed.customValue || defaultSignerByValue;
+                        break;
+                    }
+                    case "location": {
+                        const parsed = parseBooleanOrValue(currentValue);
+                        info.allowLocation = parsed.enabled;
+                        info.locationValue = parsed.customValue || defaultLocationValue;
+                        break;
+                    }
+                    case "copyright": {
+                        const parsed = parseBooleanOrValue(currentValue);
+                        info.allowCopyright = parsed.enabled;
+                        info.copyrightValue = parsed.customValue || defaultCopyrightValue;
+                        break;
+                    }
+                }
+            }
+            else {
+                // Formato: Key (attiva il campo con valore di default)
+                switch (currentKey) {
+                    case "date":
+                        info.allowDate = true;
+                        break;
+                    case "signerby":
+                        info.allowSignerBy = true;
+                        info.signerByValue = defaultSignerByValue;
+                        break;
+                    case "location":
+                        info.allowLocation = true;
+                        info.locationValue = defaultLocationValue;
+                        break;
+                    case "copyright":
+                        info.allowCopyright = true;
+                        info.copyrightValue = defaultCopyrightValue;
+                        break;
+                }
+            }
+        }
+        return info;
+    }
+    catch (error) {
+        throw error;
+    }
+};
+export const convertSearchResultDescriptorToFileItems = (documents) => {
+    const fileItems = [];
+    documents.forEach((doc, docIndex) => {
+        const columns = doc.dtdResult?.columns || [];
+        const rows = doc.dtdResult?.rows || [];
+        // Map column captions to their indexes for quick lookup
+        const colIndexMap = {};
+        columns.forEach((col, i) => {
+            if (col.caption !== undefined) {
+                colIndexMap[col.caption] = i;
+            }
+        });
+        const getVal = (row, caption) => {
+            const idx = colIndexMap[caption];
+            return idx !== undefined ? row[idx] : undefined;
+        };
+        rows.forEach((row, rowIndex) => {
+            let baseName = doc.fromName || `Document ${docIndex + 1}`;
+            const did = getVal(row, 'DID');
+            const fileExt = getVal(row, 'FileExt');
+            const tid = getVal(row, 'TID');
+            const fileSize = getVal(row, 'FileSize');
+            if (did) {
+                baseName += ` (DID: ${did})`;
+            }
+            if (fileExt) {
+                baseName += `.${fileExt}`;
+            }
+            fileItems.push({
+                id: did ? Number(did) : Number(`${docIndex}${rowIndex}`),
+                name: baseName,
+                isDirectory: false,
+                items: [],
+                tid: tid !== undefined ? Number(tid) : undefined,
+                did: did !== undefined ? Number(did) : undefined,
+                ext: fileExt ?? undefined,
+                size: fileSize !== undefined ? Number(fileSize) : 1,
+                creationTime: undefined,
+                lastUpdateTime: undefined,
+                updaterID: undefined,
+                updaterName: undefined,
+                description: undefined,
+                checkOutUserID: undefined,
+                checkOutUserName: undefined,
+                checkoutDate: null,
+                version: undefined,
+            });
+        });
+    });
+    return fileItems;
+};

package/lib/helper/checkinCheckoutManager.d.ts

@@ -0,0 +1,84 @@
+import React from "react";
+import { AccessLevels, DcmtTypeDescriptor, FileDescriptor, UserDescriptor } from "@topconsultnpm/sdk-ts";
+import { DcmtInfo, DownloadModes, DownloadTypes } from "../ts/types";
+import { FileItem } from "../components";
+/**
+ * Check-in/Check-out Manager
+ * Questo modulo gestisce tutte le operazioni di check-in e check-out
+ * dei documenti e delle bozze dei gruppi di lavoro.
+ *
+ * Operazioni gestite:
+ * - Generazione nomi file per download e checkout con timestamp e identificatori univoci
+ * - Download di documenti in modalità checkout
+ * - Gestione dello storage locale delle informazioni di checkout (aggiunta, aggiornamento, rimozione)
+ * - Validazione dei nomi file secondo le convenzioni di naming CICO
+ * - Rendering dell'interfaccia utente per conferma check-in con visualizzazione anomalie
+ * - Determinazione dello stato di check-out dei documenti (editMode/lockMode)
+ * - Verifica permessi e abilitazione funzionalità CICO per tipo documento
+ */
+export interface CheckoutInfo {
+    DID: string;
+    TID: string;
+    checkoutFolder: string;
+    checkoutName: string;
+}
+interface CheckoutStatusResult {
+    isCheckedOut: boolean;
+    mode: 'editMode' | 'lockMode' | '';
+    version: number;
+    icon: React.ReactNode | null;
+}
+export type DownloadSource = {
+    type: 'fileItem';
+    fileItem: FileItem;
+} | {
+    type: 'dcmtInfo';
+    dcmtInfo: DcmtInfo;
+    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 updateCicoCheckoutStorageItem: (item: CheckoutInfo, type: "fileItem" | "dcmtInfo", action?: "addOrUpdate" | "remove") => void;
+export declare const validateCicoFileName: (source: DownloadSource, fileName: string) => FileNameValidation;
+type ValidationResult = {
+    expected: string | number | undefined;
+    current: string | number | undefined;
+    isValid: boolean;
+};
+type FileNameValidationItems = {
+    name: ValidationResult;
+    archiveID: ValidationResult;
+    did: ValidationResult;
+    tid: ValidationResult;
+    fileExtension: ValidationResult;
+};
+type FileNameValidation = {
+    isValid: boolean;
+    validationResults?: FileNameValidationItems;
+};
+export declare const renderCicoCheckInContent: (source: DownloadSource, selectedFilename: File, isValid: boolean, validationItems: FileNameValidationItems | undefined, color?: string) => React.ReactNode;
+interface CheckInCheckOutDcmtInfo {
+    CICO: number;
+    CanCICO: AccessLevels;
+    CanDelChronology: AccessLevels;
+    UserID_MID: number;
+    Date_MID: number;
+    Ver_MID: number;
+    UserID_CanViewOrUpdate: AccessLevels;
+    Date_CanViewOrUpdate: AccessLevels;
+    Ver_CanViewOrUpdate: AccessLevels;
+}
+export declare const getDcmtCicoInfo: (dtd: DcmtTypeDescriptor | undefined) => CheckInCheckOutDcmtInfo;
+/**
+ * Determina lo stato di check-in/check-out di un documento
+ *
+ * @param dcmt - Il documento in formato array (MetadataValueDescriptorEx[]) o oggetto piatto
+ * @param allUsers - Lista di tutti gli utenti per risolvere i nomi
+ * @param dtd - Descrittore del tipo documento contenente le definizioni dei metadati CICO
+ * @returns Oggetto con cicoEnabled (se CICO è abilitato) e checkoutStatus (dettagli dello stato)
+ */
+export declare const getDcmtCicoStatus: (dcmt: any, allUsers: Array<UserDescriptor>, dtd: DcmtTypeDescriptor | undefined) => {
+    cicoEnabled: boolean;
+    checkoutStatus: CheckoutStatusResult;
+};
+export {};