udp-react-enterprise-component-library 25.18.1-beta.36 → 25.18.1-beta.38

package/dist/InquirySearchContainer-BIpngula.js

@@ -0,0 +1,835 @@
+import { r as useAgGridApi, t as AgTable } from "./AgTable-B2xTzAm2.js";
+import { t as Form$1 } from "./Form-DbOA5j38.js";
+import { t as FluentButton } from "./FluentButton-BexKrnAp.js";
+import { n as SubmitButton, t as FormButtons } from "./FormButtons-BTCO-pzW.js";
+import { t as FluentTextFieldAutoComplete } from "./FluentTextFieldAutoComplete-5Hp3qpk6.js";
+import { t as PropertyTypeEnum } from "./propertyTypeEnums-Dys-84NL.js";
+import { t as camelToPascalCaseWithSpace } from "./StringUtilities-u-cxAW6-.js";
+import { t as FluentIconButton } from "./FluentIconButton-Dc95mE3v.js";
+import { r as getSanitizedName } from "./entityUtilities-_8w-Zjs3.js";
+import { D as SearchGroupingType, O as SearchSortDirection, f as LogicalSearchOperatorEnums, p as LookupTypeEnums } from "./unitySystemEnums-e5F9Jr7m.js";
+import { n as getSearchIdentifiers, r as getSearchObject } from "./SearchUtilities-CNz302LN.js";
+import { t as PrimaryActionHeader } from "./PrimaryActionHeader-DBJpROPu.js";
+import { t as AmbientCard } from "./AmbientCard-CLW4bPCu.js";
+import { c as useGridFormat, o as useExport } from "./GridFunctions-CRTDIOe0.js";
+import { n as SearchOperators, t as FilterOperators } from "./SearchOperator-D9838PIe.js";
+import { t as useSearchFilterParamsMap } from "./useSearchFilterParamsMap-DPCfEY-N.js";
+import { t as PropertyField } from "./PropertyFields-Dm90Hcer.js";
+import { r as csvStrToArrayOfObjects } from "./SelectUtilities-Bj_xpNMs.js";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { Divider, LinearProgress, Typography, makeStyles } from "@material-ui/core";
+import { useForm } from "react-final-form";
+import clsx from "clsx";
+import { ClearIcon } from "@fluentui/react-icons";
+import { orderBy, sortBy } from "lodash";
+import { v4 } from "uuid";
+import { ServerSideRowModelModule } from "@ag-grid-enterprise/server-side-row-model";
+
+//#region src/inquiry/search/InquiryAdvancedSearchForm.jsx
+const useStyles$3 = makeStyles((theme) => ({
+	root: {
+		marginRight: theme.spacing(1),
+		marginLeft: theme.spacing(1),
+		overflowX: "auto"
+	},
+	fieldRow: {
+		display: "flex",
+		alignItems: "center"
+	},
+	dividerContainer: {
+		display: "flex",
+		justifyContent: "space-between",
+		alignItems: "center",
+		width: "100%"
+	},
+	divider: {
+		width: "100%",
+		marginTop: theme.spacing(1)
+	},
+	autocompleteRoot: {
+		width: "38%",
+		marginRight: theme.spacing(1)
+	}
+}));
+const InquiryAdvancedSearchForm = (props) => {
+	const { advancedSearchFields, selectedSearchOperators, setSelectedSearchOperators, catalogProperties, entityType, lookupPropertyNames, classes: classProps, executeQueryWithParameters, setForm } = props;
+	const { root } = classProps || {};
+	const classes = useStyles$3();
+	const form = useForm();
+	const handleSearchOperatorChange = useCallback((value, fieldName) => {
+		if (fieldName) {
+			let updatedSelectedSearchOps = {};
+			if (selectedSearchOperators) updatedSelectedSearchOps = { ...selectedSearchOperators };
+			updatedSelectedSearchOps[fieldName] = value;
+			setSelectedSearchOperators(updatedSelectedSearchOps);
+		}
+	}, [selectedSearchOperators, setSelectedSearchOperators]);
+	const getPropertyWidgetType = (type, useLookup) => {
+		if (!type) return null;
+		let propertyWidgetType = "";
+		switch (type) {
+			case PropertyTypeEnum.Int:
+			case PropertyTypeEnum.Long:
+				propertyWidgetType = "IntegerWidget";
+				break;
+			case PropertyTypeEnum.DateTime:
+				propertyWidgetType = "DateTimeWidget";
+				break;
+			case PropertyTypeEnum.Boolean:
+				propertyWidgetType = "BooleanWidget";
+				break;
+			default: propertyWidgetType = "TextWidget";
+		}
+		if (useLookup === LookupTypeEnums.Api || useLookup === LookupTypeEnums.Csv) propertyWidgetType = "AutoCompleteWidget";
+		return propertyWidgetType;
+	};
+	const getPropertyTypeSearchOperators = useCallback((type) => {
+		if (!type) return [];
+		switch (type) {
+			case PropertyTypeEnum.Boolean: return SearchOperators.filter((operator) => operator.value === "=");
+			default: return SearchOperators;
+		}
+	}, []);
+	const fieldRows = useMemo(() => {
+		if (!advancedSearchFields || !catalogProperties) return [];
+		return Object.keys(advancedSearchFields).reduce((list, key) => {
+			const groupedItems = advancedSearchFields[key];
+			let groupHeader = "";
+			const foundGroupItem = groupedItems.find((item) => !!item.groupHeader);
+			if (foundGroupItem) groupHeader = foundGroupItem.groupHeader;
+			list.push({
+				groupHeader,
+				isDivider: true,
+				id: v4()
+			});
+			groupedItems.forEach(async (item) => {
+				const foundProperty = catalogProperties.find((property) => property.name === item.name);
+				const propertyWidgetType = getPropertyWidgetType(foundProperty?.type, foundProperty?.extendedProperties?.useLookup);
+				let apiLookupOptions = null;
+				if (!item.searchable && !foundProperty?.extendedProperties?.searchable) return;
+				if (lookupPropertyNames.includes(foundProperty?.name) && foundProperty?.extendedProperties?.useLookup === LookupTypeEnums.Api) {}
+				list.push({
+					...item,
+					isDivider: false,
+					type: foundProperty?.type,
+					propertyWidgetType,
+					useLookup: foundProperty?.extendedProperties?.useLookup,
+					lookup: foundProperty?.extendedProperties?.lookup,
+					apiLookupOptions
+				});
+			});
+			return list;
+		}, []);
+	}, [
+		advancedSearchFields,
+		catalogProperties,
+		lookupPropertyNames
+	]);
+	const getPropertyFields = useCallback((config) => {
+		const searchOperator = selectedSearchOperators ? selectedSearchOperators[config?.name]?.value : null;
+		let options = [];
+		if (config?.useLookup === LookupTypeEnums.Csv) options = csvStrToArrayOfObjects(config?.lookup);
+		if (searchOperator === "BETWEEN") return /* @__PURE__ */ React.createElement("div", { style: {
+			display: "block",
+			width: "100%"
+		} }, /* @__PURE__ */ React.createElement(PropertyField, {
+			propertyType: entityType,
+			property: {
+				key: config?.name,
+				label: `${config?.columnName} (From)`,
+				type: config?.propertyWidgetType,
+				options: options || [],
+				valueName: "value"
+			}
+		}), /* @__PURE__ */ React.createElement(PropertyField, {
+			propertyType: entityType,
+			property: {
+				key: `${config?.name}:between`,
+				label: `${config?.columnName} (To)`,
+				type: config?.propertyWidgetType,
+				options: options || [],
+				valueName: "value"
+			}
+		}));
+		return /* @__PURE__ */ React.createElement(PropertyField, {
+			propertyType: entityType,
+			property: {
+				key: config?.name,
+				label: config?.columnName,
+				type: config?.propertyWidgetType,
+				options: options || [],
+				valueName: "value"
+			}
+		});
+	}, [entityType, selectedSearchOperators]);
+	const fieldComponents = useMemo(() => {
+		if (!fieldRows || !fieldRows.length) return null;
+		return fieldRows.map((config) => {
+			return /* @__PURE__ */ React.createElement("div", { key: config?.id }, !config?.isDivider && /* @__PURE__ */ React.createElement("div", { className: classes.fieldRow }, /* @__PURE__ */ React.createElement(FluentTextFieldAutoComplete, {
+				id: "udpRecord-InquiryAdvancedSearchForm-Text",
+				udprecordid: "udpRecord-InquiryAdvancedSearchForm-Text",
+				label: "Operator",
+				name: "searchOperator",
+				variant: "outlined",
+				margin: "dense",
+				size: "small",
+				options: getPropertyTypeSearchOperators(config?.type) || [],
+				optionKey: "label",
+				value: selectedSearchOperators && selectedSearchOperators[config?.name] || "",
+				onChange: (value) => handleSearchOperatorChange(value, config?.name),
+				classes: { autocompleteRoot: classes.autocompleteRoot }
+			}), getPropertyFields(config)), config?.isDivider && /* @__PURE__ */ React.createElement("div", { className: classes.dividerContainer }, /* @__PURE__ */ React.createElement("div", { className: classes.divider }, /* @__PURE__ */ React.createElement(Divider, { orientation: "horizontal" })), config?.groupHeader && /* @__PURE__ */ React.createElement("div", { style: {
+				marginRight: 8,
+				marginLeft: 8,
+				textAlign: "center",
+				whiteSpace: "nowrap"
+			} }, /* @__PURE__ */ React.createElement(Typography, { variant: "caption" }, config?.groupHeader)), /* @__PURE__ */ React.createElement("div", { className: classes.divider }, /* @__PURE__ */ React.createElement(Divider, { orientation: "horizontal" }))));
+		});
+	}, [
+		fieldRows,
+		classes,
+		handleSearchOperatorChange,
+		selectedSearchOperators,
+		getPropertyTypeSearchOperators,
+		getPropertyFields
+	]);
+	useEffect(() => {
+		if (form) setForm(form);
+	}, [form, setForm]);
+	return /* @__PURE__ */ React.createElement("div", { className: clsx(classes.root, root) }, fieldComponents);
+};
+
+//#endregion
+//#region src/inquiry/search/InquiryAdvancedSearch.jsx
+const useStyles$2 = makeStyles((theme) => ({
+	root: {},
+	entitySelect: {
+		marginRight: theme.spacing(1),
+		marginLeft: theme.spacing(1)
+	},
+	fieldsRoot: { height: (props) => "calc(100vh - 288px)" },
+	title: {
+		display: "flex",
+		justifyContent: "space-between",
+		margin: theme.spacing(1)
+	},
+	buttonWrapper: { textAlign: "center" },
+	button: {
+		textTransform: "none",
+		padding: 0,
+		"&:hover": { backgroundColor: "rgba(0, 0, 0, 0)" },
+		color: theme.palette.secondary
+	}
+}));
+const InquiryAdvancedSearch = (props) => {
+	const { entityList, onSubmit, currentNodeCatalogReturnObject, catalogObjects, entityValue, setEntityValue, changeSideBarView, tree, executeQueryWithParameters } = props;
+	const classes = useStyles$2(props);
+	const [initialSelectedSearchOperators, setInitialSelectedSearchOperators] = useState(null);
+	const [selectedSearchOperators, setSelectedSearchOperators] = useState(null);
+	const [form, setForm] = useState(null);
+	const entityTree = useMemo(() => {
+		if (!entityValue || !tree) return null;
+		const matchingEntityTree = tree.treeStructure.find((node) => node.properties.catalogReturnObject === entityValue.value);
+		let nodeTree = tree;
+		if (matchingEntityTree?.properties?.associatedInquiryTree) nodeTree = matchingEntityTree?.properties?.associatedInquiryTree;
+		return nodeTree;
+	}, [tree, entityValue]);
+	const catalogProperties = useMemo(() => {
+		if (!entityValue || !catalogObjects) return [];
+		return catalogObjects.find((catalog) => catalog.catalogObjectName === entityValue.value)?.properties || [];
+	}, [catalogObjects, entityValue]);
+	const advancedSearchFields = useMemo(() => {
+		if (!entityTree) return null;
+		const advancedSearchConfiguration = entityTree.treeStructure.find((node) => !node.parentId)?.properties?.searchConfiguration?.filter((config) => config.advancedSearch);
+		advancedSearchConfiguration?.forEach((config) => config.advancedSearch = Number.parseFloat(config.advancedSearch));
+		const orderedSearchConfiguration = orderBy(advancedSearchConfiguration, ["advancedSearch"], ["asc"]);
+		const groupedAndOrderdFields = {};
+		orderedSearchConfiguration.forEach((config) => {
+			const wholeInt = Math.floor(config.advancedSearch);
+			if (!groupedAndOrderdFields[wholeInt]) groupedAndOrderdFields[wholeInt] = [config];
+			else groupedAndOrderdFields[wholeInt].push(config);
+		});
+		return groupedAndOrderdFields;
+	}, [entityTree]);
+	const asCatalogLookupPropertyNames = useMemo(() => {
+		if (!entityTree) return [];
+		const advancedSearchPropertyName = entityTree.treeStructure.find((node) => !node.parentId)?.properties?.searchConfiguration?.filter((config) => config.advancedSearch).map((asConfig) => asConfig.name);
+		const filteredProperties = catalogProperties.filter((property) => advancedSearchPropertyName?.includes(property.name));
+		const lookupPropertyNames = [];
+		filteredProperties.forEach((property) => {
+			if (property?.extendedProperties?.useLookup !== LookupTypeEnums.No_Lookup || !property?.extendedProperties?.useLookup) lookupPropertyNames.push(property.name);
+		});
+		return lookupPropertyNames;
+	}, [catalogProperties, entityTree]);
+	const handleEntityChange = (value) => {
+		setEntityValue(value);
+	};
+	const handleOnSubmit = useCallback((values) => {
+		if (onSubmit) onSubmit(values, selectedSearchOperators, entityValue?.value, asCatalogLookupPropertyNames);
+	}, [
+		onSubmit,
+		selectedSearchOperators,
+		entityValue,
+		asCatalogLookupPropertyNames
+	]);
+	const handleClearFilter = useCallback(() => {
+		if (form) form.reset();
+		setSelectedSearchOperators(initialSelectedSearchOperators);
+	}, [initialSelectedSearchOperators, form]);
+	useEffect(() => {
+		if (entityList?.length) {
+			const foundEntity = entityList.find((entity) => entity.value === currentNodeCatalogReturnObject);
+			if (foundEntity) setEntityValue(foundEntity);
+		}
+	}, [
+		entityList,
+		currentNodeCatalogReturnObject,
+		setEntityValue
+	]);
+	useEffect(() => {
+		if (advancedSearchFields) {
+			const initialSearchOperators = [].concat.apply([], Object.values(advancedSearchFields)).reduce((operators, field) => {
+				if (field.advancedSearchOperator) {
+					const foundOperator = SearchOperators.find((op) => op.value === field.advancedSearchOperator);
+					operators[field.name] = foundOperator ?? SearchOperators[0];
+				} else operators[field.name] = SearchOperators[0];
+				return operators;
+			}, {});
+			setInitialSelectedSearchOperators(initialSearchOperators);
+			setSelectedSearchOperators(initialSearchOperators);
+		}
+	}, [advancedSearchFields]);
+	return /* @__PURE__ */ React.createElement("div", { className: classes.root }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(Divider, null)), /* @__PURE__ */ React.createElement("div", { className: classes.title }, /* @__PURE__ */ React.createElement(Typography, { variant: "subtitle1" }, "Advanced Search"), /* @__PURE__ */ React.createElement(FluentIconButton, {
+		id: "udpRecord-InquiryAdvancedSearch-ClearIcon",
+		udprecordid: "udpRecord-InquiryAdvancedSearch-ClearIcon",
+		icon: ClearIcon,
+		onClick: () => changeSideBarView(0)
+	})), /* @__PURE__ */ React.createElement("div", { className: classes.entitySelect }, /* @__PURE__ */ React.createElement(FluentTextFieldAutoComplete, {
+		id: "udpRecord-InquiryAdvancedSearch-TextField",
+		udprecordid: "udpRecord-InquiryAdvancedSearch-TextField",
+		label: "Entity",
+		variant: "outlined",
+		margin: "normal",
+		size: "small",
+		fullWidth: true,
+		options: entityList,
+		optionKey: "label",
+		value: entityValue,
+		onChange: handleEntityChange
+	})), /* @__PURE__ */ React.createElement(Form$1, { onSubmit: handleOnSubmit }, /* @__PURE__ */ React.createElement(InquiryAdvancedSearchForm, {
+		advancedSearchFields,
+		selectedSearchOperators,
+		setSelectedSearchOperators,
+		catalogProperties,
+		entityType: getSanitizedName(entityValue?.value),
+		lookupPropertyNames: asCatalogLookupPropertyNames,
+		classes: { root: classes.fieldsRoot },
+		executeQueryWithParameters,
+		setForm
+	}), /* @__PURE__ */ React.createElement("div", { className: classes.submitWrapper }, /* @__PURE__ */ React.createElement("div", { className: classes.buttonWrapper }, /* @__PURE__ */ React.createElement(FluentButton, {
+		id: "udpRecord-InquiryAdvancedSearch-ClearFilter",
+		udprecordid: "udpRecord-InquiryAdvancedSearch-ClearFilter",
+		onClick: handleClearFilter,
+		className: classes.button
+	}, /* @__PURE__ */ React.createElement(Typography, { variant: "subtitle1" }, "Clear Filter")), /* @__PURE__ */ React.createElement(FormButtons, null, /* @__PURE__ */ React.createElement(SubmitButton, {
+		id: "udpRecord-InquiryAdvancedSearch-Search",
+		udprecordid: "udpRecord-InquiryAdvancedSearch-Search",
+		variant: "contained",
+		color: "primary",
+		disablePristine: false,
+		disabled: !entityValue,
+		fullWidth: true,
+		style: {
+			marginRight: 8,
+			marginLeft: 8
+		}
+	}, "Search"))))));
+};
+
+//#endregion
+//#region src/inquiry/search/InquirySearchDatasource.js
+const InquirySearchDatasource = (queryData, apiMethodId, searchFilterElements, logicalSearchOperator = LogicalSearchOperatorEnums.And, executeQuery, searchFilterGroups) => {
+	return { async getRows(params) {
+		const { startRow, endRow, rowGroupCols, groupKeys, valueCols, filterModel, sortModel } = params.request;
+		const searchObject = getSearchObject(searchFilterElements, endRow / 20, null, false, logicalSearchOperator, searchFilterGroups);
+		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);
+				const element = filterElements.find((element$1) => element$1.searchField === formattedPropertyName);
+				if (element) {
+					element.searchValue = filterItem.filter;
+					element.searchOperator = FilterOperators[filterItem.type];
+				} else 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;
+				if (!orderElements.find((element) => element.sortColumn === formattedPropertyName)) 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);
+				if (element) {
+					element.searchValue = key;
+					element.searchOperator = "=";
+				} else filterElements.push({
+					searchField: formattedPropertyName,
+					searchValue: key,
+					searchOperator: "="
+				});
+			});
+		} else {
+			groupKeys.forEach((key, index) => {
+				const formattedPropertyNameForSearch = rowGroupCols[index].field.charAt(0).toUpperCase() + rowGroupCols[index].field.slice(1);
+				searchObject.filterElements.push({
+					searchField: formattedPropertyNameForSearch,
+					searchValue: key,
+					searchOperator: "="
+				});
+			});
+			searchObject.groupingType = SearchGroupingType.Distinct;
+			const rowGroupCol = rowGroupCols[groupKeys.length];
+			const formattedPropertyName = rowGroupCol.field.charAt(0).toUpperCase() + rowGroupCol.field.slice(1);
+			if (!searchObject.groupProperty.includes(formattedPropertyName)) {
+				searchObject.groupProperty.push(formattedPropertyName);
+				const orderElements = searchObject.orderElements;
+				if (!orderElements.find((element) => element.sortColumn === formattedPropertyName)) 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.successCallback(queryData.pageList, queryData.total);
+		else params.successCallback([], 0);
+		else {
+			let response = null;
+			if (executeQuery) response = await executeQuery({ data: searchObject }, apiMethodId);
+			const rowData = response?.data;
+			if (rowData) if (rowData?.pageList?.length > 0) params.successCallback(rowData.pageList, rowData.total);
+			else params.successCallback([], 0);
+			else params.successCallback([], 0);
+		}
+	} };
+};
+
+//#endregion
+//#region src/inquiry/search/InquirySearchTable.jsx
+const useStyles$1 = makeStyles((theme) => ({ root: { height: (props) => {
+	const rowCount = props?.queryData?.pageList?.length > 10 ? 10 : props?.queryData?.pageList?.length ?? 0;
+	const topResultsOnlyHeight = rowCount * 48 + 60;
+	const moreResultsHeight = rowCount * 48 + 116;
+	return props.topResultsOnly ? topResultsOnlyHeight : moreResultsHeight;
+} } }));
+const InquirySearchTable = (props) => {
+	const { apiMethodId, associatedInquiryTree, catalogReturnObject, catalogObjects, columns, executeQuery, queryColumnsData, isAdvancedSearch, onRowDoubleClick, queryData, searchFilterElements, searchFilterGroups, setSelectedSearchRows, treeStructure, topResultsOnly = false, topResultsSize = 50 } = props;
+	const classes = useStyles$1(props);
+	const { gridApi, onGridReady } = useAgGridApi();
+	const [agGridOptions] = useState({});
+	const [gridFormat] = useGridFormat();
+	const [exportGrid] = useExport();
+	const searchIdentifier = useMemo(() => {
+		return (getSearchIdentifiers(catalogObjects, catalogReturnObject) || []).toString();
+	}, [catalogObjects, catalogReturnObject]);
+	const columnDefs = useMemo(() => {
+		let commonCols = columns.map((column) => {
+			let matchingColumnIndex = null;
+			const matchingColumn = queryColumnsData.find((c, index) => {
+				if (c.name === column?.name) matchingColumnIndex = index;
+				return c.name === column?.name;
+			});
+			let def = {
+				headerName: column.alias || camelToPascalCaseWithSpace(column.name),
+				field: column.name
+			};
+			if (matchingColumn) def = {
+				headerName: matchingColumn.alias || camelToPascalCaseWithSpace(matchingColumn.name),
+				field: matchingColumn.name
+			};
+			if (column?.extendedProperties?.searchable) def = {
+				...def,
+				filter: "agTextColumnFilter",
+				filterParams: {
+					suppressAndOrCondition: true,
+					filterOptions: [
+						"equals",
+						"contains",
+						"notEqual",
+						"greaterThan",
+						"lessThan",
+						"greaterThanOrEqual",
+						"lessThanOrEqual"
+					]
+				},
+				enableRowGroup: true
+			};
+			if (column?.extendedProperties?.orderable) def = {
+				...def,
+				sortable: true
+			};
+			def.hide = !matchingColumn;
+			def.index = matchingColumnIndex;
+			return def;
+		});
+		const searchConfiguration = treeStructure.find((node) => node.properties?.catalogReturnObject === catalogReturnObject)?.properties?.searchConfiguration || null;
+		let requiresOrdering = false;
+		if (searchConfiguration) requiresOrdering = searchConfiguration.some((config) => !!config.results.trim());
+		if (requiresOrdering) {
+			const searchConfigWithResults = searchConfiguration.filter((config) => !!config.results);
+			commonCols.forEach((col) => {
+				col.index = null;
+				const foundSearchConfig = searchConfigWithResults.find((config) => config.name === col.field);
+				if (foundSearchConfig) col.index = parseFloat(foundSearchConfig.results);
+			});
+		}
+		commonCols = sortBy(commonCols, (col) => col.index);
+		return commonCols;
+	}, [
+		columns,
+		queryColumnsData,
+		treeStructure,
+		catalogReturnObject
+	]);
+	const defaultColDef = useMemo(() => ({
+		resizable: true,
+		editable: false,
+		enableValue: true,
+		allowedAggFuncs: [
+			"sum",
+			"min",
+			"max",
+			"count",
+			"avg",
+			"first",
+			"last"
+		]
+	}), []);
+	const rowData = useMemo(() => {
+		if (!queryData) return [];
+		return queryData?.pageList?.slice(0, topResultsSize);
+	}, [queryData, topResultsSize]);
+	const handleSelectionChanged = useCallback(() => {
+		setSelectedSearchRows(catalogReturnObject, gridApi.getSelectedRows(), searchIdentifier, apiMethodId, treeStructure, associatedInquiryTree);
+	}, [
+		gridApi,
+		catalogReturnObject,
+		setSelectedSearchRows,
+		searchIdentifier,
+		apiMethodId,
+		treeStructure,
+		associatedInquiryTree
+	]);
+	const handleRowDoubleClicked = useCallback((event) => {
+		if (!gridApi) return;
+		if (onRowDoubleClick) onRowDoubleClick(event.node.data, catalogReturnObject);
+	}, [
+		gridApi,
+		onRowDoubleClick,
+		catalogReturnObject
+	]);
+	useEffect(() => {
+		if (!gridApi) return;
+		gridApi.sizeColumnsToFit();
+		let datasource = InquirySearchDatasource(queryData, apiMethodId, searchFilterElements, isAdvancedSearch ? LogicalSearchOperatorEnums.And : LogicalSearchOperatorEnums.Or, executeQuery, searchFilterGroups);
+		gridApi?.setServerSideDatasource(datasource);
+	}, [
+		gridApi,
+		apiMethodId,
+		searchFilterElements,
+		queryData,
+		isAdvancedSearch,
+		executeQuery,
+		searchFilterGroups
+	]);
+	return /* @__PURE__ */ React.createElement("div", null, !topResultsOnly && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(PrimaryActionHeader, {
+		hidePAB: true,
+		hideActionRow: true,
+		expandAllItems: () => gridFormat(gridApi, "expand"),
+		collapse: () => gridFormat(gridApi, "collapse"),
+		resizeGrid: () => gridFormat(gridApi, "resize"),
+		exportGrid: () => exportGrid(gridApi, "csv"),
+		grid: true
+	}), /* @__PURE__ */ React.createElement(AgTable, {
+		className: classes.root,
+		modules: [ServerSideRowModelModule],
+		rowModelType: "serverSide",
+		serverSideStoreType: "partial",
+		pagination: true,
+		paginationPageSize: 20,
+		cacheOverflowSize: 2,
+		maxConcurrentDatasourceRequests: 1,
+		cacheBlockSize: 20,
+		onGridReady,
+		columnDefs,
+		defaultColDef,
+		onRowDoubleClicked: handleRowDoubleClicked,
+		rowSelection: "multiple",
+		rowMultiSelectWithClick: true,
+		onSelectionChanged: handleSelectionChanged,
+		api: gridApi,
+		dynamicSizing: true,
+		...agGridOptions
+	})), topResultsOnly && /* @__PURE__ */ React.createElement(AgTable, {
+		className: classes.root,
+		rowData: rowData || [],
+		onGridReady,
+		columnDefs,
+		defaultColDef,
+		onRowDoubleClicked: handleRowDoubleClicked,
+		rowSelection: "multiple",
+		rowMultiSelectWithClick: true,
+		onSelectionChanged: handleSelectionChanged,
+		animateRows: true,
+		api: gridApi,
+		dynamicSizing: true,
+		...agGridOptions
+	}));
+};
+
+//#endregion
+//#region src/inquiry/search/InquirySearchContainer.jsx
+const useStyles = makeStyles((theme) => ({
+	root: { overflowX: "auto" },
+	searchCard: { paddingBottom: theme.spacing(2) },
+	emptyStateWrapper: {
+		display: "flex",
+		justifyContent: "center",
+		paddingTop: "25vh"
+	}
+}));
+const InquirySearchContainer = (props) => {
+	const { advancedSearchItems, catalogObjects, classes: classProps, executeQueryAdHoc, isAdvancedSearch, loadSingleNode, onRowDoubleClick, searchItems, setSelectedSearchRows, apiMethodInstanceId } = props;
+	const { root } = classProps || {};
+	const classes = useStyles();
+	const [searchList, setSearchList] = useState(null);
+	const [loading, setLoading] = useState(false);
+	const { getQueryFilterElements, getQueryFilterGroups, getQuerySearchOperator } = useSearchFilterParamsMap();
+	const getQueryColumnsData = useCallback((apiMethodInstance) => {
+		if (!apiMethodInstance) return [];
+		let catalogMods = [];
+		try {
+			const catalogModificationStr = apiMethodInstance.catalogModification;
+			catalogMods = JSON.parse(catalogModificationStr);
+		} catch {
+			console.warn("Error parsing apiMethodInstance catalogModification");
+		}
+		return catalogMods;
+	}, []);
+	useEffect(() => {
+		if (!catalogObjects) setLoading(true);
+		if (!searchItems || !catalogObjects?.length) return;
+		setLoading(true);
+		const promises = [];
+		let list = [];
+		const promiseIndexMap = {};
+		(!isAdvancedSearch ? searchItems : advancedSearchItems || []).forEach((item, index) => {
+			let filterElementsFromQuery = getQueryFilterElements(item.apiMethodInstance);
+			let filterGroups = getQueryFilterGroups(item.apiMethodInstance);
+			const logicalOperatorFromQuery = getQuerySearchOperator(item.apiMethodInstance);
+			item.queryColumnsData = getQueryColumnsData(item.apiMethodInstance);
+			let outerQueryGroupId = 0;
+			let queryOuterGroup = null;
+			if (!!filterElementsFromQuery.length) {
+				outerQueryGroupId = filterGroups.length + 1;
+				queryOuterGroup = {
+					groupId: outerQueryGroupId,
+					logicalSearchOperator: logicalOperatorFromQuery
+				};
+			}
+			let outerTreeBuilderGroupId = 0;
+			let inquiryOuterGroup = null;
+			if (!!item?.searchFilterElements?.length) {
+				outerTreeBuilderGroupId = outerQueryGroupId + 1;
+				inquiryOuterGroup = {
+					groupId: outerTreeBuilderGroupId,
+					logicalSearchOperator: isAdvancedSearch ? LogicalSearchOperatorEnums.And : LogicalSearchOperatorEnums.Or
+				};
+			}
+			filterGroups = filterGroups.map((group) => {
+				if (!group.parentGroupId) group.parentGroupId = outerQueryGroupId;
+				return group;
+			});
+			filterElementsFromQuery = filterElementsFromQuery.map((element) => {
+				if (!element.groupId) element.groupId = outerQueryGroupId;
+				return element;
+			});
+			item.searchFilterElements = item.searchFilterElements.map((element) => {
+				element.groupId = outerTreeBuilderGroupId;
+				return element;
+			});
+			const searchFilterElements = filterElementsFromQuery.concat(item.searchFilterElements || []);
+			item.searchFilterElements = searchFilterElements;
+			if (!!inquiryOuterGroup) filterGroups.push(inquiryOuterGroup);
+			if (!!queryOuterGroup) filterGroups.push(queryOuterGroup);
+			item.searchFilterGroups = filterGroups;
+			const searchObject = getSearchObject(searchFilterElements, 1, null, false, LogicalSearchOperatorEnums.And, filterGroups);
+			let shouldSearch = true;
+			if (!searchFilterElements.some((sfe) => sfe.searchOperator !== "=")) {
+				const equalsSearchFilterElements = searchFilterElements.filter((sfe) => sfe.searchOperator === "=");
+				if (!!equalsSearchFilterElements.length) {
+					const coProperties = catalogObjects.find((co) => co.catalogObjectName === item.catalogReturnObject)?.properties || [];
+					if (!!coProperties.length) equalsSearchFilterElements.forEach((esfe) => {
+						if (!shouldSearch) return;
+						const matchingProperty = coProperties.find((cop) => cop.name?.toLowerCase() === esfe.searchField?.toLowerCase());
+						if (matchingProperty?.type) {
+							let compareNumber = true;
+							let parsedValue = esfe.searchValue;
+							switch (matchingProperty.type) {
+								case "int":
+									if (/[^0-9]/.test(esfe.searchValue)) parsedValue = NaN;
+									else parsedValue = parseInt(esfe.searchValue);
+									break;
+								case "double":
+								case "decimal":
+								case "float":
+									if (/[^0-9.]/.test(esfe.searchValue)) parsedValue = NaN;
+									else parsedValue = parseFloat(esfe.searchValue);
+									break;
+								default:
+									compareNumber = false;
+									break;
+							}
+							if (compareNumber && isNaN(parsedValue)) shouldSearch = false;
+						}
+					});
+				}
+			}
+			if (shouldSearch && executeQueryAdHoc) {
+				const data = { data: searchObject };
+				promiseIndexMap[promises.length] = index;
+				promises.push(executeQueryAdHoc(data, item.apiMethodId));
+			}
+			list.push({
+				queryData: null,
+				searchItem: item
+			});
+		});
+		Promise.all(promises.map((p) => p.catch((e) => e))).then((responses) => {
+			responses.forEach((response, i) => {
+				const index = promiseIndexMap[i];
+				if (response.status === 200) {
+					const querySearchObj = list[index];
+					querySearchObj.queryData = response.data;
+				} else if (!response.status) {
+					const querySearchObj = list[index];
+					console.error(`Retrieval Error Occured for ${querySearchObj?.searchItem?.catalogReturnObject}`);
+				}
+			});
+			let matchingItem = list.find((item) => item?.searchItem?.apiMethodInstance?.apiMethodInstanceId === apiMethodInstanceId && item?.queryData?.pageList?.length === 1);
+			if (!matchingItem) matchingItem = list.find((item) => item?.queryData?.pageList?.length === 1);
+			if (matchingItem) {
+				const querySearchObj = matchingItem;
+				const node = {};
+				const searchItem = querySearchObj?.searchItem;
+				const identifiers = getSearchIdentifiers(catalogObjects, searchItem.catalogReturnObject) || [];
+				node[searchItem.catalogReturnObject] = {
+					rows: matchingItem?.queryData?.pageList,
+					apiMethodId: searchItem.apiMethodId,
+					searchIdentifier: identifiers.toString(),
+					treeStructure: searchItem.treeStructure
+				};
+				loadSingleNode(node);
+			}
+			setSearchList(list);
+			setLoading(false);
+		});
+	}, [
+		searchItems,
+		isAdvancedSearch,
+		advancedSearchItems,
+		loadSingleNode,
+		catalogObjects,
+		executeQueryAdHoc,
+		getQueryFilterElements,
+		getQueryColumnsData,
+		getQueryFilterGroups,
+		getQuerySearchOperator,
+		apiMethodInstanceId
+	]);
+	return /* @__PURE__ */ React.createElement("div", { className: clsx(classes.root, root) }, loading && /* @__PURE__ */ React.createElement(LinearProgress, null), searchList?.map((searchObj) => {
+		return /* @__PURE__ */ React.createElement("div", {
+			key: searchObj.searchItem.catalogReturnObject,
+			className: classes.searchCard
+		}, /* @__PURE__ */ React.createElement(AmbientCard, {
+			key: `${searchObj.searchItem.catalogReturnObject}-${searchObj?.queryData?.total}`,
+			title: `${getSanitizedName(searchObj.searchItem.catalogReturnObject)} - ${searchObj.error ? searchObj.error : searchObj?.queryData?.total || "0"}`,
+			moreMessage: "Top 10 results...",
+			moreButton: "Load More",
+			moreButtonExpanded: "Minimize",
+			more: !!searchObj?.queryData?.pageList?.length,
+			header: true,
+			fullWidth: true,
+			globalToggle: true,
+			collapseChildrenWhenExpanded: true,
+			toggleGlobalExpanded: !!searchObj?.queryData?.total,
+			extendedList: /* @__PURE__ */ React.createElement(InquirySearchTable, {
+				key: searchObj.searchItem.id,
+				queryData: searchObj.queryData || [],
+				columns: searchObj.searchItem.columns,
+				apiMethodId: searchObj.searchItem.apiMethodId,
+				searchFilterElements: searchObj.searchItem.searchFilterElements,
+				searchFilterGroups: searchObj.searchItem.searchFilterGroups,
+				catalogReturnObject: searchObj.searchItem.catalogReturnObject,
+				setSelectedSearchRows,
+				catalogObjects,
+				treeStructure: searchObj.searchItem.treeStructure,
+				associatedInquiryTree: searchObj.searchItem.associatedInquiryTree || null,
+				onRowDoubleClick,
+				isAdvancedSearch,
+				executeQuery: executeQueryAdHoc,
+				queryColumnsData: searchObj.searchItem.queryColumnsData
+			})
+		}, !!searchObj?.queryData?.pageList?.length && /* @__PURE__ */ React.createElement(InquirySearchTable, {
+			key: searchObj.searchItem.id,
+			queryData: searchObj.queryData || [],
+			columns: searchObj.searchItem.columns,
+			apiMethodId: searchObj.searchItem.apiMethodId,
+			searchFilterElements: searchObj.searchItem.searchFilterElements,
+			searchFilterGroups: searchObj.searchItem.searchFilterGroups,
+			catalogReturnObject: searchObj.searchItem.catalogReturnObject,
+			setSelectedSearchRows,
+			catalogObjects,
+			treeStructure: searchObj.searchItem.treeStructure,
+			associatedInquiryTree: searchObj.searchItem.associatedInquiryTree || null,
+			onRowDoubleClick,
+			topResultsOnly: true,
+			topResultsSize: 10,
+			isAdvancedSearch,
+			executeQuery: executeQueryAdHoc,
+			queryColumnsData: searchObj.searchItem.queryColumnsData
+		})));
+	}));
+};
+
+//#endregion
+export { InquiryAdvancedSearchForm as a, InquiryAdvancedSearch as i, InquirySearchTable as n, InquirySearchDatasource as r, InquirySearchContainer as t };
+//# sourceMappingURL=InquirySearchContainer-BIpngula.js.map