@sapui5/sap.fe.macros 1.139.0 → 1.141.0

package/src/sap/fe/macros/ai/EasyFilterBar.tsx

@@ -1,7 +1,11 @@
+import type { ComplexType, EntitySet, EntityType, NavigationProperty, Property, TypeDefinition } from "@sap-ux/vocabularies-types";
 import Log from "sap/base/Log";
+import Localization from "sap/base/i18n/Localization";
+import { isConstant } from "sap/fe/base/BindingToolkit";
 import type { EnhanceWithUI5 } from "sap/fe/base/ClassSupport";
 import { aggregation, association, defineUI5Class, implementInterface, property, type PropertiesOf } from "sap/fe/base/ClassSupport";
 import type {
+	CodeListType,
 	EasyFilterBarContainer$ShowValueHelpEvent,
 	EasyFilterPropertyMetadata,
 	TokenDefinition,
@@ -14,10 +18,11 @@ import BuildingBlock from "sap/fe/core/buildingBlocks/BuildingBlock";
 import BusyLocker from "sap/fe/core/controllerextensions/BusyLocker";
 import type { ControlState, NavigationParameter } from "sap/fe/core/controllerextensions/ViewState";
 import type IViewStateContributor from "sap/fe/core/controllerextensions/viewState/IViewStateContributor";
-import type { FilterField } from "sap/fe/core/definition/FEDefinition";
+import { type FilterField } from "sap/fe/core/definition/FEDefinition";
 import type MetaPath from "sap/fe/core/helpers/MetaPath";
 import ModelHelper from "sap/fe/core/helpers/ModelHelper";
-import { isPathAnnotationExpression } from "sap/fe/core/helpers/TypeGuards";
+import { isComplexType, isEntityType, isNavigationProperty, isPathAnnotationExpression, isProperty } from "sap/fe/core/helpers/TypeGuards";
+import { isPathFilterable } from "sap/fe/core/templating/DataModelPathHelper";
 import { hasValueHelpWithFixedValues } from "sap/fe/core/templating/PropertyHelper";
 import {
 	generateSelectParameter,
@@ -42,14 +47,13 @@ import DateTimeOffset from "sap/ui/model/odata/type/DateTimeOffset";
 import type ODataType from "sap/ui/model/odata/type/ODataType";
 import TimeOfDay from "sap/ui/model/odata/type/TimeOfDay";
 import type ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
-import type { CodeList, MayBeLazy } from "ux/eng/fioriai/reuse/easyfilter/EasyFilter";
+import type { CodeList } from "ux/eng/fioriai/reuse/easyfilter/EasyFilter";
 
 type EasyFilterBarState = {};
-type FieldMetadata = EasyFilterPropertyMetadata & { filterFieldName: string };
+type FieldMetadata = EasyFilterPropertyMetadata & { maxLength?: number };
 
 /**
  * Delivery for beta release for the easy filter feature.
- * @experimental
  */
 @defineUI5Class("sap.fe.macros.EasyFilterBar")
 export default class EasyFilterBar extends BuildingBlock implements IViewStateContributor<EasyFilterBarState> {
@@ -71,8 +75,6 @@ export default class EasyFilterBar extends BuildingBlock implements IViewStateCo
 	@aggregation({ type: "sap.fe.controls.easyFilter.EasyFilterBarContainer" })
 	content?: EnhanceWithUI5<EasyFilterBarContainer>;
 
-	_fetchedCodeList!: Record<string, CodeList | undefined>;
-
 	private filterBarMetadata!: FieldMetadata[];
 
 	private easyFilterPath?: string;
@@ -142,116 +144,272 @@ export default class EasyFilterBar extends BuildingBlock implements IViewStateCo
 	}
 
 	onMetadataAvailable(): void {
-		this._fetchedCodeList ??= {};
 		this.filterBarMetadata = this.prepareFilterBarMetadata();
 		this.recommendedQueries = this.getAppComponent()?.getManifestEntry("sap.fe")?.macros?.easyFilter?.recommendedQueries ?? [];
 		this.content = this.createContent() as EnhanceWithUI5<EasyFilterBarContainer>;
 		this.content.filterBarMetadata = this.filterBarMetadata;
 	}
 
+	private getUnitForProperty(prop: Property, basePath: string): string | undefined {
+		const unitAnnotation = prop.annotations.Measures?.ISOCurrency ?? prop.annotations.Measures?.Unit;
+		return isPathAnnotationExpression(unitAnnotation) ? `${basePath}/${unitAnnotation.path}` : undefined;
+	}
+
+	private getDefaultValueForFilterField(
+		field: FilterField,
+		startupParameters: Record<string, unknown>
+	): TokenSelectedValuesDefinition[] | undefined {
+		let defaultValue: TokenSelectedValuesDefinition[] | undefined;
+		if (startupParameters.hasOwnProperty(field.name)) {
+			defaultValue = [
+				{
+					operator: FilterOperator.EQ,
+					selectedValues: startupParameters[field.name] as TokenSelectedValuesDefinition["selectedValues"]
+				}
+			];
+		} else if (field.isParameter && startupParameters.hasOwnProperty(field.name.substring(2))) {
+			defaultValue = [
+				{
+					operator: FilterOperator.EQ,
+					selectedValues: startupParameters[field.name.substring(2)] as TokenSelectedValuesDefinition["selectedValues"]
+				}
+			];
+		}
+		return defaultValue;
+	}
+
+	private getEditStateFilterMetadata(metaModel: ODataMetaModel): FieldMetadata {
+		// Assemble the code list for the editing status filter values:
+		const props = new JSONModel({
+			isDraftCollaborative: ModelHelper.isCollaborationDraftSupported(metaModel)
+		}).createBindingContext("/");
+
+		const editingStatusCodeList = DraftEditState.getEditStatesContext(props)
+			.getObject("/")
+			.map((state: { id: string; display: string }) => ({ value: state.id, description: state.display }));
+
+		return {
+			name: "$editState",
+			label: this.getTranslatedText("FILTERBAR_EDITING_STATUS"),
+			dataType: "Edm.String",
+			filterable: true,
+			codeList: editingStatusCodeList,
+			type: "MenuWithSingleSelect"
+		};
+	}
+
+	private getTokenType(prop: Property, filterRestriction: string): TokenType {
+		if (hasValueHelpWithFixedValues(prop)) {
+			return filterRestriction === "SingleValue" ? "MenuWithSingleSelect" : "MenuWithCheckBox";
+		}
+		switch (prop.type) {
+			case "Edm.Date":
+				return "Calendar";
+			case "Edm.TimeOfDay":
+				return "Time";
+			default:
+				return "ValueHelp";
+		}
+	}
+
+	private getLabel(element: Property | NavigationProperty | EntityType | ComplexType): string | undefined {
+		const label = element.annotations.Common?.Label?.toString();
+		const headerInfoTypeName = isEntityType(element) ? (element.annotations.UI?.HeaderInfo?.TypeName?.valueOf() as string) : undefined;
+		const result = headerInfoTypeName || label;
+
+		if (this.isComplexProperty(element) || isNavigationProperty(element)) {
+			return result || this.getLabel(element.targetType);
+		}
+
+		return result;
+	}
+
+	private isScalarProperty(element: unknown): element is Property & { targetType?: TypeDefinition } {
+		return isProperty(element) && !isComplexType(element.targetType);
+	}
+
+	private isComplexProperty(element: unknown): element is Property & { targetType: ComplexType } {
+		return isProperty(element) && isComplexType(element.targetType);
+	}
+
 	prepareFilterBarMetadata(): FieldMetadata[] {
+		/*
+		 * 1. INITIALIZATION:
+		 *    - Queue all root entity properties and navigation properties for traversal
+		 *    - Initialize result array and elimination set for Common.Text targets
+		 *
+		 * 2. BREADTH-FIRST TRAVERSAL:
+		 *    For each path in queue:
+		 *    - Skip UI.Hidden properties
+		 *    - Scalar properties: Generate metadata, track Common.Text targets for elimination
+		 *    - Complex properties: Add child properties to queue
+		 *    - Navigation properties: Add target EntityType properties to queue
+		 *      (Collections only if explicit filter fields exist, respect depth limits)
+		 *
+		 * 3. POST-PROCESSING:
+		 *    - Add $editState filter for draft-enabled entities
+		 *    - Remove properties marked for elimination (except explicit filter fields)
+		 */
 		const owner = this._getOwner()!;
 		const definitionForPage = owner.preprocessorContext?.getDefinitionForPage();
-		let filterBarDef;
-		if (definitionForPage) {
-			filterBarDef = definitionForPage.getFilterBarDefinition({});
 
-			const metaModel = owner.preprocessorContext?.models.metaModel as ODataMetaModel;
+		if (!definitionForPage) {
+			return [];
+		}
 
-			const getType = (edmType: string, codeList: MayBeLazy<CodeList> | undefined): TokenType => {
-				if (codeList) {
-					return "MenuWithCheckBox";
-				}
-				switch (edmType) {
-					case "Edm.Date":
-						return "Calendar";
-					case "Edm.TimeOfDay":
-						return "Time";
-					default:
-						return "ValueHelp";
-				}
-			};
-			const startupParameters = owner.getAppComponent().getComponentData()?.startupParameters ?? {};
+		const filterBarDef = definitionForPage.getFilterBarDefinition({});
+		const metaPath = definitionForPage.getMetaPath();
+		const entitySet = metaPath.getClosestEntitySet() as EntitySet;
+
+		let filterExpressionRestrictions = entitySet.annotations.Capabilities?.FilterRestrictions?.FilterExpressionRestrictions ?? [];
+
+		// TODO: Maybe we can simplify this by using restrictions on the main entity set only
+		for (const navigationProperty in entitySet.navigationPropertyBinding) {
+			if (entitySet.navigationPropertyBinding[navigationProperty]?._type === "EntitySet") {
+				// FIXME: optional chaining should not be needed here -> root cause fix pending
+				const navigationPropertyEntitySet = entitySet.navigationPropertyBinding[navigationProperty] as EntitySet;
+				const navPropertyFilterExpressionRestrictions =
+					navigationPropertyEntitySet.annotations.Capabilities?.FilterRestrictions?.FilterExpressionRestrictions ?? [];
+
+				const currentFilterRestrictions = [...filterExpressionRestrictions];
+				filterExpressionRestrictions = [
+					...filterExpressionRestrictions,
+					...navPropertyFilterExpressionRestrictions.filter((restriction) => !currentFilterRestrictions.includes(restriction))
+				];
+			}
+		}
 
-			const filterFields = filterBarDef.getFilterFields();
-			const nonHiddenFilterFields = filterFields.filter((field: FilterField) => {
-				return !field.getTarget()?.annotations?.UI?.HiddenFilter?.valueOf();
-			});
-			const result = nonHiddenFilterFields.map((field: FilterField): FieldMetadata => {
-				const propertyObject = field.getTarget();
-				let codeList: MayBeLazy<CodeList> | undefined;
-				const hasCodeList = hasValueHelpWithFixedValues(propertyObject);
-				if (hasCodeList) {
-					codeList = this._fetchedCodeList[field.name];
-					if (!codeList) {
-						codeList = async (): Promise<CodeList> => this.getCodeListForProperty(field.name, field.annotationPath!);
-					}
-				}
+		const metaModel = owner.preprocessorContext?.models.metaModel as ODataMetaModel;
 
-				// Check if the filter field's target property has a currency or a unit. If so, look for the corresponding filter field (the
-				// annotation has to be a path for that) and set the 'unit' property.
-				const unitAnnotation = propertyObject.annotations.Measures?.ISOCurrency ?? propertyObject.annotations.Measures?.Unit;
-				const unitProperty = isPathAnnotationExpression(unitAnnotation) ? unitAnnotation.$target : undefined;
-				const unit = unitProperty ? filterFields.find((f) => f.getTarget() === unitProperty)?.name : undefined;
-				let defaultValue: TokenSelectedValuesDefinition[] | undefined;
-				if (startupParameters.hasOwnProperty(field.name)) {
-					defaultValue = [
-						{
-							operator: FilterOperator.EQ,
-							selectedValues: startupParameters[field.name] as TokenSelectedValuesDefinition["selectedValues"]
-						}
-					];
-				} else if (field.isParameter && startupParameters.hasOwnProperty(field.name.substring(2))) {
-					defaultValue = [
-						{
-							operator: FilterOperator.EQ,
-							selectedValues: startupParameters[field.name.substring(2)] as TokenSelectedValuesDefinition["selectedValues"]
-						}
-					];
+		const getCodeList = (lastPathSegment: Property, propertyPath: string): CodeList | (() => Promise<CodeList>) | undefined =>
+			hasValueHelpWithFixedValues(lastPathSegment)
+				? async (): Promise<CodeList> => this.getCodeListForProperty(propertyPath)
+				: undefined;
+
+		const filterFields = filterBarDef
+			.getFilterFields()
+			.filter((field: FilterField) => !field.getTarget()?.annotations?.UI?.HiddenFilter?.valueOf());
+
+		const startupParameters = owner.getAppComponent().getComponentData()?.startupParameters ?? {};
+
+		const maxDepth = 1; // Maximum depth for navigation properties
+
+		// Initialize traversal queue with all entity properties and navigation properties.
+		// Each path to traverse is a list of segments (e.g. [navProp1, complexProp1, complexProp2, scalarProp])
+		const pathsToExplore: (Property | NavigationProperty)[][] = [
+			...entitySet.entityType.entityProperties,
+			...entitySet.entityType.navigationProperties
+		].map((element) => [element]);
+
+		// Resulting metadata array
+		const result: EasyFilterPropertyMetadata[] = [];
+
+		// Set of property paths to be eliminated from the filter bar metadata
+		const pathsToEliminate = new Set<string>();
+
+		const getPathLabel = (path: (Property | NavigationProperty)[]): string => {
+			const pathLabels = path.map((e) => this.getLabel(e) || `[${e.name}]`);
+			return Localization.getRTL() ? pathLabels.slice().reverse().join(" - ") : pathLabels.join(" - ");
+		};
+
+		while (pathsToExplore.length > 0) {
+			const currentPath = pathsToExplore.shift()!;
+
+			const navigationDepth = currentPath.filter(isNavigationProperty).length;
+
+			const lastPathSegment = currentPath[currentPath.length - 1];
+
+			if (lastPathSegment.annotations.UI?.Hidden?.valueOf() === true) {
+				continue;
+			}
+
+			const pathString = [`/${entitySet.name}`, ...currentPath.slice(0, -1).map((e) => e.name)].reduce(
+				(acc, curr) => `${acc}/${curr}`
+			);
+			const propertyPath = `${pathString}/${lastPathSegment.name}`;
+
+			if (this.isScalarProperty(lastPathSegment)) {
+				// Check for Common.Text annotation and record the annotation target path for elimination
+				const textAnnotation = lastPathSegment.annotations.Common?.Text;
+				if (isPathAnnotationExpression(textAnnotation)) {
+					// Construct the full path to the target property
+					pathsToEliminate.add(`${pathString}/${textAnnotation.path}`);
 				}
-				return {
-					name: field.annotationPath!,
-					filterFieldName: field.name,
-					label: field.label,
-					dataType: propertyObject.type,
-					required: field.required ?? false,
-					defaultValue: defaultValue,
-					filterable: true,
-					codeList: codeList,
-					type: getType(propertyObject.type, codeList) as Exclude<TokenType, "ValueHelp">,
-					unit: unit
+
+				// Scalar property: create metadata for the property
+				const filterField = filterFields.find((field) => field.getTarget() === lastPathSegment);
+				const filterRestriction = filterExpressionRestrictions.find(
+					(expression) => expression.Property?.$target === lastPathSegment
+				);
+				const filterable = isPathFilterable(this.getDataModelObjectPath(propertyPath));
+				const filterableExpression = isConstant(filterable) ? filterable.value : true;
+				const filterRestrictionExpression = filterRestriction?.AllowedExpressions as
+					| EasyFilterPropertyMetadata["filterRestriction"]
+					| undefined;
+				const codeList = getCodeList(lastPathSegment, propertyPath);
+				const metadata: EasyFilterPropertyMetadata = {
+					name: propertyPath,
+					label: getPathLabel(currentPath),
+					dataType: lastPathSegment.type,
+					required: filterField?.required,
+					defaultValue: filterField ? this.getDefaultValueForFilterField(filterField, startupParameters) : undefined,
+					filterable: filterField ? filterableExpression : undefined,
+					hiddenFilter: !filterField,
+					filterRestriction: filterField ? filterRestrictionExpression : undefined,
+					codeList,
+					type: this.getTokenType(
+						lastPathSegment,
+						filterRestriction?.AllowedExpressions?.toString() || "MultiRangeOrSearchExpression"
+					) as Exclude<TokenType, "ValueHelp">,
+					unit: this.getUnitForProperty(lastPathSegment, pathString)
 				};
-			});
+				result.push(metadata);
+			} else if (this.isComplexProperty(lastPathSegment)) {
+				// Complex property: add all properties and navigation properties of the complex type
+				lastPathSegment.targetType.properties.forEach((child) => {
+					pathsToExplore.push([...currentPath, child]);
+				});
 
-			// [Editing Status]
-
-			if (ModelHelper.isMetaPathDraftSupported(definitionForPage.getMetaPath() as unknown as MetaPath<unknown>)) {
-				// Assemble the code list for the editing status filter values:
-				const props = new JSONModel({
-					isDraftCollaborative: ModelHelper.isCollaborationDraftSupported(metaModel)
-				}).createBindingContext("/");
-
-				const editingStatusCodeList = DraftEditState.getEditStatesContext(props)
-					.getObject("/")
-					.map((state: { id: string; display: string }) => ({ value: state.id, description: state.display }));
-
-				result.push({
-					name: "$editState",
-					filterFieldName: "$editState",
-					label: this.getTranslatedText("FILTERBAR_EDITING_STATUS"),
-					dataType: "Edm.String",
-					required: false,
-					filterable: true,
-					codeList: editingStatusCodeList,
-					type: "MenuWithCheckBox"
+				// only traverse navigation properties if we are not at the maximum depth
+				if (navigationDepth < maxDepth) {
+					lastPathSegment.targetType.navigationProperties.forEach((child) => {
+						pathsToExplore.push([...currentPath, child]);
+					});
+				}
+			} else if (isNavigationProperty(lastPathSegment)) {
+				// add 1:n navigation properties only if there are filter fields for at least one of the target properties
+				if (lastPathSegment.isCollection && !filterFields.some((field) => field.annotationPath?.startsWith(propertyPath))) {
+					continue;
+				}
+
+				lastPathSegment.targetType.entityProperties.forEach((child) => {
+					pathsToExplore.push([...currentPath, child]);
 				});
+
+				// only traverse navigation properties if we are not at the maximum depth
+				if (navigationDepth < maxDepth) {
+					lastPathSegment.targetType.navigationProperties.forEach((child) => {
+						pathsToExplore.push([...currentPath, child]);
+					});
+				}
 			}
-			return result;
 		}
-		return [];
+
+		// [Editing Status]
+		if (ModelHelper.isMetaPathDraftSupported(definitionForPage.getMetaPath() as unknown as MetaPath<unknown>)) {
+			result.push(this.getEditStateFilterMetadata(metaModel));
+		}
+
+		// Remove properties marked for elimination (unless they are filter fields)
+		return result.filter((metadata) => {
+			return (
+				!metadata.hiddenFilter || // Keep if explicit filter field
+				!pathsToEliminate.has(metadata.name) // Keep if path not marked for elimination
+			);
+		});
 	}
 
-	async getCodeListForProperty(key: string, propertyPath: string): Promise<CodeList> {
+	async getCodeListForProperty(propertyPath: string): Promise<CodeList> {
 		const defaultValueList = await this.getValueList(propertyPath);
 
 		if (!defaultValueList) {
@@ -266,8 +424,7 @@ export default class EasyFilterBar extends BuildingBlock implements IViewStateCo
 		const data = await listBinding.requestContexts();
 
 		const filterGroupValues = data.map(mapValueListToCodeList(defaultValueList));
-		this._fetchedCodeList[key] = filterGroupValues;
-		const codeListProperty = this.filterBarMetadata.find((field) => field.name === key);
+		const codeListProperty = this.filterBarMetadata.find((field) => field.name === propertyPath);
 		if (codeListProperty) {
 			codeListProperty.codeList = filterGroupValues;
 		}
@@ -279,17 +436,56 @@ export default class EasyFilterBar extends BuildingBlock implements IViewStateCo
 		values: TokenSelectedValuesDefinition[]
 	): Promise<ValueHelpSelectedValuesDefinition[]> {
 		const field = this.filterBarMetadata.find(({ name }) => name === fieldName);
-		if (field) {
-			const valueList = await this.getValueList(field.name);
+		let result: ValueHelpSelectedValuesDefinition[];
 
-			if (valueList && ValueListHelper.isValueListSearchable(field.name, valueList)) {
-				const resolvedTokenValues = await Promise.all(values.map(async (value) => resolveTokenValue(valueList, value)));
-				return resolvedTokenValues.flat();
-			}
+		if (!field) {
+			// return original values converted to the expected format if no field is defined
+			return unresolvedResult(values);
+		}
+		const valueList = await this.getValueList(field.name);
+
+		if (valueList && ValueListHelper.isValueListSearchable(field.name, valueList)) {
+			const resolvedTokenValues = await Promise.all(values.map(async (value) => resolveTokenValue(valueList, value)));
+			result = resolvedTokenValues.flat();
+		} else {
+			result = unresolvedResult(values);
+		}
+
+		// Apply maxLength filtering if defined
+		if (field.maxLength !== undefined) {
+			const filteredTokens = result
+				.map((token) => {
+					if (token.operator === FilterOperator.BT || token.operator === FilterOperator.NB) {
+						// Handle between operators - selectedValues is ValueHelpBetweenSelectedValues
+						const [a, b] = token.selectedValues;
+
+						// Check if both values exceed maxLength
+						if (String(a.value).length <= field.maxLength! && String(b.value).length <= field.maxLength!) {
+							return token; // Keep the token if both values are within limit
+						} else {
+							return null; // Remove the token if either value exceeds limit
+						}
+					} else {
+						// Handle other operators - selectedValues is CodeListType[]
+						const filtered: CodeListType[] = token.selectedValues.filter(
+							(selectedValue) => String(selectedValue.value).length <= field.maxLength!
+						);
+
+						// Only return the token if there are remaining values after filtering
+						if (filtered.length > 0) {
+							return { ...token, selectedValues: filtered };
+						} else {
+							return null; // Remove the token if no values remain
+						}
+					}
+				})
+				.filter((token): token is ValueHelpSelectedValuesDefinition => token !== null);
+
+			return filteredTokens;
 		}
 
-		// return original values converted to the expected format
-		return unresolvedResult(values);
+		// if no maxLength is defined, return unfiltered result
+		return result;
 	}
 
 	async getValueList(fieldName: string): Promise<ValueListInfo | undefined> {