@sapui5/sap.fe.core 1.136.1 → 1.138.0

package/src/sap/fe/core/templating/EntitySetHelper.ts

@@ -1,4 +1,5 @@
-import type { EntitySet } from "@sap-ux/vocabularies-types";
+import type { EntitySet, NavigationProperty, PropertyPath } from "@sap-ux/vocabularies-types";
+import type { NavigationPropertyRestriction } from "@sap-ux/vocabularies-types/vocabularies/Capabilities";
 import type ConverterContext from "sap/fe/core/converters/ConverterContext";
 import { isEntitySet } from "sap/fe/core/helpers/TypeGuards";
 import { getTargetEntitySetInfo } from "./DataModelPathHelper";
@@ -10,17 +11,13 @@ export type RestrictionsOnProperties = {
 
 /**
  * Reads all FilterRestrictions and SortRestrictions of the main and child entities and their dedicated navigation restrictions.
-	1. For containment scenario:
-	   1.1. For LR, Navigation restrictions are evaluated first, followed by the restrictions on the root entity. If both a navigation property restriction and a direct restriction exist, the navigation restriction is the most precise definition and takes precedence over the direct restriction.
-	   1.2 For the OP, Restrictions are only calculated on the root entity, as there are no child entities. The same approach described in point 1.1 is applied.
- 
-	2. For a non containment scenario:
-	   2.1 The same logic described in point 1.1 applies.
-	   2.2 For the OP
-			2.2.1 Retrieve the direct restrictions configured on the child entity displayed in the table or on the root entity.
-			2.2.2 If a navigation property restriction is defined on the main entity, it takes precedence over the direct restrictions from 2.2.1.
-			2.2.3 NavigationRestrictions on the target (child) entity set are added to the list of restrictions.
- * @param entitySet Entity set to be analyzed
+1. For containment scenario:
+   1.1. For LR, Navigation restrictions are evaluated first, followed by the restrictions on the root entity. If Navigation property restriction and a direct restriction exist, both are considered.
+   1.2 For the OP, Restrictions are only calculated on the root entity, as there are no child entities. The same approach described in point 1.1 is applied.
+2. For a non containment scenario:
+   2.1 The same logic described in point 1.1 applies.
+   2.2 For the OP, the direct restrictions configured for the OP are considered along with the navigation restrictions on the target (child) entity displayed.
+ * @param entitySet Entity set to be analyzed (target or parent entity set).
  * @param targetEntitySet The target entity set, if available.  Not used in the case of containment.
  * @param parentNavigationPath The parent navigation path, specific for containment scenario to get the correct property based on the parent navigation path.
  * @returns Array containing the property names of all non-filterable and non-sortable properties
@@ -34,39 +31,23 @@ const getPropertiesRestrictionsBasedOnEntities = function (
 		nonSortableProperties: getSortRestrictionsfromNavigationRestrictions(entitySet, targetEntitySet, parentNavigationPath),
 		nonFilterableProperties: getFilterRestrictionsfromNavigationRestrictions(entitySet, targetEntitySet, parentNavigationPath)
 	};
-	if (!targetEntitySet) {
-		// if the targetEntitySet is not available, we need to get all the list of resctrictions from the root entitySet, this applies for on the list report
-		const directSortRestrictions = getDirectSortRestrictionsRecursively(entitySet, undefined, parentNavigationPath);
-		const directFilterRestrictions = getDirectFilterRestrictionsRecursively(entitySet, undefined, parentNavigationPath);
-		return {
-			nonSortableProperties: Array.from(
-				new Set([...restrictionsFromNavigationRestrictions.nonSortableProperties, ...directSortRestrictions])
-			),
-			nonFilterableProperties: Array.from(
-				new Set([...restrictionsFromNavigationRestrictions.nonFilterableProperties, ...directFilterRestrictions])
-			)
-		};
-	}
-	if (!restrictionsFromNavigationRestrictions.nonSortableProperties.length) {
-		restrictionsFromNavigationRestrictions.nonSortableProperties = getDirectSortRestrictionsRecursively(
-			entitySet,
-			targetEntitySet,
-			parentNavigationPath
-		);
-	}
-	if (!restrictionsFromNavigationRestrictions.nonFilterableProperties.length) {
-		restrictionsFromNavigationRestrictions.nonFilterableProperties = getDirectFilterRestrictionsRecursively(
-			entitySet,
-			targetEntitySet,
-			parentNavigationPath
-		);
-	}
-	return restrictionsFromNavigationRestrictions;
+	const directRestrictions = {
+		nonSortableProperties: getDirectSortRestrictions(entitySet, targetEntitySet, parentNavigationPath),
+		nonFilterableProperties: getDirectFilterRestrictions(entitySet, targetEntitySet, parentNavigationPath)
+	};
+	return {
+		nonSortableProperties: Array.from(
+			new Set([...restrictionsFromNavigationRestrictions.nonSortableProperties, ...directRestrictions.nonSortableProperties])
+		),
+		nonFilterableProperties: Array.from(
+			new Set([...restrictionsFromNavigationRestrictions.nonFilterableProperties, ...directRestrictions.nonFilterableProperties])
+		)
+	};
 };
 
 /**
  * Gets all SortRestrictions and FilterRestrictions for a given context.
- * This function verifies whether we are in a containment scenario. In a non containment scenario it determines if we are in a List Report or an Object Page.
+ * This function verifies whether we are in a containment scenario.
  * @param converterContext The converter context.
  * @returns Object containing all property names of restrictions separated by sortable and filterable capabilities.
  */
@@ -76,24 +57,9 @@ export const getRestrictionsOnProperties = function (converterContext: Converter
 	const { parentEntitySet, targetEntitySet, parentNavigationPath } = getTargetEntitySetInfo(dataModelObjectPath);
 	if (isEntitySet(targetEntitySet)) {
 		// Get the restrictions on the target navigation entity set
-		propertiesRestrictions = getPropertiesRestrictionsBasedOnEntities(targetEntitySet);
-		if (parentEntitySet && isEntitySet(parentEntitySet)) {
-			// Get the restrictions from the NavigationRestrictions / Restrictions on the parent entity set
-			// It's takes precedence over the restrictions on the target entity set
-			const parentPropertiesRestrictions = getPropertiesRestrictionsBasedOnEntities(
-				parentEntitySet,
-				targetEntitySet,
-				parentNavigationPath
-			);
-			if (parentPropertiesRestrictions.nonSortableProperties.length) {
-				propertiesRestrictions.nonSortableProperties = parentPropertiesRestrictions.nonSortableProperties;
-			}
-			if (parentPropertiesRestrictions.nonFilterableProperties.length) {
-				propertiesRestrictions.nonFilterableProperties = parentPropertiesRestrictions.nonFilterableProperties;
-			}
-		}
+		return getPropertiesRestrictionsBasedOnEntities(targetEntitySet);
 	} else if (parentEntitySet && isEntitySet(parentEntitySet)) {
-		// Find the restrictions on the parent entity set, this applies also for containment as there isn't an entity set on the OP
+		// Find the restrictions on the parent entity set, this applies for containment as there isn't an entity set available on the OP
 		return getPropertiesRestrictionsBasedOnEntities(parentEntitySet, undefined, parentNavigationPath);
 	}
 	return propertiesRestrictions;
@@ -122,25 +88,13 @@ function getSortRestrictionsfromNavigationRestrictions(
 			const navigationProperty = navigationRestriction.NavigationProperty.$target;
 			if (navigationProperty) {
 				// add all properties of the navigation property to the nonSortableProperties
-				if (parentNavigationPath) {
-					sortRestrictionsFromNavigationRestrictions.push(
-						...navigationProperty.targetType.entityProperties.map((property) => property.name)
-					);
-				} else {
-					sortRestrictionsFromNavigationRestrictions.push(
-						...navigationProperty.targetType.entityProperties.map((property) => `${navigationProperty.name}/${property.name}`)
-					);
-				}
+				sortRestrictionsFromNavigationRestrictions.push(
+					...getAllPropertiesOfNavigationProperty(navigationProperty, navigationRestriction, parentNavigationPath)
+				);
 			}
 		} else {
 			const nonSortableNavigationProperties = navigationRestriction?.SortRestrictions?.NonSortableProperties?.map((property) => {
-				// We need the property name from the navigation restriction definition when the targetEntitySet is available
-				if ((targetEntitySet || parentNavigationPath) && property.$target?.name) {
-					return property.$target?.name;
-				} else {
-					// leave the property path unchanged (it is relative to the annotation target!)
-					return property.value;
-				}
+				return getRestrictedPropertyRelativePath(property, targetEntitySet, parentNavigationPath);
 			});
 			if (nonSortableNavigationProperties?.length) {
 				sortRestrictionsFromNavigationRestrictions.push(...nonSortableNavigationProperties);
@@ -157,12 +111,8 @@ function getSortRestrictionsfromNavigationRestrictions(
  * @param parentNavigationPath The parent navigation path, specific for containment scenario to get the correct property based on the parent navigation path.
  * @returns Array containing the property names of all non-sortable properties.
  */
-function getDirectSortRestrictionsRecursively(entitySet: EntitySet, targetEntitySet?: EntitySet, parentNavigationPath?: string): string[] {
+function getDirectSortRestrictions(entitySet: EntitySet, targetEntitySet?: EntitySet, parentNavigationPath?: string): string[] {
 	const sortRestrictionsOnEntitySet: string[] = [];
-	if (targetEntitySet) {
-		// if the targetEntitySet from a navigation is available, get the direct restriction on the targetEntitySet (child entity set)
-		return getDirectSortRestrictionsRecursively(targetEntitySet, undefined, parentNavigationPath);
-	}
 	if (entitySet.annotations.Capabilities?.SortRestrictions?.Sortable === false) {
 		// add all properties of the entity set to the nonSortableProperties
 		sortRestrictionsOnEntitySet.push(...entitySet.entityType.entityProperties.map((property) => property.name));
@@ -173,11 +123,7 @@ function getDirectSortRestrictionsRecursively(entitySet: EntitySet, targetEntity
 				// skip the non sortable property if it doesn't belong to the parent navigation path in case of containment
 				return;
 			}
-			if ((targetEntitySet || parentNavigationPath) && property.$target?.name) {
-				nonSortableProperties.push(property.$target?.name);
-			} else {
-				nonSortableProperties.push(property.value);
-			}
+			nonSortableProperties.push(getRestrictedPropertyRelativePath(property, targetEntitySet, parentNavigationPath));
 		});
 		if (nonSortableProperties?.length) {
 			sortRestrictionsOnEntitySet.push(...nonSortableProperties);
@@ -200,8 +146,9 @@ function getFilterRestrictionsfromNavigationRestrictions(
 ): string[] {
 	const filterRestrictionsFromNavigationRestrictions: string[] = [];
 	entitySet.annotations.Capabilities?.NavigationRestrictions?.RestrictedProperties?.forEach((navigationRestriction) => {
-		// if containment enabled get only the filter restrictions of the related navigation path
-		if (parentNavigationPath && parentNavigationPath !== navigationRestriction?.NavigationProperty?.value) {
+		// Get the filter restrictions of the related navigation path
+		// The navigationRestriction is also relevant if it contains the parent navigation path
+		if (parentNavigationPath && !navigationRestriction?.NavigationProperty?.value.includes(parentNavigationPath)) {
 			return;
 		}
 		if (navigationRestriction?.FilterRestrictions?.Filterable === false) {
@@ -209,26 +156,14 @@ function getFilterRestrictionsfromNavigationRestrictions(
 			const navigationProperty = navigationRestriction.NavigationProperty.$target;
 			if (navigationProperty) {
 				// add all properties of the navigation property to the nonFilterableProperties
-				if (parentNavigationPath) {
-					filterRestrictionsFromNavigationRestrictions.push(
-						...navigationProperty.targetType.entityProperties.map((property) => property.name)
-					);
-				} else {
-					filterRestrictionsFromNavigationRestrictions.push(
-						...navigationProperty.targetType.entityProperties.map((property) => `${navigationProperty.name}/${property.name}`)
-					);
-				}
+				filterRestrictionsFromNavigationRestrictions.push(
+					...getAllPropertiesOfNavigationProperty(navigationProperty, navigationRestriction, parentNavigationPath)
+				);
 			}
 		} else {
 			const nonFilterableNavigationProperties = navigationRestriction?.FilterRestrictions?.NonFilterableProperties?.map(
 				(property) => {
-					// we need the property name from the navigation restriction definition when the targetEntitySet is available and it's not a containment scenario
-					if ((targetEntitySet || parentNavigationPath) && property.$target?.name) {
-						return property.$target?.name;
-					} else {
-						// leave the property path unchanged (it is relative to the annotation target!)
-						return property.value;
-					}
+					return getRestrictedPropertyRelativePath(property, targetEntitySet, parentNavigationPath);
 				}
 			);
 			if (nonFilterableNavigationProperties?.length) {
@@ -239,6 +174,57 @@ function getFilterRestrictionsfromNavigationRestrictions(
 	return filterRestrictionsFromNavigationRestrictions;
 }
 
+/**
+ * Gets all properties of a navigation property based on the navigation restriction and parent navigation path.
+ * @param navigationProperty The navigation property to be analyzed.
+ * @param navigationRestriction The navigation restriction to be applied.
+ * @param parentNavigationPath The parent navigation path, specific for containment scenario to get the correct property based on the parent navigation path.
+ * @returns The array of property names of the navigation property.
+ */
+function getAllPropertiesOfNavigationProperty(
+	navigationProperty: NavigationProperty,
+	navigationRestriction?: NavigationPropertyRestriction,
+	parentNavigationPath?: string
+): string[] {
+	if (parentNavigationPath) {
+		// for containment scenario only
+		if (navigationRestriction?.NavigationProperty?.value !== navigationProperty.name) {
+			// in case the target entity set is a child entity set (OP), we need to get the properties based on OP target entity set
+			const navigationPathBasedOnParent = navigationRestriction?.NavigationProperty?.value.replace(`${parentNavigationPath}/`, "");
+			return navigationProperty.targetType.entityProperties.map((property) => `${navigationPathBasedOnParent}/${property.name}`);
+		} else {
+			return navigationProperty.targetType.entityProperties.map((property) => property.name);
+		}
+	} else {
+		return navigationProperty.targetType.entityProperties.map((property) => `${navigationProperty.name}/${property.name}`);
+	}
+}
+
+/**
+ * Gets the relative path of the property restricted based on the target entity set and parent navigation path.
+ * @param property The property to be analyzed.
+ * @param targetEntitySet The target entity set, if available. Not present in the case of containment.
+ * @param parentNavigationPath The parent navigation path, specific for containment scenario to get the correct property based on the parent navigation path.
+ * @returns The relative path of the restricted property.
+ */
+function getRestrictedPropertyRelativePath(
+	property: PropertyPath,
+	targetEntitySet: EntitySet | undefined,
+	parentNavigationPath?: string
+): string {
+	if (parentNavigationPath && property.value.includes(parentNavigationPath)) {
+		// if the parentNavigationPath is available, we need to check if the property belongs to the parent navigation path
+		// we need to get the property path based on target entity for the child entity set (OP)
+		return property.value.replace(`${parentNavigationPath}/`, "");
+	} else if (targetEntitySet && property.$target?.name) {
+		// we need the property name from the navigation restriction definition when the targetEntitySet is available and it's not a containment scenario
+		return property.$target?.name;
+	} else {
+		// leave the property path unchanged (it is relative to the annotation target!)
+		return property.value;
+	}
+}
+
 /**
  * Gets the filter restrictions directly from the entity set.
  * @param entitySet Entity set to be analyzed.
@@ -246,31 +232,19 @@ function getFilterRestrictionsfromNavigationRestrictions(
  * @param parentNavigationPath The parent navigation path, specific for containment scenario to get the correct property based on the parent navigation path.
  * @returns Array containing the property names of all non-filterable properties.
  */
-function getDirectFilterRestrictionsRecursively(
-	entitySet: EntitySet,
-	targetEntitySet?: EntitySet,
-	parentNavigationPath?: string
-): string[] {
+function getDirectFilterRestrictions(entitySet: EntitySet, targetEntitySet?: EntitySet, parentNavigationPath?: string): string[] {
 	const filterRestrictionsOnEntitySet: string[] = [];
-	if (targetEntitySet && parentNavigationPath) {
-		// if the targetEntitySet from a navigation is available, get the direct restriction on the targetEntitySet (child entity set)
-		return getDirectFilterRestrictionsRecursively(targetEntitySet, undefined, parentNavigationPath);
-	}
 	if (entitySet.annotations.Capabilities?.FilterRestrictions?.Filterable === false) {
 		// add all properties of the entity set to the nonFilterableProperties
 		filterRestrictionsOnEntitySet.push(...entitySet.entityType.entityProperties.map((property) => property.name));
 	} else {
 		const nonFilterableProperties: string[] = [];
-		entitySet.annotations.Capabilities?.FilterRestrictions?.NonFilterableProperties?.forEach((property) => {
-			if (parentNavigationPath && !property.value.includes(parentNavigationPath)) {
+		entitySet.annotations.Capabilities?.FilterRestrictions?.NonFilterableProperties?.forEach((propertyPath) => {
+			if (parentNavigationPath && !propertyPath.value.includes(parentNavigationPath)) {
 				// skip the non filterable property if it doesn't belong to the parent navigation path in case of containment
 				return;
 			}
-			if ((targetEntitySet || parentNavigationPath) && property.$target?.name) {
-				nonFilterableProperties.push(property.$target?.name);
-			} else {
-				nonFilterableProperties.push(property.value);
-			}
+			nonFilterableProperties.push(getRestrictedPropertyRelativePath(propertyPath, targetEntitySet, parentNavigationPath));
 		});
 		if (nonFilterableProperties?.length) {
 			filterRestrictionsOnEntitySet.push(...nonFilterableProperties);