udp-react-enterprise-component-library 1.0.5 → 25.1.0-beta.2

package/dist/MyExportsPage-BYH2Wl9k.js

@@ -0,0 +1,678 @@
+import { ActionsRenderer, AmbientGridTemplate, FilterOperators, FluentDialog, getSanitizedName, useAgGridApi } from "./AmbientGridTemplate-BLwgiqwK.js";
+import { FluentButton, FluentIcon, LayoutUnit, LogicalSearchOperatorEnums, SearchGroupingType, SearchSortDirection, StatusChip, executeQueryAdHoc, executeQueryWithParameters, useAxiosGet, useBuildEnvironment, useUser } from "./EnvironmentRibbon-BMvQEZPZ.js";
+import { useHandleAxiosSnackbar } from "./apiHelpers-t3rfkjFZ.js";
+import { getSearchObject } from "./SearchUtilities-dbXvMYoa.js";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { Box, Button, Popper, TextField, Typography, makeStyles } from "@material-ui/core";
+import { ConfigService } from "udp-react-stencil-component-library";
+import Autocomplete from "@material-ui/lab/Autocomplete";
+import clsx from "clsx";
+import { DownloadIcon, ErrorIcon, StatusCircleCheckmarkIcon } from "@fluentui/react-icons";
+import PropTypes from "prop-types";
+import { cloneDeep } from "lodash";
+import { Alert, AlertTitle } from "@material-ui/lab";
+
+//#region src/utilities/aggrid/datasources/SearchServiceDatasource.js
+const SearchServiceDatasource = (queryData, apiMethodId, searchFilterElements, logicalSearchOperator = LogicalSearchOperatorEnums.And, executeQuery, storeRowData, lookupsMap, eagerLoad = false, getCleanData = null) => {
+	return { async getRows(params) {
+		const { startRow, endRow, rowGroupCols, groupKeys, valueCols, filterModel, sortModel } = params.request;
+		const page = endRow / 20;
+		const originalSearchObject = getSearchObject(searchFilterElements, page, null, eagerLoad, logicalSearchOperator);
+		const searchObject = cloneDeep(originalSearchObject);
+		if (sortModel.length) {
+			const orderElements = searchObject.orderElements;
+			sortModel.forEach((sortItem) => {
+				const formattedPropertyName = sortItem.colId.charAt(0).toUpperCase() + sortItem.colId.slice(1);
+				const element = orderElements.find((element$1) => element$1.sortColumn === formattedPropertyName);
+				if (element) element.sortDirection = sortItem.sort.toUpperCase();
+				else orderElements.push({
+					sortColumn: formattedPropertyName,
+					sortDirection: sortItem.sort.toUpperCase()
+				});
+			});
+		}
+		if (Object.keys(filterModel).length) {
+			const filterElements = searchObject.filterElements;
+			Object.keys(filterModel).forEach((key) => {
+				const filterItem = filterModel[key];
+				const formattedPropertyName = key.charAt(0).toUpperCase() + key.slice(1);
+				filterElements.push({
+					searchField: formattedPropertyName,
+					searchValue: filterItem.filter,
+					searchOperator: FilterOperators[filterItem.type]
+				});
+			});
+		}
+		if (rowGroupCols.length && !groupKeys.length) {
+			const formattedPropertyName = rowGroupCols[0].field.charAt(0).toUpperCase() + rowGroupCols[0].field.slice(1);
+			searchObject.groupingType = SearchGroupingType.Distinct;
+			if (!searchObject.groupProperty.includes(formattedPropertyName)) {
+				searchObject.groupProperty.push(formattedPropertyName);
+				const orderElements = searchObject.orderElements;
+				const element = orderElements.find((element$1) => element$1.sortColumn === formattedPropertyName);
+				if (!element) orderElements.push({
+					sortColumn: formattedPropertyName,
+					sortDirection: SearchSortDirection.Asc
+				});
+			}
+		}
+		if (groupKeys.length) if (groupKeys.length === rowGroupCols.length) {
+			searchObject.groupingType = "";
+			const filterElements = searchObject.filterElements;
+			groupKeys.forEach((key, index) => {
+				const rowGroupCol = rowGroupCols[index];
+				const formattedPropertyName = rowGroupCol.field.charAt(0).toUpperCase() + rowGroupCol.field.slice(1);
+				const element = filterElements.find((element$1) => element$1.searchField === formattedPropertyName);
+				let currentNode = null;
+				params.api.forEachNode((node) => {
+					const nodeKey = node.field;
+					if (nodeKey?.toLowerCase() === formattedPropertyName?.toLowerCase() && node?.data?.[nodeKey] === key) {
+						currentNode = node;
+						return;
+					}
+				});
+				let searchValue = key;
+				if (currentNode) {
+					const cleanData = getCleanData ? getCleanData(currentNode.data, lookupsMap) : null;
+					if (cleanData) searchValue = cleanData[currentNode.field];
+				}
+				if (element) {
+					element.searchValue = searchValue;
+					element.searchOperator = "=";
+				} else filterElements.push({
+					searchField: formattedPropertyName,
+					searchValue,
+					searchOperator: "="
+				});
+			});
+		} else {
+			groupKeys.forEach((key, index) => {
+				const formattedPropertyNameForSearch = rowGroupCols[index].field.charAt(0).toUpperCase() + rowGroupCols[index].field.slice(1);
+				let currentNode = null;
+				params.api.forEachNode((node) => {
+					const nodeKey = node.field;
+					if (nodeKey?.toLowerCase() === formattedPropertyNameForSearch?.toLowerCase() && node?.data?.[nodeKey] === key) {
+						currentNode = node;
+						return;
+					}
+				});
+				let searchValue = key;
+				if (currentNode) {
+					const cleanData = getCleanData ? getCleanData(currentNode.data, lookupsMap) : null;
+					if (cleanData) searchValue = cleanData[currentNode.field];
+				}
+				searchObject.filterElements.push({
+					searchField: formattedPropertyNameForSearch,
+					searchValue,
+					searchOperator: "="
+				});
+			});
+			searchObject.groupingType = SearchGroupingType.Distinct;
+			const searchIndex = groupKeys.length;
+			const rowGroupCol = rowGroupCols[searchIndex];
+			const formattedPropertyName = rowGroupCol.field.charAt(0).toUpperCase() + rowGroupCol.field.slice(1);
+			if (!searchObject.groupProperty.includes(formattedPropertyName)) {
+				searchObject.groupProperty.push(formattedPropertyName);
+				const orderElements = searchObject.orderElements;
+				const element = orderElements.find((element$1) => element$1.sortColumn === formattedPropertyName);
+				if (!element) orderElements.push({
+					sortColumn: formattedPropertyName,
+					sortDirection: SearchSortDirection.Asc
+				});
+			}
+		}
+		if (!startRow && rowGroupCols.length === 0 && !sortModel.length && !Object.keys(filterModel).length && !groupKeys.length && queryData) if (queryData.pageList && queryData.pageList) {
+			params.success({
+				rowData: queryData.pageList,
+				rowCount: parseInt(queryData.total)
+			});
+			if (storeRowData) storeRowData(queryData.pageList);
+		} else {
+			params.success({
+				rowData: [],
+				rowCount: 0
+			});
+			if (storeRowData) storeRowData([]);
+		}
+		else {
+			let response = null;
+			if (executeQuery) {
+				const data = { data: searchObject };
+				response = await executeQuery(data, apiMethodId, lookupsMap).catch((e) => params.success({
+					rowData: [],
+					rowCount: 0
+				}));
+			}
+			const rowData = response?.status === 200 ? response?.data : response;
+			if (rowData && response) if (rowData?.pageList?.length > 0) {
+				params.success({
+					rowData: rowData.pageList,
+					rowCount: parseInt(rowData.total)
+				});
+				if (storeRowData) storeRowData(rowData.pageList);
+			} else {
+				params.success({
+					rowData: [],
+					rowCount: 0
+				});
+				if (storeRowData) storeRowData([]);
+			}
+			else {
+				params.success({
+					rowData: [],
+					rowCount: 0
+				});
+				if (storeRowData) storeRowData([]);
+			}
+		}
+	} };
+};
+
+//#endregion
+//#region src/maintenanceEngine/tableBrowser/TableColumnDefs.js
+const TableColumnDefs = (actionList) => {
+	const getterRowData = useCallback((params) => {
+		return params.data;
+	}, []);
+	const columnDefs = [{
+		headerName: "Name",
+		field: "entityName",
+		valueGetter: (params) => params.data?.properties?.displayName || params.data?.sanitizedName || getSanitizedName(params.data?.entityName),
+		wrapText: true,
+		autoHeight: false,
+		sortable: false
+	}, {
+		headerName: "Actions",
+		filter: false,
+		pinned: "right",
+		cellRenderer: "actionsRenderer",
+		width: 150,
+		cellRendererParams: { actionList },
+		valueGetter: getterRowData,
+		maxWidth: 180,
+		suppressMenu: true,
+		sortable: false,
+		cellStyle: {
+			display: "flex",
+			alignItems: "center"
+		}
+	}];
+	return columnDefs;
+};
+const defaultColumnActionsDef = {
+	resizable: true,
+	editable: false,
+	sortable: true,
+	filter: true,
+	floatingFilter: false,
+	enableRowGroup: true
+};
+
+//#endregion
+//#region src/maintenanceEngine/tableBrowser/TableContainer.jsx
+const TableContainer$1 = (props) => {
+	const { actionList, loading, rowData, catalog, isServerSide = false, promotedEntity, filterElements, customColumnDefs, eagerLoad = false, logicalSearchOperator = 1, frameworkComponents = { actionsRenderer: ActionsRenderer }, additionalGridOptions, headerBackgroundColor, api, columnApi, gridReady, dynamicSizing,...other } = props;
+	const { gridApi, gridColumnApi, onGridReady } = useAgGridApi();
+	const gApi = api || gridApi;
+	const cApi = columnApi || gridColumnApi;
+	const gReady = gridReady || onGridReady;
+	const buildEnv = useBuildEnvironment();
+	const columnDefs = customColumnDefs || TableColumnDefs(actionList);
+	const groupData = useMemo(() => {
+		return columnDefs?.map((item) => {
+			return {
+				groupItem: item.field,
+				label: item.headerName,
+				value: item.field
+			};
+		});
+	}, [columnDefs]);
+	useEffect(() => {
+		if (!gApi) return;
+		if (promotedEntity && isServerSide) {
+			let datasource = SearchServiceDatasource(null, promotedEntity?.unityBaseSearchMethod?.apiMethodId, filterElements, logicalSearchOperator, executeQueryAdHoc, null, null, eagerLoad);
+			gApi?.setServerSideDatasource(datasource);
+		}
+	}, [
+		gApi,
+		promotedEntity,
+		isServerSide,
+		filterElements,
+		eagerLoad,
+		logicalSearchOperator
+	]);
+	return /* @__PURE__ */ React.createElement(AmbientGridTemplate, {
+		useNewHeader: true,
+		api: gApi,
+		onGridReady: gReady,
+		columnApi: cApi,
+		title: catalog?.name,
+		data: !isServerSide && rowData,
+		columnDefs,
+		groupingData: groupData,
+		height: `calc(100vh - ${buildEnv ? "139px" : "114px"})`,
+		frameworkComponents,
+		hideSearchBar: isServerSide,
+		loading,
+		suppressScrollOnNewData: true,
+		dynamicSizing: dynamicSizing ?? false,
+		disableRowSelection: true,
+		rowModelType: isServerSide ? "serverSide" : null,
+		serverSideStoreType: isServerSide ? "partial" : null,
+		cacheOverflowSize: isServerSide ? 2 : null,
+		cacheBlockSize: isServerSide ? 20 : null,
+		maxConcurrentDatasourceRequests: isServerSide ? 1 : null,
+		additionalGridOptions,
+		headerBackgroundColor,
+		...other
+	});
+};
+
+//#endregion
+//#region src/UI/inputs/textField/AmbientAutoComplete.jsx
+const useStyles$2 = makeStyles((theme) => ({
+	input: {
+		borderRadius: 2,
+		minHeight: 32,
+		padding: 0,
+		paddingTop: "0 !important",
+		paddingBottom: (props) => props.isMultiple ? "0 !important" : 10,
+		marginTop: 3,
+		"& .MuiFilledInput-inputMarginDense": { paddingTop: 8 },
+		"& .MuiFilledInput-root": { paddingTop: 0 },
+		"& .MuiInputAdornment-filled.MuiInputAdornment-positionStart:not(.MuiInputAdornment-hiddenLabel)": {
+			marginTop: theme.spacing(.5),
+			marginLeft: theme.spacing(1)
+		}
+	},
+	formTextInput: {
+		fontSize: 14,
+		marginTop: "2px !important",
+		paddingBottom: "2px !important"
+	},
+	labelRoot: { fontSize: 14 },
+	root: {
+		marginTop: 25,
+		"& .MuiFormLabel-root": {
+			marginTop: -30,
+			marginLeft: -11
+		},
+		"& .MuiInputAdornment-root": { paddingLeft: theme.spacing(1) }
+	},
+	noLabel: { marginTop: theme.spacing(1) },
+	formControl: { width: "100%" }
+}));
+const AutoCompletePopper = (props) => {
+	return /* @__PURE__ */ React.createElement(Popper, {
+		...props,
+		placement: "bottom-start"
+	});
+};
+const AmbientAutoComplete = (props) => {
+	const { getOptionLabelFunction, getOptionSelected, label, placeholder, options, textFieldProps, disabled, onChange: onChangeProp, value, additionalOnChangeAction, classes: classProps, variant = "filled", inputProps, inputPropClasses, customPopper, disableClearable = false, defaultValue, additionalOptionKey, isMultiple = false, limitTags, renderTags, size = "medium", groupBy = null, loading, disableCloseOnSelect = false,...other } = props;
+	const classes = useStyles$2(props);
+	const { autocompleteRoot } = classProps || {};
+	const onChange = useCallback((e, value$1) => {
+		if (additionalOnChangeAction) additionalOnChangeAction(value$1);
+		return onChangeProp?.(value$1);
+	}, [onChangeProp, additionalOnChangeAction]);
+	return /* @__PURE__ */ React.createElement(Autocomplete, {
+		id: "autocomplete",
+		multiple: isMultiple,
+		limitTags,
+		disabled,
+		options: options || [],
+		loading,
+		getOptionLabel: getOptionLabelFunction,
+		getOptionSelected,
+		groupBy,
+		onChange,
+		value: value || (isMultiple ? [] : null),
+		className: autocompleteRoot,
+		classes: { root: classes.formControl },
+		PopperComponent: customPopper || AutoCompletePopper,
+		disableClearable,
+		defaultValue,
+		size,
+		disableCloseOnSelect,
+		renderInput: (params) => /* @__PURE__ */ React.createElement("div", { className: label ? classes.root : classes.noLabel }, /* @__PURE__ */ React.createElement(TextField, {
+			...textFieldProps,
+			...params,
+			...other,
+			label,
+			margin: "dense",
+			variant,
+			size: "small",
+			InputProps: {
+				...params.InputProps,
+				classes: {
+					root: classes.input,
+					input: classes.formTextInput,
+					...props.InputProps?.classes
+				}
+			},
+			InputLabelProps: {
+				shrink: false,
+				classes: {
+					root: classes.labelRoot,
+					focused: classes.labelFocused
+				}
+			}
+		})),
+		renderTags
+	});
+};
+
+//#endregion
+//#region src/UI/dataDisplay/EmptyStateDisplay.jsx
+const useStyles$1 = makeStyles((theme) => ({
+	container: {
+		display: "flex",
+		flexDirection: "column",
+		alignItems: "center",
+		justifyContent: "center",
+		height: "100%",
+		width: "100%"
+	},
+	secondaryText: { color: theme.palette.text.secondary },
+	image: { width: (props) => props?.imageWidth }
+}));
+const EmptyStateDisplay = (props) => {
+	const { icon, iconSize = 48, customIconSize = true, imageSrc, imageWidth = "100px", primaryText, secondaryText, actionLabel, action } = props;
+	const classes = useStyles$1({ imageWidth });
+	return /* @__PURE__ */ React.createElement("div", { className: classes.container }, imageSrc ? /* @__PURE__ */ React.createElement("img", {
+		src: imageSrc,
+		alt: "logo",
+		className: classes.image
+	}) : /* @__PURE__ */ React.createElement(FluentIcon, {
+		component: icon ?? ErrorIcon,
+		size: iconSize,
+		customSize: customIconSize
+	}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "xxs" }), primaryText && /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(Typography, {
+		variant: "subtitle2",
+		align: "center"
+	}, primaryText)), secondaryText && /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(Typography, {
+		className: classes.secondaryText,
+		align: "center"
+	}, secondaryText)), (primaryText || secondaryText) && /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "xxs" }), action && /* @__PURE__ */ React.createElement("div", { className: primaryText || secondaryText ? classes.buttonWrapper : "" }, /* @__PURE__ */ React.createElement(FluentButton, {
+		onClick: action,
+		variant: "outlined",
+		color: "secondary",
+		id: "udpRecord-EmptyStateDisplay-" + primaryText.replace(/\s+/g, "") + "-" + actionLabel.replace(/\s+/g, ""),
+		udprecordid: "udpRecord-EmptyStateDisplay-" + primaryText.replace(/\s+/g, "") + "-" + actionLabel.replace(/\s+/g, "")
+	}, actionLabel)));
+};
+EmptyStateDisplay.propTypes = {
+	icon: PropTypes.elementType,
+	iconSize: PropTypes.number,
+	customIconSize: PropTypes.bool,
+	imageSrc: PropTypes.string,
+	imageWidth: PropTypes.string,
+	primaryText: PropTypes.string,
+	secondaryText: PropTypes.string,
+	actionLabel: PropTypes.string,
+	action: PropTypes.func
+};
+EmptyStateDisplay.defaultProps = {
+	iconSize: 48,
+	customIconSize: true,
+	imageWidth: "100px"
+};
+
+//#endregion
+//#region src/UI/feedback/AmbientAlert.jsx
+const useStyles = makeStyles((theme) => ({
+	root: {},
+	"@global": { ".MuiPaper-rounded": { borderRadius: 0 } },
+	alertSuccess: { borderLeft: `4px solid ${theme.palette.success.main}` },
+	alertWarning: { borderLeft: `4px solid ${theme.palette.warning.main}` },
+	alertError: {
+		borderLeft: `4px solid ${theme.palette.error.main}`,
+		color: theme.palette.error.main
+	},
+	alertInfo: { borderLeft: `4px solid ${theme.palette.info.main}` },
+	square: { borderRadius: 0 }
+}));
+const AmbientAlert = ({ alertButton, alertMessage, alertTitle, showAlert, alertSeverity, closeAlert, alertAction, alertActionButton, alertHandleAction,...otherProps }) => {
+	const classes = useStyles();
+	const alertColor = () => {
+		if (alertSeverity === "success") {
+			let alertLevel = classes.alertSuccess;
+			return alertLevel;
+		} else if (alertSeverity === "warning") {
+			let alertLevel = classes.alertWarning;
+			return alertLevel;
+		} else if (alertSeverity === "error") {
+			let alertLevel = classes.alertError;
+			return alertLevel;
+		} else if (alertSeverity === "info") {
+			let alertLevel = classes.alertInfo;
+			return alertLevel;
+		}
+	};
+	return /* @__PURE__ */ React.createElement("div", null, showAlert && /* @__PURE__ */ React.createElement(Alert, {
+		classes: { root: clsx(alertColor(), classes.square) },
+		...otherProps,
+		severity: alertSeverity,
+		onClose: closeAlert,
+		action: alertAction ? /* @__PURE__ */ React.createElement(Button, {
+			onClick: alertHandleAction,
+			id: "udpRecord-AmbientAlert-alertActionButton",
+			udprecordid: "udpRecord-AmbientAlert-alertActionButton"
+		}, alertActionButton) : null
+	}, alertTitle && /* @__PURE__ */ React.createElement(AlertTitle, null, alertTitle), alertMessage));
+};
+
+//#endregion
+//#region src/UI/templates/ui/renderers/StatusCellRenderer.jsx
+const StatusCellRenderer = (props) => {
+	const { value, getStatus, getLabel } = props;
+	const formattedLabel = (value$1) => {
+		return value$1?.replace(/([a-z])([A-Z])/g, "$1 $2")?.replace(/\b\w/g, (char) => char.toUpperCase());
+	};
+	return /* @__PURE__ */ React.createElement(StatusChip, {
+		status: getStatus(value),
+		label: getLabel ? formattedLabel(getLabel(value)) : formattedLabel(value)
+	});
+};
+
+//#endregion
+//#region src/udp/export/MyExportsPage.jsx
+const MyExportsPage = (props) => {
+	const { productId } = props;
+	const user = useUser();
+	const [product, setProduct] = useState();
+	const [downloadLinkLoading, setDownloadLinkLoading] = useState(false);
+	const [fileResultData, setFileResultData] = useState();
+	const [downloadOpen, setDownloadOpen] = useState(false);
+	const [noDownloadMethod, setNoDownloadMethod] = useState(false);
+	const { handleErrorSnackbar, handleSuccessSnackbar } = useHandleAxiosSnackbar();
+	const [{ data: products, loading: productsLoading }] = useAxiosGet(ConfigService.tenantV2ApiUrl, `tenant/products?tenantId=${user?.currentTenantId}&isSubscribable=${!user?.can?.CAN_MANAGE_CATALOGS_FOR_UNSUBSCRIBABLE_PRODUCTS}`, {}, !user);
+	const [{ data: apiCatalog, loading: catalogLoading, error: catalogError }] = useAxiosGet(ConfigService.integrationV1ApiUrl, `tenantProductApiCatalogBase/tenant/${user?.currentTenantId}/product/${productId ? productId : product?.productId}`, {}, !(product || productId), false);
+	const [{ data: udpJobEntity, loading: jobEntityLoading }] = useAxiosGet(ConfigService.integrationV1ApiUrl, `apicatalog/${apiCatalog?.apiCatalogId}/promotedMethodEntities/udpJob/product/${apiCatalog?.productId}?compareSanitizedName=true`, {}, !apiCatalog?.productId || !apiCatalog?.apiCatalogId, false);
+	const refetchfileResultData = useCallback(async (selectedRecord) => {
+		if (udpJobEntity?.unityBaseGetFileResultMethod?.apiMethodId) {
+			setDownloadLinkLoading(true);
+			await executeQueryWithParameters({ data: { JobId: selectedRecord?.id } }, udpJobEntity?.unityBaseGetFileResultMethod?.apiMethodId).then((res) => {
+				setFileResultData(res.data);
+			}).catch((err) => {});
+			setDownloadLinkLoading(false);
+		} else setNoDownloadMethod(true);
+	}, [udpJobEntity?.unityBaseGetFileResultMethod?.apiMethodId]);
+	const handleSelectRecord = useCallback((data) => {
+		refetchfileResultData(data);
+		setDownloadOpen(true);
+	}, [refetchfileResultData]);
+	const getOptionLabel = (val) => {
+		return val?.name;
+	};
+	const handleProductChange = useCallback((val) => {
+		setProduct(val);
+	}, []);
+	const handleFileDownload = useCallback(() => {
+		if (fileResultData?.link) {
+			const link = document.createElement("a");
+			link.href = fileResultData?.link;
+			link.download = "";
+			document.body.appendChild(link);
+			link.click();
+			document.body.removeChild(link);
+			setDownloadOpen(false);
+			handleSuccessSnackbar("File successfully downloaded");
+		}
+	}, [fileResultData?.link, handleSuccessSnackbar]);
+	const getJobStatus = (value) => {
+		if (value === 1) return null;
+		else if (value === 2) return "info";
+		else if (value === 3) return "success";
+		else if (value === 4) return "error";
+	};
+	const getJobLabel = (value) => {
+		if (value === 1) return "Pending";
+		else if (value === 2) return "Running";
+		else if (value === 3) return "Completed";
+		else if (value === 4) return "Failed";
+	};
+	useEffect(() => {
+		if (catalogError) handleErrorSnackbar("", "Error fetching catalog for the selected product");
+	}, [catalogError, handleErrorSnackbar]);
+	const filterElements = useMemo(() => {
+		return [{
+			searchField: "jobTypeId",
+			searchOperator: "=",
+			searchValue: 2
+		}];
+	}, []);
+	const actionList = useMemo(() => {
+		return [{
+			id: 1,
+			title: "Download",
+			icon: DownloadIcon,
+			onClick: handleSelectRecord,
+			disabled: false,
+			checkDisabled: (value) => value?.statusId !== 3
+		}];
+	}, [handleSelectRecord]);
+	const columnDefs = useMemo(() => [
+		{
+			headerName: "Id",
+			sortable: true,
+			field: "id",
+			suppressMenu: true
+		},
+		{
+			headerName: "Name",
+			sortable: false,
+			field: "name",
+			minWidth: 140,
+			suppressMenu: true,
+			valueFormatter: (data) => getSanitizedName(data.data.name)
+		},
+		{
+			headerName: "Date",
+			sortable: false,
+			valueFormatter: (data) => new Date(data.data.startTime).toLocaleString(),
+			minWidth: 130,
+			suppressMenu: true
+		},
+		{
+			headerName: "Status",
+			field: "statusId",
+			wrapText: true,
+			autoHeight: true,
+			sortable: false,
+			cellRenderer: "statusCellRenderer",
+			cellRendererParams: {
+				getStatus: getJobStatus,
+				getLabel: getJobLabel
+			},
+			minWidth: 130,
+			maxWidth: 130,
+			suppressMenu: true
+		},
+		{
+			headerName: "Actions",
+			filter: false,
+			pinned: "right",
+			cellRenderer: "actionsRenderer",
+			width: 120,
+			maxWidth: 120,
+			cellRendererParams: {
+				actionList,
+				value: (data) => data
+			},
+			suppressMenu: true,
+			sortable: false,
+			cellStyle: {
+				display: "flex",
+				alignItems: "center"
+			}
+		}
+	], [actionList]);
+	return /* @__PURE__ */ React.createElement("div", null, udpJobEntity && !udpJobEntity?.unityBaseSearchMethod?.apiMethodId && /* @__PURE__ */ React.createElement(AmbientAlert, {
+		alertMessage: "UdpJob's search method must be promoted",
+		showAlert: true,
+		alertSeverity: "error"
+	}), !productId && /* @__PURE__ */ React.createElement("div", { style: { margin: "0px 5px 5px 5px" } }, /* @__PURE__ */ React.createElement(AmbientAutoComplete, {
+		isMultiple: false,
+		id: "product",
+		name: "product",
+		label: "Product",
+		onChange: handleProductChange,
+		options: products,
+		size: "small",
+		getOptionLabelFunction: getOptionLabel,
+		value: product,
+		required: true
+	})), /* @__PURE__ */ React.createElement(TableContainer$1, {
+		loading: productsLoading || catalogLoading || jobEntityLoading,
+		title: `Exports`,
+		isServerSide: true,
+		eagerLoad: false,
+		logicalSearchOperator: 2,
+		promotedEntity: udpJobEntity,
+		filterElements,
+		actionList,
+		customColumnDefs: columnDefs,
+		frameworkComponents: {
+			statusCellRenderer: StatusCellRenderer,
+			actionsRenderer: ActionsRenderer
+		},
+		hideSearchBar: true,
+		hiddenActionButtons: [
+			"saveView",
+			"views",
+			"insights",
+			"importExport",
+			"group",
+			"filter",
+			"columns",
+			"clearFilters",
+			"fitGrid",
+			"expandGrid"
+		],
+		height: "calc(100vh - 167px)",
+		dynamicSizing: true
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		actionOne: handleFileDownload,
+		actionTwo: () => setDownloadOpen(false),
+		labelOne: "Download",
+		labelTwo: "Cancel",
+		open: downloadOpen,
+		handleClose: () => setDownloadOpen(false),
+		disableOne: noDownloadMethod || downloadLinkLoading,
+		progress: downloadLinkLoading,
+		fullWidth: true
+	}, noDownloadMethod ? /* @__PURE__ */ React.createElement(AmbientAlert, {
+		alertMessage: "UdpJob's get file result method must be promoted",
+		showAlert: true,
+		alertSeverity: "error"
+	}) : downloadLinkLoading ? /* @__PURE__ */ React.createElement(EmptyStateDisplay, { primaryText: "Fetching download link..." }) : /* @__PURE__ */ React.createElement(EmptyStateDisplay, {
+		icon: noDownloadMethod ? ErrorIcon : StatusCircleCheckmarkIcon,
+		primaryText: !noDownloadMethod && "File is ready to download!"
+	})));
+};
+
+//#endregion
+export { AmbientAlert, AmbientAutoComplete, EmptyStateDisplay, MyExportsPage, SearchServiceDatasource, StatusCellRenderer, TableColumnDefs, TableContainer$1 as TableContainer, defaultColumnActionsDef };
+//# sourceMappingURL=MyExportsPage-BYH2Wl9k.js.map