@sapui5/sap.fe.core 1.99.0 → 1.101.1

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

@@ -1,24 +1,24 @@
-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";
+import { PropertyPath } from "@sap-ux/vocabularies-types/dist/Edm";
+import { FieldGroup, FieldGroupType, SelectOptionType } from "@sap-ux/vocabularies-types/dist/generated/UI";
+import { ChartVisualization } from "sap/fe/core/converters/controls/Common/Chart";
 import {
 	getSelectionVariantConfiguration,
-	SelectionVariantConfiguration,
-	TableVisualization,
+	getTypeConfig,
 	isFilteringCaseSensitive,
-	getTypeConfig
+	SelectionVariantConfiguration,
+	TableVisualization
 } 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";
+import ConverterContext from "sap/fe/core/converters/ConverterContext";
+import { ConfigurableObject, CustomElement, insertCustomElements, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
+import { IssueCategory, IssueSeverity, IssueType } from "sap/fe/core/converters/helpers/IssueManager";
+import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
 import { annotationExpression, compileBinding } from "sap/fe/core/helpers/BindingExpression";
+import { AvailabilityType, FilterFieldManifestConfiguration, FilterManifestConfiguration, FilterSettings } from "../../ManifestSettings";
 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";
+//import { hasValueHelp } from "sap/fe/core/templating/PropertyHelper";
 
 export type FilterField = ConfigurableObject & {
 	type?: string;
@@ -45,6 +45,9 @@ enum filterFieldType {
 	Slot = "Slot"
 }
 
+const sEdmString = "Edm.String";
+const sStringDataType = "sap.ui.model.odata.type.String";
+
 export type CustomElementFilterField = CustomElement<FilterField>;
 
 /**
@@ -71,7 +74,7 @@ function getFieldGroupFilterGroups(fieldGroup: AnnotationTerm<FieldGroupType>):
 
 function getExcludedFilterProperties(selectionVariants: SelectionVariantConfiguration[]): Record<string, boolean> {
 	return selectionVariants.reduce((previousValue: Record<string, boolean>, selectionVariant) => {
-		selectionVariant.propertyNames.forEach(propertyName => {
+		selectionVariant.propertyNames.forEach((propertyName) => {
 			previousValue[propertyName] = true;
 		});
 		return previousValue;
@@ -86,7 +89,7 @@ function getExcludedFilterProperties(selectionVariants: SelectionVariantConfigur
  */
 function checkAllTableForEntitySetAreAnalytical(listReportTables: TableVisualization[], contextPath: string | undefined) {
 	if (contextPath && listReportTables.length > 0) {
-		return listReportTables.every(visualization => {
+		return listReportTables.every((visualization) => {
 			return visualization.enableAnalytics && contextPath === visualization.annotation.collection;
 		});
 	}
@@ -99,13 +102,13 @@ function getSelectionVariants(
 ): SelectionVariantConfiguration[] {
 	const selectionVariantPaths: string[] = [];
 	return lrTableVisualizations
-		.map(visualization => {
+		.map((visualization) => {
 			const tableFilters = visualization.control.filters;
 			const tableSVConfigs: SelectionVariantConfiguration[] = [];
 			for (const key in tableFilters) {
 				if (Array.isArray(tableFilters[key].paths)) {
 					const paths = tableFilters[key].paths;
-					paths.forEach(path => {
+					paths.forEach((path) => {
 						if (path && path.annotationPath && selectionVariantPaths.indexOf(path.annotationPath) === -1) {
 							selectionVariantPaths.push(path.annotationPath);
 							const selectionVariantConfig = getSelectionVariantConfiguration(path.annotationPath, converterContext);
@@ -129,7 +132,7 @@ function getSelectionVariants(
  * @param propertyPath The full path to the target property
  * @returns {string} The formatted condition path
  */
-const _getConditionPath = function(entityType: EntityType, propertyPath: string): string {
+const _getConditionPath = function (entityType: EntityType, propertyPath: string): string {
 	const parts = propertyPath.split("/");
 	let partialPath;
 	let key = "";
@@ -145,7 +148,7 @@ const _getConditionPath = function(entityType: EntityType, propertyPath: string)
 	return key;
 };
 
-const _createFilterSelectionField = function(
+const _createFilterSelectionField = function (
 	entityType: EntityType,
 	property: Property,
 	fullPropertyPath: string,
@@ -239,7 +242,7 @@ export function getModelType(sType: any) {
 	};
 	return sType && sType in mDefaultTypeForEdmType && mDefaultTypeForEdmType[sType].modelType;
 }
-const _getSelectionFields = function(
+const _getSelectionFields = function (
 	entityType: EntityType,
 	navigationPath: string,
 	properties: Array<Property> | undefined,
@@ -260,7 +263,7 @@ const _getSelectionFields = function(
 	return selectionFieldMap;
 };
 
-const _getSelectionFieldsByPath = function(
+const _getSelectionFieldsByPath = function (
 	entityType: EntityType,
 	propertyPaths: Array<string> | undefined,
 	includeHidden: boolean,
@@ -294,12 +297,7 @@ const _getSelectionFieldsByPath = function(
 					converterContext
 				);
 			} else {
-				const navigationPath = propertyPath.includes("/")
-					? propertyPath
-							.split("/")
-							.splice(0, 1)
-							.join("/")
-					: "";
+				const navigationPath = propertyPath.includes("/") ? propertyPath.split("/").splice(0, 1).join("/") : "";
 				localSelectionFields = _getSelectionFields(entityType, navigationPath, [property], includeHidden, converterContext);
 			}
 
@@ -312,13 +310,14 @@ const _getSelectionFieldsByPath = function(
 	return selectionFields;
 };
 
-const _getFilterField = function(
+const _getFilterField = function (
 	filterFields: Record<string, FilterField>,
 	propertyPath: string,
 	converterContext: ConverterContext,
 	entityType: EntityType
 ): FilterField | undefined {
 	let filterField: FilterField | undefined = filterFields[propertyPath];
+	const availability = filterField && filterField.availability;
 	if (filterField) {
 		delete filterFields[propertyPath];
 	} else {
@@ -329,14 +328,13 @@ const _getFilterField = function(
 	}
 	// defined SelectionFields are available by default
 	if (filterField) {
-		filterField.availability = AvailabilityType.Default;
+		filterField.availability = availability === AvailabilityType.Hidden ? AvailabilityType.Hidden : AvailabilityType.Default;
 		filterField.isParameter = !!entityType.annotations?.Common?.ResultContext;
 	}
 	return filterField;
 };
 
-const _getDefaultFilterFields = function(
-	filterFields: Record<string, FilterField>,
+const _getDefaultFilterFields = function (
 	aSelectOptions: any[],
 	entityType: EntityType,
 	converterContext: ConverterContext,
@@ -347,7 +345,7 @@ const _getDefaultFilterFields = function(
 	const UISelectionFields: any = {};
 	const properties = entityType.entityProperties;
 	// Using entityType instead of entitySet
-	annotatedSelectionFields?.forEach(SelectionField => {
+	annotatedSelectionFields?.forEach((SelectionField) => {
 		UISelectionFields[SelectionField.value] = true;
 	});
 	if (aSelectOptions && aSelectOptions.length > 0) {
@@ -355,12 +353,12 @@ const _getDefaultFilterFields = function(
 			const propertyName: any = selectOption.PropertyName;
 			const sPropertyPath: string = propertyName.value;
 			const UISelectionFields: any = {};
-			annotatedSelectionFields?.forEach(SelectionField => {
+			annotatedSelectionFields?.forEach((SelectionField) => {
 				UISelectionFields[SelectionField.value] = true;
 			});
 			if (!(sPropertyPath in excludedFilterProperties)) {
 				if (!(sPropertyPath in UISelectionFields)) {
-					const FilterField: FilterField | undefined = _getFilterField(filterFields, sPropertyPath, converterContext, entityType);
+					const FilterField: FilterField | undefined = getFilterField(sPropertyPath, converterContext, entityType);
 					if (FilterField) {
 						selectionFields.push(FilterField);
 					}
@@ -373,7 +371,7 @@ const _getDefaultFilterFields = function(
 			const PropertyPath = property.name;
 			if (!(PropertyPath in excludedFilterProperties)) {
 				if (defaultFilterValue && !(PropertyPath in UISelectionFields)) {
-					const FilterField: FilterField | undefined = _getFilterField(filterFields, PropertyPath, converterContext, entityType);
+					const FilterField: FilterField | undefined = getFilterField(PropertyPath, converterContext, entityType);
 					if (FilterField) {
 						selectionFields.push(FilterField);
 					}
@@ -396,11 +394,18 @@ function _getParameterFields(converterContext: ConverterContext): FilterField[]
 	const parameterConverterContext =
 		isParameterized && converterContext.getConverterContextFor("/" + dataModelObjectPath.startingEntitySet.name);
 
-	const parameterFields = (parameterConverterContext
-		? parameterEntityType.entityProperties.map(function(property) {
-				return _getFilterField({} as Record<string, FilterField>, property.name, parameterConverterContext, parameterEntityType);
-		  })
-		: []) as FilterField[];
+	const parameterFields = (
+		parameterConverterContext
+			? parameterEntityType.entityProperties.map(function (property) {
+					return _getFilterField(
+						{} as Record<string, FilterField>,
+						property.name,
+						parameterConverterContext,
+						parameterEntityType
+					);
+			  })
+			: []
+	) as FilterField[];
 
 	return parameterFields;
 }
@@ -413,17 +418,17 @@ function _getParameterFields(converterContext: ConverterContext): FilterField[]
  * @param {ConverterContext} converterContext The converter context
  * @returns {boolean} The information if the FilterBar search field is hidden or not
  */
-export const getFilterBarhideBasicSearch = function(
+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);
+	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);
+		listReportTables.length === 0 || listReportTables.every((table) => table.enableAnalytics && !table.enableAnalyticsSearch);
 
 	const contextPath = converterContext.getContextPath();
 	if (contextPath && noSearchInCharts && noSearchInTables) {
@@ -440,7 +445,7 @@ export const getFilterBarhideBasicSearch = function(
  * @param converterContext The converter context
  * @returns {Record<string, CustomElementFilterField>} The filter fields defined in the manifest
  */
-export const getManifestFilterFields = function(
+export const getManifestFilterFields = function (
 	entityType: EntityType,
 	converterContext: ConverterContext
 ): Record<string, CustomElementFilterField> {
@@ -448,7 +453,7 @@ export const getManifestFilterFields = function(
 	const definedFilterFields: Record<string, FilterFieldManifestConfiguration> = fbConfig?.filterFields || {};
 	const selectionFields: Record<string, FilterField> = _getSelectionFieldsByPath(
 		entityType,
-		Object.keys(definedFilterFields).map(key => KeyHelper.getPathFromSelectionFieldKey(key)),
+		Object.keys(definedFilterFields).map((key) => KeyHelper.getPathFromSelectionFieldKey(key)),
 		true,
 		converterContext
 	);
@@ -479,15 +484,15 @@ export const getManifestFilterFields = function(
 	return filterFields;
 };
 
-export const getFilterField = function(propertyPath: string, converterContext: ConverterContext, entityType: EntityType) {
+export const getFilterField = function (propertyPath: string, converterContext: ConverterContext, entityType: EntityType) {
 	return _getFilterField({}, propertyPath, converterContext, entityType);
 };
 
-export const getFilterRestrictions = function(oFilterRestrictionsAnnotation: any, sRestriction: any) {
+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) {
+			aProps = oFilterRestrictionsAnnotation[sRestriction].map(function (oProperty: any) {
 				return oProperty.$PropertyPath || oProperty.value;
 			});
 		}
@@ -495,7 +500,7 @@ export const getFilterRestrictions = function(oFilterRestrictionsAnnotation: any
 	} else if (sRestriction === "FilterAllowedExpressions") {
 		const mAllowedExpressions = {} as any;
 		if (oFilterRestrictionsAnnotation && oFilterRestrictionsAnnotation.FilterExpressionRestrictions) {
-			oFilterRestrictionsAnnotation.FilterExpressionRestrictions.forEach(function(oProperty: any) {
+			oFilterRestrictionsAnnotation.FilterExpressionRestrictions.forEach(function (oProperty: any) {
 				//SingleValue | MultiValue | SingleRange | MultiRange | SearchExpression | MultiRangeOrSearchExpression
 				if (mAllowedExpressions[oProperty.Property.value]) {
 					mAllowedExpressions[oProperty.Property.value].push(oProperty.AllowedExpressions);
@@ -509,37 +514,36 @@ export const getFilterRestrictions = function(oFilterRestrictionsAnnotation: any
 	return oFilterRestrictionsAnnotation;
 };
 
-const getSearchFilterPropertyInfo = function() {
+const getSearchFilterPropertyInfo = function () {
 	return {
 		name: "$search",
 		path: "$search",
-		dataType: "Edm.String",
+		dataType: sStringDataType,
 		maxConditions: 1
 	};
 };
 
-const getEditStateFilterPropertyInfo = function() {
+const getEditStateFilterPropertyInfo = function () {
 	return {
 		name: "$editState",
 		path: "$editState",
 		groupLabel: "",
 		group: "",
-		dataType: "Edm.String",
-		tooltip: null,
+		dataType: sStringDataType,
 		hiddenFilter: false
 	};
 };
 
-const getSearchRestrictions = function(converterContext: ConverterContext) {
+const getSearchRestrictions = function (converterContext: ConverterContext) {
 	return converterContext.getEntitySet()?.annotations?.Capabilities?.SearchRestrictions;
 };
 
-export const getNavigationRestrictions = function(converterContext: ConverterContext, sNavigationPath: string) {
+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) {
+		aRestrictedProperties.find(function (oRestrictedProperty: any) {
 			return (
 				oRestrictedProperty &&
 				oRestrictedProperty.NavigationProperty &&
@@ -550,30 +554,26 @@ export const getNavigationRestrictions = function(converterContext: ConverterCon
 	);
 };
 
-const _fetchBasicPropertyInfo = function(oFilterFieldInfo: any) {
+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
+		type: oFilterFieldInfo.type,
+		template: oFilterFieldInfo.template,
+		menu: oFilterFieldInfo.menu
 	};
 };
 
-export const getSpecificAllowedExpression = function(aExpressions: any) {
+export const getSpecificAllowedExpression = function (aExpressions: any) {
 	const aAllowedExpressionsPriority = [
 		"SingleValue",
 		"MultiValue",
@@ -583,14 +583,14 @@ export const getSpecificAllowedExpression = function(aExpressions: any) {
 		"MultiRangeOrSearchExpression"
 	];
 
-	aExpressions.sort(function(a: any, b: any) {
+	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) {
+export const displayMode = function (oPropertyAnnotations: any, oCollectionAnnotations: any) {
 	const oTextAnnotation = oPropertyAnnotations?.Common?.Text,
 		oTextArrangmentAnnotation =
 			oTextAnnotation &&
@@ -608,7 +608,7 @@ export const displayMode = function(oPropertyAnnotations: any, oCollectionAnnota
 	return oTextAnnotation ? "DescriptionValue" : "Value";
 };
 
-const _fetchPropertyInfo = function(converterContext: ConverterContext, oFilterFieldInfo: any, oTypeConfig: any) {
+const _fetchPropertyInfo = function (converterContext: ConverterContext, oFilterFieldInfo: any, oTypeConfig: any) {
 	let oPropertyInfo = _fetchBasicPropertyInfo(oFilterFieldInfo);
 	const sAnnotationPath = oFilterFieldInfo.annotationPath;
 
@@ -616,47 +616,21 @@ const _fetchPropertyInfo = function(converterContext: ConverterContext, oFilterF
 		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
+		display: displayMode(oPropertyAnnotations, oCollectionAnnotations)
 	});
 	return oPropertyInfo;
 };
 
-export const isMultiValue = function(oProperty: any) {
+export const isMultiValue = function (oProperty: any) {
 	let bIsMultiValue = true;
 	//SingleValue | MultiValue | SingleRange | MultiRange | SearchExpression | MultiRangeOrSearchExpression
 	switch (oProperty.filterExpression) {
@@ -674,7 +648,7 @@ export const isMultiValue = function(oProperty: any) {
 	return bIsMultiValue;
 };
 
-const getAnnotatedSelectionFieldData = function(
+const getAnnotatedSelectionFieldData = function (
 	converterContext: ConverterContext,
 	lrTables: TableVisualization[] = [],
 	annotationPath: string = ""
@@ -702,6 +676,11 @@ const getAnnotatedSelectionFieldData = function(
 			converterContext
 		)
 	};
+	let aSelectOptions: any[] = [];
+	const selectionVariant = getSelectionVariant(entityType, converterContext);
+	if (selectionVariant) {
+		aSelectOptions = selectionVariant.SelectOptions;
+	}
 
 	const propertyInfoFields: any =
 		annotatedSelectionFields?.reduce((selectionFields: FilterField[], selectionField) => {
@@ -717,189 +696,56 @@ const getAnnotatedSelectionFieldData = function(
 			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.
- *
- * @param {ConverterContext} converterContext
- * @param {TableVisualization[]} lrTables
- * @param {string} annotationPath
- * @returns {FilterSelectionField[]} An array of selection fields
- */
-export const getSelectionFields = function(
-	converterContext: ConverterContext,
-	lrTables: TableVisualization[] = [],
-	annotationPath: string = ""
-): FilterField[] {
-	const oAnnotatedSelectionFieldData = getAnnotatedSelectionFieldData(converterContext, lrTables, annotationPath);
-
-	// create a map of properties to be used in selection variants
-	const excludedFilterProperties: Record<string, boolean> = oAnnotatedSelectionFieldData.excludedFilterProperties;
-	const entityType = oAnnotatedSelectionFieldData.entityType;
-	const filterFacets = entityType.annotations.UI?.FilterFacets;
-	let filterFacetMap: Record<string, FilterGroup> = {};
-
-	const aFieldGroups = converterContext.getAnnotationsByTerm("UI", UIAnnotationTerms.FieldGroup);
-
-	if (filterFacets === undefined || filterFacets.length < 0) {
-		for (const i in aFieldGroups) {
-			filterFacetMap = {
-				...filterFacetMap,
-				...getFieldGroupFilterGroups(aFieldGroups[i] as AnnotationTerm<FieldGroupType>)
-			};
-		}
-	} else {
-		filterFacetMap = filterFacets.reduce((previousValue: Record<string, FilterGroup>, filterFacet: ReferenceFacetTypes) => {
-			for (let i = 0; i < (filterFacet.Target.$target as FieldGroup).Data.length; i++) {
-				previousValue[((filterFacet.Target.$target as FieldGroup).Data[i] as DataFieldTypes).Value.path] = {
-					group: filterFacet?.ID?.toString(),
-					groupLabel: filterFacet?.Label?.toString()
-				};
-			}
-			return previousValue;
-		}, {});
-	}
-
-	let aSelectOptions: any[] = [];
-	const selectionVariant = getSelectionVariant(entityType, converterContext);
-	if (selectionVariant) {
-		aSelectOptions = selectionVariant.SelectOptions;
-	}
-
-	// create a map of all potential filter fields based on...
-	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 = oAnnotatedSelectionFieldData.annotatedSelectionFields;
-	const defaultFilters = _getDefaultFilterFields(
-		filterFields,
+	let defaultFilterFields = _getDefaultFilterFields(
 		aSelectOptions,
 		entityType,
 		converterContext,
 		excludedFilterProperties,
 		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(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)
-		.concat(
-			Object.keys(filterFields)
-				.filter(propertyPath => !(propertyPath in excludedFilterProperties))
-				.map(propertyPath => {
-					return Object.assign(filterFields[propertyPath], filterFacetMap[propertyPath]);
-				})
-		);
-	const sContextPath = converterContext.getContextPath();
 
-	//if all tables are analytical tables "aggregatable" properties must be excluded
-	if (checkAllTableForEntitySetAreAnalytical(lrTables, sContextPath)) {
-		// Currently all agregates are root entity properties (no properties coming from navigation) and all
-		// tables with same entitySet gets same aggreagte configuration that's why we can use first table into
-		// LR to get aggregates (without currency/unit properties since we expect to be able to filter them).
-		const aggregates = lrTables[0].aggregates;
-		if (aggregates) {
-			const aggregatableProperties: string[] = Object.keys(aggregates).map(aggregateKey => aggregates[aggregateKey].relativePath);
-			allFilters = allFilters.filter(filterField => {
-				return aggregatableProperties.indexOf(filterField.key) === -1;
-			});
-		}
-	}
-
-	const selectionFields = insertCustomElements(allFilters, getManifestFilterFields(entityType, converterContext), {
-		"availability": "overwrite",
-		label: "overwrite",
-		type: "overwrite",
-		position: "overwrite",
-		template: "overwrite",
-		settings: "overwrite",
-		visualFilter: "overwrite"
-	});
-
-	// Add caseSensitive property to all selection fields.
-	const isCaseSensitive = isFilteringCaseSensitive(converterContext);
-	selectionFields.forEach(filterField => {
-		filterField.caseSensitive = isCaseSensitive;
-	});
-
-	return selectionFields;
+	return {
+		excludedFilterProperties: excludedFilterProperties,
+		entityType: entityType,
+		annotatedSelectionFields: annotatedSelectionFields,
+		filterFields: filterFields,
+		propertyInfoFields: propertyInfoFields,
+		defaultFilterFields: defaultFilterFields
+	};
 };
-
-export const getPropertyInfoFields = function(
+export const processSelectionFields = function (
+	propertyInfoFields: any,
 	converterContext: ConverterContext,
-	lrTables: TableVisualization[] = [],
-	lrCharts: ChartVisualization[] = [],
-	annotationPath: string = ""
+	defaultValuePropertyFields: any
 ) {
-	const oAnnotatedSelectionFieldData = getAnnotatedSelectionFieldData(converterContext, lrTables, annotationPath);
-	//const annotatedSelectionFields: any = oAnnotatedSelectionFieldData.annotatedSelectionFields;
+	//get TypeConfig function
 	const selectionFieldTypes: any = [];
-	const isCaseSensitive = isFilteringCaseSensitive(converterContext);
-	const aTypeConfig: any = [];
-	const _fnTypeConfig = function(property: Property) {
-		const oTypeConfig = getTypeConfig(property, undefined);
+	const aTypeConfig: any = {};
+	const _fnTypeConfig = function (property: Property, key: string) {
+		const oTypeConfig = getTypeConfig(property, property?.type);
 		selectionFieldTypes.push(property?.type);
-		if (property?.type === "Edm.String" && (!oTypeConfig.constraints.nullable || oTypeConfig.constraints.nullable === true)) {
+		if (property?.type === sEdmString && (!oTypeConfig.constraints.nullable || oTypeConfig.constraints.nullable === true)) {
 			oTypeConfig.formatOptions.parseKeepsEmptyString = false;
 		}
-		aTypeConfig.push(oTypeConfig);
+		aTypeConfig[key] = 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 (defaultValuePropertyFields) {
+		propertyInfoFields = propertyInfoFields.concat(defaultValuePropertyFields);
+	}
+	//add typeConfig
+	propertyInfoFields.forEach(function (parameterField: any) {
 		if (parameterField.annotationPath) {
 			const propertyConvertyContext = converterContext.getConverterContextFor(parameterField.annotationPath);
 			const propertyTargetObject = propertyConvertyContext.getDataModelObjectPath().targetObject;
-			_fnTypeConfig(propertyTargetObject);
+			_fnTypeConfig(propertyTargetObject, parameterField.key);
 		} else {
-			selectionFieldTypes.push("Edm.String");
-			aTypeConfig.push({});
+			selectionFieldTypes.push(sEdmString);
+			aTypeConfig[parameterField.key] = { type: sStringDataType };
 		}
 	});
 
+	// filterRestrictions
 	const oFilterRestrictions = converterContext.getEntitySet()?.annotations?.Capabilities?.FilterRestrictions;
 	const oRet = {} as any;
 	oRet["RequiredProperties"] = getFilterRestrictions(oFilterRestrictions, "RequiredProperties") || [];
@@ -920,58 +766,94 @@ export const getPropertyInfoFields = function(
 			...oRet.FilterAllowedExpressions
 		};
 	}
-
+	const isCaseSensitive = isFilteringCaseSensitive(converterContext);
 	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, "");
-
+	const aFetchedProperties: any = [];
+
+	// process the fields to add necessary properties
+	propertyInfoFields.forEach(function (propertyInfoField: any) {
+		const oConvertedProperty = propertyInfoField;
+		let sPropertyPath;
+		if (oConvertedProperty.conditionPath) {
+			sPropertyPath = oConvertedProperty.conditionPath.replace(/\+|\*/g, "");
+		}
 		if (aNonFilterableProps.indexOf(sPropertyPath) === -1) {
-			oPropertyInfo = _fetchPropertyInfo(converterContext, oConvertedProperty, aTypeConfig[sFilterFieldKey]);
+			oPropertyInfo = _fetchPropertyInfo(converterContext, oConvertedProperty, aTypeConfig[propertyInfoField.key]);
 			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)
+					dataType: aTypeConfig[propertyInfoField.key].type
 				});
 
 				aFetchedProperties.push(oPropertyInfo);
-				if (oPropertyInfo.isParameter) {
-					aParameterFields.push(sPropertyPath);
-				}
 			}
 		}
 	});
 
+	//add edit
 	if (converterContext.getDataModelObjectPath().targetObject?.annotations?.Common?.DraftRoot) {
 		aFetchedProperties.push(getEditStateFilterPropertyInfo());
 	}
-
-	if (sEntitySetPath && getFilterBarhideBasicSearch(lrTables, lrCharts, converterContext) !== true) {
-		const searchRestrictions = getSearchRestrictions(converterContext);
+	// add search
+	const searchRestrictions = getSearchRestrictions(converterContext);
+	const hideBasicSearch = Boolean(searchRestrictions && !searchRestrictions.Searchable);
+	if (sEntitySetPath && hideBasicSearch !== true) {
 		if (!searchRestrictions || searchRestrictions?.Searchable) {
 			aFetchedProperties.push(getSearchFilterPropertyInfo());
 		}
 	}
 
-	aFetchedProperties.sort(function(a: any, b: any) {
+	return aFetchedProperties;
+};
+
+export const insertCustomManifestElements = function (
+	filterFields: FilterField[],
+	entityType: EntityType,
+	converterContext: ConverterContext
+) {
+	return insertCustomElements(filterFields, getManifestFilterFields(entityType, converterContext), {
+		"availability": "overwrite",
+		label: "overwrite",
+		type: "overwrite",
+		position: "overwrite",
+		template: "overwrite",
+		settings: "overwrite",
+		visualFilter: "overwrite"
+	});
+};
+
+/**
+ * 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.
+ * @param {ConverterContext} converterContext
+ * @param {TableVisualization[]} lrTables
+ * @param {string} annotationPath
+ * @returns {FilterSelectionField[]} An array of selection fields
+ */
+export const getSelectionFields = function (
+	converterContext: ConverterContext,
+	lrTables: TableVisualization[] = [],
+	annotationPath: string = ""
+): any {
+	const oAnnotatedSelectionFieldData = getAnnotatedSelectionFieldData(converterContext, lrTables, annotationPath);
+	const parameterFields = _getParameterFields(converterContext);
+	let propertyInfoFields: FilterField[] = JSON.parse(JSON.stringify(oAnnotatedSelectionFieldData.propertyInfoFields));
+	const entityType = oAnnotatedSelectionFieldData.entityType;
+
+	propertyInfoFields = parameterFields.concat(propertyInfoFields);
+
+	propertyInfoFields = insertCustomManifestElements(propertyInfoFields, entityType, converterContext);
+
+	const aFetchedProperties = processSelectionFields(
+		propertyInfoFields,
+		converterContext,
+		oAnnotatedSelectionFieldData.defaultFilterFields
+	);
+	aFetchedProperties.sort(function (a: any, b: any) {
 		if (a.groupLabel === undefined || a.groupLabel === null) {
 			return -1;
 		}
@@ -984,6 +866,100 @@ export const getPropertyInfoFields = function(
 	let sFetchProperties = JSON.stringify(aFetchedProperties);
 	sFetchProperties = sFetchProperties.replace(/\{/g, "\\{");
 	sFetchProperties = sFetchProperties.replace(/\}/g, "\\}");
+	const sPropertyInfo = sFetchProperties;
+	// end of propertyFields processing
 
-	return sFetchProperties;
+	// to populate selection fields
+	let propSelectionFields: FilterField[] = JSON.parse(JSON.stringify(oAnnotatedSelectionFieldData.propertyInfoFields));
+	propSelectionFields = parameterFields.concat(propSelectionFields);
+	// create a map of properties to be used in selection variants
+	const excludedFilterProperties: Record<string, boolean> = oAnnotatedSelectionFieldData.excludedFilterProperties;
+	const filterFacets = entityType?.annotations?.UI?.FilterFacets;
+	let filterFacetMap: Record<string, FilterGroup> = {};
+
+	const aFieldGroups = converterContext.getAnnotationsByTerm("UI", UIAnnotationTerms.FieldGroup);
+
+	if (filterFacets === undefined || filterFacets.length < 0) {
+		for (const i in aFieldGroups) {
+			filterFacetMap = {
+				...filterFacetMap,
+				...getFieldGroupFilterGroups(aFieldGroups[i] as AnnotationTerm<FieldGroupType>)
+			};
+		}
+	} else {
+		filterFacetMap = filterFacets.reduce((previousValue: Record<string, FilterGroup>, filterFacet: ReferenceFacetTypes) => {
+			for (let i = 0; i < (filterFacet.Target.$target as FieldGroup).Data.length; i++) {
+				previousValue[((filterFacet.Target.$target as FieldGroup).Data[i] as DataFieldTypes).Value.path] = {
+					group: filterFacet?.ID?.toString(),
+					groupLabel: filterFacet?.Label?.toString()
+				};
+			}
+			return previousValue;
+		}, {});
+	}
+
+	// create a map of all potential filter fields based on...
+	const filterFields: Record<string, FilterField> = oAnnotatedSelectionFieldData.filterFields;
+
+	// finally create final list of filter fields by adding the SelectionFields first (order matters)...
+	let allFilters = propSelectionFields
+
+		// ...and adding remaining filter fields, that are not used in a SelectionVariant (order doesn't matter)
+		.concat(
+			Object.keys(filterFields)
+				.filter((propertyPath) => !(propertyPath in excludedFilterProperties))
+				.map((propertyPath) => {
+					return Object.assign(filterFields[propertyPath], filterFacetMap[propertyPath]);
+				})
+		);
+	const sContextPath = converterContext.getContextPath();
+
+	//if all tables are analytical tables "aggregatable" properties must be excluded
+	if (checkAllTableForEntitySetAreAnalytical(lrTables, sContextPath)) {
+		// Currently all agregates are root entity properties (no properties coming from navigation) and all
+		// tables with same entitySet gets same aggreagte configuration that's why we can use first table into
+		// LR to get aggregates (without currency/unit properties since we expect to be able to filter them).
+		const aggregates = lrTables[0].aggregates;
+		if (aggregates) {
+			const aggregatableProperties: string[] = Object.keys(aggregates).map((aggregateKey) => aggregates[aggregateKey].relativePath);
+			allFilters = allFilters.filter((filterField) => {
+				return aggregatableProperties.indexOf(filterField.key) === -1;
+			});
+		}
+	}
+
+	const selectionFields = insertCustomManifestElements(allFilters, entityType, converterContext);
+
+	// Add caseSensitive property to all selection fields.
+	const isCaseSensitive = isFilteringCaseSensitive(converterContext);
+	selectionFields.forEach((filterField) => {
+		filterField.caseSensitive = isCaseSensitive;
+	});
+
+	return { selectionFields, sPropertyInfo };
+};
+
+/**
+ * Determines whether the filter bar inside a value help dialog should be expanded. This is true if one of the following condition holds:
+ * (1) a filter property is mandatory,
+ * (2) no search field exists (entity isn't search enabled),
+ * (3) when the data isn't loaded by default (annotation FetchValues = 2).
+ * @param {ConverterContext} converterContext The converter context
+ * @param {any} filterRestrictionsAnnotation The FilterRestriction annotation
+ * @param {any} valueListAnnotation The ValueList annotation
+ * @returns {boolean} The value for expandFilterFields
+ */
+export const getExpandFilterFields = function(
+	converterContext: ConverterContext,
+	filterRestrictionsAnnotation: any,
+	valueListAnnotation: any
+): boolean {
+	const requiredProperties = getFilterRestrictions(filterRestrictionsAnnotation, "RequiredProperties");
+	const searchRestrictions = getSearchRestrictions(converterContext);
+	const hideBasicSearch = Boolean(searchRestrictions && !searchRestrictions.Searchable);
+	const valueList = valueListAnnotation.getObject();
+	if (requiredProperties.length > 0 || hideBasicSearch || valueList?.FetchValues === 2) {
+		return true;
+	}
+	return false;
 };