@sapui5/sap.fe.core 1.135.0 → 1.136.0

package/src/sap/fe/core/services/SideEffectsServiceFactory.ts

@@ -21,6 +21,7 @@ import type {
 } from "sap/fe/core/converters/ManifestSettings";
 import * as MetaModelConverter from "sap/fe/core/converters/MetaModelConverter";
 import { convertTypes, getInvolvedDataModelObjects } from "sap/fe/core/converters/MetaModelConverter";
+import { getResourceModel } from "sap/fe/core/helpers/ResourceModelHelper";
 import {
 	isComplexType,
 	isEntitySet,
@@ -29,14 +30,15 @@ import {
 	isProperty,
 	isPropertyPathExpression
 } from "sap/fe/core/helpers/TypeGuards";
-import { ChannelType, createWebSocket, getWebSocketBaseUrl, getWebSocketChannelUrl } from "sap/fe/core/helpers/WebSocket";
+import { ChannelType, WEBSOCKET_STATUS, createWebSocket, getWebSocketBaseUrl, getWebSocketChannelUrl } from "sap/fe/core/helpers/WebSocket";
 import { getAssociatedTextPropertyPath } from "sap/fe/core/templating/PropertyHelper";
+import MessageBox from "sap/m/MessageBox";
 import type Event from "sap/ui/base/Event";
 import type Control from "sap/ui/core/Control";
 import Service from "sap/ui/core/service/Service";
 import ServiceFactory from "sap/ui/core/service/ServiceFactory";
 import type SapPcpWebSocket from "sap/ui/core/ws/SapPcpWebSocket";
-import type { WebSocket$MessageEvent } from "sap/ui/core/ws/WebSocket";
+import type { WebSocket$CloseEvent, WebSocket$MessageEvent } from "sap/ui/core/ws/WebSocket";
 import type { default as Context } from "sap/ui/model/odata/v4/Context";
 import type ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
 import type ODataModel from "sap/ui/model/odata/v4/ODataModel";
@@ -154,6 +156,7 @@ export class SideEffectsService extends Service<SideEffectsSettings> {
 
 	private entityTypeRegexPattern!: RegExp;
 
+	private webSocketStatus!: WEBSOCKET_STATUS;
 	// Interaction type for SideEffects events
 	private interactionTypeDefinition?: SideEffectsEventsInteractionManifestSetting;
 
@@ -190,8 +193,34 @@ export class SideEffectsService extends Service<SideEffectsSettings> {
 		if (url && channel) {
 			this.webSocket = createWebSocket(ChannelType.SideEffectsEvents, model);
 			this.webSocket.attachMessage(this.onSideEffectsEventReceived.bind(this));
+			this.webSocketStatus = WEBSOCKET_STATUS.CONNECTED;
+
+			const showConnectionLostDialog = (): void => {
+				if ([WEBSOCKET_STATUS.CLOSED, WEBSOCKET_STATUS.ERROR].includes(this.webSocketStatus)) {
+					const resourceModel = getResourceModel(this.appComponent);
+					const lostOfConnectionText = resourceModel.getText("C_SIDEEFFECT_CONNECTION_LOST");
+
+					MessageBox.warning(lostOfConnectionText, {
+						actions: [MessageBox.Action.OK],
+						emphasizedAction: MessageBox.Action.OK
+					});
+				}
+			};
+
+			this.webSocket.attachError(() => {
+				this.webSocketStatus = WEBSOCKET_STATUS.ERROR;
+				showConnectionLostDialog();
+			});
+
+			this.webSocket.attachClose((evt: WebSocket$CloseEvent) => {
+				this.webSocketStatus = WEBSOCKET_STATUS.CLOSED;
+				// RFC 6455 defines the status codes when closing an established connection :  https://datatracker.ietf.org/doc/html/rfc6455#section-7.4
+				// status code 1000 means normal closure
+				if ((evt.getParameter("code") as number | undefined) !== 1000) {
+					showConnectionLostDialog();
+				}
+			});
 		}
-		return;
 	}
 
 	/**

package/src/sap/fe/core/services/view/TemplatingErrorPage.view.xml

@@ -1,7 +1,7 @@
 <mvc:View xmlns:mvc="sap.ui.core.mvc" xmlns="sap.m" controllerName="sap.fe.core.services.view.TemplatingErrorPage">
 	<Page showHeader="false">
 		<IllustratedMessage
-			illustrationType="sapIllus-ErrorScreen"
+			illustrationType="sapIllus-UnableToLoad"
 			title="{sap.fe.i18n>T_TEMPLATING_ERROR_PAGE_SAPFE_APPSTART_TEMPLATING_FAILED}"
 			description="{= ${error>/message} ? ${error>/message} : ''}"
 		/>

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

@@ -2,96 +2,236 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2025 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/fe/core/helpers/TypeGuards"], function (TypeGuards) {
+sap.ui.define(["sap/fe/core/helpers/TypeGuards", "./DataModelPathHelper"], function (TypeGuards, DataModelPathHelper) {
   "use strict";
 
   var _exports = {};
+  var getTargetEntitySetInfo = DataModelPathHelper.getTargetEntitySetInfo;
   var isEntitySet = TypeGuards.isEntitySet;
   /**
-   * Gets NonFilterableProperties on FilterRestrictions of the main entity.
+   * Reads all FilterRestrictions of the main entity and the navigation restrictions.
+   * We get the restrictions first on the navigation property (most precise definition), and if not available, then we get the restrictions on the entitySet.
+   * In case of containment, we only get the restrictions on the navigation property of the parent entitySet.
    * @param entitySet Entity set to be analyzed
+   * @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 properties
    */
-  const getNonFilterablePropertiesRestrictions = function (entitySet) {
-    let nonFilterableProperties = [];
-    if (entitySet.annotations.Capabilities?.FilterRestrictions?.Filterable === false) {
-      // add all properties of the entity to the nonFilterableProperties
-      nonFilterableProperties.push(...entitySet.entityType.entityProperties.map(property => property.name));
-    } else {
-      nonFilterableProperties = entitySet.annotations.Capabilities?.FilterRestrictions?.NonFilterableProperties?.map(property => property.value) || [];
+  const getNonFilterablePropertiesRestrictions = function (entitySet, targetEntitySet, parentNavigationPath) {
+    const filterRestrictionsFromNavigationRestrictions = getFilterRestrictionsfromNavigationRestrictions(entitySet, targetEntitySet, parentNavigationPath);
+    const directFilterRestrictions = getDirectFilterRestrictions(entitySet, targetEntitySet, parentNavigationPath);
+    // Merge two filter restrictions found on the navigation property and directly from the entity set
+    return Array.from(new Set([...filterRestrictionsFromNavigationRestrictions, ...directFilterRestrictions]));
+  };
+
+  /**
+   * Reads all SortRestrictions of the main entity and the navigation restrictions.
+   * We retrieve the restrictions first on the navigation property (most precise definition), and if not available, then we get the restrictions on the entitySet
+   * In case of containment, we only get the restrictions on the navigation property of the parent entitySet.
+   * @param entitySet Entity set to be analyzed
+   * @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-sortable properties
+   */
+  _exports.getNonFilterablePropertiesRestrictions = getNonFilterablePropertiesRestrictions;
+  const getNonSortablePropertiesRestrictions = function (entitySet, targetEntitySet, parentNavigationPath) {
+    const sortRestrictionsFromNavigationRestrictions = getSortRestrictionsfromNavigationRestrictions(entitySet, targetEntitySet, parentNavigationPath);
+    const directSortRestrictions = getDirectSortRestrictions(entitySet, targetEntitySet, parentNavigationPath);
+    // Merge two sort restrictions found on the navigation property and directly from the entity set
+    return Array.from(new Set([...sortRestrictionsFromNavigationRestrictions, ...directSortRestrictions]));
+  };
+
+  /**
+   * Gets all SortRestrictions and FilterRestrictions for a given context.
+   * @param converterContext The converter context.
+   * @returns Object containing all property names of restrictions separated by sortable and filterable capabilities.
+   */
+  _exports.getNonSortablePropertiesRestrictions = getNonSortablePropertiesRestrictions;
+  const getRestrictionsOnProperties = function (converterContext) {
+    let propertiesRestrictions = {
+      nonSortableProperties: [],
+      nonFilterableProperties: []
+    };
+    const dataModelObjectPath = converterContext.getDataModelObjectPath();
+    const {
+      parentEntitySet,
+      targetEntitySet,
+      parentNavigationPath
+    } = getTargetEntitySetInfo(dataModelObjectPath);
+    if (isEntitySet(targetEntitySet)) {
+      if (parentEntitySet && isEntitySet(parentEntitySet)) {
+        propertiesRestrictions = {
+          nonSortableProperties: getNonSortablePropertiesRestrictions(parentEntitySet, targetEntitySet),
+          nonFilterableProperties: getNonFilterablePropertiesRestrictions(parentEntitySet, targetEntitySet)
+        };
+        if (propertiesRestrictions.nonSortableProperties.length || propertiesRestrictions.nonFilterableProperties.length) {
+          return propertiesRestrictions;
+        }
+      }
+      return {
+        nonSortableProperties: getNonSortablePropertiesRestrictions(targetEntitySet),
+        nonFilterableProperties: getNonFilterablePropertiesRestrictions(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
+      return {
+        nonSortableProperties: getNonSortablePropertiesRestrictions(parentEntitySet, undefined, parentNavigationPath),
+        nonFilterableProperties: getNonFilterablePropertiesRestrictions(parentEntitySet, undefined, parentNavigationPath)
+      };
     }
+    return propertiesRestrictions;
+  };
 
-    // Check for every navigationRestriction if it has FilterRestrictions
+  /**
+   * Gets the sort restrictions from the navigation restrictions.
+   * @param entitySet Entity set to be analyzed.
+   * @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-sortable properties from navigation restrictions.
+   */
+  _exports.getRestrictionsOnProperties = getRestrictionsOnProperties;
+  function getSortRestrictionsfromNavigationRestrictions(entitySet, targetEntitySet, parentNavigationPath) {
+    const sortRestrictionsFromNavigationRestrictions = [];
     entitySet.annotations.Capabilities?.NavigationRestrictions?.RestrictedProperties?.forEach(navigationRestriction => {
-      // leave the property path unchanged (it is relative to the annotation target!)
-      const nonFilterableNavigationProperties = navigationRestriction?.FilterRestrictions?.NonFilterableProperties?.map(property => property.value);
-      if (nonFilterableNavigationProperties) {
-        nonFilterableProperties.push(...nonFilterableNavigationProperties);
+      // if containment enabled get only the sort restrictions of the related navigation path
+      if (parentNavigationPath && parentNavigationPath !== navigationRestriction?.NavigationProperty?.value) {
+        return;
+      }
+      if (navigationRestriction?.SortRestrictions?.Sortable === false) {
+        // find correct navigation property
+        const navigationProperty = entitySet.entityType.navigationProperties.by_name(navigationRestriction?.NavigationProperty?.value);
+        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}`));
+          }
+        }
+      } 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;
+          }
+        });
+        if (nonSortableNavigationProperties?.length) {
+          sortRestrictionsFromNavigationRestrictions.push(...nonSortableNavigationProperties);
+        }
       }
     });
-    return nonFilterableProperties;
-  };
+    return sortRestrictionsFromNavigationRestrictions;
+  }
 
   /**
-   * Reads all SortRestrictions of the main entity and the (first level) navigation restrictions.
-   * This does not work for more than one level of navigation.
-   * @param entitySet Entity set to be analyzed
-   * @returns Array containing the property names of all non-sortable properties
+   * Gets the sort restrictions directly from the entity set.
+   * @param entitySet Entity set to be analyzed.
+   * @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-sortable properties.
    */
-  _exports.getNonFilterablePropertiesRestrictions = getNonFilterablePropertiesRestrictions;
-  const getNonSortablePropertiesRestrictions = function (entitySet) {
-    let nonSortableProperties = [];
-    // Check annotations for main entity
+  function getDirectSortRestrictions(entitySet, targetEntitySet, parentNavigationPath) {
+    const sortRestrictionsOnEntitySet = [];
     if (entitySet.annotations.Capabilities?.SortRestrictions?.Sortable === false) {
-      // add all properties of the entity to the nonSortableProperties
-      nonSortableProperties.push(...entitySet.entityType.entityProperties.map(property => property.name));
+      // add all properties of the entity set to the nonSortableProperties
+      sortRestrictionsOnEntitySet.push(...entitySet.entityType.entityProperties.map(property => property.name));
     } else {
-      nonSortableProperties = entitySet.annotations.Capabilities?.SortRestrictions?.NonSortableProperties?.map(property => property.value) || [];
+      const nonSortableProperties = [];
+      entitySet.annotations.Capabilities?.SortRestrictions?.NonSortableProperties?.forEach(property => {
+        if (parentNavigationPath && !property.value.includes(parentNavigationPath)) {
+          // 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);
+        }
+      });
+      if (nonSortableProperties?.length) {
+        sortRestrictionsOnEntitySet.push(...nonSortableProperties);
+      }
     }
-    // Check for every navigationRestriction if it has sortRestrictions
+    return sortRestrictionsOnEntitySet;
+  }
+
+  /**
+   * Gets the filter restrictions from the navigation restrictions.
+   * @param entitySet Entity set to be analyzed.
+   * @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 properties from navigation restrictions.
+   */
+  function getFilterRestrictionsfromNavigationRestrictions(entitySet, targetEntitySet, parentNavigationPath) {
+    const filterRestrictionsFromNavigationRestrictions = [];
     entitySet.annotations.Capabilities?.NavigationRestrictions?.RestrictedProperties?.forEach(navigationRestriction => {
-      if (navigationRestriction?.SortRestrictions?.Sortable === false) {
+      // if containment enabled get only the filter restrictions of the related navigation path
+      if (parentNavigationPath && parentNavigationPath !== navigationRestriction?.NavigationProperty?.value) {
+        return;
+      }
+      if (navigationRestriction?.FilterRestrictions?.Filterable === false) {
         // find correct navigation property
         const navigationProperty = entitySet.entityType.navigationProperties.by_name(navigationRestriction?.NavigationProperty?.value);
         if (navigationProperty) {
-          // add all properties of the navigation property to the nonSortableProperties
-          nonSortableProperties.push(...navigationProperty.targetType.entityProperties.map(property => `${navigationProperty.name}/${property.name}`));
+          // 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}`));
+          }
         }
       } else {
-        // leave the property path unchanged (it is relative to the annotation target!)
-        const nonSortableNavigationProperties = navigationRestriction?.SortRestrictions?.NonSortableProperties?.map(property => property.value);
-        if (nonSortableNavigationProperties) {
-          nonSortableProperties.push(...nonSortableNavigationProperties);
+        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;
+          }
+        });
+        if (nonFilterableNavigationProperties?.length) {
+          filterRestrictionsFromNavigationRestrictions.push(...nonFilterableNavigationProperties);
         }
       }
     });
-    return nonSortableProperties;
-  };
+    return filterRestrictionsFromNavigationRestrictions;
+  }
 
   /**
-   * Gets all SortRestrictions and FilterRestriction of the main entity and the (first level) navigation restrictions.
-   * This does not work for more than one level of navigation.
-   * @param entitySet Entity set to be analyzed
-   * @returns Object containing all property names with restrictions separated by sortable and filterable capabilities
+   * Gets the filter restrictions directly from the entity set.
+   * @param entitySet Entity set to be analyzed.
+   * @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 properties.
    */
