@sapui5/sap.fe.core 1.96.4 → 1.99.0

package/src/sap/fe/core/converters/controls/ListReport/FilterBar.ts

@@ -1,10 +1,4 @@
-import {
-	AvailabilityType,
-	FilterFieldManifestConfiguration,
-	FilterManifestConfiguration,
-	FilterSettings,
-	TemplateType
-} from "../../ManifestSettings";
+import { AvailabilityType, FilterFieldManifestConfiguration, FilterManifestConfiguration, FilterSettings } from "../../ManifestSettings";
 import { EntityType, NavigationProperty, Property } from "@sap-ux/annotation-converter";
 import ConverterContext from "sap/fe/core/converters/ConverterContext";
 import { AnnotationTerm, DataFieldAbstractTypes, DataFieldTypes, ReferenceFacetTypes, UIAnnotationTerms } from "@sap-ux/vocabularies-types";
@@ -12,8 +6,10 @@ import {
 	getSelectionVariantConfiguration,
 	SelectionVariantConfiguration,
 	TableVisualization,
-	isFilteringCaseSensitive
+	isFilteringCaseSensitive,
+	getTypeConfig
 } from "sap/fe/core/converters/controls/Common/Table";
+import { ChartVisualization } from "sap/fe/core/converters/controls/Common/Chart";
 import { ConfigurableObject, CustomElement, insertCustomElements, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
 import { getVisualFilters, VisualFilters } from "sap/fe/core/converters/controls/ListReport/VisualFilters";
 import { SelectOptionType, FieldGroupType, FieldGroup } from "@sap-ux/vocabularies-types/dist/generated/UI";
@@ -22,8 +18,10 @@ import { getSelectionVariant } from "../Common/DataVisualization";
 import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
 import { IssueType, IssueSeverity, IssueCategory } from "sap/fe/core/converters/helpers/IssueManager";
 import { PropertyPath } from "@sap-ux/vocabularies-types/dist/Edm";
+import { hasValueHelp } from "sap/fe/core/templating/PropertyHelper";
 
 export type FilterField = ConfigurableObject & {
+	type?: string;
 	conditionPath: string;
 	availability: AvailabilityType;
 	annotationPath: string;
@@ -42,13 +40,18 @@ type FilterGroup = {
 	groupLabel?: string;
 };
 
+enum filterFieldType {
+	Default = "Default",
+	Slot = "Slot"
+}
+
 export type CustomElementFilterField = CustomElement<FilterField>;
 
 /**
  * Enter all DataFields of a given FieldGroup into the filterFacetMap.
  *
  * @param {AnnotationTerm<FieldGroupType>} fieldGroup
- * @returns {Record<string, FilterGroup>} The map of facets for the given fieldGroup
+ * @returns {Record<string, FilterGroup>} The map of facets for the given FieldGroup
  */
 function getFieldGroupFilterGroups(fieldGroup: AnnotationTerm<FieldGroupType>): Record<string, FilterGroup> {
 	const filterFacetMap: Record<string, FilterGroup> = {};
@@ -76,8 +79,8 @@ function getExcludedFilterProperties(selectionVariants: SelectionVariantConfigur
 }
 
 /**
- * Check that all the tables for a dedicated entityset are configured as analytical table.
- * @param {TableVisualization[]} listReportTables List Report tables
+ * Check that all the tables for a dedicated entity set are configured as analytical table.
+ * @param {TableVisualization[]} listReportTables List report tables
  * @param {string} contextPath
  * @returns {boolean} Is FilterBar search field hidden or not
  */
@@ -119,10 +122,10 @@ function getSelectionVariants(
 }
 
 /**
- * Returns the condition path required for the condition model. It looks like follow:
+ * Returns the condition path required for the condition model. It looks as follows:
  * <1:N-PropertyName>*\/<1:1-PropertyName>/<PropertyName>.
  *
- * @param entityType The root EntityTy[e
+ * @param entityType The root EntityType
  * @param propertyPath The full path to the target property
  * @returns {string} The formatted condition path
  */
@@ -172,6 +175,70 @@ const _createFilterSelectionField = function(
 	return undefined;
 };
 
+export function getModelType(sType: any) {
+	type defaultModelType = {
+		[key: string]: {
+			[key: string]: string;
+		};
+	};
+	const mDefaultTypeForEdmType: defaultModelType = {
+		"Edm.Boolean": {
+			modelType: "Bool"
+		},
+		"Edm.Byte": {
+			modelType: "Int"
+		},
+		"Edm.Date": {
+			modelType: "Date"
+		},
+		"Edm.DateTime": {
+			modelType: "Date"
+		},
+		"Edm.DateTimeOffset": {
+			modelType: "DateTimeOffset"
+		},
+		"Edm.Decimal": {
+			modelType: "Decimal"
+		},
+		"Edm.Double": {
+			modelType: "Float"
+		},
+		"Edm.Float": {
+			modelType: "Float"
+		},
+		"Edm.Guid": {
+			modelType: "Guid"
+		},
+		"Edm.Int16": {
+			modelType: "Int"
+		},
+		"Edm.Int32": {
+			modelType: "Int"
+		},
+		"Edm.Int64": {
+			modelType: "Int"
+		},
+		"Edm.SByte": {
+			modelType: "Int"
+		},
+		"Edm.Single": {
+			modelType: "Float"
+		},
+		"Edm.String": {
+			modelType: "String"
+		},
+		"Edm.Time": {
+			modelType: "TimeOfDay"
+		},
+		"Edm.TimeOfDay": {
+			modelType: "TimeOfDay"
+		},
+		"Edm.Stream": {
+			//no corresponding modelType - ignore for filtering
+		}
+	};
+	return sType && sType in mDefaultTypeForEdmType && mDefaultTypeForEdmType[sType].modelType;
+}
 const _getSelectionFields = function(
 	entityType: EntityType,
 	navigationPath: string,
@@ -217,7 +284,7 @@ const _getSelectionFieldsByPath = function(
 					includeHidden,
 					converterContext
 				);
-			} else if (property.targetType !== undefined) {
+			} else if (property.targetType !== undefined && property.targetType._type === "ComplexType") {
 				// handle ComplexType properties
 				localSelectionFields = _getSelectionFields(
 					entityType,
@@ -258,7 +325,7 @@ const _getFilterField = function(
 		filterField = _createFilterSelectionField(entityType, entityType.resolvePath(propertyPath), propertyPath, true, converterContext);
 	}
 	if (!filterField) {
-		converterContext.getDiagnostics().addIssue(IssueCategory.Annotation, IssueSeverity.High, IssueType.MISSING_SELECTIONFIELD);
+		converterContext.getDiagnostics()?.addIssue(IssueCategory.Annotation, IssueSeverity.High, IssueType.MISSING_SELECTIONFIELD);
 	}
 	// defined SelectionFields are available by default
 	if (filterField) {
@@ -318,7 +385,7 @@ const _getDefaultFilterFields = function(
 };
 
 /**
- * Get all Parameter filterFields in case of a parameterized service.
+ * Get all parameter filter fields in case of a parameterized service.
  * @param {ConverterContext} converterContext
  * @returns {FilterField[]} An array of parameter filterfields
  */
@@ -342,20 +409,28 @@ function _getParameterFields(converterContext: ConverterContext): FilterField[]
  * Determines if the FilterBar search field is hidden or not.
  *
  * @param {TableVisualization[]} listReportTables The list report tables
+ * @param {ChartVisualization[]} charts The ALP charts
  * @param {ConverterContext} converterContext The converter context
  * @returns {boolean} The information if the FilterBar search field is hidden or not
  */
-export const getFilterBarhideBasicSearch = function(listReportTables: TableVisualization[], converterContext: ConverterContext): boolean {
-	if (
-		converterContext.getManifestWrapper().hasMultipleVisualizations() ||
-		converterContext.getTemplateType() === TemplateType.AnalyticalListPage
-	) {
+export const getFilterBarhideBasicSearch = function(
+	listReportTables: TableVisualization[],
+	charts: ChartVisualization[],
+	converterContext: ConverterContext
+): boolean {
+	// Check if charts allow search
+	const noSearchInCharts = charts.length === 0 || charts.every(chart => !chart.applySupported.enableSearch);
+
+	// Check if all tables are analytical and none of them allow for search
+	const noSearchInTables =
+		listReportTables.length === 0 || listReportTables.every(table => table.enableAnalytics && !table.enableAnalyticsSearch);
+
+	const contextPath = converterContext.getContextPath();
+	if (contextPath && noSearchInCharts && noSearchInTables) {
 		return true;
+	} else {
+		return false;
 	}
-	// Tries to find a non-analytical table with the main entity set (page entity set) as collection
-	// if at least one table matches these conditions, basic search field must be displayed.
-	const sContextPath = converterContext.getContextPath();
-	return checkAllTableForEntitySetAreAnalytical(listReportTables, sContextPath);
 };
 
 /**
@@ -383,9 +458,14 @@ export const getManifestFilterFields = function(
 		const filterField = definedFilterFields[sKey];
 		const propertyName = KeyHelper.getPathFromSelectionFieldKey(sKey);
 		const selectionField = selectionFields[propertyName];
-		const visualFilter = getVisualFilters(entityType, converterContext, sKey, definedFilterFields);
+		const type = filterField.type === "Slot" ? filterFieldType.Slot : filterFieldType.Default;
+		const visualFilter =
+			filterField && filterField?.visualFilter
+				? getVisualFilters(entityType, converterContext, sKey, definedFilterFields)
+				: undefined;
 		filterFields[sKey] = {
 			key: sKey,
+			type: type,
 			annotationPath: selectionField?.annotationPath,
 			conditionPath: selectionField?.conditionPath || propertyName,
 			template: filterField.template,
@@ -403,6 +483,249 @@ export const getFilterField = function(propertyPath: string, converterContext: C
 	return _getFilterField({}, propertyPath, converterContext, entityType);
 };
 
+export const getFilterRestrictions = function(oFilterRestrictionsAnnotation: any, sRestriction: any) {
+	if (sRestriction === "RequiredProperties" || sRestriction === "NonFilterableProperties") {
+		let aProps = [];
+		if (oFilterRestrictionsAnnotation && oFilterRestrictionsAnnotation[sRestriction]) {
+			aProps = oFilterRestrictionsAnnotation[sRestriction].map(function(oProperty: any) {
+				return oProperty.$PropertyPath || oProperty.value;
+			});
+		}
+		return aProps;
+	} else if (sRestriction === "FilterAllowedExpressions") {
+		const mAllowedExpressions = {} as any;
+		if (oFilterRestrictionsAnnotation && oFilterRestrictionsAnnotation.FilterExpressionRestrictions) {
+			oFilterRestrictionsAnnotation.FilterExpressionRestrictions.forEach(function(oProperty: any) {
+				//SingleValue | MultiValue | SingleRange | MultiRange | SearchExpression | MultiRangeOrSearchExpression
+				if (mAllowedExpressions[oProperty.Property.value]) {
+					mAllowedExpressions[oProperty.Property.value].push(oProperty.AllowedExpressions);
+				} else {
+					mAllowedExpressions[oProperty.Property.value] = [oProperty.AllowedExpressions];
+				}
+			});
+		}
+		return mAllowedExpressions;
+	}
+	return oFilterRestrictionsAnnotation;
+};
+
+const getSearchFilterPropertyInfo = function() {
+	return {
+		name: "$search",
+		path: "$search",
+		dataType: "Edm.String",
+		maxConditions: 1
+	};
+};
+
+const getEditStateFilterPropertyInfo = function() {
+	return {
+		name: "$editState",
+		path: "$editState",
+		groupLabel: "",
+		group: "",
+		dataType: "Edm.String",
+		tooltip: null,
+		hiddenFilter: false
+	};
+};
+
+const getSearchRestrictions = function(converterContext: ConverterContext) {
+	return converterContext.getEntitySet()?.annotations?.Capabilities?.SearchRestrictions;
+};
+
+export const getNavigationRestrictions = function(converterContext: ConverterContext, sNavigationPath: string) {
+	const oNavigationRestrictions: any = converterContext.getEntitySet()?.annotations?.Capabilities?.NavigationRestrictions;
+	const aRestrictedProperties = oNavigationRestrictions && oNavigationRestrictions.RestrictedProperties;
+	return (
+		aRestrictedProperties &&
+		aRestrictedProperties.find(function(oRestrictedProperty: any) {
+			return (
+				oRestrictedProperty &&
+				oRestrictedProperty.NavigationProperty &&
+				(oRestrictedProperty.NavigationProperty.$NavigationPropertyPath === sNavigationPath ||
+					oRestrictedProperty.NavigationProperty.value === sNavigationPath)
+			);
+		})
+	);
+};
+
+const _fetchBasicPropertyInfo = function(oFilterFieldInfo: any) {
+	return {
+		key: oFilterFieldInfo.key,
+		annotationPath: oFilterFieldInfo.annotationPath,
+		conditionPath: oFilterFieldInfo.conditionPath,
+		name: oFilterFieldInfo.conditionPath,
+		path: oFilterFieldInfo.conditionPath,
+		groupLabel: oFilterFieldInfo.groupLabel,
+		group: oFilterFieldInfo.group,
+		label: oFilterFieldInfo.label,
+		tooltip: null,
+		hiddenFilter: oFilterFieldInfo.availability === "Hidden",
+		removeFromAppState: false,
+		hasValueHelp: false,
+		display: "Value",
+		isParameter: oFilterFieldInfo.isParameter,
+		caseSensitive: oFilterFieldInfo.caseSensitive,
+		availability: oFilterFieldInfo.availability,
+		position: oFilterFieldInfo.position,
+		type: oFilterFieldInfo.type
+	};
+};
+
+export const getSpecificAllowedExpression = function(aExpressions: any) {
+	const aAllowedExpressionsPriority = [
+		"SingleValue",
+		"MultiValue",
+		"SingleRange",
+		"MultiRange",
+		"SearchExpression",
+		"MultiRangeOrSearchExpression"
+	];
+
+	aExpressions.sort(function(a: any, b: any) {
+		return aAllowedExpressionsPriority.indexOf(a) - aAllowedExpressionsPriority.indexOf(b);
+	});
+
+	return aExpressions[0];
+};
+
+export const displayMode = function(oPropertyAnnotations: any, oCollectionAnnotations: any) {
+	const oTextAnnotation = oPropertyAnnotations?.Common?.Text,
+		oTextArrangmentAnnotation =
+			oTextAnnotation &&
+			((oPropertyAnnotations && oPropertyAnnotations?.Common?.Text?.annotations?.UI?.TextArrangement) ||
+				(oCollectionAnnotations && oCollectionAnnotations?.UI?.TextArrangement));
+
+	if (oTextArrangmentAnnotation) {
+		if (oTextArrangmentAnnotation.valueOf() === "UI.TextArrangementType/TextOnly") {
+			return "Description";
+		} else if (oTextArrangmentAnnotation.valueOf() === "UI.TextArrangementType/TextLast") {
+			return "ValueDescription";
+		}
+		return "DescriptionValue"; //TextFirst
+	}
+	return oTextAnnotation ? "DescriptionValue" : "Value";
+};
+
+const _fetchPropertyInfo = function(converterContext: ConverterContext, oFilterFieldInfo: any, oTypeConfig: any) {
+	let oPropertyInfo = _fetchBasicPropertyInfo(oFilterFieldInfo);
+	const sAnnotationPath = oFilterFieldInfo.annotationPath;
+
+	if (!sAnnotationPath) {
+		return oPropertyInfo;
+	}
+	const targetPropertyObject = converterContext.getConverterContextFor(sAnnotationPath).getDataModelObjectPath().targetObject;
+	const oProperty = {
+		$MaxLength: targetPropertyObject.maxLength,
+		$Type: targetPropertyObject.type,
+		$kind: targetPropertyObject._type
+	};
+	const oPropertyAnnotations = targetPropertyObject?.annotations;
+	const oCollectionAnnotations = converterContext?.getDataModelObjectPath().targetObject?.annotations;
+
+	let oFilterDefaultValue;
+	const oFormatOptions = oTypeConfig.formatOptions;
+	const oConstraints = oTypeConfig.constraints;
+	const bRemoveFromAppState =
+		oPropertyAnnotations?.PersonalData?.IsPotentiallySensitive ||
+		oPropertyAnnotations?.ExcludeFromNavigationContext ||
+		oPropertyAnnotations?.Analytics?.Measure;
+
+	const oFilterDefaultValueAnnotation = oPropertyAnnotations?.Common?.FilterDefaultValue;
+	if (oFilterDefaultValueAnnotation) {
+		oFilterDefaultValue = oFilterDefaultValueAnnotation["$" + getModelType(oProperty.$Type)];
+	}
+	oPropertyInfo = Object.assign(oPropertyInfo, {
+		tooltip: oPropertyAnnotations?.Common?.QuickInfo?.valueOf() || undefined,
+		removeFromAppState: bRemoveFromAppState,
+		hasValueHelp: hasValueHelp(targetPropertyObject),
+		formatOptions: oFormatOptions,
+		constraints: oConstraints,
+		display: displayMode(oPropertyAnnotations, oCollectionAnnotations),
+		defaultFilterConditions: oFilterDefaultValue
+			? [
+					{
+						fieldPath: oFilterFieldInfo.conditionPath,
+						operator: "EQ",
+						values: [oFilterDefaultValue]
+					}
+			  ]
+			: undefined
+	});
+	return oPropertyInfo;
+};
+
+export const isMultiValue = function(oProperty: any) {
+	let bIsMultiValue = true;
+	//SingleValue | MultiValue | SingleRange | MultiRange | SearchExpression | MultiRangeOrSearchExpression
+	switch (oProperty.filterExpression) {
+		case "SearchExpression":
+		case "SingleRange":
+		case "SingleValue":
+			bIsMultiValue = false;
+			break;
+		default:
+			break;
+	}
+	if (oProperty.type && oProperty.type.indexOf("Boolean") > 0) {
+		bIsMultiValue = false;
+	}
+	return bIsMultiValue;
+};
+
+const getAnnotatedSelectionFieldData = function(
+	converterContext: ConverterContext,
+	lrTables: TableVisualization[] = [],
+	annotationPath: string = ""
+) {
+	// Fetch all selectionVariants defined in the different visualizations and different views (multi table mode)
+	const selectionVariants: SelectionVariantConfiguration[] = getSelectionVariants(lrTables, converterContext);
+
+	// create a map of properties to be used in selection variants
+	const excludedFilterProperties: Record<string, boolean> = getExcludedFilterProperties(selectionVariants);
+	const entityType = converterContext.getEntityType();
+	//Filters which has to be added which is part of SV/Default annotations but not present in the SelectionFields
+	const annotatedSelectionFields = ((annotationPath && converterContext.getEntityTypeAnnotation(annotationPath)?.annotation) ||
+		entityType.annotations?.UI?.SelectionFields ||
+		[]) as PropertyPath[];
+
+	// create a map of all potential filter fields based on...
+	const filterFields: Record<string, FilterField> = {
+		// ...non hidden properties of the entity
+		..._getSelectionFields(entityType, "", entityType.entityProperties, false, converterContext),
+		// ...additional manifest defined navigation properties
+		..._getSelectionFieldsByPath(
+			entityType,
+			converterContext.getManifestWrapper().getFilterConfiguration().navigationProperties,
+			false,
+			converterContext
+		)
+	};
+
+	const propertyInfoFields: any =
+		annotatedSelectionFields?.reduce((selectionFields: FilterField[], selectionField) => {
+			const propertyPath = selectionField.value;
+			if (!(propertyPath in excludedFilterProperties)) {
+				const filterField: FilterField | undefined = _getFilterField(filterFields, propertyPath, converterContext, entityType);
+				if (filterField) {
+					filterField.group = "";
+					filterField.groupLabel = "";
+					selectionFields.push(filterField);
+				}
+			}
+			return selectionFields;
+		}, []) || [];
+
+	return {
+		excludedFilterProperties: excludedFilterProperties,
+		entityType: entityType,
+		annotatedSelectionFields: annotatedSelectionFields,
+		filterFields: filterFields,
+		propertyInfoFields: propertyInfoFields
+	};
+};
+
 /**
  * Retrieve the configuration for the selection fields that will be used within the filter bar
  * This configuration takes into account annotation and the selection variants.
@@ -417,12 +740,11 @@ export const getSelectionFields = function(
 	lrTables: TableVisualization[] = [],
 	annotationPath: string = ""
 ): FilterField[] {
-	// Fetch all selectionVariants defined in the different visualizations and different views (multi table mode)
-	const selectionVariants: SelectionVariantConfiguration[] = getSelectionVariants(lrTables, converterContext);
+	const oAnnotatedSelectionFieldData = getAnnotatedSelectionFieldData(converterContext, lrTables, annotationPath);
 
 	// create a map of properties to be used in selection variants
-	const excludedFilterProperties: Record<string, boolean> = getExcludedFilterProperties(selectionVariants);
-	const entityType = converterContext.getEntityType();
+	const excludedFilterProperties: Record<string, boolean> = oAnnotatedSelectionFieldData.excludedFilterProperties;
+	const entityType = oAnnotatedSelectionFieldData.entityType;
 	const filterFacets = entityType.annotations.UI?.FilterFacets;
 	let filterFacetMap: Record<string, FilterGroup> = {};
 
@@ -454,22 +776,10 @@ export const getSelectionFields = function(
 	}
 
 	// create a map of all potential filter fields based on...
-	const filterFields: Record<string, FilterField> = {
-		// ...non hidden properties of the entity
-		..._getSelectionFields(entityType, "", entityType.entityProperties, false, converterContext),
-		// ...additional manifest defined navigation properties
-		..._getSelectionFieldsByPath(
-			entityType,
-			converterContext.getManifestWrapper().getFilterConfiguration().navigationProperties,
-			false,
-			converterContext
-		)
-	};
+	const filterFields: Record<string, FilterField> = oAnnotatedSelectionFieldData.filterFields;
 
 	//Filters which has to be added which is part of SV/Default annotations but not present in the SelectionFields
-	const annotatedSelectionFields = ((annotationPath && converterContext.getEntityTypeAnnotation(annotationPath)?.annotation) ||
-		entityType.annotations?.UI?.SelectionFields ||
-		[]) as PropertyPath[];
+	const annotatedSelectionFields = oAnnotatedSelectionFieldData.annotatedSelectionFields;
 	const defaultFilters = _getDefaultFilterFields(
 		filterFields,
 		aSelectOptions,
@@ -479,23 +789,23 @@ export const getSelectionFields = function(
 		annotatedSelectionFields
 	);
 	const parameterFields = _getParameterFields(converterContext);
+	const propertyInfoFields: any =
+		annotatedSelectionFields?.reduce((selectionFields: FilterField[], selectionField) => {
+			const propertyPath = selectionField.value;
+			if (!(propertyPath in excludedFilterProperties)) {
+				const filterField: FilterField | undefined = _getFilterField(filterFields, propertyPath, converterContext, entityType);
+				if (filterField) {
+					filterField.group = "";
+					filterField.groupLabel = "";
+					selectionFields.push(filterField);
+				}
+			}
+			return selectionFields;
+		}, []) || [];
 
 	// finally create final list of filter fields by adding the SelectionFields first (order matters)...
 	let allFilters = parameterFields
-		.concat(
-			annotatedSelectionFields?.reduce((selectionFields: FilterField[], selectionField) => {
-				const propertyPath = selectionField.value;
-				if (!(propertyPath in excludedFilterProperties)) {
-					const filterField: FilterField | undefined = _getFilterField(filterFields, propertyPath, converterContext, entityType);
-					if (filterField) {
-						filterField.group = "";
-						filterField.groupLabel = "";
-						selectionFields.push(filterField);
-					}
-				}
-				return selectionFields;
-			}, []) || []
-		)
+		.concat(propertyInfoFields)
 		// To add the FilterField which is not part of the Selection Fields but the property is mentioned in the Selection Variant
 		.concat(defaultFilters || [])
 		// ...and adding remaining filter fields, that are not used in a SelectionVariant (order doesn't matter)
@@ -525,6 +835,7 @@ export const getSelectionFields = function(
 	const selectionFields = insertCustomElements(allFilters, getManifestFilterFields(entityType, converterContext), {
 		"availability": "overwrite",
 		label: "overwrite",
+		type: "overwrite",
 		position: "overwrite",
 		template: "overwrite",
 		settings: "overwrite",
@@ -539,3 +850,140 @@ export const getSelectionFields = function(
 
 	return selectionFields;
 };
+
+export const getPropertyInfoFields = function(
+	converterContext: ConverterContext,
+	lrTables: TableVisualization[] = [],
+	lrCharts: ChartVisualization[] = [],
+	annotationPath: string = ""
+) {
+	const oAnnotatedSelectionFieldData = getAnnotatedSelectionFieldData(converterContext, lrTables, annotationPath);
+	//const annotatedSelectionFields: any = oAnnotatedSelectionFieldData.annotatedSelectionFields;
+	const selectionFieldTypes: any = [];
+	const isCaseSensitive = isFilteringCaseSensitive(converterContext);
+	const aTypeConfig: any = [];
+	const _fnTypeConfig = function(property: Property) {
+		const oTypeConfig = getTypeConfig(property, undefined);
+		selectionFieldTypes.push(property?.type);
+		if (property?.type === "Edm.String" && (!oTypeConfig.constraints.nullable || oTypeConfig.constraints.nullable === true)) {
+			oTypeConfig.formatOptions.parseKeepsEmptyString = false;
+		}
+		aTypeConfig.push(oTypeConfig);
+	};
+
+	let propertyInfoFields: any = oAnnotatedSelectionFieldData.propertyInfoFields;
+	const parameterFields = _getParameterFields(converterContext);
+	propertyInfoFields = propertyInfoFields.concat(parameterFields);
+
+	propertyInfoFields = insertCustomElements(
+		propertyInfoFields,
+		getManifestFilterFields(converterContext.getEntityType(), converterContext),
+		{
+			"availability": "overwrite",
+			label: "overwrite",
+			type: "overwrite",
+			position: "overwrite",
+			template: "overwrite",
+			settings: "overwrite",
+			visualFilter: "overwrite"
+		}
+	);
+
+	propertyInfoFields.forEach(function(parameterField: any) {
+		if (parameterField.annotationPath) {
+			const propertyConvertyContext = converterContext.getConverterContextFor(parameterField.annotationPath);
+			const propertyTargetObject = propertyConvertyContext.getDataModelObjectPath().targetObject;
+			_fnTypeConfig(propertyTargetObject);
+		} else {
+			selectionFieldTypes.push("Edm.String");
+			aTypeConfig.push({});
+		}
+	});
+
+	const oFilterRestrictions = converterContext.getEntitySet()?.annotations?.Capabilities?.FilterRestrictions;
+	const oRet = {} as any;
+	oRet["RequiredProperties"] = getFilterRestrictions(oFilterRestrictions, "RequiredProperties") || [];
+	oRet["NonFilterableProperties"] = getFilterRestrictions(oFilterRestrictions, "NonFilterableProperties") || [];
+	oRet["FilterAllowedExpressions"] = getFilterRestrictions(oFilterRestrictions, "FilterAllowedExpressions") || {};
+
+	const sEntitySetPath = converterContext.getContextPath();
+	const aPathParts = sEntitySetPath.split("/");
+	if (aPathParts.length > 2) {
+		const sNavigationPath = aPathParts[aPathParts.length - 1];
+		aPathParts.splice(-1, 1);
+		const oNavigationRestrictions = getNavigationRestrictions(converterContext, sNavigationPath);
+		const oNavigationFilterRestrictions = oNavigationRestrictions && oNavigationRestrictions.FilterRestrictions;
+		oRet.RequiredProperties.concat(getFilterRestrictions(oNavigationFilterRestrictions, "RequiredProperties") || []);
+		oRet.NonFilterableProperties.concat(getFilterRestrictions(oNavigationFilterRestrictions, "NonFilterableProperties") || []);
+		oRet.FilterAllowedExpressions = {
+			...(getFilterRestrictions(oNavigationFilterRestrictions, "FilterAllowedExpressions") || {}),
+			...oRet.FilterAllowedExpressions
+		};
+	}
+
+	const aRequiredProps = oRet.RequiredProperties;
+	const aNonFilterableProps = oRet.NonFilterableProperties;
+	const mAllowedExpressions = oRet.FilterAllowedExpressions;
+	let oPropertyInfo;
+	const aFetchedProperties: any = [],
+		aParameterFields = [];
+	Object.keys(propertyInfoFields).forEach(function(sFilterFieldKey: string) {
+		const oConvertedProperty = propertyInfoFields[sFilterFieldKey];
+		const sPropertyPath = oConvertedProperty.conditionPath.replace(/\+|\*/g, "");
+
+		if (aNonFilterableProps.indexOf(sPropertyPath) === -1) {
+			oPropertyInfo = _fetchPropertyInfo(converterContext, oConvertedProperty, aTypeConfig[sFilterFieldKey]);
+			if (oPropertyInfo) {
+				if (mAllowedExpressions[sPropertyPath] && mAllowedExpressions[sPropertyPath].length > 0) {
+					oPropertyInfo = Object.assign(oPropertyInfo, {
+						filterExpression: getSpecificAllowedExpression(mAllowedExpressions[sPropertyPath])
+					});
+				} else {
+					oPropertyInfo = Object.assign(oPropertyInfo, {
+						filterExpression: "auto"
+					});
+				}
+				oPropertyInfo = Object.assign(oPropertyInfo, {
+					maxConditions: !oPropertyInfo.isParameter && isMultiValue(oPropertyInfo) ? -1 : 1,
+					required: oPropertyInfo.isParameter || aRequiredProps.indexOf(sPropertyPath) >= 0,
+					caseSensitive: isCaseSensitive,
+					visible: oConvertedProperty.availability === "Default",
+					dataType: selectionFieldTypes[sFilterFieldKey]
+					//label: getLocalizedText(oConvertedProperty.label)
+				});
+
+				aFetchedProperties.push(oPropertyInfo);
+				if (oPropertyInfo.isParameter) {
+					aParameterFields.push(sPropertyPath);
+				}
+			}
+		}
+	});
+
+	if (converterContext.getDataModelObjectPath().targetObject?.annotations?.Common?.DraftRoot) {
+		aFetchedProperties.push(getEditStateFilterPropertyInfo());
+	}
+
+	if (sEntitySetPath && getFilterBarhideBasicSearch(lrTables, lrCharts, converterContext) !== true) {
+		const searchRestrictions = getSearchRestrictions(converterContext);
+		if (!searchRestrictions || searchRestrictions?.Searchable) {
+			aFetchedProperties.push(getSearchFilterPropertyInfo());
+		}
+	}
+
+	aFetchedProperties.sort(function(a: any, b: any) {
+		if (a.groupLabel === undefined || a.groupLabel === null) {
+			return -1;
+		}
+		if (b.groupLabel === undefined || b.groupLabel === null) {
+			return 1;
+		}
+		return a.groupLabel.localeCompare(b.groupLabel);
+	});
+
+	let sFetchProperties = JSON.stringify(aFetchedProperties);
+	sFetchProperties = sFetchProperties.replace(/\{/g, "\\{");
+	sFetchProperties = sFetchProperties.replace(/\}/g, "\\}");
+
+	return sFetchProperties;
+};