udp-react-enterprise-component-library 25.18.1-beta.24 → 25.18.1-beta.26

package/dist/UdpTransactionsPage-CpgF8O9C.js

@@ -0,0 +1,928 @@
+import { t as __export } from "./chunk-B4enJp2Q.js";
+import { t as FluentButton } from "./FluentButton-BexKrnAp.js";
+import { t as ConfigService } from "./configService-C4uoG3wj.js";
+import { t as useUser } from "./useUser-wpHGo6jU.js";
+import { n as useAxiosMutate, t as apiMutate } from "./useAxiosMutate-DcLxzykX.js";
+import { M as TransactionActionEnums, N as TransactionEventTypeEnums } from "./unitySystemEnums-DtVX3A-I.js";
+import { t as useCatalogStore } from "./catalogStore-DP2GxpTJ.js";
+import { t as Typography$1 } from "./Typography-BMsa1JYd.js";
+import { S as getIconFromName } from "./TreeUtilities-CDlHioSI.js";
+import { n as SideSheet } from "./SideSheet-C-rILQqR.js";
+import { t as useAxiosGet } from "./useAxiosGet-vvPjwB4W.js";
+import { t as StatusChip } from "./StatusChip-DZAN88VU.js";
+import { t as UdpTabs } from "./UdpTabs-DVZGEwOC.js";
+import { t as PageContainer } from "./PageContainer-N4d5KO-T.js";
+import { t as FluentDialog } from "./FluentDialog-B5ZxvX1E.js";
+import { t as LinearProgress$1 } from "./LinearProgress-DM2DNWCe.js";
+import { t as SearchMethodUdpGrid } from "./SearchMethodUdpGrid-QU4FZ0Gk.js";
+import { t as Divider$1 } from "./Divider-DNtKMiBL.js";
+import { t as EmptyStateDisplay } from "./EmptyStateDisplay-CVeCBelv.js";
+import { n as AmbientList } from "./dataDisplay-CAKbZ3U3.js";
+import { t as FileViewer } from "./fileViewer-Sj7Bvi_o.js";
+import { t as UdpActionCard } from "./UdpActionCard-DeLkj1IR.js";
+import React$1, { React as React$2, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { makeStyles } from "@material-ui/core";
+import { useSnackbar } from "notistack";
+import { DocumentIcon, FileImageIcon, PDFIcon, ViewIcon, WordDocumentIcon } from "@fluentui/react-icons";
+import { useTranslation } from "react-i18next";
+import { create } from "zustand";
+import { devtools } from "zustand/middleware";
+import jsonLogic from "json-logic-js";
+import "./udp/pages/UdpTransactionsPage/sidesheets/WorkflowActions.css";
+import "./udp/pages/UdpTransactionsPage/sidesheets/EditTransaction.css";
+
+//#region src/stores/transactionStore.ts
+const useTransactionStore = create()(devtools((set) => ({
+	transactionTypesMap: {},
+	setTransactionTypesMap: (transactionTypesMap) => set((state) => ({ transactionTypesMap: {
+		...state.transactionTypesMap,
+		...transactionTypesMap
+	} }))
+})));
+
+//#endregion
+//#region src/utilities/transactions/useTransactionEngine.js
+const useTransactionEngine = (transactionTypeId) => {
+	const user = useUser();
+	const [transactionTypeFields, setTransactionTypeFields] = useState([]);
+	const currentApiCatalogId = useCatalogStore((state) => state.currentApiCatalogId);
+	const catalogsMap = useCatalogStore((state) => state.catalogsMap);
+	const transactionTypesMap = useTransactionStore((state) => state.transactionTypesMap);
+	const transactionType = transactionTypesMap ? transactionTypesMap[transactionTypeId] : null;
+	const evaluateRule = useCallback((rule, udpTransaction) => {
+		let udpTransactionEvaluationData = {
+			currentStatusId: udpTransaction?.currentStatusId,
+			currentDomainValue: udpTransaction?.entityBusinessObject,
+			tenantUserRoleIds: user?.roleIds || []
+		};
+		return jsonLogic.apply(rule, udpTransactionEvaluationData);
+	}, [user?.roleIds]);
+	const getTransactionTypeTransactionActions = useCallback((udpTransaction, ruleTypeId = null) => {
+		return transactionType?.udpTransactionTypeUdpTransactionTypeConfiguration?.reduce((actions, config) => {
+			const ruleLogic = config?.expressionLogic;
+			if (!ruleTypeId) return actions;
+			if (config.transactionRuleTypeId === ruleTypeId && config.enabled && ruleLogic) {
+				if (evaluateRule(ruleLogic, udpTransaction)) {
+					const nestedActions = (config?.udpTransactionTypeConfigurationUdpTransactionTypeConfigurationTransactionAction || []).map((action) => action.udpTransactionTypeConfigurationTransactionActionUdpTransactionTypeTransactionAction).filter((action) => action);
+					if (nestedActions.length > 0) actions = actions.concat(nestedActions);
+				}
+				return actions;
+			}
+			return actions;
+		}, []);
+	}, [transactionType, evaluateRule]);
+	const hasRevisions = useMemo(() => {
+		return transactionType?.hasRevision;
+	}, [transactionType]);
+	const hasClosedStatus = useMemo(() => {
+		return transactionType?.udpTransactionTypeUdpTransactionTypeStatus?.some((status) => status.isClosedStatus);
+	}, [transactionType]);
+	const transactionTypeGridColumns = useMemo(() => {
+		return transactionType?.domainFields || [];
+	}, [transactionType]);
+	const getHiddenFields = useCallback((udpTransaction) => {
+		const transactionActions = getTransactionTypeTransactionActions(udpTransaction, TransactionEventTypeEnums.Form);
+		if (!transactionActions) return false;
+		let hiddenFields = [];
+		transactionActions.filter((action) => action.transactionActionId === TransactionActionEnums.Set_Fields_Hidden).forEach((action) => {
+			if (action.parameters?.hiddenFields) hiddenFields = hiddenFields.concat(action.parameters.hiddenFields);
+		});
+		return hiddenFields;
+	}, [getTransactionTypeTransactionActions]);
+	const getRequiredFields = useCallback((udpTransaction) => {
+		const transactionActions = getTransactionTypeTransactionActions(udpTransaction, TransactionEventTypeEnums.Form);
+		if (!transactionActions) return false;
+		let requiredFields = [];
+		transactionActions.filter((action) => action.transactionActionId === TransactionActionEnums.Set_Mandatory_Fields).forEach((action) => {
+			if (action.parameters?.mandatoryFields) requiredFields = requiredFields.concat(action.parameters.mandatoryFields);
+		});
+		return requiredFields;
+	}, [getTransactionTypeTransactionActions]);
+	useEffect(() => {
+		if (catalogsMap && currentApiCatalogId && transactionType) {
+			const apiCatalog = catalogsMap[currentApiCatalogId];
+			if (apiCatalog) {
+				const transactionTypeObject = apiCatalog.ctlg.catalogObjectList.find((obj) => obj.catalogObjectName.toLowerCase() === transactionType?.domainName?.toLowerCase());
+				if (transactionTypeObject) setTransactionTypeFields(transactionTypeObject.properties || []);
+			}
+		}
+	}, [
+		catalogsMap,
+		currentApiCatalogId,
+		transactionType
+	]);
+	return {
+		currentTransactionType: transactionType,
+		evaluateRule,
+		getTransactionTypeTransactionActions,
+		hasRevisions,
+		getHiddenFields,
+		getRequiredFields,
+		hasClosedStatus,
+		transactionTypeGridColumns
+	};
+};
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/UdpTransactionGrid.jsx
+const UdpTransactionGrid = (props) => {
+	const { transactionTypeId, domainName, transactionTypeLoading, handleGridApiCallback, openAddTransaction, openViewTransaction, openEditTransaction, openAttachmentTransaction, openWorkflowActionTransaction, searchMethodObject, domainColumnFormatters } = props;
+	const { t } = useTranslation();
+	const { hasRevisions, transactionTypeGridColumns } = useTransactionEngine(transactionTypeId);
+	const columnDefs = useMemo(() => {
+		const initialColumnDefs = [
+			{
+				headerName: t("Transaction Id"),
+				field: "transactionId"
+			},
+			{
+				headerName: t("Created On"),
+				field: "createdOn",
+				cellDataType: "dateString",
+				valueFormatter: (params) => {
+					const parsedDate = new Date(params?.data.createdOn);
+					if (parsedDate.getTime()) {
+						const year = parsedDate.getFullYear();
+						const month = parsedDate.getMonth() + 1;
+						const day = parsedDate.getDate().toString();
+						return `${year}-${month.toString()}-${day}`;
+					}
+				}
+			},
+			{
+				headerName: t("Current Status"),
+				field: "currentStatusId",
+				valueFormatter: (params) => params?.data.udpTransactionUdpTransactionTypeStatus.name
+			},
+			{
+				headerName: t("Revision No"),
+				field: "currentRevisionNo"
+			},
+			{
+				headerName: t("Last Event Type"),
+				field: "lastEventTypeId",
+				valueFormatter: (params) => params?.data.udpTransactionUdpTransactionEventType.name
+			},
+			{
+				headerName: t("Attachments"),
+				field: "attachments",
+				pinned: "right",
+				onCellClicked: (event) => {
+					openAttachmentTransaction(event.data);
+				},
+				valueFormatter: (params) => {
+					return params?.data.udpTransactionUdpTransactionAttachment.length;
+				}
+			},
+			{
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [
+					{
+						id: 0,
+						title: "Action",
+						iconName: "migrateAlt",
+						handleOnClick: (e, params) => {
+							openWorkflowActionTransaction(params?.data);
+						}
+					},
+					{
+						id: 1,
+						title: t("View"),
+						iconName: "view",
+						handleOnClick: (e, params) => {
+							openViewTransaction(params?.data);
+						}
+					},
+					{
+						id: 2,
+						title: t("Edit"),
+						iconName: "edit",
+						handleOnClick: (e, params) => {
+							openEditTransaction(params?.data);
+						}
+					},
+					{
+						id: 3,
+						title: t("Delete"),
+						iconName: "trashCan",
+						handleOnClick: (e, params) => {}
+					}
+				] }
+			}
+		];
+		transactionTypeGridColumns.forEach((column) => {
+			let formatedHeaderName = column.slice(0, 1).toUpperCase() + column.slice(1);
+			let valueFormatter = (params) => {
+				return params?.data ? params?.data?.entityBusinessObject[column] : "";
+			};
+			if (domainColumnFormatters.has(column)) valueFormatter = domainColumnFormatters.get(column);
+			initialColumnDefs.push({
+				headerName: formatedHeaderName,
+				field: domainName + column,
+				valueFormatter
+			});
+		});
+		return initialColumnDefs;
+	}, [
+		domainName,
+		t,
+		openViewTransaction,
+		openEditTransaction,
+		openAttachmentTransaction,
+		openWorkflowActionTransaction,
+		domainColumnFormatters,
+		transactionTypeGridColumns
+	]);
+	const secondaryActionButtons = useMemo(() => {
+		const buttons = [{
+			label: t("Print"),
+			iconName: "printer",
+			onClick: () => {}
+		}];
+		if (hasRevisions) buttons.unshift({
+			label: t("Create Revision"),
+			iconName: "edit",
+			onClick: () => {}
+		});
+		return buttons;
+	}, [hasRevisions, t]);
+	const headerConfig = {
+		title: domainName,
+		primaryActionButton: {
+			label: domainName + " Entry",
+			iconName: "add",
+			onClick: () => {
+				openAddTransaction();
+			}
+		},
+		secondaryActionButtons
+	};
+	const gridFunctions = [
+		{ name: "agGridExport" },
+		{ name: "agGridHideShowColumns" },
+		{ name: "agGridSizeColumnsToFit" }
+	];
+	const gridOptions = useMemo(() => {
+		return {
+			pagination: true,
+			rowSelection: { mode: "multiRow" }
+		};
+	}, []);
+	const searchMethodConfig = useMemo(() => {
+		let combinedSearchObject = {
+			eagerLoad: true,
+			filterElements: [{
+				searchField: "transactionTypeId",
+				searchOperator: "=",
+				searchValue: transactionTypeId
+			}]
+		};
+		let combinedFilterElems = combinedSearchObject.filterElements.concat(searchMethodObject?.filterElements);
+		combinedSearchObject = {
+			...combinedSearchObject,
+			...searchMethodObject
+		};
+		combinedSearchObject = {
+			...combinedSearchObject,
+			filterElements: combinedFilterElems
+		};
+		combinedSearchObject = {
+			...combinedSearchObject,
+			filterElement: combinedSearchObject.filterElements.concat({
+				searchField: "transactionTypeId",
+				searchOperator: "=",
+				searchValue: transactionTypeId
+			})
+		};
+		return {
+			requestUrl: `${process.env.REACT_APP_PRODUCT_API_BASE}/UdpTransaction/search`,
+			customSearchObject: combinedSearchObject
+		};
+	}, [transactionTypeId, searchMethodObject]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, transactionTypeLoading && /* @__PURE__ */ React.createElement(LinearProgress$1, null), /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
+		gridHeaderConfig: headerConfig,
+		gridFunctions,
+		gridOptions,
+		columnDefs,
+		searchMethodConfig,
+		gridApiCallback: handleGridApiCallback
+	}));
+};
+var UdpTransactionGrid_default = UdpTransactionGrid;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/ViewTransaction.jsx
+const ViewTransaction = (props) => {
+	const { transaction } = props;
+	return /* @__PURE__ */ React$1.createElement(React$1.Fragment, null, /* @__PURE__ */ React$1.createElement(FileViewer, {
+		data: {
+			filePath: "",
+			fileExtension: "pdf"
+		},
+		acceptedFileExtensions: "pdf"
+	}));
+};
+var ViewTransaction_default = ViewTransaction;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/AttachmentList.jsx
+const AttachmentList = (props) => {
+	const { attachments, setSelectedAttachment } = props;
+	const formattedAttachments = useMemo(() => {
+		return attachments.map((attachment) => ({
+			attachmentName: attachment.fileName,
+			extension: attachment.extension,
+			transactionAttachmentId: attachment.transactionAttachmentId
+		}));
+	}, [attachments]);
+	const getFileIcon = (item) => {
+		if (item.attachmentName.includes(".pdf")) return PDFIcon;
+		else if (item.attachmentName.includes(".docx")) return WordDocumentIcon;
+		else if (item.attachmentName.includes(".")) return FileImageIcon;
+	};
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(AmbientList, {
+		data: formattedAttachments,
+		useAvatar: false,
+		fieldConfig: {
+			primaryText: "attachmentName",
+			secondaryText: "description"
+		},
+		onItemClick: (item) => {
+			setSelectedAttachment(item);
+		},
+		getItemIcon: (item) => {
+			return getFileIcon(item);
+		},
+		listHeight: 800,
+		maxHeight: 900
+	}));
+};
+var AttachmentList_default = AttachmentList;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/AttachmentTransaction.jsx
+const AttachmentTransaction = (props) => {
+	const { transaction } = props;
+	const [selectedAttachment, setSelectedAttachment] = useState("");
+	const attachments = transaction?.udpTransactionUdpTransactionAttachment;
+	const [{ data: attachmentFileInfo }, refetchattachmentFileInfo] = useAxiosGet(`${process.env.REACT_APP_PRODUCT_API_BASE}`, `UdpTransactionAttachment/${selectedAttachment?.transactionAttachmentId}/udpDriveFile/download`, {}, true);
+	useEffect(() => {
+		if (selectedAttachment) refetchattachmentFileInfo();
+	}, [selectedAttachment, refetchattachmentFileInfo]);
+	let fileDataObj = {
+		filePath: attachmentFileInfo?.link,
+		fileExtension: attachmentFileInfo?.extension
+	};
+	const classStyles = makeStyles((theme) => ({
+		sidesheet: {
+			display: "flex",
+			flexDirection: "row",
+			flex: 1
+		},
+		attachmentListContainer: {
+			textAlign: "left",
+			width: "35%"
+		},
+		attachmentListHeader: {
+			backgroundColor: "white",
+			marginTop: "-7%",
+			marginBottom: "-5%",
+			justifyItems: "left",
+			paddingLeft: "5%"
+		},
+		attachmentListHeaderPrimaryText: {
+			fontSize: "var(--h6-font-size)",
+			fontWeight: "var(--body1-font-weight)",
+			marginBottom: "-5%",
+			color: "var(--text-main)"
+		},
+		attachmentListHeaderSecondaryText: {
+			fontSize: "var(--body2-font-size)",
+			color: "var(--text-secondary)",
+			paddingBottom: "2%"
+		},
+		attachemntFileInfoCol: {
+			width: "50%",
+			display: "flex",
+			flexDirection: "column",
+			flex: 1
+		},
+		attachmentFileNameHeader: { backgroundColor: "white" },
+		attachmentFileName: {
+			color: "var(--text-main)",
+			fontSize: "var(--h6-font-size)",
+			fontWeight: "var(--body1-font-weight)",
+			marginTop: "1%",
+			marginBottom: "1%",
+			justifySelf: "center"
+		},
+		fileViewer: {
+			marginLeft: "var(--spacing-02)",
+			marginRight: "var(--spacing-02)"
+		},
+		divider: { "& MuiDivider-root": { backgroundColor: "var(--gray-02)" } }
+	}))();
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", { className: classStyles.sidesheet }, /* @__PURE__ */ React.createElement("div", { className: classStyles.attachmentListContainer }, /* @__PURE__ */ React.createElement("div", { className: classStyles.attachmentListHeader }, /* @__PURE__ */ React.createElement("p", { className: classStyles.attachmentListHeaderPrimaryText }, "Attachments"), /* @__PURE__ */ React.createElement("p", { className: classStyles.attachmentListHeaderSecondaryText }, attachments.length + " file(s) attached")), /* @__PURE__ */ React.createElement("div", { className: classStyles.divider }, /* @__PURE__ */ React.createElement(Divider$1, null)), /* @__PURE__ */ React.createElement(AttachmentList_default, {
+		transaction,
+		attachments,
+		setSelectedAttachment
+	})), /* @__PURE__ */ React.createElement("div", { className: classStyles.attachemntFileInfoCol }, /* @__PURE__ */ React.createElement("div", { className: classStyles.attachmentFileNameHeader }, selectedAttachment && /* @__PURE__ */ React.createElement("p", { className: classStyles.attachmentFileName }, selectedAttachment.attachmentName), /* @__PURE__ */ React.createElement("div", { className: classStyles.divider }, /* @__PURE__ */ React.createElement(Divider$1, null))), selectedAttachment?.attachmentName != attachmentFileInfo?.name ? /* @__PURE__ */ React.createElement(LinearProgress$1, null) : selectedAttachment && attachmentFileInfo ? /* @__PURE__ */ React.createElement("div", { className: classStyles.fileViewer }, /* @__PURE__ */ React.createElement(FileViewer, { data: attachmentFileInfo?.extension == "pdf" ? fileDataObj : [fileDataObj] })) : /* @__PURE__ */ React.createElement(EmptyStateDisplay, {
+		icon: ViewIcon,
+		primaryText: "Select an attachment to preview",
+		secondaryText: "Choose a file from the attachments list to view its contents"
+	}))));
+};
+var AttachmentTransaction_default = AttachmentTransaction;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/WorkflowActions.jsx
+const TransactionActionButton = ({ icon, primaryText, secondaryText, onClick, action }) => {
+	const actionCardIcon = useMemo(() => getIconFromName(icon), [icon]);
+	return /* @__PURE__ */ React$2.createElement(UdpActionCard, {
+		icon: actionCardIcon ? actionCardIcon : DocumentIcon,
+		primaryText,
+		secondaryText,
+		onClick: () => {
+			onClick(action);
+		}
+	});
+};
+const WorkflowActions = ({ transaction, closeSideSheet }) => {
+	const [dialogOpen, setDialogOpen] = useState(true);
+	const [dialogUserStrings, setDialogUserStrings] = useState(null);
+	const [selectedAction, setSelectedAction] = useState(null);
+	const [sideSheetOpen, setSideSheetOpen] = useState(false);
+	const [loading, setLoading] = useState(false);
+	const [{ data: pageData }, refetchPageData] = useAxiosGet(ConfigService.tenantV1ApiUrl, "", {}, true, false);
+	const { getTransactionTypeTransactionActions } = useTransactionEngine(transaction.transactionTypeId);
+	const transactionTypeTransactionActions = useMemo(() => {
+		return getTransactionTypeTransactionActions(transaction, TransactionEventTypeEnums.Sidesheet) || [];
+	}, [getTransactionTypeTransactionActions, transaction]);
+	const [{ data: transactionData }, postTransactionData] = useAxiosMutate(`${process.env.REACT_APP_PRODUCT_API_BASE}udptransactiontypeTransactionAction`, "1db1abc1d-8210-42bc-99fc-2f8794ad5c69/transaction/a0f65808-3590-4de0-8857-a183fe85fdf3/submit", { method: "post" }, {});
+	const i18n = useTranslation().t;
+	const { enqueueSnackbar } = useSnackbar();
+	const handleDialogOpen = useCallback((title, message) => {
+		setDialogUserStrings({
+			title,
+			message
+		});
+		setDialogOpen(true);
+	}, []);
+	const handleDialogClose = useCallback(() => {
+		setDialogOpen(false);
+	}, []);
+	const handleConfirmActionDialog = useCallback(async () => {
+		setDialogOpen(true);
+		handleDialogClose();
+		setLoading(true);
+		try {
+			await postTransactionData({
+				url: `${process.env.REACT_APP_PRODUCT_API_BASE}/udptransactiontypeTransactionAction/${selectedAction.transactionTypeTransactionActionId}/transaction/${transaction.transactionId}/submit`,
+				data: {}
+			});
+			enqueueSnackbar(i18n("Successfully submitted!"), {
+				variant: "success",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+			closeSideSheet();
+		} catch (event) {
+			enqueueSnackbar(i18n(event.message), {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+		setLoading(false);
+	}, [
+		postTransactionData,
+		handleDialogClose,
+		transaction,
+		selectedAction,
+		enqueueSnackbar,
+		i18n
+	]);
+	const handleOnCloseSideSheet = useCallback(() => {
+		setSideSheetOpen(false);
+	}, []);
+	const fetchPageData = useCallback(async (pageId) => {
+		setLoading(true);
+		try {
+			return await refetchPageData({ url: `${ConfigService.tenantV1ApiUrl}/page/${pageId}` });
+		} catch (event) {
+			enqueueSnackbar(i18n(event.message), {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		} finally {
+			setLoading(false);
+		}
+	}, [
+		refetchPageData,
+		enqueueSnackbar,
+		i18n
+	]);
+	const handleOnActionClick = useCallback((action) => {
+		const pageId = action.parameters.pageId;
+		setSelectedAction(action);
+		if (pageId) {
+			fetchPageData(action.parameters.pageId);
+			setSideSheetOpen(true);
+		} else handleDialogOpen(action.name, action.description);
+	}, [handleDialogOpen, fetchPageData]);
+	const TransactionActionButtons = useMemo(() => {
+		if (!transactionTypeTransactionActions.length) return null;
+		return transactionTypeTransactionActions?.map((action) => /* @__PURE__ */ React$2.createElement(TransactionActionButton, {
+			key: action.transactionTypeTransactionActionId,
+			primaryText: action.name,
+			secondaryText: action.description,
+			icon: action.icon,
+			onClick: handleOnActionClick,
+			action
+		}));
+	}, [transactionTypeTransactionActions, handleOnActionClick]);
+	return /* @__PURE__ */ React$2.createElement(React$2.Fragment, null, loading && /* @__PURE__ */ React$2.createElement(LinearProgress$1, null), /* @__PURE__ */ React$2.createElement("div", { className: "transaction-action-buttons-container" }, TransactionActionButtons), dialogUserStrings && /* @__PURE__ */ React$2.createElement(FluentDialog, {
+		title: i18n(`Are you sure you want to proceed with \"${dialogUserStrings.title}\"?`),
+		message: dialogUserStrings.message,
+		labelOne: i18n("Confirm"),
+		actionOne: handleConfirmActionDialog,
+		labelTwo: i18n("Cancel"),
+		actionTwo: handleDialogClose,
+		open: dialogOpen,
+		handleClose: handleDialogClose
+	}), /* @__PURE__ */ React$2.createElement(SideSheet, {
+		open: sideSheetOpen,
+		title: "",
+		onClose: handleOnCloseSideSheet,
+		width: 600
+	}, pageData && /* @__PURE__ */ React$2.createElement(PageContainer, {
+		key: selectedAction?.actionId,
+		pageData,
+		widgetParams: pageData?.widgets,
+		disableMargins: true
+	})));
+};
+var WorkflowActions_default = WorkflowActions;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/EditTransactionHeaderItem.jsx
+const EditTransactionHeaderItem = (props) => {
+	const { label, value, statusChip } = props;
+	return /* @__PURE__ */ React$1.createElement("div", { className: "transaction-sidesheet-header-item" }, /* @__PURE__ */ React$1.createElement(Typography$1, { variant: "caption" }, label), statusChip ? /* @__PURE__ */ React$1.createElement("div", { className: "transaction-sidesheet-header-item-status" }, /* @__PURE__ */ React$1.createElement(StatusChip, statusChip)) : /* @__PURE__ */ React$1.createElement(Typography$1, { variant: "body1" }, value));
+};
+var EditTransactionHeaderItem_default = EditTransactionHeaderItem;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/EditTransaction.jsx
+const EditTransaction = (props) => {
+	const { transaction, openInnerSidesheetState, setOpenInnerSidesheetState } = props;
+	const { t } = useTranslation();
+	const [selectedTab, setSelectedTab] = useState();
+	const tabNames = [
+		t("Details"),
+		t("History"),
+		t("Attachments"),
+		t("Notes")
+	];
+	const headerItemInfo = [{
+		label: "Status",
+		statusChip: {
+			label: transaction.udpTransactionUdpTransactionTypeStatus?.name,
+			status: "success"
+		}
+	}, {
+		label: "Revision",
+		value: transaction?.currentRevisionNo
+	}];
+	const innerSidesheetList = [
+		{
+			open: openInnerSidesheetState.workflowAction,
+			closeSheet: () => setOpenInnerSidesheetState({ workflowActions: false }),
+			title: "Available Workflow Actions",
+			children: /* @__PURE__ */ React.createElement(WorkflowActions_default, {
+				transaction,
+				closeSideSheet: () => {
+					setOpenInnerSidesheetState({ workflowActions: false });
+				}
+			})
+		},
+		{
+			open: openInnerSidesheetState.attachments,
+			closeSheet: () => setOpenInnerSidesheetState({ attachments: false }),
+			title: "Add Attachment",
+			children: /* @__PURE__ */ React.createElement("h1", null, "Add Attachments content")
+		},
+		{
+			open: openInnerSidesheetState.notes,
+			closeSheet: () => setOpenInnerSidesheetState({ notes: false }),
+			title: "Add Note",
+			buttonLabel: "Save note",
+			buttonTwoLabel: "Clear",
+			buttonTwoAction: () => {},
+			children: /* @__PURE__ */ React.createElement("h1", null, "Add Notes content")
+		}
+	];
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet" }, /* @__PURE__ */ React.createElement("div", { className: `edit-transaction-sidesheet-header 'is-sticky'` }, /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-header-title" }), /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-header-content" }, /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-header-items" }, headerItemInfo.map((headerItem) => {
+		return /* @__PURE__ */ React.createElement(EditTransactionHeaderItem_default, {
+			key: headerItem.label,
+			label: headerItem.label,
+			statusChip: headerItem.statusChip,
+			value: headerItem.value
+		});
+	})), /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-header-buttons" }, /* @__PURE__ */ React.createElement(FluentButton, {
+		variant: "contained",
+		color: "secondary",
+		onClick: () => {
+			setOpenInnerSidesheetState({ attachments: true });
+		}
+	}, "Add Attachment"), /* @__PURE__ */ React.createElement(FluentButton, {
+		variant: "contained",
+		color: "secondary",
+		onClick: () => {
+			setOpenInnerSidesheetState({ notes: true });
+		}
+	}, "Add Note")), /* @__PURE__ */ React.createElement("div", { className: "divider" }, /* @__PURE__ */ React.createElement(Divider$1, null)), /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-tabs" }, /* @__PURE__ */ React.createElement(UdpTabs, {
+		value: selectedTab,
+		onChange: (value, tabIndex) => {
+			setSelectedTab(tabNames[tabIndex]);
+		},
+		tabList: tabNames.map((tabName) => ({ label: tabName })),
+		buttonWidth: "100%"
+	}))), /* @__PURE__ */ React.createElement("div", { className: "divider" }, /* @__PURE__ */ React.createElement(Divider$1, null))), /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-body" }, /* @__PURE__ */ React.createElement("div", { style: { height: 1600 } }, /* @__PURE__ */ React.createElement(Typography$1, { variant: "body1" }, "Tab Content Placeholder"), /* @__PURE__ */ React.createElement(Typography$1, { variant: "body1" }, selectedTab)))), openInnerSidesheetState && innerSidesheetList.map((item) => {
+		return /* @__PURE__ */ React.createElement(SideSheet, {
+			key: item.title,
+			open: item.open,
+			width: 600,
+			title: item.title,
+			onClose: item.closeSheet,
+			buttonLabel: item?.buttonLabel,
+			buttonTwoLabel: item?.buttonTwoLabel,
+			color: "primary"
+		}, item.children);
+	}));
+};
+var EditTransaction_default = EditTransaction;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/UdpTransactionSidesheet.jsx
+const UdpTransactionSidesheet = (props) => {
+	const { openStates, handleSidesheet, handleAttachmentTransaction, transaction, transactionTypeId, domainName, refreshGridData } = props;
+	const [sidesheetLoading, setSidesheetLoading] = useState(false);
+	const [editTransactionopenInnerSidesheetState, setEditTransactionOpenInnerSidesheetState] = useState({
+		attachments: false,
+		workflowActions: false,
+		notes: false
+	});
+	const { hasClosedStatus } = useTransactionEngine(transactionTypeId);
+	const sidesheetWidth = 800;
+	const formattedBusinesskey = (transaction?.entityBusinessObject)?.businessObjectKey?.split("|")?.pop();
+	const sidesheetList = useMemo(() => {
+		const buttons = [
+			{
+				open: openStates.viewTransaction,
+				closeSheet: () => handleSidesheet("view", false),
+				title: domainName + " " + formattedBusinesskey + " - Preview",
+				width: sidesheetWidth,
+				children: /* @__PURE__ */ React$1.createElement(ViewTransaction_default, { transaction }),
+				buttonLabel: "Download"
+			},
+			{
+				open: openStates.attachmentTransaction,
+				closeSheet: () => handleSidesheet("view", false),
+				title: "Attachment for " + domainName + " " + formattedBusinesskey,
+				width: sidesheetWidth,
+				buttonLabel: "Download",
+				children: /* @__PURE__ */ React$1.createElement(AttachmentTransaction_default, {
+					handleAttachmentTransaction,
+					transaction,
+					domainName,
+					setSidesheetLoading
+				})
+			},
+			{
+				open: openStates.workflowAction,
+				closeSheet: () => handleSidesheet("action", false),
+				title: `Workflow Actions - ${domainName} ${formattedBusinesskey}`,
+				width: sidesheetWidth,
+				children: /* @__PURE__ */ React$1.createElement(WorkflowActions_default, {
+					transaction,
+					closeSideSheet: () => {
+						handleSidesheet("action", false);
+						refreshGridData();
+					}
+				})
+			}
+		];
+		if (hasClosedStatus) buttons.push({
+			open: openStates.editTransaction,
+			closeSheet: () => handleSidesheet("edit", false),
+			title: `Edit ${domainName} ${formattedBusinesskey}`,
+			width: sidesheetWidth,
+			buttonLabel: "Next Steps",
+			onSubmit: () => setEditTransactionOpenInnerSidesheetState({ workflowAction: true }),
+			buttonTwoLabel: "Close " + domainName,
+			buttonTwoAction: () => {},
+			children: /* @__PURE__ */ React$1.createElement(EditTransaction_default, {
+				transaction,
+				openInnerSidesheetState: editTransactionopenInnerSidesheetState,
+				setOpenInnerSidesheetState: setEditTransactionOpenInnerSidesheetState
+			})
+		});
+		return buttons;
+	}, [
+		openStates,
+		handleSidesheet,
+		handleAttachmentTransaction,
+		transaction,
+		domainName,
+		editTransactionopenInnerSidesheetState,
+		setEditTransactionOpenInnerSidesheetState,
+		formattedBusinesskey,
+		hasClosedStatus,
+		refreshGridData
+	]);
+	return /* @__PURE__ */ React$1.createElement(React$1.Fragment, null, openStates && sidesheetList.map((item) => {
+		return /* @__PURE__ */ React$1.createElement(SideSheet, {
+			key: item.title,
+			open: item.open,
+			width: sidesheetWidth,
+			title: item.title,
+			onClose: item.closeSheet,
+			noPadding: openStates.attachmentTransaction || openStates.editTransaction,
+			buttonLabel: item?.buttonLabel,
+			onSubmit: item?.onSubmit,
+			color: "primary",
+			buttonTwoLabel: item?.buttonTwoLabel,
+			buttonTwoAction: item?.buttonTwoAction
+		}, sidesheetLoading && /* @__PURE__ */ React$1.createElement(LinearProgress$1, null), /* @__PURE__ */ React$1.createElement("div", null, item.children));
+	}));
+};
+var UdpTransactionSidesheet_default = UdpTransactionSidesheet;
+
+//#endregion
+//#region src/hooks/useTransactionType.js
+const useTransactionType = (options = {}) => {
+	const { transactionTypeId, domainName, domainFieldType, domainFieldValue } = options;
+	const [resolvedId, setResolvedId] = useState(transactionTypeId || null);
+	const [data, setData] = useState(void 0);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState(void 0);
+	const [promise, setPromise] = useState(void 0);
+	const { transactionTypesMap, setTransactionTypesMap } = useTransactionStore();
+	const setSuccessState = useCallback((response) => {
+		setError(void 0);
+		setLoading(false);
+		setData(response);
+	}, []);
+	useEffect(() => {
+		if (transactionTypeId) {
+			setResolvedId(transactionTypeId);
+			return;
+		}
+		if (!domainName) return;
+		setLoading(true);
+		const domainPromise = apiMutate(ConfigService.productV1ApiUrl, `udpTransactionType/domain/${domainName}${domainFieldType && domainFieldValue ? `?domainFieldType=${domainFieldType}&domainFieldValue=${domainFieldValue}` : ""}`, {});
+		domainPromise.then((res) => {
+			const newId = res.data?.transactionTypeId;
+			if (newId) setResolvedId(newId);
+			else setError("Transaction type not found for domain.");
+		}).catch(setError).finally(() => setPromise(domainPromise));
+	}, [
+		transactionTypeId,
+		domainName,
+		domainFieldType,
+		domainFieldValue
+	]);
+	useEffect(() => {
+		if (!resolvedId) return;
+		if (transactionTypesMap[resolvedId]) {
+			setSuccessState(transactionTypesMap[resolvedId]);
+			return;
+		}
+		setLoading(true);
+		const fetchPromise = apiMutate(ConfigService.productV1ApiUrl, `udpTransactionType/${resolvedId}?withAssociationData=true`, {});
+		fetchPromise.then((res) => {
+			const transactionType = res.data;
+			setTransactionTypesMap({ [resolvedId]: transactionType });
+			setSuccessState(transactionType);
+		}).catch(setError).finally(() => setPromise(fetchPromise));
+	}, [
+		resolvedId,
+		transactionTypesMap,
+		setTransactionTypesMap,
+		setSuccessState
+	]);
+	return {
+		data,
+		loading,
+		error,
+		promise
+	};
+};
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/UdpTransactionsPage.jsx
+const UdpTransactionsPage = (props) => {
+	const { transactionTypeId = "", domainName: initialDomainName = "Univerus.Unity.CPS.Domain.Models.RFI", domainFieldType, domainFieldValue } = props;
+	const [sidesheetState, setSidesheetState] = useState({
+		workflowAction: false,
+		addTransaction: false,
+		editTransaction: false,
+		viewTransaction: false,
+		attachmentTransaction: false
+	});
+	const [selectedTransaction, setSelectedTransaction] = useState(null);
+	const [domainName, setDomainName] = useState(initialDomainName);
+	const { data: transactionType, loading: transactionTypeLoading, error: transactionTypeError } = useTransactionType({
+		transactionTypeId,
+		domainName: initialDomainName,
+		domainFieldType,
+		domainFieldValue
+	});
+	useTransactionEngine(transactionType?.transactionTypeId);
+	const gridApiRef = useRef(null);
+	const searchMethodObject = { filterElements: [{
+		searchField: "transactionId",
+		searchOperator: "NOTNULL"
+	}] };
+	const domainColumnFormatters = new Map([
+		["submittedBy", (params) => {
+			return params?.data ? params?.data?.entityBusinessObject["submittedBy"] : "";
+		}],
+		["submittedTo", (params) => {
+			return params?.data ? params?.data?.entityBusinessObject["submittedTo"] : "";
+		}],
+		["rfiNo", (params) => {
+			return params?.data ? params?.data?.entityBusinessObject["rfiNo"] : "";
+		}],
+		["description", (params) => {
+			return params?.data ? params?.data?.entityBusinessObject["description"] : "";
+		}]
+	]);
+	const handleSidesheet = (actionType, openStatus, transaction) => {
+		if (actionType == "add") setSidesheetState({ addTransaction: openStatus });
+		else if (actionType == "edit") setSidesheetState({ editTransaction: openStatus });
+		else if (actionType == "view") setSidesheetState({ viewTransaction: openStatus });
+		else if (actionType == "attachment") setSidesheetState({ attachmentTransaction: openStatus });
+		else if (actionType == "action") setSidesheetState({ workflowAction: openStatus });
+		setSelectedTransaction(transaction);
+	};
+	const handleAttachmentTransaction = () => {};
+	const handleGridApiCallback = (api) => {
+		return gridApiRef.current = api;
+	};
+	useEffect(() => {
+		if (transactionType) setDomainName(transactionType.domainName.split(".").pop());
+	}, [transactionType]);
+	return /* @__PURE__ */ React$1.createElement(React$1.Fragment, null, /* @__PURE__ */ React$1.createElement(UdpTransactionGrid_default, {
+		transactionTypeId: transactionType?.transactionTypeId,
+		transactionType,
+		domainName,
+		transactionTypeLoading,
+		searchMethodObject,
+		domainColumnFormatters,
+		openAddTransaction: () => {
+			handleSidesheet("add", true);
+		},
+		openViewTransaction: (transaction) => {
+			handleSidesheet("view", true, transaction);
+		},
+		openEditTransaction: (transaction) => {
+			handleSidesheet("edit", true, transaction);
+		},
+		openAttachmentTransaction: (transaction) => {
+			handleSidesheet("attachment", true, transaction);
+		},
+		openWorkflowActionTransaction: (transaction) => {
+			handleSidesheet("action", true, transaction);
+		},
+		handleGridApiCallback
+	}), /* @__PURE__ */ React$1.createElement(UdpTransactionSidesheet_default, {
+		openStates: sidesheetState,
+		handleSidesheet,
+		handleAttachmentTransaction,
+		transaction: selectedTransaction,
+		transactionTypeId: transactionType?.transactionTypeId,
+		domainName,
+		refreshGridData: () => {
+			gridApiRef?.current?.refreshServerSide();
+		}
+	}));
+};
+var UdpTransactionsPage_default = UdpTransactionsPage;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/index.ts
+var UdpTransactionsPage_exports = /* @__PURE__ */ __export({ default: () => UdpTransactionsPage_default });
+
+//#endregion
+export { UdpTransactionsPage_default as n, UdpTransactionsPage_exports as t };
+//# sourceMappingURL=UdpTransactionsPage-CpgF8O9C.js.map