@sapui5/sap.fe.core 1.99.0 → 1.100.0

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

@@ -18,7 +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";
+//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>;
 
 /**
@@ -513,7 +516,7 @@ const getSearchFilterPropertyInfo = function() {
 	return {
 		name: "$search",
 		path: "$search",
-		dataType: "Edm.String",
+		dataType: sStringDataType,
 		maxConditions: 1
 	};
 };
@@ -524,8 +527,7 @@ const getEditStateFilterPropertyInfo = function() {
 		path: "$editState",
 		groupLabel: "",
 		group: "",
-		dataType: "Edm.String",
-		tooltip: null,
+		dataType: sStringDataType,
 		hiddenFilter: false
 	};
 };
@@ -556,20 +558,16 @@ const _fetchBasicPropertyInfo = function(oFilterFieldInfo: any) {
 		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
 	};
 };
 
@@ -616,42 +614,16 @@ 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;
 };
@@ -725,11 +697,115 @@ const getAnnotatedSelectionFieldData = function(
 		propertyInfoFields: propertyInfoFields
 	};
 };
+export const processSelectionFields = function(propertyInfoFields: any, converterContext: ConverterContext) {
+	//get TypeConfig function
+	const aTypeConfig: any = [];
+	const selectionFieldTypes: any = [];
+	const _fnTypeConfig = function(property: Property) {
+		const oTypeConfig = getTypeConfig(property, undefined);
+		selectionFieldTypes.push(property?.type);
+		if (property?.type === sEdmString && (!oTypeConfig.constraints.nullable || oTypeConfig.constraints.nullable === true)) {
+			oTypeConfig.formatOptions.parseKeepsEmptyString = false;
+		}
+		aTypeConfig.push(oTypeConfig);
+	};
+
+	//add typeConfig
+	propertyInfoFields.forEach(function(parameterField: any) {
+		if (parameterField.annotationPath) {
+			const propertyConvertyContext = converterContext.getConverterContextFor(parameterField.annotationPath);
+			const propertyTargetObject = propertyConvertyContext.getDataModelObjectPath().targetObject;
+			_fnTypeConfig(propertyTargetObject);
+		} else {
+			selectionFieldTypes.push(sEdmString);
+			aTypeConfig.push({ type: sStringDataType });
+		}
+	});
+
+	// filterRestrictions
+	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 isCaseSensitive = isFilteringCaseSensitive(converterContext);
+	const aRequiredProps = oRet.RequiredProperties;
+	const aNonFilterableProps = oRet.NonFilterableProperties;
+	let oPropertyInfo;
+	const aFetchedProperties: any = [];
+
+	// process the fields to add necessary properties
+	Object.keys(propertyInfoFields).forEach(function(sFilterFieldKey: string) {
+		const oConvertedProperty = propertyInfoFields[sFilterFieldKey];
+		let sPropertyPath;
+		if (oConvertedProperty.conditionPath) {
+			sPropertyPath = oConvertedProperty.conditionPath.replace(/\+|\*/g, "");
+		}
+		if (aNonFilterableProps.indexOf(sPropertyPath) === -1) {
+			oPropertyInfo = _fetchPropertyInfo(converterContext, oConvertedProperty, aTypeConfig[sFilterFieldKey]);
+			if (oPropertyInfo) {
+				oPropertyInfo = Object.assign(oPropertyInfo, {
+					maxConditions: !oPropertyInfo.isParameter && isMultiValue(oPropertyInfo) ? -1 : 1,
+					required: oPropertyInfo.isParameter || aRequiredProps.indexOf(sPropertyPath) >= 0,
+					caseSensitive: isCaseSensitive,
+					dataType: selectionFieldTypes[sFilterFieldKey]
+				});
+
+				aFetchedProperties.push(oPropertyInfo);
+			}
+		}
+	});
+
+	//add edit
+	if (converterContext.getDataModelObjectPath().targetObject?.annotations?.Common?.DraftRoot) {
+		aFetchedProperties.push(getEditStateFilterPropertyInfo());
+	}
+	// add search
+	const searchRestrictions = getSearchRestrictions(converterContext);
+	const hideBasicSearch = Boolean(searchRestrictions && !searchRestrictions.Searchable);
+	if (sEntitySetPath && hideBasicSearch !== true) {
+		if (!searchRestrictions || searchRestrictions?.Searchable) {
+			aFetchedProperties.push(getSearchFilterPropertyInfo());
+		}
+	}
+
+	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
@@ -739,13 +815,39 @@ export const getSelectionFields = function(
 	converterContext: ConverterContext,
 	lrTables: TableVisualization[] = [],
 	annotationPath: string = ""
-): FilterField[] {
+): 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);
+	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, "\\}");
+	const sPropertyInfo = sFetchProperties;
+	// end of propertyFields processing
+
+	// 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 entityType = oAnnotatedSelectionFieldData.entityType;
-	const filterFacets = entityType.annotations.UI?.FilterFacets;
+	const filterFacets = entityType?.annotations?.UI?.FilterFacets;
 	let filterFacetMap: Record<string, FilterGroup> = {};
 
 	const aFieldGroups = converterContext.getAnnotationsByTerm("UI", UIAnnotationTerms.FieldGroup);
@@ -788,24 +890,9 @@ export const getSelectionFields = function(
 		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)
+	let allFilters = propSelectionFields
 		// 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)
@@ -832,15 +919,7 @@ export const getSelectionFields = function(
 		}
 	}
 
-	const selectionFields = insertCustomElements(allFilters, getManifestFilterFields(entityType, converterContext), {
-		"availability": "overwrite",
-		label: "overwrite",
-		type: "overwrite",
-		position: "overwrite",
-		template: "overwrite",
-		settings: "overwrite",
-		visualFilter: "overwrite"
-	});
+	const selectionFields = insertCustomManifestElements(allFilters, entityType, converterContext);
 
 	// Add caseSensitive property to all selection fields.
 	const isCaseSensitive = isFilteringCaseSensitive(converterContext);
@@ -848,142 +927,5 @@ export const getSelectionFields = function(
 		filterField.caseSensitive = isCaseSensitive;
 	});
 
-	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;
+	return { selectionFields, sPropertyInfo };
 };