@topconsultnpm/sdkui-react-beta 6.12.37 → 6.12.39

package/lib/components/grids/TMBlogsUtils.d.ts

@@ -0,0 +1,83 @@
+import React from 'react';
+import { BlogPost, BlogPostAttachment, DcmtTypeDescriptor, HomeBlogPost } from "@topconsultnpm/sdk-ts-beta";
+import { FileItem } from '../base/TMFileManager';
+export declare const DRAFT_TYPE_TID = 6;
+export declare const colors: {
+    DARK_BLUE: string;
+    WHITE: string;
+    BLACK: string;
+    RED: string;
+    LIGHT_GRAY: string;
+    PRIMARY_BLUE: string;
+    PRIMARY_ORANGE: string;
+    PRIMARY_GREEN: string;
+};
+export interface TMBlogContextMenuItem {
+    text: string;
+    icon: string;
+    onClick?: (param?: any) => void;
+    operationType?: 'singleRow' | 'multiRow';
+    disabled?: boolean;
+    id?: string;
+    items?: Array<TMBlogContextMenuItem>;
+    beginGroup?: boolean;
+    tooltip?: string;
+    visible?: boolean;
+}
+export declare enum TMBlogsFilterCategoryId {
+    PublishedBlogs = 1,
+    SystemBlogs = 2,
+    DeletedBlogs = 3
+}
+export interface BlogPostContainerProps {
+    $color?: string;
+    $textDecoration?: string;
+    $backgroundColor?: string;
+    $isNew?: boolean;
+    $canNavigate?: boolean;
+}
+export declare const BlogPostContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, BlogPostContainerProps>> & string;
+export declare const getTooltipContent: (title: string | undefined, content: JSX.Element) => import("react/jsx-runtime").JSX.Element;
+export declare const highlightText: (text: string, searchText: string, isSelected: boolean) => string | (string | import("react/jsx-runtime").JSX.Element)[];
+export declare const lightenColor: (hex: string, amount: number) => string;
+export declare const removeFileExtension: (filename: string) => string;
+export declare const getAttachmentInfo: (attachment: BlogPostAttachment, treeFs: FileItem | undefined, draftLatestInfoMap: Map<number, {
+    latestVersion: number;
+    folderId: number;
+    folderName: string;
+    fileExt: string;
+    fileSize: string;
+}> | undefined, archivedDocumentMap: Map<number, {
+    tid: number;
+    did: number;
+    fileExt: string;
+    fileSize: string;
+}> | undefined, dcmtTypeDescriptors: Map<number, DcmtTypeDescriptor>, isSelected: boolean, searchText: string, color: string) => {
+    name: string;
+    nameElement: import("react/jsx-runtime").JSX.Element;
+    folderId: number;
+    fileExt: string;
+    draftExist: boolean;
+    archivedDocumentsExist: boolean;
+};
+export declare const AttachmentElement: (attachment: BlogPostAttachment, treeFs: FileItem | undefined, draftLatestInfoMap: Map<number, {
+    latestVersion: number;
+    folderId: number;
+    folderName: string;
+    fileExt: string;
+    fileSize: string;
+}> | undefined, archivedDocumentMap: Map<number, {
+    tid: number;
+    did: number;
+    fileExt: string;
+    fileSize: string;
+}> | undefined, dcmtTypeDescriptors: Map<number, DcmtTypeDescriptor>, isSelected: boolean, searchText: string, color: string, handleClickAttachmentFolderFileCallback: ((folderId: number, draftId: number) => void) | undefined, downloadDcmtsAsync: (inputDcmts: Array<any> | undefined) => Promise<void>) => import("react/jsx-runtime").JSX.Element;
+export declare const OwnerInitialsBadge: (blogPost: BlogPost | HomeBlogPost) => import("react/jsx-runtime").JSX.Element;
+export declare const IconAndHeaderElement: (blogPost: BlogPost | HomeBlogPost, iconColor: string, isSelected: boolean, headerClickCallback: () => void, searchText: string) => import("react/jsx-runtime").JSX.Element;
+export declare const findFileItemByDraftID: (tree: FileItem | undefined, draftID: number | undefined) => FileItem | null;
+export declare const isHeaderFullyHidden: (header: {
+    showViewMode: boolean;
+    showFilters: boolean;
+    showSearchBar: boolean;
+    showPostsDropDown: boolean;
+} | undefined) => boolean;

package/lib/components/grids/TMBlogsUtils.js

