@sap/open.fe 1.94.0

package/packages/sap.fe.core/src/sap/fe/core/templating/DataModelPathHelper.ts

@@ -0,0 +1,428 @@
+import { EntitySet, EntityType, NavigationProperty, Property } from "@sap-ux/annotation-converter";
+import { annotationExpression, constant, equal, Expression } from "sap/fe/core/helpers/BindingExpression";
+import { NavigationPropertyRestrictionTypes } from "@sap-ux/vocabularies-types/dist/generated/Capabilities";
+import { PropertyOrPath } from "sap/fe/core/templating/UIFormatters";
+import { isAnnotationPathExpression, isPathExpression } from "sap/fe/core/templating/PropertyHelper";
+import {
+	FilterExpressionRestrictionTypeTypes,
+	NavigationPropertyRestriction
+} from "@sap-ux/vocabularies-types/types/generated/Capabilities";
+import {
+	EntitySetAnnotations_Capabilities,
+	EntityTypeAnnotations_Capabilities
+} from "@sap-ux/vocabularies-types/dist/generated/Capabilities_Edm";
+import { PropertyPath } from "@sap-ux/vocabularies-types";
+
+export type DataModelObjectPath = {
+	startingEntitySet: EntitySet;
+	contextLocation?: DataModelObjectPath;
+	navigationProperties: NavigationProperty[];
+	targetEntitySet?: EntitySet;
+	targetEntityType: EntityType;
+	targetObject: any;
+};
+
+export const getPathRelativeLocation = function(
+	contextPath?: DataModelObjectPath,
+	visitedNavProps: NavigationProperty[] = []
+): NavigationProperty[] {
+	if (!contextPath) {
+		return visitedNavProps;
+	} else {
+		if (visitedNavProps.length >= contextPath.navigationProperties.length) {
+			let remainingNavProps: NavigationProperty[] = [];
+			contextPath.navigationProperties.forEach((navProp, navIndex) => {
+				if (visitedNavProps[navIndex] !== navProp) {
+					remainingNavProps.push(visitedNavProps[navIndex]);
+				}
+			});
+			remainingNavProps = remainingNavProps.concat(visitedNavProps.slice(contextPath.navigationProperties.length));
+			// Clean up NavProp -> Owner
+			let currentIdx = 0;
+			while (remainingNavProps.length > 1 && currentIdx != remainingNavProps.length - 1) {
+				const currentNav = remainingNavProps[currentIdx];
+				const nextNavProp = remainingNavProps[currentIdx + 1];
+				if (currentNav.partner === nextNavProp.name) {
+					remainingNavProps.splice(0, 2);
+				} else {
+					currentIdx++;
+				}
+			}
+			return remainingNavProps;
+		} else {
+			let extraNavProp: NavigationProperty[] = [];
+			visitedNavProps.forEach((navProp, navIndex) => {
+				if (contextPath.navigationProperties[navIndex] !== navProp) {
+					extraNavProp.push(visitedNavProps[navIndex]);
+				}
+			});
+			extraNavProp = extraNavProp.concat(contextPath.navigationProperties.slice(visitedNavProps.length));
+			// Clean up NavProp -> Owner
+			let currentIdx = 0;
+			while (extraNavProp.length > 1 && currentIdx != extraNavProp.length - 1) {
+				const currentNav = extraNavProp[currentIdx];
+				const nextNavProp = extraNavProp[currentIdx + 1];
+				if (currentNav.partner === nextNavProp.name) {
+					extraNavProp.splice(0, 2);
+				} else {
+					currentIdx++;
+				}
+			}
+			extraNavProp = extraNavProp.map(navProp => {
+				return navProp.targetType.navigationProperties.find(np => np.name === navProp.partner) as NavigationProperty;
+			});
+			return extraNavProp;
+		}
+	}
+};
+
+export const enhanceDataModelPath = function(
+	dataModelObjectPath: DataModelObjectPath,
+	propertyPath?: PropertyOrPath<Property>
+): DataModelObjectPath {
+	let sPropertyPath: string = "";
+	if ((isPathExpression(propertyPath) || isAnnotationPathExpression(propertyPath)) && propertyPath.path) {
+		sPropertyPath = propertyPath.path;
+	} else if (typeof propertyPath === "string") {
+		sPropertyPath = propertyPath as string;
+	}
+	let oTarget;
+	if (isPathExpression(propertyPath) || isAnnotationPathExpression(propertyPath)) {
+		oTarget = propertyPath.$target;
+	} else if (dataModelObjectPath.targetEntityType) {
+		oTarget = dataModelObjectPath.targetEntityType.resolvePath(sPropertyPath);
+	} else {
+		oTarget = dataModelObjectPath.targetObject;
+	}
+	const aPathSplit = sPropertyPath.split("/");
+	let currentEntitySet = dataModelObjectPath.targetEntitySet;
+	let currentEntityType = dataModelObjectPath.targetEntityType;
+	const navigationProperties = dataModelObjectPath.navigationProperties.concat();
+	// Process only if we have to go through navigation properties
+
+	aPathSplit.reduce((reducedEntityType: EntityType | undefined, pathPart: string) => {
+		if (!reducedEntityType) {
+			return undefined;
+		}
+		const potentialNavProp = reducedEntityType.navigationProperties.find(navProp => navProp.name === pathPart);
+		if (potentialNavProp) {
+			navigationProperties.push(potentialNavProp);
+			currentEntityType = potentialNavProp.targetType;
+			if (currentEntitySet && currentEntitySet.navigationPropertyBinding.hasOwnProperty(pathPart)) {
+				currentEntitySet = currentEntitySet.navigationPropertyBinding[pathPart];
+			}
+			return currentEntityType;
+		}
+		return undefined;
+	}, dataModelObjectPath.targetEntityType);
+
+	return {
+		startingEntitySet: dataModelObjectPath.startingEntitySet,
+		navigationProperties: navigationProperties,
+		contextLocation: dataModelObjectPath.contextLocation,
+		targetEntitySet: currentEntitySet,
+		targetEntityType: currentEntityType,
+		targetObject: oTarget
+	};
+};
+
+export const getTargetEntitySetPath = function(dataModelObjectPath: DataModelObjectPath, bRelative: boolean = false): string {
+	let targetEntitySetPath: string = "";
+	if (!bRelative) {
+		targetEntitySetPath += `/${dataModelObjectPath.startingEntitySet.name}`;
+	}
+	let currentEntitySet = dataModelObjectPath.startingEntitySet;
+	let navigatedPaths: string[] = [];
+	dataModelObjectPath.navigationProperties.forEach(navProp => {
+		navigatedPaths.push(navProp.name);
+		if (currentEntitySet && currentEntitySet.navigationPropertyBinding.hasOwnProperty(navigatedPaths.join("/"))) {
+			if (bRelative) {
+				targetEntitySetPath += `${navigatedPaths.join("/")}`;
+			} else {
+				targetEntitySetPath += `/$NavigationPropertyBinding/${navigatedPaths.join("/")}/$`;
+			}
+			currentEntitySet = currentEntitySet.navigationPropertyBinding[navigatedPaths.join("/")];
+			navigatedPaths = [];
+		}
+	});
+	return targetEntitySetPath;
+};
+
+export const getTargetEntitySetNavigation = function(dataModelObjectPath: DataModelObjectPath): NavigationProperty[] {
+	const visitedNavigationProperties: NavigationProperty[] = [];
+	let currentEntitySet = dataModelObjectPath.startingEntitySet;
+	let navigatedPaths: string[] = [];
+	dataModelObjectPath.navigationProperties.forEach(navProp => {
+		navigatedPaths.push(navProp.name);
+		if (currentEntitySet && currentEntitySet.navigationPropertyBinding.hasOwnProperty(navigatedPaths.join("/"))) {
+			visitedNavigationProperties.push(navProp);
+			currentEntitySet = currentEntitySet.navigationPropertyBinding[navigatedPaths.join("/")];
+			navigatedPaths = [];
+		}
+	});
+	return visitedNavigationProperties;
+};
+
+export const getTargetObjectPath = function(dataModelObjectPath: DataModelObjectPath, bRelative: boolean = false): string {
+	let path = "";
+	if (!dataModelObjectPath.startingEntitySet) {
+		return "/";
+	}
+	if (!bRelative) {
+		path += `/${dataModelObjectPath.startingEntitySet.name}`;
+	}
+	if (dataModelObjectPath.navigationProperties.length > 0) {
+		if (path.length > 0) {
+			path += "/";
+		}
+		path += dataModelObjectPath.navigationProperties.map(navProp => navProp.name).join("/");
+	}
+
+	if (
+		dataModelObjectPath.targetObject &&
+		dataModelObjectPath.targetObject.name &&
+		dataModelObjectPath.targetObject._type !== "NavigationProperty" &&
+		dataModelObjectPath.targetObject._type !== "EntityType" &&
+		dataModelObjectPath.targetObject !== dataModelObjectPath.startingEntitySet
+	) {
+		if (!path.endsWith("/")) {
+			path += "/";
+		}
+		path += `${dataModelObjectPath.targetObject.name}`;
+	} else if (dataModelObjectPath.targetObject && dataModelObjectPath.targetObject.hasOwnProperty("term")) {
+		if (path.length > 0 && !path.endsWith("/")) {
+			path += "/";
+		}
+		path += `@${dataModelObjectPath.targetObject.term}`;
+	}
+	return path;
+};
+
+export const getContextRelativeTargetObjectPath = function(
+	dataModelObjectPath: DataModelObjectPath,
+	forBindingExpression: boolean = false
+): string | undefined {
+	const navProperties = getPathRelativeLocation(dataModelObjectPath.contextLocation, dataModelObjectPath.navigationProperties);
+	if (forBindingExpression) {
+		if (navProperties.find(np => np.isCollection)) {
+			return undefined;
+		}
+	}
+	let path = navProperties.map(np => np.name).join("/");
+	if (
+		dataModelObjectPath.targetObject &&
+		(dataModelObjectPath.targetObject.name ||
+			(dataModelObjectPath.targetObject.type === "PropertyPath" && dataModelObjectPath.targetObject.value)) &&
+		dataModelObjectPath.targetObject._type !== "NavigationProperty" &&
+		dataModelObjectPath.targetObject !== dataModelObjectPath.startingEntitySet
+	) {
+		if (path.length > 0 && !path.endsWith("/")) {
+			path += "/";
+		}
+		path +=
+			dataModelObjectPath.targetObject.type === "PropertyPath"
+				? `${dataModelObjectPath.targetObject.value}`
+				: `${dataModelObjectPath.targetObject.name}`;
+	} else if (dataModelObjectPath.targetObject && dataModelObjectPath.targetObject.hasOwnProperty("term")) {
+		if (path.length > 0 && !path.endsWith("/")) {
+			path += "/";
+		}
+		path += `@${dataModelObjectPath.targetObject.term}`;
+		if (dataModelObjectPath.targetObject.hasOwnProperty("qualifier") && !!dataModelObjectPath.targetObject.qualifier) {
+			path += `#${dataModelObjectPath.targetObject.qualifier}`;
+		}
+	} else if (!dataModelObjectPath.targetObject) {
+		return undefined;
+	}
+	return path;
+};
+
+export const isPathUpdatable = function(
+	dataModelObjectPath: DataModelObjectPath | undefined,
+	propertyPath?: PropertyOrPath<Property>,
+	bTableCase?: boolean
+): Expression<boolean> {
+	return checkOnPath(
+		dataModelObjectPath,
+		(annotationObject: NavigationPropertyRestriction | EntitySetAnnotations_Capabilities | EntityTypeAnnotations_Capabilities) => {
+			return annotationObject?.UpdateRestrictions?.Updatable;
+		},
+		propertyPath,
+		bTableCase
+	);
+};
+
+export const isPathSearchable = function(
+	dataModelObjectPath: DataModelObjectPath | undefined,
+	propertyPath?: PropertyOrPath<Property>,
+	bTableCase?: boolean
+): Expression<boolean> {
+	return checkOnPath(
+		dataModelObjectPath,
+		(annotationObject: NavigationPropertyRestriction | EntitySetAnnotations_Capabilities) => {
+			return annotationObject?.SearchRestrictions?.Searchable;
+		},
+		propertyPath,
+		bTableCase
+	);
+};
+
+export const isPathDeletable = function(
+	dataModelObjectPath: DataModelObjectPath | undefined,
+	propertyPath?: PropertyOrPath<Property>,
+	bTableCase?: boolean
+): Expression<boolean> {
+	return checkOnPath(
+		dataModelObjectPath,
+		(annotationObject: NavigationPropertyRestriction | EntitySetAnnotations_Capabilities | EntityTypeAnnotations_Capabilities) => {
+			return annotationObject?.DeleteRestrictions?.Deletable;
+		},
+		propertyPath,
+		bTableCase
+	);
+};
+
+export const isPathInsertable = function(
+	dataModelObjectPath: DataModelObjectPath | undefined,
+	propertyPath?: PropertyOrPath<Property>
+): Expression<boolean> {
+	return checkOnPath(
+		dataModelObjectPath,
+		(annotationObject: NavigationPropertyRestriction | EntitySetAnnotations_Capabilities | EntityTypeAnnotations_Capabilities) => {
+			return annotationObject?.InsertRestrictions?.Insertable;
+		},
+		propertyPath
+	);
+};
+
+export const checkFilterExpressionRestrictions = function(
+	dataModelObjectPath: DataModelObjectPath,
+	allowedExpression: (string | undefined)[]
+): Expression<boolean> {
+	return checkOnPath(
+		dataModelObjectPath,
+		(annotationObject: NavigationPropertyRestriction | EntitySetAnnotations_Capabilities | EntityTypeAnnotations_Capabilities) => {
+			if (annotationObject && "FilterRestrictions" in annotationObject) {
+				const filterExpressionRestrictions: FilterExpressionRestrictionTypeTypes[] =
+					(annotationObject?.FilterRestrictions?.FilterExpressionRestrictions as FilterExpressionRestrictionTypeTypes[]) || [];
+				const currentObjectRestriction = filterExpressionRestrictions.find(restriction => {
+					return (restriction.Property as PropertyPath).$target === dataModelObjectPath.targetObject;
+				});
+				if (currentObjectRestriction) {
+					return allowedExpression.indexOf(currentObjectRestriction?.AllowedExpressions?.toString()) !== -1;
+				} else {
+					return false;
+				}
+			} else {
+				return false;
+			}
+		}
+	);
+};
+
+export const checkOnPath = function(
+	dataModelObjectPath: DataModelObjectPath | undefined,
+	checkFunction: Function,
+	propertyPath?: PropertyOrPath<Property>,
+	bTableCase?: boolean
+): Expression<boolean> {
+	if (!dataModelObjectPath || !dataModelObjectPath.startingEntitySet) {
+		return constant(true);
+	}
+	dataModelObjectPath = enhanceDataModelPath(dataModelObjectPath, propertyPath);
+
+	let currentEntitySet: EntitySet | null = dataModelObjectPath.startingEntitySet;
+	let parentEntitySet: EntitySet | null = null;
+	let visitedNavigationPropsName: string[] = [];
+	const allVisitedNavigationProps: NavigationProperty[] = [];
+	let targetEntitySet: EntitySet | null = currentEntitySet;
+	const targetEntityType: EntityType | null = dataModelObjectPath.targetEntityType;
+	let resetVisitedNavProps = false;
+
+	dataModelObjectPath.navigationProperties.forEach((navigationProperty: NavigationProperty) => {
+		if (resetVisitedNavProps) {
+			visitedNavigationPropsName = [];
+		}
+		visitedNavigationPropsName.push(navigationProperty.name);
+		allVisitedNavigationProps.push(navigationProperty);
+		if (!navigationProperty.containsTarget) {
+			// We should have a navigationPropertyBinding associated with the path so far which can consist of ([ContainmentNavProp]/)*[NavProp]
+			const fullNavigationPath = visitedNavigationPropsName.join("/");
+			if (currentEntitySet && currentEntitySet.navigationPropertyBinding.hasOwnProperty(fullNavigationPath)) {
+				parentEntitySet = currentEntitySet;
+				currentEntitySet = currentEntitySet.navigationPropertyBinding[fullNavigationPath];
+				targetEntitySet = currentEntitySet;
+				// If we reached a navigation property with a navigationpropertybinding, we need to reset the visited path on the next iteration (if there is one)
+				resetVisitedNavProps = true;
+			} else {
+				// We really should not end up here but at least let's try to avoid incorrect behavior
+				parentEntitySet = currentEntitySet;
+				currentEntitySet = null;
+				resetVisitedNavProps = true;
+			}
+		} else {
+			parentEntitySet = currentEntitySet;
+			targetEntitySet = null;
+		}
+	});
+
+	// At this point we have navigated down all the nav prop and we should have
+	// The target entityset pointing to either null (in case of containment navprop a last part), or the actual target (non containment as target)
+	// The parent entitySet pointing to the previous entityset used in the path
+	// VisitedNavigationPath should contain the path up to this property
+
+	// Restrictions should then be evaluated as ParentEntitySet.NavRestrictions[NavpropertyPath] || TargetEntitySet.Restrictions
+	const fullNavigationPath = visitedNavigationPropsName.join("/");
+	let restrictions, visitedNavProps;
+	if (parentEntitySet !== null) {
+		const _parentEntitySet: EntitySet = parentEntitySet;
+		_parentEntitySet.annotations?.Capabilities?.NavigationRestrictions?.RestrictedProperties.forEach(
+			(restrictedNavProp: NavigationPropertyRestrictionTypes) => {
+				if (restrictedNavProp.NavigationProperty?.type === "NavigationPropertyPath") {
+					const restrictionDefinition = checkFunction(restrictedNavProp);
+					if (fullNavigationPath === restrictedNavProp.NavigationProperty.value && restrictionDefinition !== undefined) {
+						const _allVisitedNavigationProps = allVisitedNavigationProps.slice(0, -1);
+						if (targetEntitySet !== null) {
+							visitedNavProps = _allVisitedNavigationProps;
+						} else {
+							if (_allVisitedNavigationProps.length === 0) {
+								visitedNavProps = allVisitedNavigationProps.slice(0);
+							} else {
+								visitedNavProps = _allVisitedNavigationProps;
+							}
+						}
+						restrictions = equal(
+							annotationExpression(
+								restrictionDefinition,
+								getPathRelativeLocation(dataModelObjectPath?.contextLocation, visitedNavProps).map(np => np.name)
+							),
+							true
+						);
+					}
+				}
+			}
+		);
+	}
+	let targetRestrictions;
+	let restrictionDefinition = checkFunction(targetEntitySet?.annotations?.Capabilities);
+	if (targetEntitySet === null && restrictionDefinition === undefined) {
+		restrictionDefinition = checkFunction(targetEntityType?.annotations?.Capabilities);
+	}
+	if (restrictionDefinition !== undefined) {
+		targetRestrictions = equal(
+			annotationExpression(
+				restrictionDefinition,
+				getPathRelativeLocation(dataModelObjectPath.contextLocation, allVisitedNavigationProps).map(np => np.name)
+			),
+			true
+		);
+	}
+	//object page table case in path based scenario's fallback to exisiting approach
+	if (bTableCase && !restrictions && restrictionDefinition?.path) {
+		const oResult: any = {
+			"currentEntityRestriction": targetRestrictions
+		};
+		return oResult;
+	}
+	return restrictions || targetRestrictions || constant(true);
+};

