@sapui5/sap.fe.core 1.131.0 → 1.133.0

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

@@ -1,6 +1,8 @@
 import type { Action, EntityType, PropertyAnnotationValue } from "@sap-ux/vocabularies-types";
 import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import type {
+	DataFieldForAction,
+	DataFieldForActionGroupTypes,
 	DataFieldForActionTypes,
 	DataFieldForIntentBasedNavigationTypes,
 	DeleteHidden,
@@ -19,8 +21,9 @@ import {
 	not,
 	pathInModel
 } from "sap/fe/base/BindingToolkit";
+import type { HiddenDraft } from "sap/fe/core/converters/ManifestSettings";
 import type { PageContextPathTarget } from "sap/fe/core/converters/TemplateConverter";
-import type { AnnotationAction, BaseAction } from "sap/fe/core/converters/controls/Common/Action";
+import type { AnnotationAction, BaseAction, DataFieldForActionOrActionGroup } from "sap/fe/core/converters/controls/Common/Action";
 import {
 	ButtonType,
 	dataFieldIsCopyAction,
@@ -36,16 +39,17 @@ import { isPathDeletable } from "sap/fe/core/templating/DataModelPathHelper";
 import { isVisible } from "sap/fe/core/templating/UIFormatters";
 import Library from "sap/ui/core/Lib";
 import { Draft, UI, singletonPathVisitor } from "../../helpers/BindingHelper";
+import type { EnvironmentCapabilities } from "../../services/EnvironmentServiceFactory";
 import type ConverterContext from "../ConverterContext";
 import { ActionType } from "../ManifestSettings";
 
 /**
- * Retrieves all the data field for actions for the identification annotation
+ * Retrieves all the DataFieldForActions from the Identification annotation
  * They must be
- * - Either linked to an Unbound action or to an action which has an OperationAvailable that is not set to false statically.
+ * - Either linked to an unbound action or to an action which has an OperationAvailable that is not set to false statically.
  * @param entityType The current entity type
  * @param isDeterminingAction The flag which denotes whether or not the action is a determining action
- * @returns An array of DataField for action respecting the input parameter 'isDeterminingAction'
+ * @returns An array of DataFieldForAction respecting the input parameter 'isDeterminingAction'
  */
 export function getIdentificationDataFieldForActions(entityType: EntityType, isDeterminingAction: boolean): DataFieldForActionTypes[] {
 	return (entityType.annotations?.UI?.Identification?.filter((identificationDataField) => {
@@ -58,6 +62,29 @@ export function getIdentificationDataFieldForActions(entityType: EntityType, isD
 	}) || []) as DataFieldForActionTypes[];
 }
 
+/**
+ * Retrieves all the data field for actions for the identification annotation
+ * They must be
+ * - Either linked to an Unbound action or to an action which has an OperationAvailable that is not set to false statically.
+ * @param entityType The current entity type
+ * @param isDeterminingAction The flag which denotes whether or not the action is a determining action
+ * @returns An array of DataField for action respecting the input parameter 'isDeterminingAction'
+ */
+export function getIdentificationDataFieldForActionsOrGroups(
+	entityType: EntityType,
+	isDeterminingAction: boolean
+): DataFieldForActionOrActionGroup[] {
+	return (entityType.annotations?.UI?.Identification?.filter((identificationDataField) => {
+		return (identificationDataField.$Type === UIAnnotationTypes.DataFieldForAction &&
+			Boolean(identificationDataField.Determining?.valueOf()) === isDeterminingAction &&
+			(identificationDataField.ActionTarget?.isBound?.valueOf() !== true ||
+				identificationDataField?.ActionTarget?.annotations?.Core?.OperationAvailable?.valueOf() !== false)) ||
+			identificationDataField.$Type === UIAnnotationTypes.DataFieldForActionGroup
+			? true
+			: false;
+	}) || []) as DataFieldForActionOrActionGroup[];
+}
+
 /**
  * Retrieve all the IBN actions for the identification annotation.
  * @param entityType The current entitytype
@@ -152,6 +179,7 @@ export function getDeleteButtonEnabled(
  * @param rootConverterContext
  * @param updateHidden
  * @param viewLevel
+ * @param capabilities
  * @returns The binding expression for the 'visible' property of the Edit button.
  */
 export function getEditButtonVisibility(
@@ -159,13 +187,15 @@ export function getEditButtonVisibility(
 	rootUpdateHidden: UpdateHidden | undefined,
 	rootConverterContext: ConverterContext<PageContextPathTarget>,
 	updateHidden?: UpdateHidden | undefined,
-	viewLevel?: number | undefined
+	viewLevel?: number | undefined,
+	capabilities?: EnvironmentCapabilities
 ): BindingToolkitExpression<boolean> {
 	const rootEntitySet = rootConverterContext?.getEntitySet(),
 		entitySet = converterContext.getEntitySet(),
 		isFCLEnabled = converterContext.getManifestWrapper().isFclEnabled();
 	let isDraftEnabled;
 	const rootUpdateHiddenExpression = getHiddenExpression(rootConverterContext, rootUpdateHidden);
+	const hiddenDraft = (capabilities?.HiddenDraft as HiddenDraft)?.enabled;
 	if (viewLevel && viewLevel > 1) {
 		// if viewlevel > 1 check if node is draft enabled
 		isDraftEnabled = ModelHelper.isDraftNode(entitySet);
@@ -181,7 +211,7 @@ export function getEditButtonVisibility(
 	// else,
 	// Edit button is visible based on both annotation path and in display mode.
 	const resultantExpression: BindingToolkitExpression<boolean> = ifElse(
-		(viewLevel as number) > 1,
+		(viewLevel as number) > 1 || hiddenDraft,
 		ifElse(
 			updateHidden === undefined || updateHidden.valueOf() === false,
 			and(
@@ -264,7 +294,10 @@ export function getEditButtonEnabled(
 	return "true";
 }
 
-export function getHeaderDefaultActions(converterContext: ConverterContext<PageContextPathTarget>): BaseAction[] {
+export function getHeaderDefaultActions(
+	converterContext: ConverterContext<PageContextPathTarget>,
+	capabilities?: EnvironmentCapabilities
+): BaseAction[] {
 	const sContextPath = converterContext.getContextPath();
 	const rootEntitySetPath = ModelHelper.getRootEntitySetPath(sContextPath);
 	const rootConverterContext = converterContext.getConverterContextFor<PageContextPathTarget>("/" + rootEntitySetPath);
@@ -284,19 +317,21 @@ export function getHeaderDefaultActions(converterContext: ConverterContext<PageC
 				singletonPathVisitor(path, converterContext.getConvertedTypes(), navigationPaths)
 		}),
 		parentEntitySetDeletable = isParentDeletable ? compileExpression(isParentDeletable) : isParentDeletable,
-		identificationFieldForActions = getIdentificationDataFieldForActions(converterContext.getEntityType(), false);
+		identificationDataFieldForActions = getIdentificationDataFieldForActionsOrGroups(converterContext.getEntityType(), false);
 
 	const copyDataField =
 		converterContext.getManifestWrapper().getViewLevel() === 1
 			? getCopyAction(
-					identificationFieldForActions.filter((dataField) => {
-						return dataFieldIsCopyAction(dataField);
-					})
+					identificationDataFieldForActions.filter((dataField) => {
+						if (dataField.$Type === UIAnnotationTypes.DataFieldForAction) {
+							return dataFieldIsCopyAction(dataField);
+						}
+					}) as DataFieldForAction[]
 			  )
 			: undefined;
 
-	const headerDataFieldForActions = identificationFieldForActions.filter((dataField) => {
-		return !dataFieldIsCopyAction(dataField);
+	const headerDataFieldForActions = identificationDataFieldForActions.filter((dataField) => {
+		return !dataFieldIsCopyAction(dataField as DataFieldForActionTypes);
 	});
 
 	// Initialize actions and start with draft actions if available since they should appear in the first
@@ -314,15 +349,9 @@ export function getHeaderDefaultActions(converterContext: ConverterContext<PageC
 	if (draftRoot || draftNode) {
 		headerActions.push({ type: ActionType.CollaborationAvatars, key: "CollaborationAvatars" });
 	}
-	// Then add the "Critical" DataFieldForActions
-	headerDataFieldForActions
-		.filter((dataField) => {
-			const criticality = compileExpression(getExpressionFromAnnotation(dataField?.Criticality));
-			return IMPORTANT_CRITICALITIES.includes(criticality!);
-		})
-		.forEach((dataField) => {
-			headerActions.push(getDataFieldAnnotationAction(dataField, converterContext));
-		});
+	// Then add the "Critical" DataFieldForActions and DataFieldForActionGroups
+	// Prioritizes actions and action groups that have the Criticality annotation, placing them before those without the annotation
+	computeActionsAndActionGroups(headerActions, true, headerDataFieldForActions, converterContext);
 
 	// Then the edit action if it exists
 	if ((draftRoot?.EditAction || stickySessionSupported?.EditAction) && updateHidden !== true) {
@@ -335,7 +364,8 @@ export function getHeaderDefaultActions(converterContext: ConverterContext<PageC
 					rootUpdateHidden,
 					rootConverterContext,
 					ModelHelper.isUpdateHidden(entitySet, entityType),
-					viewLevel
+					viewLevel,
+					capabilities
 				)
 			),
 			enabled: getEditButtonEnabled(rootConverterContext, updatablePropertyPath, viewLevel)
@@ -412,15 +442,8 @@ export function getHeaderDefaultActions(converterContext: ConverterContext<PageC
 				})
 			} as AnnotationAction);
 		});
-	// Finally the non critical DataFieldForActions
-	headerDataFieldForActions
-		.filter((dataField) => {
-			const criticality = compileExpression(getExpressionFromAnnotation(dataField?.Criticality));
-			return !IMPORTANT_CRITICALITIES.includes(criticality!);
-		})
-		.forEach((dataField) => {
-			headerActions.push(getDataFieldAnnotationAction(dataField, converterContext));
-		});
+	// Finally the non critical DataFieldForActions and DataFieldForActionGroups
+	computeActionsAndActionGroups(headerActions, false, headerDataFieldForActions, converterContext);
 
 	return headerActions;
 }
@@ -438,7 +461,11 @@ export function getHiddenHeaderActions(converterContext: ConverterContext<PageCo
 	});
 }
 
-export function getFooterDefaultActions(viewLevel: number, converterContext: ConverterContext<PageContextPathTarget>): BaseAction[] {
+export function getFooterDefaultActions(
+	viewLevel: number,
+	converterContext: ConverterContext<PageContextPathTarget>,
+	capabilities?: EnvironmentCapabilities
+): BaseAction[] {
 	const entitySet = converterContext.getEntitySet();
 	const entityType = converterContext.getEntityType();
 	const stickySessionSupported = ModelHelper.getStickySession(entitySet), //for sticky app
@@ -446,12 +473,20 @@ export function getFooterDefaultActions(viewLevel: number, converterContext: Con
 			isEntitySet(entitySet) &&
 			(entitySet.annotations.Common?.DraftRoot?.term ?? entitySet.annotations.Session?.StickySessionSupported?.term),
 		conditionSave = Boolean(
-			entitySetDraftRoot === CommonAnnotationTerms.DraftRoot || (stickySessionSupported && stickySessionSupported?.SaveAction)
+			entitySetDraftRoot === CommonAnnotationTerms.DraftRoot ||
+				(capabilities?.HiddenDraft as HiddenDraft)?.enabled ||
+				(stickySessionSupported && stickySessionSupported?.SaveAction)
 		),
-		conditionApply = viewLevel > 1,
+		conditionApply = viewLevel > 1 && !(capabilities?.HiddenDraft as HiddenDraft)?.enabled,
 		conditionCancel = Boolean(
-			entitySetDraftRoot === CommonAnnotationTerms.DraftRoot || (stickySessionSupported && stickySessionSupported?.DiscardAction)
-		);
+			entitySetDraftRoot === CommonAnnotationTerms.DraftRoot ||
+				(capabilities?.HiddenDraft as HiddenDraft)?.enabled ||
+				(stickySessionSupported && stickySessionSupported?.DiscardAction)
+		),
+		conditionCreateNext =
+			viewLevel > 1 &&
+			(capabilities?.HiddenDraft as HiddenDraft)?.enabled &&
+			!(capabilities?.HiddenDraft as HiddenDraft)?.hideCreateNext;
 
 	// Retrieve all determining actions
 	const footerDataFieldForActions = getIdentificationDataFieldForActions(converterContext.getEntityType(), true);
@@ -465,7 +500,9 @@ export function getFooterDefaultActions(viewLevel: number, converterContext: Con
 		.map((dataField) => {
 			return getDataFieldAnnotationAction(dataField, converterContext);
 		});
-
+	if (conditionCreateNext) {
+		footerActions.push({ type: ActionType.CreateNext, key: "CreateNextAction" });
+	}
 	// Then the save action if it exists
 	if (entitySet?.entityTypeName === entityType?.fullyQualifiedName && conditionSave) {
 		footerActions.push({ type: ActionType.Primary, key: "SaveAction" });
@@ -475,7 +512,6 @@ export function getFooterDefaultActions(viewLevel: number, converterContext: Con
 	if (conditionApply) {
 		footerActions.push({ type: ActionType.DefaultApply, key: "ApplyAction" });
 	}
-
 	// Then the non critical DataFieldForActions
 	footerDataFieldForActions
 		.filter((dataField) => {
@@ -511,3 +547,39 @@ function getDataFieldAnnotationAction(
 		isNavigable: true
 	};
 }
+
+/**
+ * Adds actions and action groups to the headerActions array, prioritizing them according to their criticality.
+ * @param headerActions Array with all the current header actions in it
+ * @param prioritizeCriticality Flag to determine the priority of the criticality action or actionGroups inside headerActions
+ * @param headerDataFieldForActionsOrGroups All actions and action groups from the identification annotation with CopyAction filtered out
+ * @param converterContext Instance of the converter context
+ */
+function computeActionsAndActionGroups(
+	headerActions: BaseAction[],
+	prioritizeCriticality: boolean,
+	headerDataFieldForActionsOrGroups: (DataFieldForActionTypes | DataFieldForActionGroupTypes)[],
+	converterContext: ConverterContext<PageContextPathTarget>
+): void {
+	headerDataFieldForActionsOrGroups
+		.filter((dataField) => {
+			const criticality = compileExpression(getExpressionFromAnnotation(dataField?.Criticality));
+			return prioritizeCriticality ? IMPORTANT_CRITICALITIES.includes(criticality!) : !IMPORTANT_CRITICALITIES.includes(criticality!);
+		})
+		.forEach((dataField) => {
+			if (dataField.$Type === UIAnnotationTypes.DataFieldForAction) {
+				headerActions.push(getDataFieldAnnotationAction(dataField, converterContext));
+			} else if (dataField.$Type === UIAnnotationTypes.DataFieldForActionGroup) {
+				headerActions.push({
+					type: ActionType.Menu,
+					text: dataField.Label as string,
+					key: KeyHelper.generateKeyFromDataField(dataField),
+					id: KeyHelper.generateKeyFromDataField(dataField),
+					visible: compileExpression(not(equal(getExpressionFromAnnotation(dataField.annotations?.UI?.Hidden), true))),
+					menu: dataField.Actions.map((action) =>
+						getDataFieldAnnotationAction(action as DataFieldForActionTypes, converterContext)
+					)
+				});
+			}
+		});
+}