@sap/open.fe 1.98.0 → 1.99.0

package/packages/sap.fe.core/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,6 +18,7 @@ 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;
@@ -178,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,
@@ -264,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) {
@@ -348,24 +409,25 @@ 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
-	) {
-		return true;
-	}
+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);
 
-	// If all tables are analytical and none of them allow for search
-	// then the search field must be hidden
 	const contextPath = converterContext.getContextPath();
-	if (contextPath && listReportTables.length > 0) {
-		return listReportTables.every(visualization => {
-			return visualization.enableAnalytics && !visualization.enableAnalyticsSearch;
-		});
+	if (contextPath && noSearchInCharts && noSearchInTables) {
+		return true;
 	} else {
 		return false;
 	}
@@ -421,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.
@@ -435,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> = {};
 
@@ -472,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,
@@ -497,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)
@@ -558,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;
+};