-  _exports.getNonSortablePropertiesRestrictions = getNonSortablePropertiesRestrictions;
-  const getRestrictionsOnProperties = function (entitySet) {
-    let propertiesRestrictions = {
-      nonSortableProperties: [],
-      nonFilterableProperties: []
-    };
-    // Check annotations for main entity
-    if (!isEntitySet(entitySet)) {
-      return propertiesRestrictions;
+  function getDirectFilterRestrictions(entitySet, targetEntitySet, parentNavigationPath) {
+    const filterRestrictionsOnEntitySet = [];
+    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 {
-      propertiesRestrictions = {
-        nonSortableProperties: getNonSortablePropertiesRestrictions(entitySet),
-        nonFilterableProperties: getNonFilterablePropertiesRestrictions(entitySet)
-      };
-      return propertiesRestrictions;
+      const nonFilterableProperties = [];
+      entitySet.annotations.Capabilities?.FilterRestrictions?.NonFilterableProperties?.forEach(property => {
+        if (parentNavigationPath && !property.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);
+        }
+      });
+      if (nonFilterableProperties?.length) {
+        filterRestrictionsOnEntitySet.push(...nonFilterableProperties);
+      }
     }
-  };
-  _exports.getRestrictionsOnProperties = getRestrictionsOnProperties;
+    return filterRestrictionsOnEntitySet;
+  }
   return _exports;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getNonFilterablePropertiesRestrictions","entitySet","nonFilterableProperties","annotations","Capabilities","FilterRestrictions","Filterable","push","entityType","entityProperties","map","property","name","NonFilterableProperties","value","NavigationRestrictions","RestrictedProperties","forEach","navigationRestriction","nonFilterableNavigationProperties","_exports","getNonSortablePropertiesRestrictions","nonSortableProperties","SortRestrictions","Sortable","NonSortableProperties","navigationProperty","navigationProperties","by_name","NavigationProperty","targetType","nonSortableNavigationProperties","getRestrictionsOnProperties","propertiesRestrictions","isEntitySet"],"sourceRoot":".","sources":["EntitySetHelper.ts"],"sourcesContent":["import type { EntitySet, Singleton } from \"@sap-ux/vocabularies-types\";\nimport { isEntitySet } from \"sap/fe/core/helpers/TypeGuards\";\n\nexport type RestrictionsOnProperties = {\n\tnonSortableProperties: string[];\n\tnonFilterableProperties: string[];\n};\n\ntype currentEntitySet = EntitySet | Singleton | undefined;\n\n/**\n * Gets NonFilterableProperties on FilterRestrictions of the main entity.\n * @param entitySet Entity set to be analyzed\n * @returns Array containing the property names of all non-filterable properties\n */\nexport const getNonFilterablePropertiesRestrictions = function (entitySet: EntitySet): string[] {\n\tlet nonFilterableProperties = [];\n\tif (entitySet.annotations.Capabilities?.FilterRestrictions?.Filterable === false) {\n\t\t// add all properties of the entity to the nonFilterableProperties\n\t\tnonFilterableProperties.push(...entitySet.entityType.entityProperties.map((property) => property.name));\n\t} else {\n\t\tnonFilterableProperties =\n\t\t\tentitySet.annotations.Capabilities?.FilterRestrictions?.NonFilterableProperties?.map((property) => property.value) || [];\n\t}\n\n\t// Check for every navigationRestriction if it has FilterRestrictions\n\tentitySet.annotations.Capabilities?.NavigationRestrictions?.RestrictedProperties?.forEach((navigationRestriction) => {\n\t\t// leave the property path unchanged (it is relative to the annotation target!)\n\t\tconst nonFilterableNavigationProperties = navigationRestriction?.FilterRestrictions?.NonFilterableProperties?.map(\n\t\t\t(property) => property.value\n\t\t);\n\t\tif (nonFilterableNavigationProperties) {\n\t\t\tnonFilterableProperties.push(...nonFilterableNavigationProperties);\n\t\t}\n\t});\n\treturn nonFilterableProperties;\n};\n\n/**\n * Reads all SortRestrictions of the main entity and the (first level) navigation restrictions.\n * This does not work for more than one level of navigation.\n * @param entitySet Entity set to be analyzed\n * @returns Array containing the property names of all non-sortable properties\n */\nexport const getNonSortablePropertiesRestrictions = function (entitySet: EntitySet): string[] {\n\tlet nonSortableProperties = [];\n\t// Check annotations for main entity\n\tif (entitySet.annotations.Capabilities?.SortRestrictions?.Sortable === false) {\n\t\t// add all properties of the entity to the nonSortableProperties\n\t\tnonSortableProperties.push(...entitySet.entityType.entityProperties.map((property) => property.name));\n\t} else {\n\t\tnonSortableProperties =\n\t\t\tentitySet.annotations.Capabilities?.SortRestrictions?.NonSortableProperties?.map((property) => property.value) || [];\n\t}\n\t// Check for every navigationRestriction if it has sortRestrictions\n\tentitySet.annotations.Capabilities?.NavigationRestrictions?.RestrictedProperties?.forEach((navigationRestriction) => {\n\t\tif (navigationRestriction?.SortRestrictions?.Sortable === false) {\n\t\t\t// find correct navigation property\n\t\t\tconst navigationProperty = entitySet.entityType.navigationProperties.by_name(navigationRestriction?.NavigationProperty?.value);\n\t\t\tif (navigationProperty) {\n\t\t\t\t// add all properties of the navigation property to the nonSortableProperties\n\t\t\t\tnonSortableProperties.push(\n\t\t\t\t\t...navigationProperty.targetType.entityProperties.map((property) => `${navigationProperty.name}/${property.name}`)\n\t\t\t\t);\n\t\t\t}\n\t\t} else {\n\t\t\t// leave the property path unchanged (it is relative to the annotation target!)\n\t\t\tconst nonSortableNavigationProperties = navigationRestriction?.SortRestrictions?.NonSortableProperties?.map(\n\t\t\t\t(property) => property.value\n\t\t\t);\n\t\t\tif (nonSortableNavigationProperties) {\n\t\t\t\tnonSortableProperties.push(...nonSortableNavigationProperties);\n\t\t\t}\n\t\t}\n\t});\n\treturn nonSortableProperties;\n};\n\n/**\n * Gets all SortRestrictions and FilterRestriction of the main entity and the (first level) navigation restrictions.\n * This does not work for more than one level of navigation.\n * @param entitySet Entity set to be analyzed\n * @returns Object containing all property names with restrictions separated by sortable and filterable capabilities\n */\n\nexport const getRestrictionsOnProperties = function (entitySet: currentEntitySet): RestrictionsOnProperties {\n\tlet propertiesRestrictions: RestrictionsOnProperties = { nonSortableProperties: [], nonFilterableProperties: [] };\n\t// Check annotations for main entity\n\tif (!isEntitySet(entitySet)) {\n\t\treturn propertiesRestrictions;\n\t} else {\n\t\tpropertiesRestrictions = {\n\t\t\tnonSortableProperties: getNonSortablePropertiesRestrictions(entitySet),\n\t\t\tnonFilterableProperties: getNonFilterablePropertiesRestrictions(entitySet)\n\t\t};\n\t\treturn propertiesRestrictions;\n\t}\n};\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getNonFilterablePropertiesRestrictions","entitySet","targetEntitySet","parentNavigationPath","filterRestrictionsFromNavigationRestrictions","getFilterRestrictionsfromNavigationRestrictions","directFilterRestrictions","getDirectFilterRestrictions","Array","from","Set","_exports","getNonSortablePropertiesRestrictions","sortRestrictionsFromNavigationRestrictions","getSortRestrictionsfromNavigationRestrictions","directSortRestrictions","getDirectSortRestrictions","getRestrictionsOnProperties","converterContext","propertiesRestrictions","nonSortableProperties","nonFilterableProperties","dataModelObjectPath","getDataModelObjectPath","parentEntitySet","getTargetEntitySetInfo","isEntitySet","length","undefined","annotations","Capabilities","NavigationRestrictions","RestrictedProperties","forEach","navigationRestriction","NavigationProperty","value","SortRestrictions","Sortable","navigationProperty","entityType","navigationProperties","by_name","push","targetType","entityProperties","map","property","name","nonSortableNavigationProperties","NonSortableProperties","$target","sortRestrictionsOnEntitySet","includes","FilterRestrictions","Filterable","nonFilterableNavigationProperties","NonFilterableProperties","filterRestrictionsOnEntitySet"],"sourceRoot":".","sources":["EntitySetHelper.ts"],"sourcesContent":["import type { EntitySet } from \"@sap-ux/vocabularies-types\";\nimport type ConverterContext from \"sap/fe/core/converters/ConverterContext\";\nimport { isEntitySet } from \"sap/fe/core/helpers/TypeGuards\";\nimport { getTargetEntitySetInfo } from \"./DataModelPathHelper\";\n\nexport type RestrictionsOnProperties = {\n\tnonSortableProperties: string[];\n\tnonFilterableProperties: string[];\n};\n\n/**\n * Reads all FilterRestrictions of the main entity and the navigation restrictions.\n * We get the restrictions first on the navigation property (most precise definition), and if not available, then we get the restrictions on the entitySet.\n * In case of containment, we only get the restrictions on the navigation property of the parent entitySet.\n * @param entitySet Entity set to be analyzed\n * @param targetEntitySet The target entity set, if available.  Not used in the case of containment.\n * @param parentNavigationPath The parent navigation path, specific for containment scenario to get the correct property based on the parent navigation path.\n * @returns Array containing the property names of all non-filterable properties\n */\nexport const getNonFilterablePropertiesRestrictions = function (\n\tentitySet: EntitySet,\n\ttargetEntitySet?: EntitySet,\n\tparentNavigationPath?: string\n): string[] {\n\tconst filterRestrictionsFromNavigationRestrictions = getFilterRestrictionsfromNavigationRestrictions(\n\t\tentitySet,\n\t\ttargetEntitySet,\n\t\tparentNavigationPath\n\t);\n\tconst directFilterRestrictions = getDirectFilterRestrictions(entitySet, targetEntitySet, parentNavigationPath);\n\t// Merge two filter restrictions found on the navigation property and directly from the entity set\n\treturn Array.from(new Set([...filterRestrictionsFromNavigationRestrictions, ...directFilterRestrictions]));\n};\n\n/**\n * Reads all SortRestrictions of the main entity and the navigation restrictions.\n * We retrieve the restrictions first on the navigation property (most precise definition), and if not available, then we get the restrictions on the entitySet\n * In case of containment, we only get the restrictions on the navigation property of the parent entitySet.\n * @param entitySet Entity set to be analyzed\n * @param targetEntitySet The target entity set, if available. Not used in the case of containment.\n * @param parentNavigationPath The parent navigation path, specific for containment scenario to get the correct property based on the parent navigation path.\n * @returns Array containing the property names of all non-sortable properties\n */\nexport const getNonSortablePropertiesRestrictions = function (\n\tentitySet: EntitySet,\n\ttargetEntitySet?: EntitySet,\n\tparentNavigationPath?: string\n): string[] {\n\tconst sortRestrictionsFromNavigationRestrictions = getSortRestrictionsfromNavigationRestrictions(\n\t\tentitySet,\n\t\ttargetEntitySet,\n\t\tparentNavigationPath\n\t);\n\tconst directSortRestrictions = getDirectSortRestrictions(entitySet, targetEntitySet, parentNavigationPath);\n\t// Merge two sort restrictions found on the navigation property and directly from the entity set\n\treturn Array.from(new Set([...sortRestrictionsFromNavigationRestrictions, ...directSortRestrictions]));\n};\n\n/**\n * Gets all SortRestrictions and FilterRestrictions for a given context.\n * @param converterContext The converter context.\n * @returns Object containing all property names of restrictions separated by sortable and filterable capabilities.\n */\nexport const getRestrictionsOnProperties = function (converterContext: ConverterContext): RestrictionsOnProperties {\n\tlet propertiesRestrictions: RestrictionsOnProperties = { nonSortableProperties: [], nonFilterableProperties: [] };\n\tconst dataModelObjectPath = converterContext.getDataModelObjectPath();\n\tconst { parentEntitySet, targetEntitySet, parentNavigationPath } = getTargetEntitySetInfo(dataModelObjectPath);\n\tif (isEntitySet(targetEntitySet)) {\n\t\tif (parentEntitySet && isEntitySet(parentEntitySet)) {\n\t\t\tpropertiesRestrictions = {\n\t\t\t\tnonSortableProperties: getNonSortablePropertiesRestrictions(parentEntitySet, targetEntitySet),\n\t\t\t\tnonFilterableProperties: getNonFilterablePropertiesRestrictions(parentEntitySet, targetEntitySet)\n\t\t\t};\n\t\t\tif (propertiesRestrictions.nonSortableProperties.length || propertiesRestrictions.nonFilterableProperties.length) {\n\t\t\t\treturn propertiesRestrictions;\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\tnonSortableProperties: getNonSortablePropertiesRestrictions(targetEntitySet),\n\t\t\tnonFilterableProperties: getNonFilterablePropertiesRestrictions(targetEntitySet)\n\t\t};\n\t} else if (parentEntitySet && isEntitySet(parentEntitySet)) {\n\t\t// Find the restrictions on the parent entity set, this applies also for containment as there isn't an entity set on the OP\n\t\treturn {\n\t\t\tnonSortableProperties: getNonSortablePropertiesRestrictions(parentEntitySet, undefined, parentNavigationPath),\n\t\t\tnonFilterableProperties: getNonFilterablePropertiesRestrictions(parentEntitySet, undefined, parentNavigationPath)\n\t\t};\n\t}\n\treturn propertiesRestrictions;\n};\n\n/**\n * Gets the sort restrictions from the navigation restrictions.\n * @param entitySet Entity set to be analyzed.\n * @param targetEntitySet The target entity set, if available. Not used in the case of containment.\n * @param parentNavigationPath The parent navigation path, specific for containment scenario to get the correct property based on the parent navigation path.\n * @returns Array containing the property names of all non-sortable properties from navigation restrictions.\n */\nfunction getSortRestrictionsfromNavigationRestrictions(\n\tentitySet: EntitySet,\n\ttargetEntitySet?: EntitySet,\n\tparentNavigationPath?: string\n): string[] {\n\tconst sortRestrictionsFromNavigationRestrictions: string[] = [];\n\tentitySet.annotations.Capabilities?.NavigationRestrictions?.RestrictedProperties?.forEach((navigationRestriction) => {\n\t\t// if containment enabled get only the sort restrictions of the related navigation path\n\t\tif (parentNavigationPath && parentNavigationPath !== navigationRestriction?.NavigationProperty?.value) {\n\t\t\treturn;\n\t\t}\n\t\tif (navigationRestriction?.SortRestrictions?.Sortable === false) {\n\t\t\t// find correct navigation property\n\t\t\tconst navigationProperty = entitySet.entityType.navigationProperties.by_name(navigationRestriction?.NavigationProperty?.value);\n\t\t\tif (navigationProperty) {\n\t\t\t\t// add all properties of the navigation property to the nonSortableProperties\n\t\t\t\tif (parentNavigationPath) {\n\t\t\t\t\tsortRestrictionsFromNavigationRestrictions.push(\n\t\t\t\t\t\t...navigationProperty.targetType.entityProperties.map((property) => property.name)\n\t\t\t\t\t);\n\t\t\t\t} else {\n\t\t\t\t\tsortRestrictionsFromNavigationRestrictions.push(\n\t\t\t\t\t\t...navigationProperty.targetType.entityProperties.map((property) => `${navigationProperty.name}/${property.name}`)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tconst nonSortableNavigationProperties = navigationRestriction?.SortRestrictions?.NonSortableProperties?.map((property) => {\n\t\t\t\t// We need the property name from the navigation restriction definition when the targetEntitySet is available\n\t\t\t\tif ((targetEntitySet || parentNavigationPath) && property.$target?.name) {\n\t\t\t\t\treturn property.$target?.name;\n\t\t\t\t} else {\n\t\t\t\t\t// leave the property path unchanged (it is relative to the annotation target!)\n\t\t\t\t\treturn property.value;\n\t\t\t\t}\n\t\t\t});\n\t\t\tif (nonSortableNavigationProperties?.length) {\n\t\t\t\tsortRestrictionsFromNavigationRestrictions.push(...nonSortableNavigationProperties);\n\t\t\t}\n\t\t}\n\t});\n\treturn sortRestrictionsFromNavigationRestrictions;\n}\n\n/**\n * Gets the sort restrictions directly from the entity set.\n * @param entitySet Entity set to be analyzed.\n * @param targetEntitySet The target entity set, if available. Not used in the case of containment.\n * @param parentNavigationPath The parent navigation path, specific for containment scenario to get the correct property based on the parent navigation path.\n * @returns Array containing the property names of all non-sortable properties.\n */\nfunction getDirectSortRestrictions(entitySet: EntitySet, targetEntitySet?: EntitySet, parentNavigationPath?: string): string[] {\n\tconst sortRestrictionsOnEntitySet: string[] = [];\n\tif (entitySet.annotations.Capabilities?.SortRestrictions?.Sortable === false) {\n\t\t// add all properties of the entity set to the nonSortableProperties\n\t\tsortRestrictionsOnEntitySet.push(...entitySet.entityType.entityProperties.map((property) => property.name));\n\t} else {\n\t\tconst nonSortableProperties: string[] = [];\n\t\tentitySet.annotations.Capabilities?.SortRestrictions?.NonSortableProperties?.forEach((property) => {\n\t\t\tif (parentNavigationPath && !property.value.includes(parentNavigationPath)) {\n\t\t\t\t// skip the non sortable property if it doesn't belong to the parent navigation path in case of containment\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif ((targetEntitySet || parentNavigationPath) && property.$target?.name) {\n\t\t\t\tnonSortableProperties.push(property.$target?.name);\n\t\t\t} else {\n\t\t\t\tnonSortableProperties.push(property.value);\n\t\t\t}\n\t\t});\n\t\tif (nonSortableProperties?.length) {\n\t\t\tsortRestrictionsOnEntitySet.push(...nonSortableProperties);\n\t\t}\n\t}\n\treturn sortRestrictionsOnEntitySet;\n}\n\n/**\n * Gets the filter restrictions from the navigation restrictions.\n * @param entitySet Entity set to be analyzed.\n * @param targetEntitySet The target entity set, if available. Not used in the case of containment.\n * @param parentNavigationPath The parent navigation path, specific for containment scenario to get the correct property based on the parent navigation path.\n * @returns Array containing the property names of all non-filterable properties from navigation restrictions.\n */\nfunction getFilterRestrictionsfromNavigationRestrictions(\n\tentitySet: EntitySet,\n\ttargetEntitySet?: EntitySet,\n\tparentNavigationPath?: string\n): string[] {\n\tconst filterRestrictionsFromNavigationRestrictions: string[] = [];\n\tentitySet.annotations.Capabilities?.NavigationRestrictions?.RestrictedProperties?.forEach((navigationRestriction) => {\n\t\t// if containment enabled get only the filter restrictions of the related navigation path\n\t\tif (parentNavigationPath && parentNavigationPath !== navigationRestriction?.NavigationProperty?.value) {\n\t\t\treturn;\n\t\t}\n\t\tif (navigationRestriction?.FilterRestrictions?.Filterable === false) {\n\t\t\t// find correct navigation property\n\t\t\tconst navigationProperty = entitySet.entityType.navigationProperties.by_name(navigationRestriction?.NavigationProperty?.value);\n\t\t\tif (navigationProperty) {\n\t\t\t\t// add all properties of the navigation property to the nonFilterableProperties\n\t\t\t\tif (parentNavigationPath) {\n\t\t\t\t\tfilterRestrictionsFromNavigationRestrictions.push(\n\t\t\t\t\t\t...navigationProperty.targetType.entityProperties.map((property) => property.name)\n\t\t\t\t\t);\n\t\t\t\t} else {\n\t\t\t\t\tfilterRestrictionsFromNavigationRestrictions.push(\n\t\t\t\t\t\t...navigationProperty.targetType.entityProperties.map((property) => `${navigationProperty.name}/${property.name}`)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tconst nonFilterableNavigationProperties = navigationRestriction?.FilterRestrictions?.NonFilterableProperties?.map(\n\t\t\t\t(property) => {\n\t\t\t\t\t// we need the property name from the navigation restriction definition when the targetEntitySet is available and it's not a containment scenario\n\t\t\t\t\tif ((targetEntitySet || parentNavigationPath) && property.$target?.name) {\n\t\t\t\t\t\treturn property.$target?.name;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// leave the property path unchanged (it is relative to the annotation target!)\n\t\t\t\t\t\treturn property.value;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t);\n\t\t\tif (nonFilterableNavigationProperties?.length) {\n\t\t\t\tfilterRestrictionsFromNavigationRestrictions.push(...nonFilterableNavigationProperties);\n\t\t\t}\n\t\t}\n\t});\n\treturn filterRestrictionsFromNavigationRestrictions;\n}\n\n/**\n * Gets the filter restrictions directly from the entity set.\n * @param entitySet Entity set to be analyzed.\n * @param targetEntitySet The target entity set, if available. Not used in the case of containment.\n * @param parentNavigationPath The parent navigation path, specific for containment scenario to get the correct property based on the parent navigation path.\n * @returns Array containing the property names of all non-filterable properties.\n */\nfunction getDirectFilterRestrictions(entitySet: EntitySet, targetEntitySet?: EntitySet, parentNavigationPath?: string): string[] {\n\tconst filterRestrictionsOnEntitySet: string[] = [];\n\tif (entitySet.annotations.Capabilities?.FilterRestrictions?.Filterable === false) {\n\t\t// add all properties of the entity set to the nonFilterableProperties\n\t\tfilterRestrictionsOnEntitySet.push(...entitySet.entityType.entityProperties.map((property) => property.name));\n\t} else {\n\t\tconst nonFilterableProperties: string[] = [];\n\t\tentitySet.annotations.Capabilities?.FilterRestrictions?.NonFilterableProperties?.forEach((property) => {\n\t\t\tif (parentNavigationPath && !property.value.includes(parentNavigationPath)) {\n\t\t\t\t// skip the non filterable property if it doesn't belong to the parent navigation path in case of containment\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif ((targetEntitySet || parentNavigationPath) && property.$target?.name) {\n\t\t\t\tnonFilterableProperties.push(property.$target?.name);\n\t\t\t} else {\n\t\t\t\tnonFilterableProperties.push(property.value);\n\t\t\t}\n\t\t});\n\t\tif (nonFilterableProperties?.length) {\n\t\t\tfilterRestrictionsOnEntitySet.push(...nonFilterableProperties);\n\t\t}\n\t}\n\treturn filterRestrictionsOnEntitySet;\n}\n"],"mappings":"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","ignoreList":[]}