@sapui5/sap.fe.core 1.99.0 → 1.100.0

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

@@ -4,6 +4,7 @@ import {
 	addTypeInformation,
 	and,
 	annotationExpression,
+	bindingExpression,
 	BindingExpression,
 	BindingExpressionExpression,
 	compileBinding,
@@ -18,7 +19,7 @@ import {
 	not,
 	or
 } from "sap/fe/core/helpers/BindingExpression";
-import { UI } from "sap/fe/core/converters/helpers/BindingHelper";
+import { singletonPathVisitor, UI } from "sap/fe/core/converters/helpers/BindingHelper";
 import {
 	getAssociatedUnitProperty,
 	getAssociatedCurrencyProperty,
@@ -33,9 +34,9 @@ import { NavigationProperty, Property } from "@sap-ux/annotation-converter";
 import { PathAnnotationExpression } from "@sap-ux/vocabularies-types/types/Edm";
 import {
 	DataModelObjectPath,
-	getTargetEntitySetPath,
 	isPathUpdatable,
-	getPathRelativeLocation
+	getPathRelativeLocation,
+	getTargetObjectPath
 } from "sap/fe/core/templating/DataModelPathHelper";
 import {
 	isReadOnlyExpression,
@@ -96,7 +97,7 @@ export type configType = {
 export const getEditableExpression = function(
 	oPropertyPath: PropertyOrPath<Property>,
 	oDataFieldConverted: any = null,
-	oDataModelObjectPath?: DataModelObjectPath,
+	oDataModelObjectPath: DataModelObjectPath,
 	bAsObject: boolean = false
 ): BindingExpression<boolean> | ExpressionOrPrimitive<boolean> {
 	if (!oPropertyPath || typeof oPropertyPath === "string") {
@@ -118,7 +119,11 @@ export const getEditableExpression = function(
 	// Else, to be editable you need
 	// immutable and key while in the creation row
 	// ui/isEditable
-	const isPathUpdatableExpression = isPathUpdatable(oDataModelObjectPath, oPropertyPath);
+	const isPathUpdatableExpression = isPathUpdatable(oDataModelObjectPath, {
+		propertyPath: oPropertyPath,
+		pathVisitor: (path: string, navigationPaths: string[]) =>
+			singletonPathVisitor(path, oDataModelObjectPath.convertedTypes, navigationPaths)
+	});
 	const editableExpression = ifElse(
 		or(
 			not(isPathUpdatableExpression),
@@ -136,6 +141,18 @@ export const getEditableExpression = function(
 	return compileBinding(and(editableExpression, dataFieldEditableExpression));
 };
 
+export const getCollaborationExpression = function(dataModelObjectPath: DataModelObjectPath, formatter: any): BindingExpression<any> {
+	const objectPath = getTargetObjectPath(dataModelObjectPath);
+	const activityExpression = bindingExpression("/collaboration/activities" + objectPath, "internal");
+	const keys = dataModelObjectPath?.targetEntityType?.keys;
+	const keysExpressions: BindingExpressionExpression<any>[] = [];
+	keys?.forEach(function(key) {
+		const keyExpression = bindingExpression(key.name) as BindingExpressionExpression<any>;
+		keysExpressions.push(keyExpression);
+	});
+	return formatResult([activityExpression, ...keysExpressions], formatter);
+};
+
 /**
  * Create the expression to generate an "enabled" boolean value.
  *
@@ -169,6 +186,7 @@ export const getEnabledExpression = function(
 
 /**
  * Create the expression to generate an "editMode" enum value.
+ *
  * @param {PropertyPath} oPropertyPath The input property
  * @param {DataModelObjectPath} oDataModelObjectPath The list of data model objects that are involved to reach that property
  * @param {boolean} bMeasureReadOnly Whether we should set UoM / currency field mode to read only
@@ -267,13 +285,17 @@ export const getFieldDisplay = function(
 		: compileBinding(ifElse(equal(oComputedEditMode, "Editable"), "Value", sTargetDisplayMode));
 };
 
-export const formatWithTypeInformation = function(oProperty: Property, propertyBindingExpression: Expression<string>): Expression<string> {
+export const formatWithTypeInformation = function(
+	oProperty: Property,
+	propertyBindingExpression: Expression<string>,
+	ignoreConstraints?: boolean
+): Expression<string> {
 	const outExpression: BindingExpressionExpression<any> = propertyBindingExpression as BindingExpressionExpression<any>;
 	if (oProperty._type === "Property") {
 		const oTargetMapping = EDM_TYPE_MAPPING[(oProperty as Property).type];
 		if (oTargetMapping) {
 			outExpression.type = oTargetMapping.type;
-			if (oTargetMapping.constraints) {
+			if (oTargetMapping.constraints && !ignoreConstraints) {
 				outExpression.constraints = {};
 				if (oTargetMapping.constraints.$Scale && oProperty.scale !== undefined) {
 					outExpression.constraints.scale = oProperty.scale;
@@ -387,7 +409,8 @@ export const getTypeConfig = function(oProperty: Property | DataFieldAbstractTyp
 
 export const getBindingWithUnitOrCurrency = function(
 	oPropertyDataModelPath: DataModelObjectPath,
-	propertyBindingExpression: Expression<string>
+	propertyBindingExpression: Expression<string>,
+	ignoreUnitConstraint?: boolean
 ): Expression<string> {
 	const oPropertyDefinition = oPropertyDataModelPath.targetObject as Property;
 	let unit = oPropertyDefinition.annotations?.Measures?.Unit;
@@ -402,8 +425,13 @@ export const getBindingWithUnitOrCurrency = function(
 	const complexType = unit ? "sap.ui.model.odata.type.Unit" : "sap.ui.model.odata.type.Currency";
 	unit = unit ? unit : oPropertyDefinition.annotations?.Measures?.ISOCurrency;
 	const unitBindingExpression = (unit as any).$target
-		? formatWithTypeInformation((unit as any).$target, annotationExpression(unit, relativeLocation) as Expression<string>)
+		? formatWithTypeInformation(
+				(unit as any).$target,
+				annotationExpression(unit, relativeLocation) as Expression<string>,
+				ignoreUnitConstraint
+		  )
 		: (annotationExpression(unit, relativeLocation) as Expression<string>);
+
 	return addTypeInformation([propertyBindingExpression, unitBindingExpression], complexType);
 };
 
@@ -458,21 +486,6 @@ export const getExpressionBinding = function(expression: Expression<any>): Bindi
 	return compileBinding(expression);
 };
 
-/**
- * Retrieve the target entityset for a context path if it exists.
- *
- * @param oContext
- * @returns {string}
- */
-export const getTargetEntitySet = function(oContext: Context): string | null {
-	if (oContext) {
-		const oDataModelPath = getInvolvedDataModelObjects(oContext);
-		return getTargetEntitySetPath(oDataModelPath);
-	}
-
-	return null;
-};
-
 export const isCollectionField = function(oDataModelPath: DataModelObjectPath): boolean {
 	if (oDataModelPath.navigationProperties?.length) {
 		const hasOneToManyNavigation =