@sapui5/sap.fe.core 1.110.0 → 1.111.0

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

@@ -1,7 +1,16 @@
 import type { Action, EntitySet, EntityType, PropertyAnnotationValue } from "@sap-ux/vocabularies-types";
+import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import type { DataFieldForActionTypes, DataFieldForIntentBasedNavigationTypes } from "@sap-ux/vocabularies-types/vocabularies/UI";
-import type { AnnotationAction, BaseAction } from "sap/fe/core/converters/controls/Common/Action";
-import { ButtonType, getEnabledForAnnotationAction, getSemanticObjectMapping } from "sap/fe/core/converters/controls/Common/Action";
+import { UIAnnotationTypes } from "@sap-ux/vocabularies-types/vocabularies/UI";
+import {
+	AnnotationAction,
+	BaseAction,
+	ButtonType,
+	dataFieldIsCopyAction,
+	getCopyAction,
+	getEnabledForAnnotationAction,
+	getSemanticObjectMapping
+} from "sap/fe/core/converters/controls/Common/Action";
 import { Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
 import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
 import {
@@ -19,6 +28,7 @@ import {
 } from "sap/fe/core/helpers/BindingToolkit";
 import ModelHelper from "sap/fe/core/helpers/ModelHelper";
 import { isPathDeletable } from "sap/fe/core/templating/DataModelPathHelper";
+import Core from "sap/ui/core/Core";
 import type ConverterContext from "../ConverterContext";
 import { Draft, singletonPathVisitor, UI } from "../helpers/BindingHelper";
 import { ActionType } from "../ManifestSettings";
@@ -30,22 +40,18 @@ import { ActionType } from "../ManifestSettings";
  * - 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 bDetermining The flag which denotes whether or not the action is a determining action
- * @returns An array of DataField for action respecting the input parameter 'bDetermining'
+ * @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 getIdentificationDataFieldForActions(entityType: EntityType, bDetermining: boolean): DataFieldForActionTypes[] {
+export function getIdentificationDataFieldForActions(entityType: EntityType, isDeterminingAction: boolean): DataFieldForActionTypes[] {
 	return (entityType.annotations?.UI?.Identification?.filter((identificationDataField) => {
-		if (identificationDataField?.annotations?.UI?.Hidden?.valueOf() !== true) {
-			if (
-				identificationDataField?.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAction" &&
-				!!identificationDataField.Determining === bDetermining &&
-				(!identificationDataField?.ActionTarget?.isBound ||
-					identificationDataField?.ActionTarget?.annotations?.Core?.OperationAvailable?.valueOf() !== false)
-			) {
-				return true;
-			}
-		}
-		return false;
+		return identificationDataField.annotations?.UI?.Hidden?.valueOf() !== true &&
+			identificationDataField.$Type === UIAnnotationTypes.DataFieldForAction &&
+			Boolean(identificationDataField.Determining?.valueOf()) === isDeterminingAction &&
+			(identificationDataField.ActionTarget?.isBound?.valueOf() !== true ||
+				identificationDataField?.ActionTarget?.annotations?.Core?.OperationAvailable?.valueOf() !== false)
+			? true
+			: false;
 	}) || []) as DataFieldForActionTypes[];
 }
 
@@ -55,21 +61,19 @@ export function getIdentificationDataFieldForActions(entityType: EntityType, bDe
  * - Not statically hidden.
  *
  * @param entityType The current entitytype
- * @param bDetermining Whether or not the action should be determining
- * @returns An array of data field for action respecting the bDetermining property.
+ * @param isDeterminingAction Whether or not the action should be determining
+ * @returns An array of data field for action respecting the isDeterminingAction property.
  */
-function getIdentificationDataFieldForIBNActions(entityType: EntityType, bDetermining: boolean): DataFieldForIntentBasedNavigationTypes[] {
+function getIdentificationDataFieldForIBNActions(
+	entityType: EntityType,
+	isDeterminingAction: boolean
+): DataFieldForIntentBasedNavigationTypes[] {
 	return (entityType.annotations?.UI?.Identification?.filter((identificationDataField) => {
-		if (identificationDataField?.annotations?.UI?.Hidden?.valueOf() !== true) {
-			if (
-				identificationDataField?.$Type === "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation" &&
-				!!identificationDataField.Determining === bDetermining
-			) {
-				return true;
-			}
-		}
-
-		return false;
+		return identificationDataField.annotations?.UI?.Hidden?.valueOf() !== true &&
+			identificationDataField.$Type === UIAnnotationTypes.DataFieldForIntentBasedNavigation &&
+			Boolean(identificationDataField.Determining?.valueOf()) === isDeterminingAction
+			? true
+			: false;
 	}) || []) as DataFieldForIntentBasedNavigationTypes[];
 }
 
@@ -133,7 +137,7 @@ export function getDeleteButtonEnabled(
 	converterContext: ConverterContext
 ): BindingToolkitExpression<boolean> {
 	const entitySet = converterContext.getEntitySet(),
-		bIsDraftRoot = ModelHelper.isDraftRoot(entitySet);
+		isDraftRoot = ModelHelper.isDraftRoot(entitySet);
 
 	let ret = ifElse(
 		isParentDeletable !== undefined,
@@ -142,7 +146,7 @@ export function getDeleteButtonEnabled(
 	);
 
 	// delete should be disabled for Locked objects
-	ret = bIsDraftRoot ? and(ret, not(pathInModel("DraftAdministrativeData/InProcessByUser"))) : ret;
+	ret = isDraftRoot ? and(ret, not(pathInModel("DraftAdministrativeData/InProcessByUser"))) : ret;
 
 	return ret;
 }
@@ -154,7 +158,7 @@ export function getDeleteButtonEnabled(
  * @param rootUpdateHidden The value of the UI.UpdateHidden annotation on the entity set / type.
  * @param rootConverterContext
  * @param updateHidden
- * @param iViewLevel
+ * @param viewLevel
  * @returns The binding expression for the 'visible' property of the Edit button.
  */
 export function getEditButtonVisibility(
@@ -162,15 +166,22 @@ export function getEditButtonVisibility(
 	rootUpdateHidden: PropertyAnnotationValue<boolean> | undefined,
 	rootConverterContext: ConverterContext,
 	updateHidden?: PropertyAnnotationValue<boolean> | undefined,
-	iViewLevel?: number | undefined
+	viewLevel?: number | undefined
 ): BindingToolkitExpression<boolean> {
-	const entitySet = rootConverterContext?.getEntitySet(),
-		bIsDraftRoot = ModelHelper.isDraftRoot(entitySet),
-		bisFCLEnabled = converterContext.getManifestWrapper().isFclEnabled();
+	const rootEntitySet = rootConverterContext?.getEntitySet(),
+		entitySet = converterContext.getEntitySet(),
+		isFCLEnabled = converterContext.getManifestWrapper().isFclEnabled();
+	let isDraftEnabled;
 	const rootUpdateHiddenExpression: BindingToolkitExpression<boolean | undefined> = getHiddenExpression(
 		rootConverterContext,
 		rootUpdateHidden
 	);
+	if (viewLevel && viewLevel > 1) {
+		// if viewlevel > 1 check if node is draft enabled
+		isDraftEnabled = ModelHelper.isDraftNode(entitySet);
+	} else {
+		isDraftEnabled = ModelHelper.isDraftRoot(rootEntitySet);
+	}
 	const updateHiddenExpression: BindingToolkitExpression<boolean | undefined> = getHiddenExpression(rootConverterContext, updateHidden);
 
 	const notEditableExpression: BindingToolkitExpression<boolean> = not(UI.IsEditable);
@@ -180,19 +191,19 @@ export function getEditButtonVisibility(
 	// else,
 	// Edit button is visible based on both annotation path and in display mode.
 	const resultantExpression: BindingToolkitExpression<boolean> = ifElse(
-		(iViewLevel as number) > 1,
+		(viewLevel as number) > 1,
 		ifElse(
 			updateHidden === undefined || updateHidden.valueOf() === false,
 			and(
 				notEditableExpression,
 				equal(pathInModel("rootEditVisible", "internal"), true),
-				ifElse(bisFCLEnabled, equal(pathInModel("/showEditButton", "fclhelper"), true), true)
+				ifElse(isFCLEnabled, equal(pathInModel("/showEditButton", "fclhelper"), true), true)
 			),
 			and(
 				notEditableExpression,
 				equal(updateHiddenExpression, false),
 				equal(pathInModel("rootEditVisible", "internal"), true),
-				ifElse(bisFCLEnabled, equal(pathInModel("/showEditButton", "fclhelper"), true), true)
+				ifElse(isFCLEnabled, equal(pathInModel("/showEditButton", "fclhelper"), true), true)
 			)
 		),
 		ifElse(
@@ -201,7 +212,7 @@ export function getEditButtonVisibility(
 			and(notEditableExpression, equal(rootUpdateHiddenExpression, false))
 		)
 	);
-	return ifElse(bIsDraftRoot, and(resultantExpression, Draft.HasNoDraftForCurrentUser), resultantExpression);
+	return ifElse(isDraftEnabled, and(resultantExpression, Draft.HasNoDraftForCurrentUser), resultantExpression);
 }
 
 export function getHiddenExpression(converterContext: ConverterContext, updateHidden: PropertyAnnotationValue<boolean> | undefined) {
@@ -222,13 +233,13 @@ export function getHiddenExpression(converterContext: ConverterContext, updateHi
  *
  * @param converterContext Instance of the converter context.
  * @param updateRestrictions
- * @param iViewLevel
+ * @param viewLevel
  * @returns The binding expression for the 'enabled' property of the Edit button.
  */
 export function getEditButtonEnabled(
 	converterContext: ConverterContext,
 	updateRestrictions?: any,
-	iViewLevel?: number | undefined
+	viewLevel?: number | undefined
 ): CompiledBindingToolkitExpression {
 	const entitySet = converterContext.getEntitySet(),
 		isDraftRoot = ModelHelper.isDraftRoot(entitySet),
@@ -245,7 +256,7 @@ export function getEditButtonEnabled(
 		if (editAction?.annotations?.Core?.OperationAvailable === null) {
 			// We disabled action advertisement but kept it in the code for the time being
 			//return "{= ${#" + editActionName + "} ? true : false }";
-		} else if ((iViewLevel as number) > 1) {
+		} else if ((viewLevel as number) > 1) {
 			// Edit button is enabled based on the update restrictions of the sub-OP
 			if (updateRestrictions !== undefined) {
 				return compileExpression(
@@ -272,19 +283,32 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 		entityType = converterContext.getEntityType(),
 		rootEntitySet = rootConverterContext.getEntitySet(),
 		rootEntityType = rootConverterContext.getEntityType(),
-		oStickySessionSupported = ModelHelper.getStickySession(rootEntitySet), //for sticky app
-		oDraftRoot = ModelHelper.getDraftRoot(rootEntitySet), //entitySet && entitySet.annotations.Common?.DraftRoot,
-		oDraftNode = ModelHelper.getDraftNode(rootEntitySet),
-		oEntityDeleteRestrictions = entitySet && entitySet.annotations?.Capabilities?.DeleteRestrictions,
+		stickySessionSupported = ModelHelper.getStickySession(rootEntitySet), //for sticky app
+		draftRoot = ModelHelper.getDraftRoot(rootEntitySet), //entitySet && entitySet.annotations.Common?.DraftRoot,
+		draftNode = ModelHelper.getDraftNode(rootEntitySet),
+		entityDeleteRestrictions = entitySet && entitySet.annotations?.Capabilities?.DeleteRestrictions,
 		rootUpdateHidden = ModelHelper.isUpdateHidden(rootEntitySet, rootEntityType),
-		bUpdateHidden = rootEntitySet && !ModelHelper.isSingleton(rootEntitySet) && rootUpdateHidden?.valueOf(),
+		updateHidden = rootEntitySet && !ModelHelper.isSingleton(rootEntitySet) && rootUpdateHidden?.valueOf(),
 		dataModelObjectPath = converterContext.getDataModelObjectPath(),
 		isParentDeletable = isPathDeletable(dataModelObjectPath, {
 			pathVisitor: (path: string, navigationPaths: string[]) =>
 				singletonPathVisitor(path, converterContext.getConvertedTypes(), navigationPaths)
 		}),
-		bParentEntitySetDeletable = isParentDeletable ? compileExpression(isParentDeletable) : isParentDeletable,
-		headerDataFieldForActions = getIdentificationDataFieldForActions(converterContext.getEntityType(), false);
+		parentEntitySetDeletable = isParentDeletable ? compileExpression(isParentDeletable) : isParentDeletable,
+		identificationFieldForActions = getIdentificationDataFieldForActions(converterContext.getEntityType(), false);
+
+	const copyDataField =
+		converterContext.getManifestWrapper().getViewLevel() === 1
+			? getCopyAction(
+					identificationFieldForActions.filter((dataField) => {
+						return dataFieldIsCopyAction(dataField);
+					})
+			  )
+			: undefined;
+
+	const headerDataFieldForActions = identificationFieldForActions.filter((dataField) => {
+		return !dataFieldIsCopyAction(dataField);
+	});
 
 	// Initialize actions and start with draft actions if available since they should appear in the first
 	// leftmost position in the actions area of the OP header
@@ -292,13 +316,13 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 	// the button for switching between draft and active document versions but also the controls for
 	// the collaborative draft fragment.
 	const headerActions: BaseAction[] = [];
-	if (!ModelHelper.isSingleton(entitySet) && oDraftRoot?.EditAction && bUpdateHidden !== true) {
+	if (!ModelHelper.isSingleton(entitySet) && draftRoot?.EditAction && updateHidden !== true) {
 		headerActions.push({ type: ActionType.DraftActions, key: "DraftActions" });
 	}
 
-	const iViewLevel = converterContext.getManifestWrapper().getViewLevel();
-	const updatablePropertyPath = iViewLevel > 1 ? entitySet?.annotations.Capabilities?.UpdateRestrictions?.Updatable : undefined;
-	if (oDraftRoot || oDraftNode) {
+	const viewLevel = converterContext.getManifestWrapper().getViewLevel();
+	const updatablePropertyPath = viewLevel > 1 ? entitySet?.annotations.Capabilities?.UpdateRestrictions?.Updatable : undefined;
+	if (draftRoot || draftNode) {
 		headerActions.push({ type: ActionType.CollaborationAvatars, key: "CollaborationAvatars" });
 	}
 	// Then add the "Critical" DataFieldForActions
@@ -307,40 +331,46 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 			return IMPORTANT_CRITICALITIES.indexOf(dataField?.Criticality as string) > -1;
 		})
 		.forEach((dataField) => {
-			headerActions.push({
-				type: ActionType.DataFieldForAction,
-				annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
-				key: KeyHelper.generateKeyFromDataField(dataField),
-				visible: compileExpression(not(equal(getExpressionFromAnnotation(dataField.annotations?.UI?.Hidden), true))),
-				enabled: getEnabledForAnnotationAction(converterContext, dataField.ActionTarget),
-				isNavigable: true
-			});
+			headerActions.push(getDataFieldAnnotationAction(dataField, converterContext));
 		});
 
 	// Then the edit action if it exists
-	if ((oDraftRoot?.EditAction || oStickySessionSupported?.EditAction) && bUpdateHidden !== true) {
-		const updateHidden = ModelHelper.isUpdateHidden(entitySet, entityType);
+	if ((draftRoot?.EditAction || stickySessionSupported?.EditAction) && updateHidden !== true) {
 		headerActions.push({
 			type: ActionType.Primary,
 			key: "EditAction",
 			visible: compileExpression(
-				getEditButtonVisibility(converterContext, rootUpdateHidden, rootConverterContext, updateHidden, iViewLevel)
+				getEditButtonVisibility(
+					converterContext,
+					rootUpdateHidden,
+					rootConverterContext,
+					ModelHelper.isUpdateHidden(entitySet, entityType),
+					viewLevel
+				)
 			),
-			enabled: getEditButtonEnabled(rootConverterContext, updatablePropertyPath, iViewLevel)
+			enabled: getEditButtonEnabled(rootConverterContext, updatablePropertyPath, viewLevel)
 		});
 	}
 	// Then the delete action if we're not statically not deletable
 	if (
-		(bParentEntitySetDeletable && bParentEntitySetDeletable !== "false") ||
-		(oEntityDeleteRestrictions?.Deletable?.valueOf() !== false && bParentEntitySetDeletable !== "false")
+		(parentEntitySetDeletable && parentEntitySetDeletable !== "false") ||
+		(entityDeleteRestrictions?.Deletable?.valueOf() !== false && parentEntitySetDeletable !== "false")
 	) {
 		const deleteHidden = ModelHelper.getDeleteHidden(entitySet, entityType) as PropertyAnnotationValue<boolean>;
 		headerActions.push({
 			type: ActionType.Secondary,
 			key: "DeleteAction",
 			visible: compileExpression(getDeleteButtonVisibility(converterContext, deleteHidden)),
-			enabled: compileExpression(getDeleteButtonEnabled(oEntityDeleteRestrictions?.Deletable, isParentDeletable, converterContext)),
-			parentEntityDeleteEnabled: bParentEntitySetDeletable
+			enabled: compileExpression(getDeleteButtonEnabled(entityDeleteRestrictions?.Deletable, isParentDeletable, converterContext)),
+			parentEntityDeleteEnabled: parentEntitySetDeletable
+		});
+	}
+
+	if (copyDataField) {
+		headerActions.push({
+			...getDataFieldAnnotationAction(copyDataField, converterContext),
+			type: ActionType.Copy,
+			text: copyDataField.Label?.toString() ?? Core.getLibraryResourceBundle("sap.fe.core").getText("C_COMMON_COPY")
 		});
 	}
 
@@ -351,15 +381,16 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 			return IMPORTANT_CRITICALITIES.indexOf(dataField?.Criticality as string) === -1;
 		})
 		.forEach((dataField) => {
-			const oNavigationParams = {
-				semanticObjectMapping: dataField.Mapping ? getSemanticObjectMapping(dataField.Mapping) : []
-			};
-
 			if (dataField.RequiresContext?.valueOf() === true) {
 				throw new Error(`RequiresContext property should not be true for header IBN action : ${dataField.Label}`);
-			} else if (dataField.Inline?.valueOf() === true) {
+			}
+			if (dataField.Inline?.valueOf() === true) {
 				throw new Error(`Inline property should not be true for header IBN action : ${dataField.Label}`);
 			}
+			const oNavigationParams = {
+				semanticObjectMapping: getSemanticObjectMapping(dataField.Mapping)
+			};
+
 			headerActions.push({
 				type: ActionType.DataFieldForIntentBasedNavigation,
 				text: dataField.Label?.toString(),
@@ -391,14 +422,7 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 			return IMPORTANT_CRITICALITIES.indexOf(dataField?.Criticality as string) === -1;
 		})
 		.forEach((dataField) => {
-			headerActions.push({
-				type: ActionType.DataFieldForAction,
-				annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
-				key: KeyHelper.generateKeyFromDataField(dataField),
-				visible: compileExpression(not(equal(getExpressionFromAnnotation(dataField.annotations?.UI?.Hidden), true))),
-				enabled: getEnabledForAnnotationAction(converterContext, dataField.ActionTarget),
-				isNavigable: true
-			} as AnnotationAction);
+			headerActions.push(getDataFieldAnnotationAction(dataField, converterContext));
 		});
 
 	return headerActions;
@@ -420,19 +444,19 @@ export function getHiddenHeaderActions(converterContext: ConverterContext): Base
 export function getFooterDefaultActions(viewLevel: number, converterContext: ConverterContext): BaseAction[] {
 	const entitySet = converterContext.getEntitySet();
 	const entityType = converterContext.getEntityType();
-	const oStickySessionSupported = ModelHelper.getStickySession(entitySet), //for sticky app
-		sEntitySetDraftRoot =
+	const stickySessionSupported = ModelHelper.getStickySession(entitySet), //for sticky app
+		entitySetDraftRoot =
 			!ModelHelper.isSingleton(entitySet) &&
 			entitySet &&
 			((entitySet as EntitySet).annotations.Common?.DraftRoot?.term ||
 				(entitySet as EntitySet).annotations?.Session?.StickySessionSupported?.term),
-		bConditionSave =
-			sEntitySetDraftRoot === "com.sap.vocabularies.Common.v1.DraftRoot" ||
-			(oStickySessionSupported && oStickySessionSupported?.SaveAction),
-		bConditionApply = viewLevel > 1,
-		bConditionCancel =
-			sEntitySetDraftRoot === "com.sap.vocabularies.Common.v1.DraftRoot" ||
-			(oStickySessionSupported && oStickySessionSupported?.DiscardAction);
+		conditionSave = Boolean(
+			entitySetDraftRoot === CommonAnnotationTerms.DraftRoot || (stickySessionSupported && stickySessionSupported?.SaveAction)
+		),
+		conditionApply = viewLevel > 1,
+		conditionCancel = Boolean(
+			entitySetDraftRoot === CommonAnnotationTerms.DraftRoot || (stickySessionSupported && stickySessionSupported?.DiscardAction)
+		);
 
 	// Retrieve all determining actions
 	const footerDataFieldForActions = getIdentificationDataFieldForActions(converterContext.getEntityType(), true);
@@ -443,23 +467,16 @@ export function getFooterDefaultActions(viewLevel: number, converterContext: Con
 			return IMPORTANT_CRITICALITIES.indexOf(dataField?.Criticality as string) > -1;
 		})
 		.map((dataField) => {
-			return {
-				type: ActionType.DataFieldForAction,
-				annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
-				key: KeyHelper.generateKeyFromDataField(dataField),
-				visible: compileExpression(not(equal(getExpressionFromAnnotation(dataField.annotations?.UI?.Hidden), true))),
-				enabled: getEnabledForAnnotationAction(converterContext, dataField.ActionTarget),
-				isNavigable: true
-			};
+			return getDataFieldAnnotationAction(dataField, converterContext);
 		});
 
 	// Then the save action if it exists
-	if (entitySet?.entityTypeName === entityType?.fullyQualifiedName && bConditionSave) {
+	if (entitySet?.entityTypeName === entityType?.fullyQualifiedName && conditionSave) {
 		footerActions.push({ type: ActionType.Primary, key: "SaveAction" });
 	}
 
 	// Then the apply action if it exists
-	if (bConditionApply) {
+	if (conditionApply) {
 		footerActions.push({ type: ActionType.DefaultApply, key: "ApplyAction" });
 	}
 
@@ -469,18 +486,11 @@ export function getFooterDefaultActions(viewLevel: number, converterContext: Con
 			return IMPORTANT_CRITICALITIES.indexOf(dataField?.Criticality as string) === -1;
 		})
 		.forEach((dataField) => {
-			footerActions.push({
-				type: ActionType.DataFieldForAction,
-				annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
-				key: KeyHelper.generateKeyFromDataField(dataField),
-				visible: compileExpression(not(equal(getExpressionFromAnnotation(dataField.annotations?.UI?.Hidden), true))),
-				enabled: getEnabledForAnnotationAction(converterContext, dataField.ActionTarget),
-				isNavigable: true
-			} as AnnotationAction);
+			footerActions.push(getDataFieldAnnotationAction(dataField, converterContext));
 		});
 
 	// Then the cancel action if it exists
-	if (bConditionCancel) {
+	if (conditionCancel) {
 		footerActions.push({
 			type: ActionType.Secondary,
 			key: "CancelAction",
@@ -489,3 +499,14 @@ export function getFooterDefaultActions(viewLevel: number, converterContext: Con
 	}
 	return footerActions;
 }
+
+function getDataFieldAnnotationAction(dataField: DataFieldForActionTypes, converterContext: ConverterContext): AnnotationAction {
+	return {
+		type: ActionType.DataFieldForAction,
+		annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
+		key: KeyHelper.generateKeyFromDataField(dataField),
+		visible: compileExpression(not(equal(getExpressionFromAnnotation(dataField.annotations?.UI?.Hidden), true))),
+		enabled: getEnabledForAnnotationAction(converterContext, dataField.ActionTarget),
+		isNavigable: true
+	} as AnnotationAction;
+}