package/packages/sap.fe.core/src/sap/fe/core/templating/EntitySetHelper-dbg.js

@@ -0,0 +1,33 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define([], function () {
+  "use strict";
+
+  var _exports = {};
+
+  var isEntitySet = function (dataObject) {
+    return dataObject && dataObject.hasOwnProperty("_type") && dataObject._type === "EntitySet";
+  };
+
+  _exports.isEntitySet = isEntitySet;
+
+  var getFilterExpressionRestrictions = function (entitySet) {
+    var _entitySet$annotation, _entitySet$annotation2, _entitySet$annotation3;
+
+    return ((_entitySet$annotation = entitySet.annotations) === null || _entitySet$annotation === void 0 ? void 0 : (_entitySet$annotation2 = _entitySet$annotation.Capabilities) === null || _entitySet$annotation2 === void 0 ? void 0 : (_entitySet$annotation3 = _entitySet$annotation2.FilterRestrictions) === null || _entitySet$annotation3 === void 0 ? void 0 : _entitySet$annotation3.FilterExpressionRestrictions) || [];
+  };
+
+  _exports.getFilterExpressionRestrictions = getFilterExpressionRestrictions;
+
+  var isStickySessionSupported = function (entitySet) {
+    var _entitySet$annotation4;
+
+    return !!((_entitySet$annotation4 = entitySet.annotations.Session) !== null && _entitySet$annotation4 !== void 0 && _entitySet$annotation4.StickySessionSupported);
+  };
+
+  _exports.isStickySessionSupported = isStickySessionSupported;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIkVudGl0eVNldEhlbHBlci50cyJdLCJuYW1lcyI6WyJpc0VudGl0eVNldCIsImRhdGFPYmplY3QiLCJoYXNPd25Qcm9wZXJ0eSIsIl90eXBlIiwiZ2V0RmlsdGVyRXhwcmVzc2lvblJlc3RyaWN0aW9ucyIsImVudGl0eVNldCIsImFubm90YXRpb25zIiwiQ2FwYWJpbGl0aWVzIiwiRmlsdGVyUmVzdHJpY3Rpb25zIiwiRmlsdGVyRXhwcmVzc2lvblJlc3RyaWN0aW9ucyIsImlzU3RpY2t5U2Vzc2lvblN1cHBvcnRlZCIsIlNlc3Npb24iLCJTdGlja3lTZXNzaW9uU3VwcG9ydGVkIl0sIm1hcHBpbmdzIjoiO0FBQUE7QUFDQTtBQUNBOzs7Ozs7QUFBTyxNQUFNQSxXQUFXLEdBQUcsVUFBU0MsVUFBVCxFQUFtRDtBQUM3RSxXQUFPQSxVQUFVLElBQUlBLFVBQVUsQ0FBQ0MsY0FBWCxDQUEwQixPQUExQixDQUFkLElBQW9ERCxVQUFVLENBQUNFLEtBQVgsS0FBcUIsV0FBaEY7QUFDQSxHQUZNOzs7O0FBSUEsTUFBTUMsK0JBQStCLEdBQUcsVUFBU0MsU0FBVCxFQUErQjtBQUFBOztBQUM3RSxXQUFPLDBCQUFBQSxTQUFTLENBQUNDLFdBQVYsMEdBQXVCQyxZQUF2Qiw0R0FBcUNDLGtCQUFyQyxrRkFBeURDLDRCQUF6RCxLQUF5RixFQUFoRztBQUNBLEdBRk07Ozs7QUFJQSxNQUFNQyx3QkFBd0IsR0FBRyxVQUFTTCxTQUFULEVBQXdDO0FBQUE7O0FBQy9FLFdBQU8sQ0FBQyw0QkFBQ0EsU0FBUyxDQUFDQyxXQUFWLENBQXNCSyxPQUF2QixtREFBQyx1QkFBK0JDLHNCQUFoQyxDQUFSO0FBQ0EsR0FGTSIsInNvdXJjZVJvb3QiOiIuIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRW50aXR5U2V0IH0gZnJvbSBcIkBzYXAtdXgvYW5ub3RhdGlvbi1jb252ZXJ0ZXJcIjtcblxuZXhwb3J0IGNvbnN0IGlzRW50aXR5U2V0ID0gZnVuY3Rpb24oZGF0YU9iamVjdDogYW55KTogZGF0YU9iamVjdCBpcyBFbnRpdHlTZXQge1xuXHRyZXR1cm4gZGF0YU9iamVjdCAmJiBkYXRhT2JqZWN0Lmhhc093blByb3BlcnR5KFwiX3R5cGVcIikgJiYgZGF0YU9iamVjdC5fdHlwZSA9PT0gXCJFbnRpdHlTZXRcIjtcbn07XG5cbmV4cG9ydCBjb25zdCBnZXRGaWx0ZXJFeHByZXNzaW9uUmVzdHJpY3Rpb25zID0gZnVuY3Rpb24oZW50aXR5U2V0OiBFbnRpdHlTZXQpIHtcblx0cmV0dXJuIGVudGl0eVNldC5hbm5vdGF0aW9ucz8uQ2FwYWJpbGl0aWVzPy5GaWx0ZXJSZXN0cmljdGlvbnM/LkZpbHRlckV4cHJlc3Npb25SZXN0cmljdGlvbnMgfHwgW107XG59O1xuXG5leHBvcnQgY29uc3QgaXNTdGlja3lTZXNzaW9uU3VwcG9ydGVkID0gZnVuY3Rpb24oZW50aXR5U2V0OiBFbnRpdHlTZXQpOiBib29sZWFuIHtcblx0cmV0dXJuICEhZW50aXR5U2V0LmFubm90YXRpb25zLlNlc3Npb24/LlN0aWNreVNlc3Npb25TdXBwb3J0ZWQ7XG59O1xuIl19

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

@@ -0,0 +1,5 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define([],function(){"use strict";var _={};var i=function(d){return d&&d.hasOwnProperty("_type")&&d._type==="EntitySet";};_.isEntitySet=i;var g=function(e){var b,c,d;return((b=e.annotations)===null||b===void 0?void 0:(c=b.Capabilities)===null||c===void 0?void 0:(d=c.FilterRestrictions)===null||d===void 0?void 0:d.FilterExpressionRestrictions)||[];};_.getFilterExpressionRestrictions=g;var a=function(e){var b;return!!((b=e.annotations.Session)!==null&&b!==void 0&&b.StickySessionSupported);};_.isStickySessionSupported=a;return _;},false);

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

@@ -0,0 +1,13 @@
+import { EntitySet } from "@sap-ux/annotation-converter";
+
+export const isEntitySet = function(dataObject: any): dataObject is EntitySet {
+	return dataObject && dataObject.hasOwnProperty("_type") && dataObject._type === "EntitySet";
+};
+
+export const getFilterExpressionRestrictions = function(entitySet: EntitySet) {
+	return entitySet.annotations?.Capabilities?.FilterRestrictions?.FilterExpressionRestrictions || [];
+};
+
+export const isStickySessionSupported = function(entitySet: EntitySet): boolean {
+	return !!entitySet.annotations.Session?.StickySessionSupported;
+};

package/packages/sap.fe.core/src/sap/fe/core/templating/FieldControlHelper-dbg.js

@@ -0,0 +1,89 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/helpers/BindingExpression"], function (BindingExpression) {
+  "use strict";
+
+  var _exports = {};
+  var annotationExpression = BindingExpression.annotationExpression;
+  var or = BindingExpression.or;
+  var equal = BindingExpression.equal;
+
+  /**
+   * Create the binding expression to check if the property is non editable or not.
+   *
+   * @param {object} oTarget The target property or DataField
+   * @returns {ExpressionOrPrimitive<boolean>} The binding expression resolving to a boolean being true if it's non editable
+   */
+  var isNonEditableExpression = function (oTarget) {
+    return or(isReadOnlyExpression(oTarget), isDisabledExpression(oTarget));
+  };
+  /**
+   * Create the binding expression to check if the property is read only or not.
+   *
+   * @param {object} oTarget The target property or DataField
+   * @returns {ExpressionOrPrimitive<boolean>} The binding expression resolving to a boolean being true if it's read only
+   */
+
+
+  _exports.isNonEditableExpression = isNonEditableExpression;
+
+  var isReadOnlyExpression = function (oTarget) {
+    var _oTarget$annotations, _oTarget$annotations$, _oTarget$annotations$2;
+
+    var oFieldControlValue = oTarget === null || oTarget === void 0 ? void 0 : (_oTarget$annotations = oTarget.annotations) === null || _oTarget$annotations === void 0 ? void 0 : (_oTarget$annotations$ = _oTarget$annotations.Common) === null || _oTarget$annotations$ === void 0 ? void 0 : (_oTarget$annotations$2 = _oTarget$annotations$.FieldControl) === null || _oTarget$annotations$2 === void 0 ? void 0 : _oTarget$annotations$2.valueOf();
+
+    if (typeof oFieldControlValue === "object") {
+      return !!oFieldControlValue && equal(annotationExpression(oFieldControlValue), 1);
+    }
+
+    return oFieldControlValue === "Common.FieldControlType/ReadOnly";
+  };
+  /**
+   * Create the binding expression to check if the property is disabled or not.
+   *
+   * @param {object} oTarget The target property or DataField
+   * @returns {ExpressionOrPrimitive<boolean>} The binding expression resolving to a boolean being true if it's disabled
+   */
+
+
+  _exports.isReadOnlyExpression = isReadOnlyExpression;
+
+  var isDisabledExpression = function (oTarget) {
+    var _oTarget$annotations2, _oTarget$annotations3, _oTarget$annotations4;
+
+    var oFieldControlValue = oTarget === null || oTarget === void 0 ? void 0 : (_oTarget$annotations2 = oTarget.annotations) === null || _oTarget$annotations2 === void 0 ? void 0 : (_oTarget$annotations3 = _oTarget$annotations2.Common) === null || _oTarget$annotations3 === void 0 ? void 0 : (_oTarget$annotations4 = _oTarget$annotations3.FieldControl) === null || _oTarget$annotations4 === void 0 ? void 0 : _oTarget$annotations4.valueOf();
+
+    if (typeof oFieldControlValue === "object") {
+      return !!oFieldControlValue && equal(annotationExpression(oFieldControlValue), 0);
+    }
+
+    return oFieldControlValue === "Common.FieldControlType/Inapplicable";
+  };
+  /**
+   * Create the binding expression to check if the property is read only or not.
+   *
+   * @param {object} oTarget The target property or DataField
+   * @returns {ExpressionOrPrimitive<boolean>} The binding expression resolving to a boolean being true if it's read only
+   */
+
+
+  _exports.isDisabledExpression = isDisabledExpression;
+
+  var isRequiredExpression = function (oTarget) {
+    var _oTarget$annotations5, _oTarget$annotations6, _oTarget$annotations7;
+
+    var oFieldControlValue = oTarget === null || oTarget === void 0 ? void 0 : (_oTarget$annotations5 = oTarget.annotations) === null || _oTarget$annotations5 === void 0 ? void 0 : (_oTarget$annotations6 = _oTarget$annotations5.Common) === null || _oTarget$annotations6 === void 0 ? void 0 : (_oTarget$annotations7 = _oTarget$annotations6.FieldControl) === null || _oTarget$annotations7 === void 0 ? void 0 : _oTarget$annotations7.valueOf();
+
+    if (typeof oFieldControlValue === "object") {
+      return !!oFieldControlValue && equal(annotationExpression(oFieldControlValue), 7);
+    }
+
+    return oFieldControlValue === "Common.FieldControlType/Mandatory";
+  };
+
+  _exports.isRequiredExpression = isRequiredExpression;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/packages/sap.fe.core/src/sap/fe/core/templating/FieldControlHelper.js

@@ -0,0 +1,5 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/helpers/BindingExpression"],function(B){"use strict";var _={};var a=B.annotationExpression;var o=B.or;var e=B.equal;var i=function(t){return o(b(t),c(t));};_.isNonEditableExpression=i;var b=function(t){var f,g,h;var F=t===null||t===void 0?void 0:(f=t.annotations)===null||f===void 0?void 0:(g=f.Common)===null||g===void 0?void 0:(h=g.FieldControl)===null||h===void 0?void 0:h.valueOf();if(typeof F==="object"){return!!F&&e(a(F),1);}return F==="Common.FieldControlType/ReadOnly";};_.isReadOnlyExpression=b;var c=function(t){var f,g,h;var F=t===null||t===void 0?void 0:(f=t.annotations)===null||f===void 0?void 0:(g=f.Common)===null||g===void 0?void 0:(h=g.FieldControl)===null||h===void 0?void 0:h.valueOf();if(typeof F==="object"){return!!F&&e(a(F),0);}return F==="Common.FieldControlType/Inapplicable";};_.isDisabledExpression=c;var d=function(t){var f,g,h;var F=t===null||t===void 0?void 0:(f=t.annotations)===null||f===void 0?void 0:(g=f.Common)===null||g===void 0?void 0:(h=g.FieldControl)===null||h===void 0?void 0:h.valueOf();if(typeof F==="object"){return!!F&&e(a(F),7);}return F==="Common.FieldControlType/Mandatory";};_.isRequiredExpression=d;return _;},false);

package/packages/sap.fe.core/src/sap/fe/core/templating/FieldControlHelper.ts

@@ -0,0 +1,53 @@
+import { equal, Expression, ExpressionOrPrimitive, or, annotationExpression } from "sap/fe/core/helpers/BindingExpression";
+
+/**
+ * Create the binding expression to check if the property is non editable or not.
+ *
+ * @param {object} oTarget The target property or DataField
+ * @returns {ExpressionOrPrimitive<boolean>} The binding expression resolving to a boolean being true if it's non editable
+ */
+export const isNonEditableExpression = function(oTarget: any): Expression<boolean> {
+	return or(isReadOnlyExpression(oTarget), isDisabledExpression(oTarget));
+};
+
+/**
+ * Create the binding expression to check if the property is read only or not.
+ *
+ * @param {object} oTarget The target property or DataField
+ * @returns {ExpressionOrPrimitive<boolean>} The binding expression resolving to a boolean being true if it's read only
+ */
+export const isReadOnlyExpression = function(oTarget: any): ExpressionOrPrimitive<boolean> {
+	const oFieldControlValue = oTarget?.annotations?.Common?.FieldControl?.valueOf();
+	if (typeof oFieldControlValue === "object") {
+		return !!oFieldControlValue && equal(annotationExpression(oFieldControlValue) as ExpressionOrPrimitive<number>, 1);
+	}
+	return oFieldControlValue === "Common.FieldControlType/ReadOnly";
+};
+
+/**
+ * Create the binding expression to check if the property is disabled or not.
+ *
+ * @param {object} oTarget The target property or DataField
+ * @returns {ExpressionOrPrimitive<boolean>} The binding expression resolving to a boolean being true if it's disabled
+ */
+export const isDisabledExpression = function(oTarget: any): ExpressionOrPrimitive<boolean> {
+	const oFieldControlValue = oTarget?.annotations?.Common?.FieldControl?.valueOf();
+	if (typeof oFieldControlValue === "object") {
+		return !!oFieldControlValue && equal(annotationExpression(oFieldControlValue) as ExpressionOrPrimitive<number>, 0);
+	}
+	return oFieldControlValue === "Common.FieldControlType/Inapplicable";
+};
+
+/**
+ * Create the binding expression to check if the property is read only or not.
+ *
+ * @param {object} oTarget The target property or DataField
+ * @returns {ExpressionOrPrimitive<boolean>} The binding expression resolving to a boolean being true if it's read only
+ */
+export const isRequiredExpression = function(oTarget: any): ExpressionOrPrimitive<boolean> {
+	const oFieldControlValue = oTarget?.annotations?.Common?.FieldControl?.valueOf();
+	if (typeof oFieldControlValue === "object") {
+		return !!oFieldControlValue && equal(annotationExpression(oFieldControlValue) as ExpressionOrPrimitive<number>, 7);
+	}
+	return oFieldControlValue === "Common.FieldControlType/Mandatory";
+};