@@ -0,0 +1,258 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import styled from "styled-components";
+import { SDK_Globals } from "@topconsultnpm/sdk-ts-beta";
+import { formatBytes, getFileIcon, IconAttachment, IconUserGroup, IconWorkspace, SDKUI_Localizator } from "../../helper";
+import TMTooltip from "../base/TMTooltip";
+export const DRAFT_TYPE_TID = 6;
+export const colors = {
+    DARK_BLUE: "#1a0dab",
+    WHITE: "#fff",
+    BLACK: "#000000",
+    RED: '#ff0000',
+    LIGHT_GRAY: "#f9f9f9",
+    PRIMARY_BLUE: "#135596",
+    PRIMARY_ORANGE: "#e65b00",
+    PRIMARY_GREEN: "#009700"
+};
+export var TMBlogsFilterCategoryId;
+(function (TMBlogsFilterCategoryId) {
+    TMBlogsFilterCategoryId[TMBlogsFilterCategoryId["PublishedBlogs"] = 1] = "PublishedBlogs";
+    TMBlogsFilterCategoryId[TMBlogsFilterCategoryId["SystemBlogs"] = 2] = "SystemBlogs";
+    TMBlogsFilterCategoryId[TMBlogsFilterCategoryId["DeletedBlogs"] = 3] = "DeletedBlogs";
+})(TMBlogsFilterCategoryId || (TMBlogsFilterCategoryId = {}));
+export const BlogPostContainer = styled.div `
+    color: ${(props) => (props.$color ?? colors.BLACK)};
+    text-decoration: ${(props) => (props.$textDecoration ?? 'none')};
+    height: auto;
+    background-color: ${(props) => (props.$backgroundColor ?? colors.WHITE)};
+    display: inline-block;
+    width: 100%;
+    max-width: 100%;
+    cursor: ${(props) => (props.$canNavigate ? "pointer" : "default")};
+    border-radius: 5px;
+    margin: 5px 0;
+    padding: 10px;
+    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
+    word-wrap: break-word;
+    white-space: pre-wrap;
+    font-weight: ${(props) => (props.$isNew ? 'bold' : 'normal')};
+    &:focus {
+        outline: none;
+    }
+`;
+export const getTooltipContent = (title, content) => {
+    return (_jsxs("div", { style: { textAlign: 'left' }, children: [_jsx("div", { style: { fontWeight: 'bold' }, children: title }), _jsx("hr", {}), content] }));
+};
+export const highlightText = (text, searchText, isSelected) => {
+    if (!searchText)
+        return text;
+    const regex = new RegExp(`(${searchText.trim()})`, 'gi');
+    return text.split(regex).map((part, index) => regex.test(part) ? (_jsx("span", { style: { backgroundColor: isSelected ? '#6c9023' : 'yellow' }, children: part }, index)) : (part));
+};
+export const lightenColor = (hex, amount) => {
+    let color = hex.replace('#', '');
+    // Expand shorthand like #123 to #112233
+    if (color.length === 3) {
+        color = color.split('').map(c => c + c).join('');
+    }
+    const num = parseInt(color, 16);
+    let r = (num >> 16) + amount;
+    let g = ((num >> 8) & 0x00FF) + amount;
+    let b = (num & 0x0000FF) + amount;
+    r = Math.min(255, Math.max(0, r));
+    g = Math.min(255, Math.max(0, g));
+    b = Math.min(255, Math.max(0, b));
+    return `#${(r << 16 | g << 8 | b).toString(16).padStart(6, '0')}`;
+};
+export const removeFileExtension = (filename) => {
+    return filename.includes('.') ? filename.substring(0, filename.lastIndexOf('.')) : filename;
+};
+export const getAttachmentInfo = (attachment, treeFs, draftLatestInfoMap, archivedDocumentMap, dcmtTypeDescriptors, isSelected, searchText, color) => {
+    let nameElement = (_jsx("span", { children: `${SDKUI_Localizator.DocumentNotAvailable} (DID: ${attachment.did})` }));
+    let folderId = -1;
+    let fileExt = '';
+    let draftExist = false;
+    let archivedDocumentsExist = false;
+    let name = '';
+    if (attachment.tid === DRAFT_TYPE_TID && treeFs) {
+        const draftfileItem = findFileItemByDraftID(treeFs, attachment.draftID);
+        if (draftfileItem) {
+            let latestVersion = true;
+            let pathName = '';
+            draftExist = true;
+            let fileSize = '0';
+            name = draftfileItem.name;
+            if (draftLatestInfoMap && attachment.draftID && attachment.version) {
+                const draftInfo = draftLatestInfoMap.get(attachment.draftID);
+                if (draftInfo) {
+                    folderId = draftInfo.folderId;
+                    latestVersion = draftInfo.latestVersion === attachment.version;
+                    pathName = draftInfo.folderName;
+                    fileExt = draftInfo.fileExt;
+                    fileSize = formatBytes(draftInfo.fileSize ? Number(draftInfo.fileSize) : 0);
+                }
+            }
+            const content = (_jsxs("div", { children: [_jsxs("div", { children: [_jsx("span", { style: { fontWeight: 'bold' }, children: SDKUI_Localizator.Version }), ": ", attachment.version] }), draftLatestInfoMap && (_jsxs("div", { children: [_jsxs("div", { children: [_jsx("span", { style: { fontWeight: 'bold' }, children: SDKUI_Localizator.LastVersion }), ": ", latestVersion ? SDKUI_Localizator.Yes : SDKUI_Localizator.No] }), _jsxs("div", { children: [_jsx("span", { style: { fontWeight: 'bold' }, children: SDKUI_Localizator.Size }), ": ", fileSize] })] })), _jsx("hr", {}), _jsxs("div", { children: [_jsx("span", { style: { fontWeight: 'bold' }, children: SDKUI_Localizator.Path }), ": \"", SDKUI_Localizator.Drafts, "\\", pathName.length > 0 ? (pathName + '\\') : '', name, "\""] })] }));
+            const tooltipContent = getTooltipContent(draftfileItem.name, content);
+            nameElement = (_jsx("span", { children: _jsxs(TMTooltip, { content: tooltipContent, children: [highlightText(`${draftfileItem.name} (DID: ${attachment.did})`, searchText, isSelected), "\u00A0", _jsx("span", { style: {
+                                display: 'inline-flex',
+                                marginLeft: '5px',
+                                width: '20px',
+                                height: '20px',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                backgroundColor: isSelected ? '#fff' : (latestVersion ? '#28a745' : '#cc7000'),
+                                color: isSelected ? color : '#fff',
+                                boxShadow: '1px 1px 2px #00000020',
+                                borderRadius: '30px',
+                                fontWeight: 'bold',
+                            }, children: attachment.version })] }) }));
+        }
+    }
+    else if (attachment.tid) {
+        const descriptor = dcmtTypeDescriptors.get(attachment.tid);
+        let fileSize = '0';
+        if (archivedDocumentMap && attachment.did) {
+            const archivedDocumentInfo = archivedDocumentMap.get(attachment.did);
+            if (archivedDocumentInfo) {
+                archivedDocumentsExist = true;
+                fileExt = archivedDocumentInfo.fileExt;
+                fileSize = formatBytes(archivedDocumentInfo.fileSize ? Number(archivedDocumentInfo.fileSize) : 0);
+            }
+        }
+        if (descriptor) {
+            name = descriptor.name ?? "-";
+            const content = (_jsxs("div", { children: [archivedDocumentMap && (_jsxs("div", { children: [_jsx("span", { style: { fontWeight: 'bold' }, children: SDKUI_Localizator.Size }), ": ", fileSize] })), _jsx("hr", {}), _jsxs("div", { children: [_jsx("span", { style: { fontWeight: 'bold' }, children: SDKUI_Localizator.Path }), ": \"", SDKUI_Localizator.ArchivedDocuments, "\\", `${descriptor.name} (DID: ${attachment.did})`, "\""] })] }));
+            const tooltipContent = getTooltipContent(descriptor.name, content);
+            nameElement = (_jsx("span", { children: _jsx(TMTooltip, { content: tooltipContent, children: highlightText(`${name} (DID: ${attachment.did})`, searchText, isSelected) }) }));
+        }
+    }
+    return { name, nameElement, folderId, fileExt, draftExist, archivedDocumentsExist };
+};
+export const AttachmentElement = (attachment, treeFs, draftLatestInfoMap, archivedDocumentMap, dcmtTypeDescriptors, isSelected, searchText, color, handleClickAttachmentFolderFileCallback, downloadDcmtsAsync) => {
+    const { name, nameElement, folderId, fileExt, draftExist } = getAttachmentInfo(attachment, treeFs, draftLatestInfoMap, archivedDocumentMap, dcmtTypeDescriptors, isSelected, searchText, color);
+    const onClickCallback = (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        if (attachment.tid === DRAFT_TYPE_TID && treeFs && draftExist) {
+            const folderIdAttachment = folderId === 0 ? -1 : folderId;
+            if (handleClickAttachmentFolderFileCallback && attachment.draftID)
+                handleClickAttachmentFolderFileCallback(folderIdAttachment, attachment.draftID);
+        }
+    };
+    const onDoubleClick = (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        const archiveID = SDK_Globals.tmSession?.SessionDescr?.archiveID;
+        const fileName = `${removeFileExtension(name)}_${archiveID}_${attachment.tid}_${attachment.did}.${fileExt}`;
+        if (downloadDcmtsAsync)
+            downloadDcmtsAsync([{ TID: attachment.tid, DID: attachment.did, fileName }]);
+    };
+    return _jsx("div", { onClick: onClickCallback, onDoubleClick: onDoubleClick, style: {
+            display: 'inline-flex',
+            padding: '8px 12px',
+            margin: '4px',
+            border: '1px solid #ddd',
+            borderRadius: '8px',
+            boxShadow: '0 2px 4px rgba(0, 0, 0, 0.1)',
+            backgroundColor: isSelected ? color : colors.WHITE,
+            cursor: "pointer"
+        }, onMouseEnter: (e) => {
+            e.currentTarget.style.boxShadow = '0 4px 8px rgba(0, 0, 0, 0.15)';
+            e.currentTarget.style.backgroundColor = isSelected ? lightenColor(color, 40) : '#cfcfcf';
+        }, onMouseLeave: (e) => {
+            e.currentTarget.style.boxShadow = '0 2px 4px rgba(0, 0, 0, 0.1)';
+            e.currentTarget.style.backgroundColor = isSelected ? color : colors.WHITE;
+        }, children: _jsxs("div", { style: { alignItems: 'center', display: 'flex' }, children: [fileExt ? _jsx("span", { style: { marginRight: "10px" }, children: getFileIcon(fileExt, undefined) }) : _jsx(IconAttachment, { style: { marginRight: "5px" } }), _jsx("span", { children: nameElement })] }) }, attachment.did);
+};
+export const OwnerInitialsBadge = (blogPost) => {
+    const generateDarkColorFromName = (str) => {
+        // Create a hash of the string
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            hash = str.charCodeAt(i) + ((hash << 5) - hash);
+        }
+        // Convert the hash to a color (ensure it's within RGB range)
+        const hue = Math.floor((hash & 0x00FFFFFF) / 0x10000);
+        // Define color ranges for dark red, green, yellow, and others
+        let colorRange;
+        if (hue >= 0 && hue < 30) { // Dark red
+            colorRange = 0; // Red hue
+        }
+        else if (hue >= 30 && hue < 90) { // Dark orange to yellow
+            colorRange = 60; // Yellow hue
+        }
+        else if (hue >= 90 && hue < 150) { // Dark green
+            colorRange = 120; // Green hue
+        }
+        else if (hue >= 150 && hue < 210) { // Dark cyan
+            colorRange = 180; // Cyan hue
+        }
+        else if (hue >= 210 && hue < 270) { // Dark blue
+            colorRange = 240; // Blue hue
+        }
+        else if (hue >= 270 && hue < 330) { // Dark purple
+            colorRange = 300; // Purple hue
+        }
+        else { // Dark magenta
+            colorRange = 360; // Magenta hue
+        }
+        // Use a low lightness value to keep the color dark
+        return `hsl(${colorRange}, 70%, 30%)`; // Low lightness for dark colors
+    };
+    const extractInitialsFromName = (name) => {
+        // If the name has 3 characters, return the first 2 characters
+        if (name.length >= 3) {
+            const lettersOnly = name.replace(/[^a-zA-Z]/g, '');
+            return lettersOnly.substring(0, 3).toUpperCase();
+        }
+        // If only 1 character, return that character
+        return name[0].toUpperCase();
+    };
+    return _jsx(TMTooltip, { content: blogPost.ownerName ?? '-', children: _jsx("div", { style: {
+                width: "40px",
+                height: "40px",
+                borderRadius: "50%",
+                backgroundColor: generateDarkColorFromName(blogPost.ownerName ?? '-'),
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                marginRight: "10px",
+                fontWeight: "bold",
+                color: colors.WHITE,
+                fontSize: "18px",
+            }, children: _jsx("span", { style: { fontSize: "12px" }, children: extractInitialsFromName(blogPost.ownerName ?? '-') }) }) });
+};
+export const IconAndHeaderElement = (blogPost, iconColor, isSelected, headerClickCallback, searchText) => {
+    return _jsxs("span", { style: { marginLeft: "5px", cursor: blogPost.classID === 'WG' ? "pointer" : "default", display: "inline-flex", alignItems: "center" }, onClick: headerClickCallback, children: [_jsx(TMTooltip, { content: blogPost.classID === 'DS' ? SDKUI_Localizator.Practice : SDKUI_Localizator.WorkGroup, children: blogPost.classID === "DS" ? (_jsx(IconWorkspace, { color: iconColor })) : (_jsx(IconUserGroup, { color: iconColor })) }), _jsx("span", { style: {
+                    marginLeft: "5px",
+                    textDecoration: blogPost.classID === "WG" ? "underline" : "none",
+                    cursor: blogPost.classID === "WG" ? "pointer" : "default",
+                    color: isSelected
+                        ? "#fff"
+                        : (blogPost.classID === "WG" ? colors.DARK_BLUE : colors.BLACK),
+                    display: "inline-block" // Ensure both elements are in a row
+                }, onClick: headerClickCallback, children: highlightText(blogPost.header ?? '', searchText, isSelected) })] });
+};
+export const findFileItemByDraftID = (tree, draftID) => {
+    if (tree === undefined || draftID === undefined)
+        return null;
+    if (tree.id === draftID) {
+        return tree;
+    }
+    if (tree.items && tree.items.length > 0) {
+        for (const item of tree.items) {
+            const found = findFileItemByDraftID(item, draftID);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return null;
+};
+export const isHeaderFullyHidden = (header) => {
+    if (!header) {
+        return true;
+    }
+    return !header.showViewMode && !header.showFilters && !header.showSearchBar && !header.showPostsDropDown;
+};

package/lib/components/index.d.ts

@@ -41,6 +41,8 @@ export * from './choosers/TMDcmtTypeChooser';
 export * from './choosers/TMMetadataChooser';
 export * from './choosers/TMUserChooser';
 export { default as TMValidationItemsList } from './grids/TMValidationItemsList';
+export { default as TMBlogs } from './grids/TMBlogs';
+export * from './query/TMDcmtIcon';
 export * from './query/TMQueryEditor';
 export * from './query/TMQueryResultForm';
 export * from './query/TMQuerySummary';

package/lib/components/index.js

@@ -45,7 +45,9 @@ export * from './choosers/TMMetadataChooser';
 export * from './choosers/TMUserChooser';
 //grids
 export { default as TMValidationItemsList } from './grids/TMValidationItemsList';
+export { default as TMBlogs } from './grids/TMBlogs';
 //query
+export * from './query/TMDcmtIcon';
 export * from './query/TMQueryEditor';
 export * from './query/TMQueryResultForm';
 export * from './query/TMQuerySummary';

package/lib/components/query/TMBatchUpdateForm.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { DcmtInfo } from '../../ts';
+interface ITMBatchUpdateFormProps {
+    inputDcmts: DcmtInfo[];
+    TID: number | undefined;
+    DID: number | undefined;
+    onBack?: () => void;
+    onSavedCallbackAsync?: () => Promise<void>;
+    onStatusChanged?: (isModified: boolean, isValid: boolean) => void;
+}
+declare const TMBatchUpdateForm: React.FC<ITMBatchUpdateFormProps>;
+export default TMBatchUpdateForm;

package/lib/components/query/TMBatchUpdateForm.js

@@ -0,0 +1,149 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { AccessLevels, DcmtTypeListCacheService, LayoutModes, MetadataDataDomains, ResultTypes, SDK_Globals, ValidationItem } from '@topconsultnpm/sdk-ts-beta';
+import { searchResultToMetadataValues, getSystemMetadata, calcIsModified, getListMaxItems, SDKUI_Localizator, IconHide, IconShow } from '../../helper';
+import { useDcmtOperations } from '../../hooks/useDcmtOperations';
+import { DcmtOperationTypes, FormModes } from '../../ts';
+import { TMColors } from '../../utils/theme';
+import { StyledToolbarCardContainer, StyledFormButtonsContainer } from '../base/Styled';
+import TMButton from '../base/TMButton';
+import { useDeviceType, DeviceType } from '../base/TMDeviceProvider';
+import { TMSplitterLayout } from '../base/TMLayout';
+import { TMExceptionBoxManager } from '../base/TMPopUp';
+import TMShowAllOrMaxItemsButton from '../base/TMShowAllOrMaxItemsButton';
+import TMSpinner from '../base/TMSpinner';
+import TMToolbarCard from '../base/TMToolbarCard';
+import { TMLayoutWaitingContainer } from '../base/TMWaitPanel';
+import TMDistinctValues from '../choosers/TMDistinctValues';
+import TMFormulaEditor, { FormulaDescriptor, FormulaHelper, FormulaTargets } from '../editors/TMFormulaEditor';
+import { useMetadataEditableList } from '../editors/TMMetadataEditor';
+import TMMetadataValues, { ShowCheckBoxesMode, AdvancedMenuButtons } from '../editors/TMMetadataValues';
+import { TMSaveFormButtonSave, TMSaveFormButtonUndo } from '../forms/TMSaveForm';
+const TMBatchUpdateForm = ({ inputDcmts, TID, DID, onSavedCallbackAsync, onBack, onStatusChanged }) => {
+    const [metadataValues, setMetadataValues] = useState([]);
+    const [metadataValuesOrig, setMetadataValuesOrig] = useState([]);
+    const [validationItems, setValidationItems] = useState([]);
+    const [showAll, setShowAll] = useState(false);
+    const [showAdvancedMenu, setShowAdvancedMenu] = useState(false);
+    const [showDistinctValuesPanel, setShowDistinctValuesPanel] = useState(false);
+    const [showFormulaEditor, setShowFormulaEditor] = useState(false);
+    const [focusedMetadataValue, setFocusedMetadataValue] = useState();
+    const [addOrRemoveEditableList] = useMetadataEditableList();
+    const { abortController, runOperationAsync, showWaitPanel, waitPanelTitle, showPrimary, waitPanelTextPrimary, waitPanelValuePrimary, waitPanelMaxValuePrimary } = useDcmtOperations();
+    const deviceType = useDeviceType();
+    useEffect(() => {
+        if (!TID)
+            return;
+        if (!DID)
+            return;
+        if (isModified)
+            return;
+        retrieveMetadataAsync();
+    }, [TID, DID]);
+    useEffect(() => {
+        validateAsync();
+        onStatusChanged?.(isModified, validationItems.findIndex(o => o.ResultType != ResultTypes.SUCCESS) >= 0);
+    }, [metadataValues]);
+    const validateAsync = async () => {
+        let vil = [];
+        if (metadataValues.filter(o => o.isSelected).length <= 0)
+            vil.push(new ValidationItem(ResultTypes.ERROR, "isSelectd", `${'Selezionare almeno un metadato da aggiornare'}`));
+        else {
+            for (const mvd of metadataValues) {
+                if (!mvd.isSelected)
+                    continue;
+                if (!mvd.value && !mvd.isNull)
+                    vil.push(new ValidationItem(ResultTypes.ERROR, mvd.md?.nameLoc ?? "", `Specificare un valore (${mvd.md?.nameLoc})`));
+            }
+        }
+        setValidationItems(vil);
+    };
+    const retrieveMetadataAsync = async () => {
+        try {
+            await DcmtTypeListCacheService.GetAsync(TID).then(async (dtd) => {
+                let mdList = dtd?.metadata ?? [];
+                await setMetadataListAsync(mdList);
+            });
+        }
+        catch (e) {
+            let err = e;
+            TMExceptionBoxManager.show({ exception: err });
+        }
+    };
+    const setMetadataListAsync = async (mdList) => {
+        try {
+            TMSpinner.show({ description: 'Caricamento metadati...' });
+            let res = await SDK_Globals.tmSession?.NewSearchEngine().GetMetadataAsync(TID, DID, true);
+            let dtd = res?.dtdResult;
+            let rows = dtd.rows ? dtd.rows[0] : [];
+            let mids = res?.selectMIDs;
+            let metadataList = searchResultToMetadataValues(TID, dtd, rows, mids, mdList, LayoutModes.Update)
+                .filter(o => o.md?.dataDomain !== MetadataDataDomains.Computed &&
+                o.md?.perm?.canUpdate === AccessLevels.Yes &&
+                o.md.isSystem !== 1);
+            metadataList.forEach(mvd => { mvd.isSelected = false; mvd.isNull = false; });
+            setMetadataValuesOrig(structuredClone(metadataList));
+            setMetadataValues(structuredClone(metadataList));
+        }
+        catch (e) {
+            TMExceptionBoxManager.show({ exception: e });
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    };
+    const onUndoHandler = () => {
+        setMetadataValues(structuredClone(metadataValuesOrig));
+    };
+    const onSavedAsync = async () => {
+        let dcmts = inputDcmts.slice();
+        dcmts.forEach(o => o.metadataValues = metadataValues);
+        await runOperationAsync(dcmts, DcmtOperationTypes.BatchUpdate, onSavedCallbackAsync);
+    };
+    const getFormula = () => {
+        let fd = new FormulaDescriptor();
+        fd.expression = FormulaHelper.isFormula(focusedMetadataValue?.value) ? FormulaHelper.removeFormulaTag(focusedMetadataValue?.value) : undefined;
+        fd.formulaTarget = FormulaTargets.BatchUpdate;
+        fd.items = FormulaHelper.TreeViewList(TID ?? 0, getSystemMetadata(true), undefined, FormulaTargets.BatchUpdate, SDK_Globals.dbBrand);
+        fd.mid = focusedMetadataValue?.mid ?? 0;
+        fd.tid = TID;
+        return fd;
+    };
+    const isModified = calcIsModified(metadataValues, metadataValuesOrig);
+    const errors = validationItems.filter(o => o.ResultType == ResultTypes.ERROR);
+    const listMaxItems = getListMaxItems(deviceType ?? DeviceType.DESKTOP);
+    const totalItems = metadataValues.filter(o => o.mid && o.mid > 100).length;
+    const metadataValuesSource = metadataValues.filter(o => o.mid && o.mid > 100).slice(0, showAll ? metadataValues.filter(o => o.mid && o.mid > 100).length : listMaxItems);
+    const metadataValuesSourceOrig = metadataValuesOrig.filter(o => o.mid && o.mid > 100).slice(0, showAll ? metadataValuesOrig.filter(o => o.mid && o.mid > 100).length : listMaxItems);
+    return (_jsx(TMLayoutWaitingContainer, { showWaitPanel: showWaitPanel, showWaitPanelPrimary: showPrimary, waitPanelTitle: waitPanelTitle, waitPanelTextPrimary: waitPanelTextPrimary, waitPanelValuePrimary: waitPanelValuePrimary, waitPanelMaxValuePrimary: waitPanelMaxValuePrimary, isCancelable: true, abortController: abortController, children: _jsxs(TMSplitterLayout, { separatorSize: 5, separatorColor: 'transparent', showSeparator: showDistinctValuesPanel || showFormulaEditor, start: showDistinctValuesPanel || showFormulaEditor ? ['50%', '50%'] : ['100%', '0%'], min: ['0', '0'], direction: 'horizontal', children: [_jsx(TMToolbarCard, { title: `${SDKUI_Localizator.BatchUpdate} (${inputDcmts.length} documenti selezionati)`, backgroundColorContainer: TMColors.default_background, toolbar: _jsx(TMButton, { btnStyle: 'icon', icon: showAdvancedMenu ? _jsx(IconHide, { color: 'white' }) : _jsx(IconShow, { color: 'white' }), caption: showAdvancedMenu ? SDKUI_Localizator.StandardMode : SDKUI_Localizator.ExpertMode, onClick: () => setShowAdvancedMenu(!showAdvancedMenu) }), onBack: deviceType === DeviceType.MOBILE ? onBack : undefined, onClose: deviceType !== DeviceType.MOBILE ? onBack : undefined, children: _jsxs(StyledToolbarCardContainer, { children: [_jsx(TMMetadataValues, { TID: TID, showAdvancedMenu: showAdvancedMenu, showCheckBoxes: ShowCheckBoxesMode.Always, showNullValueCheckBoxes: true, metadataValues: metadataValuesSource, metadataValuesOrig: metadataValuesSourceOrig, validationItems: validationItems, isOpenDistinctValues: showDistinctValuesPanel, selectedMID: focusedMetadataValue?.mid, onFocusedItemChanged: (item) => { setFocusedMetadataValue(item); }, onValueChanged: (newItems) => {
+                                    setMetadataValues((prevItems) => prevItems.map((item) => {
+                                        const newItem = newItems.find((newItem) => newItem.tid === item.tid && newItem.mid === item.mid);
+                                        return newItem ? { ...item, ...newItem } : item;
+                                    }));
+                                }, onAdvancedMenuClick: (e) => {
+                                    switch (e.button) {
+                                        case AdvancedMenuButtons.DistinctValues:
+                                            setShowDistinctValuesPanel(!showDistinctValuesPanel);
+                                            break;
+                                        case AdvancedMenuButtons.FormulaEditor:
+                                            setShowFormulaEditor(!showFormulaEditor);
+                                            break;
+                                    }
+                                } }), _jsxs(StyledFormButtonsContainer, { children: [_jsx("div", { style: { display: 'flex', flexDirection: 'column', gap: 10 }, children: _jsxs("div", { style: { display: 'flex', justifyContent: 'center', alignItems: 'center', gap: '8px' }, children: [_jsx(TMSaveFormButtonSave, { showTooltip: false, btnStyle: 'advanced', advancedColor: '#f09c0a', isModified: errors.length <= 0 && isModified, formMode: FormModes.Update, errorsCount: errors.length, onSaveAsync: onSavedAsync }), _jsx(TMSaveFormButtonUndo, { btnStyle: 'toolbar', showTooltip: true, color: 'primary', isModified: isModified, formMode: FormModes.Update, onUndo: onUndoHandler })] }) }), totalItems > listMaxItems && _jsx(TMShowAllOrMaxItemsButton, { showAll: showAll, dataSourceLength: totalItems, onClick: () => { setShowAll(!showAll); } })] })] }) }), showDistinctValuesPanel && focusedMetadataValue &&
+                    _jsx(TMDistinctValues, { tid: TID, mid: focusedMetadataValue?.mid, separator: ', ', allowAppendMode: false, onClosePanelCallback: () => setShowDistinctValuesPanel(false), onSelectionChanged: (e) => {
+                            if (!e)
+                                return;
+                            setMetadataValues((prevItems) => prevItems.map((item) => item.tid == e.tid && item.mid === e.mid ? { ...item, value: e.newValue, isSelected: true } : item));
+                        } }), showFormulaEditor && focusedMetadataValue &&
+                    _jsx(TMToolbarCard, { title: SDKUI_Localizator.FormulaEditorTitle + (focusedMetadataValue?.md?.nameLoc ? ` (${focusedMetadataValue?.md?.nameLoc})` : ''), onClose: () => setShowFormulaEditor(false), children: _jsx(TMFormulaEditor, { isModal: false, formMode: FormModes.Update, inputData: getFormula(), showBack: false, onClose: () => setShowFormulaEditor(false), onApplied: (newFormula) => {
+                                setMetadataValues((prevItems) => prevItems.map((item) => item.tid == newFormula.tid && item.mid === newFormula.mid ? { ...item, value: FormulaHelper.addFormulaTag(newFormula.expression), isSelected: true, isEditable: true } : item));
+                                setFocusedMetadataValue(prevState => ({
+                                    ...prevState,
+                                    isSelected: true,
+                                    isEditable: true,
+                                    value: FormulaHelper.addFormulaTag(newFormula.expression)
+                                }));
+                                addOrRemoveEditableList(newFormula.mid);
+                            } }) })] }) }));
+};
+export default TMBatchUpdateForm;

package/lib/components/query/TMDcmtBlog.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface ITMDcmtBlogProps {
+    tid: number | undefined;
+    did: number | undefined;
+}
+declare const TMDcmtBlog: React.FC<ITMDcmtBlogProps>;
+export default TMDcmtBlog;

package/lib/components/query/TMDcmtBlog.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { SDK_Globals } from '@topconsultnpm/sdk-ts-beta';
+import { useEffect, useState } from 'react';
+import styled from 'styled-components';
+import { TMExceptionBoxManager } from '../base/TMPopUp';
+import TMSpinner from '../base/TMSpinner';
+import TMBlogs from '../grids/TMBlogs';
+const TMDcmtBlog = ({ tid, did }) => {
+    const [blogsDatasource, setBlogsDatasource] = useState([]);
+    useEffect(() => {
+        if (!tid || !did)
+            return;
+        loadDataAsync(tid, did);
+    }, [did]);
+    const loadDataAsync = async (tid, did) => {
+        try {
+            TMSpinner.show({ description: 'Caricamento - Bacheca...' });
+            let res = await SDK_Globals.tmSession?.NewSearchEngine().BlogRetrieveAsync(tid, did);
+            setBlogsDatasource(res ?? []);
+        }
+        catch (e) {
+            let err = e;
+            TMExceptionBoxManager.show({ exception: err });
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    };
+    return (_jsx(StyledContainer, { children: _jsx(StyledSectionContainer, { style: { position: 'relative' }, children: _jsx(StyledBoardContainer, { children: _jsx(TMBlogs, { id: "dcmt-blog", allData: blogsDatasource, showExtendedAttachments: false }) }) }) }));
+};
+export default TMDcmtBlog;
+const StyledContainer = styled.div ` user-select: none; overflow: hidden; background-color: #ffffff; width: calc(100%); height: calc(100%); display: flex; gap: 10px; `;
+const StyledSectionContainer = styled.div ` width:  100%; height: 100%; display:flex; flex-direction: column; `;
+const StyledBoardContainer = styled.div `width: 100%; height: 100%; padding: 10px;`;

package/lib/components/query/TMDcmtForm.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import { LayoutModes } from '@topconsultnpm/sdk-ts-beta';
+import { FormModes } from '../../ts';
+import { ITMRightSidebarItem } from '../base/TMRightSidebar';
+interface ITMDcmtFormProps {
+    TID?: number;
+    DID?: number;
+    layoutMode?: LayoutModes;
+    formMode?: FormModes;
+    allowNavigation?: boolean;
+    allowRelations?: boolean;
+    showHeader?: boolean;
+    showDcmtForm?: boolean;
+    showPreview?: boolean;
+    showBoard?: boolean;
+    showSysMetadata?: boolean;
+    customRightSidebarItems?: ITMRightSidebarItem[];
+    showDcmtFormSidebar?: boolean;
+    count?: number;
+    itemIndex?: number;
+    canNext?: boolean;
+    canPrev?: boolean;
+    isClosable?: boolean;
+    onNext?: () => void;
+    onPrev?: () => void;
+    onClose?: () => void;
+    onSavedAsyncCallback?: (tid: number | undefined, did: number | undefined) => Promise<void>;
+    onSaveRecents?: (TIDs: number[]) => void;
+    onClosePreview?: () => void;
+}
+declare const TMDcmtForm: React.FC<ITMDcmtFormProps>;
+export default TMDcmtForm;