@sapui5/sap.fe.core 1.92.0 → 1.93.3

package/src/sap/fe/core/converters/objectPage/HeaderAndFooterAction.ts

@@ -1,22 +1,23 @@
 import { ActionType } from "../ManifestSettings";
 import { EntityType } from "@sap-ux/annotation-converter";
 import { AnnotationAction, BaseAction, ButtonType, getSemanticObjectMapping } from "sap/fe/core/converters/controls/Common/Action";
-import { DataFieldForActionTypes, DataFieldForIntentBasedNavigationTypes } from "@sap-ux/vocabularies-types";
+import { DataFieldForActionTypes, DataFieldForIntentBasedNavigationTypes, PropertyAnnotationValue } from "@sap-ux/vocabularies-types";
 import { Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
-import { annotationExpression, compileBinding, not, equal, fn } from "sap/fe/core/helpers/BindingExpression";
+import { annotationExpression, compileBinding, not, equal, fn, Expression, and, ifElse } from "sap/fe/core/helpers/BindingExpression";
 import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
 import { isPathDeletable } from "sap/fe/core/templating/DataModelPathHelper";
 import ConverterContext from "../ConverterContext";
+import { Draft, singletonPathVisitor, UI } from "../helpers/BindingHelper";
 
 /**
- * Retrieve all the data field for actions for the identification annotation
+ * Retrieves all the data field for actions for the identification annotation
  * They must be
  * - Not statically hidden
- * - Either linked to an Unbound action or to an action which has an OperationAvailable not statically false.
+ * - Either linked to an Unbound action or to an action which has an OperationAvailable that is not set to false statically.
  *
- * @param {EntityType} entityType The current entitytype
- * @param {boolean} bDetermining Whether or not the action should be determining
- * @returns {DataFieldForActionTypes[]} An array of DataField for action respecting the bDetermining property
+ * @param {EntityType} entityType The current entity type
+ * @param {boolean} bDetermining The flag which denotes whether or not the action is a determining action
+ * @returns {DataFieldForActionTypes[]} An array of DataField for action respecting the input parameter 'bDetermining'
  */
 export function getIdentificationDataFieldForActions(entityType: EntityType, bDetermining: boolean): DataFieldForActionTypes[] {
 	return (entityType.annotations?.UI?.Identification?.filter(identificationDataField => {
@@ -63,17 +64,95 @@ const IMPORTANT_CRITICALITIES = [
 	"UI.CriticalityType/Negative",
 	"UI.CriticalityType/VeryNegative"
 ];
+
+/**
+ * Method to determine the 'visible' property binding for the Delete button on an object page.
+ *
+ * @param {ConverterContext} converterContext Instance of the converter context.
+ * @param {PropertyAnnotationValue<boolean> | undefined} deleteHidden The value of the UI.DeleteHidden annotation on the entity set / type.
+ * @returns {Expression<boolean>} The binding expression for the 'visible' property of the Delete button.
+ */
+export function getDeleteButtonVisibility(
+	converterContext: ConverterContext,
+	deleteHidden: PropertyAnnotationValue<boolean> | undefined
+): Expression<boolean> {
+	const dataModelObjectPath = converterContext.getDataModelObjectPath(),
+		visitedNavigationPaths = dataModelObjectPath.navigationProperties.map(navProp => navProp.name),
+		// Set absolute binding path for Singleton references, otherwise the configured annotation path itself.
+		// For e.g. /com.sap.namespace.EntityContainer/Singleton/Property to /Singleton/Property
+		deleteHiddenExpression: Expression<boolean | undefined> = annotationExpression(
+			deleteHidden,
+			visitedNavigationPaths,
+			undefined,
+			(path: string) => singletonPathVisitor(path, converterContext, visitedNavigationPaths)
+		),
+		manifestWrapper = converterContext.getManifestWrapper(),
+		viewLevel = manifestWrapper.getViewLevel(),
+		// Delete button is visible
+		// In OP 		-->  when not in edit mode
+		// In sub-OP 	-->  when in edit mode
+		editableExpression: Expression<boolean> = viewLevel > 1 ? UI.IsEditable : not(UI.IsEditable);
+
+	// If UI.DeleteHidden annotation on entity set or type is either not defined or explicitly set to false,
+	// Delete button is visible based on editableExpression.
+	// else,
+	// Delete button is visible based on both annotation path and editableExpression.
+	return ifElse(
+		deleteHidden === undefined || deleteHidden.valueOf() === false,
+		editableExpression,
+		and(editableExpression, equal(deleteHiddenExpression, false))
+	);
+}
+
+/**
+ * Method to determine the 'visible' property binding for the Edit button on an object page.
+ *
+ * @param {ConverterContext} converterContext Instance of the converter context.
+ * @param {PropertyAnnotationValue<boolean> | undefined} updateHidden The value of the UI.UpdateHidden annotation on the entity set / type.
+ * @returns {Expression<boolean>} The binding expression for the 'visible' property of the Edit button.
+ */
+export function getEditButtonVisibility(
+	converterContext: ConverterContext,
+	updateHidden: PropertyAnnotationValue<boolean> | undefined
+): Expression<boolean> {
+	const entitySet = converterContext.getEntitySet(),
+		bIsDraftRoot = entitySet && entitySet.annotations.Common?.DraftRoot ? true : false,
+		dataModelObjectPath = converterContext.getDataModelObjectPath(),
+		visitedNavigationPaths = dataModelObjectPath.navigationProperties.map(navProp => navProp.name),
+		// Set absolute binding path for Singleton references, otherwise the configured annotation path itself.
+		// For e.g. /com.sap.namespace.EntityContainer/Singleton/Property to /Singleton/Property
+		updateHiddenExpression: Expression<boolean | undefined> = annotationExpression(
+			updateHidden,
+			visitedNavigationPaths,
+			undefined,
+			(path: string) => singletonPathVisitor(path, converterContext, visitedNavigationPaths)
+		),
+		notEditableExpression: Expression<boolean> = not(UI.IsEditable);
+
+	// If UI.UpdateHidden annotation on entity set or type is either not defined or explicitly set to false,
+	// Edit button is visible in display mode.
+	// else,
+	// Edit button is visible based on both annotation path and in display mode.
+	const resultantExpression: Expression<boolean> = ifElse(
+		updateHidden === undefined || updateHidden.valueOf() === false,
+		notEditableExpression,
+		and(notEditableExpression, equal(updateHiddenExpression, false))
+	);
+
+	return ifElse(bIsDraftRoot, and(resultantExpression, Draft.HasNoDraftForCurrentUser), resultantExpression);
+}
+
 export function getHeaderDefaultActions(converterContext: ConverterContext): BaseAction[] {
-	const entitySet = converterContext.getEntitySet();
-	const oStickySessionSupported = entitySet && entitySet.annotations?.Session?.StickySessionSupported, //for sticky app
+	const entitySet = converterContext.getEntitySet(),
+		entityType = converterContext.getEntityType(),
+		oStickySessionSupported = entitySet && entitySet.annotations?.Session?.StickySessionSupported, //for sticky app
 		oDraftRoot = entitySet && entitySet.annotations.Common?.DraftRoot,
 		oEntityDeleteRestrictions = entitySet && entitySet.annotations?.Capabilities?.DeleteRestrictions,
-		bUpdateHidden = entitySet && entitySet.annotations.UI?.UpdateHidden?.valueOf();
-	const oDataModelObjectPath = converterContext.getDataModelObjectPath(),
-		isParentDeletable = isPathDeletable(oDataModelObjectPath),
-		bParentEntitySetDeletable = isParentDeletable ? compileBinding(isParentDeletable) : isParentDeletable;
-
-	const headerDataFieldForActions = getIdentificationDataFieldForActions(converterContext.getEntityType(), false);
+		bUpdateHidden = entitySet && entitySet.annotations.UI?.UpdateHidden?.valueOf(),
+		dataModelObjectPath = converterContext.getDataModelObjectPath(),
+		isParentDeletable = isPathDeletable(dataModelObjectPath),
+		bParentEntitySetDeletable = isParentDeletable ? compileBinding(isParentDeletable) : isParentDeletable,
+		headerDataFieldForActions = getIdentificationDataFieldForActions(converterContext.getEntityType(), false);
 
 	// First add the "Critical" DataFieldForActions
 	const headerActions: BaseAction[] = headerDataFieldForActions
@@ -92,14 +171,29 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 
 	// Then the edit action if it exists
 	if ((oDraftRoot?.EditAction || oStickySessionSupported?.EditAction) && bUpdateHidden !== true) {
-		headerActions.push({ type: ActionType.Primary, key: "EditAction" });
+		const updateHidden = (entitySet?.annotations.UI?.UpdateHidden?.valueOf() !== undefined
+			? entitySet?.annotations.UI?.UpdateHidden
+			: entityType?.annotations.UI?.UpdateHidden) as PropertyAnnotationValue<boolean>;
+		headerActions.push({
+			type: ActionType.Primary,
+			key: "EditAction",
+			visible: compileBinding(getEditButtonVisibility(converterContext, updateHidden))
+		});
 	}
 	// Then the delete action if we're not statically not deletable
 	if (
 		(bParentEntitySetDeletable && bParentEntitySetDeletable !== "false") ||
 		(oEntityDeleteRestrictions?.Deletable?.valueOf() !== false && bParentEntitySetDeletable !== "false")
 	) {
-		headerActions.push({ type: ActionType.Secondary, key: "DeleteAction", parentEntityDeleteEnabled: bParentEntitySetDeletable });
+		const deleteHidden = (entitySet?.annotations.UI?.DeleteHidden?.valueOf() !== undefined
+			? entitySet?.annotations.UI?.DeleteHidden
+			: entityType?.annotations.UI?.DeleteHidden) as PropertyAnnotationValue<boolean>;
+		headerActions.push({
+			type: ActionType.Secondary,
+			key: "DeleteAction",
+			visible: compileBinding(getDeleteButtonVisibility(converterContext, deleteHidden)),
+			parentEntityDeleteEnabled: bParentEntitySetDeletable
+		});
 	}
 
 	if (oDraftRoot?.EditAction && bUpdateHidden !== true) {