@sapui5/sap.fe.core 1.98.0 → 1.101.0

package/src/sap/fe/core/converters/controls/Common/table/StandardActions.ts

@@ -16,13 +16,21 @@ import {
 	not,
 	notEqual,
 	or,
-	greaterThan
+	greaterThan,
+	formatResult
 } from "sap/fe/core/helpers/BindingExpression";
-import { CreationMode, NavigationSettingsConfiguration, TemplateType, ViewPathConfiguration } from "../../../ManifestSettings";
+import { CreationMode, TemplateType, ViewPathConfiguration } from "../../../ManifestSettings";
 import { singletonPathVisitor, UI } from "../../../helpers/BindingHelper";
 import { PropertyAnnotationValue } from "@sap-ux/vocabularies-types";
 import { getTargetObjectPath, isPathDeletable, isPathInsertable, isPathUpdatable } from "sap/fe/core/templating/DataModelPathHelper";
 import { TableControlConfiguration } from "../Table";
+import tableFormatters from "sap/fe/core/formatters/TableFormatter";
+
+enum AnnotationHiddenProperty {
+	CreateHidden = "CreateHidden",
+	DeleteHidden = "DeleteHidden",
+	UpdateHidden = "UpdateHidden"
+}
 
 export type StandardActionConfigType = {
 	isTemplated?: BindingExpression<boolean>;
@@ -32,7 +40,7 @@ export type StandardActionConfigType = {
 
 type ExpressionRestrictionsType = {
 	expression: Expression<boolean>;
-	isOnlyCurrentEntityExpression: boolean;
+	navigationExpression: Expression<boolean>;
 };
 type StandardActionsRestrictionsType = Record<string, ExpressionRestrictionsType>;
 
@@ -43,7 +51,7 @@ export type StandardActionsContext = {
 		"delete": Expression<boolean>;
 		update: Expression<boolean>;
 	};
-	isExternalCreateConfigured: boolean;
+	creationMode: CreationMode;
 	isDraftOrStickySupported: boolean;
 	isViewWithMultipleVisualizations: boolean;
 	newAction?: {
@@ -55,29 +63,28 @@ export type StandardActionsContext = {
 };
 
 /**
- * Generates context for the standard actions.
+ * Generates the context for the standard actions.
  *
  * @param {ConverterContext} converterContext
- * @param {NavigationSettingsConfiguration} navigationSettings
+ * @param {NavigationSettingsConfiguration} creationMode
  * @param {TableControlConfiguration} tableManifestConfiguration
  * @param {ViewPathConfiguration} viewConfiguration
  * @returns  The context for table actions
  */
-
 export function generateStandardActionsContext(
 	converterContext: ConverterContext,
-	navigationSettings: NavigationSettingsConfiguration,
+	creationMode: CreationMode,
 	tableManifestConfiguration: TableControlConfiguration,
 	viewConfiguration?: ViewPathConfiguration
 ): StandardActionsContext {
 	return {
 		collectionPath: getTargetObjectPath(converterContext.getDataModelObjectPath()),
 		hiddenAnnotation: {
-			create: isActionAnnotatedHidden(converterContext, "CreateHidden"),
-			"delete": isActionAnnotatedHidden(converterContext, "DeleteHidden"),
-			update: isActionAnnotatedHidden(converterContext, "UpdateHidden")
+			create: isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.CreateHidden),
+			"delete": isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.DeleteHidden),
+			update: isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.UpdateHidden)
 		},
-		isExternalCreateConfigured: isExternalCreateConfigured(navigationSettings),
+		creationMode: creationMode,
 		isDraftOrStickySupported: isDraftOrStickySupported(converterContext),
 		isViewWithMultipleVisualizations: viewConfiguration
 			? converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration)
@@ -89,14 +96,23 @@ export function generateStandardActionsContext(
 }
 
 /**
- * Checks if an external created is configured for the navigation.
+ * Checks if draft is supported.
  *
- * @param {NavigationSettingsConfiguration} navigationSettings
+ * @param {ConverterContext} converterContext
  * @returns {boolean}
  */
-export function isExternalCreateConfigured(navigationSettings: NavigationSettingsConfiguration): boolean {
-	const navigation = navigationSettings?.create;
-	return (navigation && navigation.outbound && navigation.outboundDetail) !== undefined;
+export function isDraftSupported(converterContext: ConverterContext): boolean {
+	const currentEntitySet = converterContext.getEntitySet();
+	const bIsDraftRoot = currentEntitySet && currentEntitySet.annotations?.Common?.DraftRoot ? true : false;
+	const bIsDraftNode = currentEntitySet && currentEntitySet.annotations?.Common?.DraftNode ? true : false;
+	const bIsDraftParentEntityForContainment =
+		converterContext.getDataModelObjectPath().targetObject?.containsTarget &&
+		(converterContext.getDataModelObjectPath().startingEntitySet?.annotations?.Common?.DraftRoot ||
+			converterContext.getDataModelObjectPath().startingEntitySet?.annotations?.Common?.DraftNode)
+			? true
+			: false;
+
+	return bIsDraftRoot || bIsDraftNode || (!converterContext.getEntitySet() && bIsDraftParentEntityForContainment);
 }
 
 /**
@@ -106,26 +122,13 @@ export function isExternalCreateConfigured(navigationSettings: NavigationSetting
  * @returns {boolean}
  */
 export function isDraftOrStickySupported(converterContext: ConverterContext): boolean {
-	const currentEntitySet = converterContext.getEntitySet();
+	const bIsDraftSupported = isDraftSupported(converterContext);
 	const bIsStickySessionSupported = converterContext.getDataModelObjectPath().startingEntitySet?.annotations?.Session
 		?.StickySessionSupported
 		? true
 		: false;
-	const bIsDraftRoot = currentEntitySet && currentEntitySet.annotations?.Common?.DraftRoot ? true : false;
-	const bIsDraftNode = currentEntitySet && currentEntitySet.annotations?.Common?.DraftNode ? true : false;
-	const bIsDraftParentEntityForContainment =
-		converterContext.getDataModelObjectPath().targetObject?.containsTarget &&
-		(converterContext.getDataModelObjectPath().startingEntitySet?.annotations?.Common?.DraftRoot ||
-			converterContext.getDataModelObjectPath().startingEntitySet?.annotations?.Common?.DraftNode)
-			? true
-			: false;
 
-	return (
-		bIsDraftRoot ||
-		bIsDraftNode ||
-		bIsStickySessionSupported ||
-		(!converterContext.getEntitySet() && bIsDraftParentEntityForContainment)
-	);
+	return bIsDraftSupported || bIsStickySessionSupported;
 }
 
 /**
@@ -152,32 +155,37 @@ export function getNewAction(converterContext: ConverterContext): any {
 }
 
 /**
- * Gets binding expression for the action visibility configured into annotation.
+ * Gets the binding expression for the action visibility configured into annotation.
  *
  * @param {ConverterContext} converterContext
  * @param {string} sAnnotationTerm
+ * @param {boolean} bWithNavigationPath
  * @returns {Expression<boolean>}
  */
-export function isActionAnnotatedHidden(converterContext: ConverterContext, sAnnotationTerm: string): Expression<boolean> {
+export function isActionAnnotatedHidden(
+	converterContext: ConverterContext,
+	sAnnotationTerm: string,
+	bWithNavigationPath = true
+): Expression<boolean> {
 	const currentEntitySet = converterContext.getEntitySet();
 	const dataModelObjectPath = converterContext.getDataModelObjectPath();
 	// Consider only the last level of navigation. The others are already considered in the element binding of the page.
 	const visitedNavigationPaths =
-		dataModelObjectPath.navigationProperties.length > 0
+		dataModelObjectPath.navigationProperties.length > 0 && bWithNavigationPath
 			? [dataModelObjectPath.navigationProperties[dataModelObjectPath.navigationProperties.length - 1].name]
 			: [];
+	const actionAnnotationValue =
+		((currentEntitySet?.annotations.UI as any)?.[sAnnotationTerm] as PropertyAnnotationValue<boolean>) || false;
+
 	return currentEntitySet
-		? annotationExpression(
-				((currentEntitySet?.annotations.UI as any)?.[sAnnotationTerm] as PropertyAnnotationValue<boolean>) || false,
-				visitedNavigationPaths,
-				undefined,
-				(path: string) => singletonPathVisitor(path, converterContext, visitedNavigationPaths)
+		? annotationExpression(actionAnnotationValue, visitedNavigationPaths, undefined, (path: string) =>
+				singletonPathVisitor(path, converterContext.getConvertedTypes(), visitedNavigationPaths)
 		  )
 		: constant(false);
 }
 
 /**
- * Gets annotated restrictions for actions.
+ * Gets the annotated restrictions for the actions.
  *
  * @param {ConverterContext} converterContext
  * @returns {StandardActionsRestrictionsType}
@@ -202,9 +210,22 @@ export function getRestrictions(converterContext: ConverterContext): StandardAct
 	restrictionsDef.forEach(function(def) {
 		const defFunction = def["function"];
 		result[def.key] = {
-			expression: defFunction.apply(null, [dataModelObjectPath]),
-			isOnlyCurrentEntityExpression: !!(defFunction.apply(null, [dataModelObjectPath, undefined, true]) as any)
-				?.currentEntityRestriction
+			expression: defFunction.apply(null, [
+				dataModelObjectPath,
+				{
+					pathVisitor: (path: string, navigationPaths: string[]) =>
+						singletonPathVisitor(path, converterContext.getConvertedTypes(), navigationPaths)
+				}
+			]),
+			navigationExpression: defFunction.apply(null, [
+				dataModelObjectPath,
+				{
+					ignoreTargetCollection: true,
+					authorizeUnresolvable: true,
+					pathVisitor: (path: string, navigationPaths: string[]) =>
+						singletonPathVisitor(path, converterContext.getConvertedTypes(), navigationPaths)
+				}
+			])
 		};
 	});
 	return result;
@@ -214,20 +235,20 @@ export function getRestrictions(converterContext: ConverterContext): StandardAct
  * Checks if templating for insert/update actions is mandatory.
  *
  * @param {StandardActionsContext} standardActionsContext
- * @param {boolean} isDraftOrStickySupported
+ * @param {boolean} isDraftOrSticky
  * @param {boolean} isCreateAlwaysHidden
  * @returns {boolean}
  */
 export function getInsertUpdateActionsTemplating(
 	standardActionsContext: StandardActionsContext,
-	isDraftOrStickySupported: boolean,
+	isDraftOrSticky: boolean,
 	isCreateAlwaysHidden: boolean
 ): boolean {
-	return (isDraftOrStickySupported || standardActionsContext.isExternalCreateConfigured) && !isCreateAlwaysHidden;
+	return (isDraftOrSticky || standardActionsContext.creationMode === CreationMode.External) && !isCreateAlwaysHidden;
 }
 
 /**
- * Gets binding expressions for the properties of the action Create.
+ * Gets the binding expressions for the properties of the action Create.
  *
  * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
@@ -246,7 +267,7 @@ export function getStandardActionCreate(
 }
 
 /**
- * Gets binding expressions for the properties of the action Delete.
+ * Gets the binding expressions for the properties of the action Delete.
  *
  * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
@@ -266,112 +287,120 @@ export function getStandardActionDelete(
 }
 
 /**
- * Gets binding expressions for the properties of the action Paste.
+ * @param converterContext
+ * @param standardActionsContext
+ * @returns StandardActionConfigType
+ */
+export function getCreationRow(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext
+): StandardActionConfigType {
+	const creationRowVisibility = getCreateVisibility(converterContext, standardActionsContext, true);
+
+	return {
+		isTemplated: compileBinding(getCreateTemplating(standardActionsContext, creationRowVisibility, true)),
+		visible: compileBinding(creationRowVisibility),
+		enabled: compileBinding(getCreationRowEnablement(converterContext, standardActionsContext, creationRowVisibility))
+	};
+}
+
+/**
+ * Gets the binding expressions for the properties of the action Paste.
  *
  * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
+ * @param {boolean} isInsertUpdateActionsTemplated
  * @returns {StandardActionConfigType}
  */
 export function getStandardActionPaste(
 	converterContext: ConverterContext,
-	standardActionsContext: StandardActionsContext
+	standardActionsContext: StandardActionsContext,
+	isInsertUpdateActionsTemplated: boolean
 ): StandardActionConfigType {
 	const createVisibility = getCreateVisibility(converterContext, standardActionsContext);
-	const pasteVisibility = getPasteVisibility(converterContext, standardActionsContext, createVisibility);
-
+	const createEnablement = getCreateEnablement(converterContext, standardActionsContext, createVisibility);
+	const pasteVisibility = getPasteVisibility(converterContext, standardActionsContext, createVisibility, isInsertUpdateActionsTemplated);
 	return {
-		isTemplated: compileBinding(getDefaultTemplating(pasteVisibility)),
 		visible: compileBinding(pasteVisibility),
-		enabled: compileBinding(pasteVisibility)
+		enabled: compileBinding(getPasteEnablement(pasteVisibility, createEnablement))
 	};
 }
 
 /**
- * Gets binding expressions for the properties of the action MassEdit.
+ * Gets the binding expressions for the properties of the action MassEdit.
  *
  * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
- * @param {string | undefined} selectionMode
  * @returns {StandardActionConfigType}
  */
 export function getStandardActionMassEdit(
 	converterContext: ConverterContext,
-	standardActionsContext: StandardActionsContext,
-	selectionMode: string | undefined
+	standardActionsContext: StandardActionsContext
 ): StandardActionConfigType {
-	const massEditVisibility = getMassEditVisibility(converterContext, standardActionsContext, selectionMode);
+	const massEditVisibility = getMassEditVisibility(converterContext, standardActionsContext);
 
 	return {
 		isTemplated: compileBinding(getDefaultTemplating(massEditVisibility)),
 		visible: compileBinding(massEditVisibility),
-		enabled: compileBinding(getMassEditEnablement(standardActionsContext, massEditVisibility))
+		enabled: compileBinding(getMassEditEnablement(converterContext, standardActionsContext, massEditVisibility))
 	};
 }
 
 /**
- * Gets binding expressions for the templating of the action Create.
+ * Gets the binding expression for the templating of the action Create.
  *
  * @param {StandardActionsContext} standardActionsContext
  * @param {Expression<boolean>} createVisibility
+ * @param {boolean} isForCreationRow
  * @returns {Expression<boolean> }
  */
 export function getCreateTemplating(
 	standardActionsContext: StandardActionsContext,
-	createVisibility: Expression<boolean>
+	createVisibility: Expression<boolean>,
+	isForCreationRow = false
 ): Expression<boolean> {
-	const isCreationRow = standardActionsContext.tableManifestConfiguration.creationMode === CreationMode.CreationRow;
-	const newAction = standardActionsContext.newAction;
-	const isInsertable = standardActionsContext.restrictions.isInsertable.expression;
-
 	//Templating of Create Button is not done:
-	// 	 - If Button is never visible or CreationMode is on CreationRow
-	//   - Otherwise If new action is configured and never available
-	//	 - Otherwise If delete restrictions coming from NavigationRestrictions are constantly false
-	//   - Otherwise If there is no external create action
-	//	 - Otherwise if there is delete restrictions on the current entitySet set to false
+	// 	 - If Button is never visible(covered the External create button, new Action)
+	//	 - or CreationMode is on CreationRow for Create Button
+	//	 - or CreationMode is not on CreationRow for CreationRow Button
 
-	return ifElse(
-		or(and(isConstant(createVisibility), equal(createVisibility, false)), isCreationRow),
-		false,
-		ifElse(
-			and(isConstant(newAction?.available), equal(newAction?.available, false)),
-			false,
-			ifElse(
-				and(not(standardActionsContext.restrictions.isInsertable.isOnlyCurrentEntityExpression), isConstant(isInsertable)),
-				isInsertable,
-				ifElse(
-					standardActionsContext.isExternalCreateConfigured,
-					true,
-					not(and(isConstant(isInsertable), equal(isInsertable, constant(false))))
-				)
-			)
-		)
+	return and(
+		//XNOR gate
+		or(
+			and(isForCreationRow, standardActionsContext.creationMode === CreationMode.CreationRow),
+			and(!isForCreationRow, standardActionsContext.creationMode !== CreationMode.CreationRow)
+		),
+		or(not(isConstant(createVisibility)), createVisibility)
 	);
 }
 
 /**
- * Gets binding expressions for the templating of the non-Create actions.
+ * Gets the binding expression for the templating of the non-Create actions.
  *
  * @param {Expression<boolean>} actionVisibility
  * @returns {Expression<boolean> }
  */
 export function getDefaultTemplating(actionVisibility: Expression<boolean>): Expression<boolean> {
-	return not(and(isConstant(actionVisibility), equal(actionVisibility, false)));
+	return or(not(isConstant(actionVisibility)), actionVisibility);
 }
 
 /**
- * Gets binding expressions for the property visible of the action Create.
+ * Gets the binding expression for the property visible of the action Create.
  *
  * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
+ * @param {boolean} isForCreationRow
  * @returns {Expression<boolean> }
  */
 export function getCreateVisibility(
 	converterContext: ConverterContext,
-	standardActionsContext: StandardActionsContext
+	standardActionsContext: StandardActionsContext,
+	isForCreationRow = false
 ): Expression<boolean> {
 	const isInsertable = standardActionsContext.restrictions.isInsertable.expression;
-	const isCreateHidden = standardActionsContext.hiddenAnnotation.create;
+	const isCreateHidden = isForCreationRow
+		? isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.CreateHidden, false)
+		: standardActionsContext.hiddenAnnotation.create;
 	const newAction = standardActionsContext.newAction;
 
 	//Create Button is visible:
@@ -385,12 +414,8 @@ export function getCreateVisibility(
 	// 	 	- Otherwise
 	// 	  	 - This depends on the value of the the UI.IsEditable
 	return ifElse(
-		standardActionsContext.isExternalCreateConfigured,
-		ifElse(
-			converterContext.getTemplateType() === TemplateType.ListReport,
-			not(isCreateHidden),
-			and(not(isCreateHidden), UI.IsEditable)
-		),
+		standardActionsContext.creationMode === CreationMode.External,
+		and(not(isCreateHidden), or(converterContext.getTemplateType() === TemplateType.ListReport, UI.IsEditable)),
 		ifElse(
 			or(
 				and(isConstant(newAction?.available), equal(newAction?.available, false)),
@@ -402,7 +427,7 @@ export function getCreateVisibility(
 			false,
 			ifElse(
 				converterContext.getTemplateType() === TemplateType.ListReport,
-				ifElse(isBinding(isCreateHidden), not(isCreateHidden), true),
+				or(not(isBinding(isCreateHidden)), not(isCreateHidden)),
 				and(not(isCreateHidden), UI.IsEditable)
 			)
 		)
@@ -410,7 +435,7 @@ export function getCreateVisibility(
 }
 
 /**
- * Gets binding expressions for the property visible of the action Delete.
+ * Gets the binding expression for the property visible of the action Delete.
  *
  * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
@@ -421,7 +446,7 @@ export function getDeleteVisibility(
 	standardActionsContext: StandardActionsContext
 ): Expression<boolean> {
 	const isDeleteHidden = standardActionsContext.hiddenAnnotation.delete;
-	const isPathDeletable = standardActionsContext.restrictions.isDeletable.expression;
+	const pathDeletableExpression = standardActionsContext.restrictions.isDeletable.expression;
 
 	//Delete Button is visible:
 	// 	 Prerequisites:
@@ -431,7 +456,7 @@ export function getDeleteVisibility(
 	//   - Otherwise
 	//			- If UI.DeleteHidden is true -> not visible
 	//			- Otherwise
-	// 	 			- If we're on OP -> depending of the editMode and restrictions on deletable
+	// 	 			- If we're on OP -> depending if UI is editable and restrictions on deletable
 	//				- Otherwise
 	//				 	- If UI.DeleteHidden points to a property path -> provide a negated binding to this path
 	//	 	 		 	- Otherwise, delete is visible
@@ -440,15 +465,15 @@ export function getDeleteVisibility(
 		or(standardActionsContext.isViewWithMultipleVisualizations, converterContext.getTemplateType() === TemplateType.AnalyticalListPage),
 		false,
 		ifElse(
-			and(isConstant(isPathDeletable), equal(isPathDeletable, false)),
+			and(isConstant(pathDeletableExpression), equal(pathDeletableExpression, false)),
 			false,
 			ifElse(
 				and(isConstant(isDeleteHidden), equal(isDeleteHidden, constant(true))),
 				false,
 				ifElse(
 					converterContext.getTemplateType() !== TemplateType.ListReport,
-					and(not(isDeleteHidden), equal(bindingExpression("/editMode", "ui"), "Editable")),
-					ifElse(isBinding(isDeleteHidden), not(isDeleteHidden), true)
+					and(not(isDeleteHidden), UI.IsEditable),
+					not(and(isBinding(isDeleteHidden), isDeleteHidden))
 				)
 			)
 		)
@@ -456,47 +481,50 @@ export function getDeleteVisibility(
 }
 
 /**
- * Gets binding expressions for the property visible of the action Paste.
+ * Gets the binding expression for the property visible of the action Paste.
  *
  * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
  * @param {Expression<boolean>} createVisibility
+ * @param {boolean} isInsertUpdateActionsTemplated
  * @returns {Expression<boolean> }
  */
 export function getPasteVisibility(
 	converterContext: ConverterContext,
 	standardActionsContext: StandardActionsContext,
-	createVisibility: Expression<boolean>
+	createVisibility: Expression<boolean>,
+	isInsertUpdateActionsTemplated: boolean
 ): Expression<boolean> {
-	// If Create is visible, enablePaste is not disabled into manifest and we are on OP/blocks outside Fiori elements templates, button will be visible according to insertable restrictions and create visibility
+	// If Create is visible, enablePaste is not disabled into manifest and we are on OP/blocks outside Fiori elements templates
+	// Then button will be visible according to insertable restrictions and create visibility
 	// Otherwise it's not visible
-	return ifElse(
-		and(notEqual(standardActionsContext.tableManifestConfiguration.enablePaste, false), equal(createVisibility, true)),
-		[TemplateType.ListReport, TemplateType.AnalyticalListPage].indexOf(converterContext.getTemplateType()) === -1 &&
-			standardActionsContext.restrictions.isInsertable.expression,
-		false
+	return and(
+		notEqual(standardActionsContext.tableManifestConfiguration.enablePaste, false),
+		createVisibility,
+		isInsertUpdateActionsTemplated,
+		[TemplateType.ListReport, TemplateType.AnalyticalListPage].indexOf(converterContext.getTemplateType()) === -1,
+		standardActionsContext.restrictions.isInsertable.expression
 	);
 }
 
 /**
- * Gets binding expressions for the property visible of the action MassEdit.
+ * Gets the binding expression for the property visible of the action MassEdit.
  *
  * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
- * @param {string | undefined} selectionMode
  * @returns {Expression<boolean> }
  */
 export function getMassEditVisibility(
 	converterContext: ConverterContext,
-	standardActionsContext: StandardActionsContext,
-	selectionMode: string | undefined
+	standardActionsContext: StandardActionsContext
 ): Expression<boolean> {
 	const isUpdateHidden = standardActionsContext.hiddenAnnotation.update,
-		isPathUpdatable = standardActionsContext.restrictions.isUpdatable.expression,
-		bMassEditEnabledInManifest: boolean = standardActionsContext.tableManifestConfiguration?.enableMassEdit || false,
-		iSelectionLimit: number = standardActionsContext.tableManifestConfiguration?.selectionLimit;
-	const bIsRelevantSelectionMode: boolean = !((selectionMode && selectionMode === "Single") || (iSelectionLimit && iSelectionLimit < 2));
-
+		pathUpdatableExpression = standardActionsContext.restrictions.isUpdatable.expression,
+		bMassEditEnabledInManifest: boolean = standardActionsContext.tableManifestConfiguration?.enableMassEdit || false;
+	const templateBindingExpression =
+		converterContext.getTemplateType() === TemplateType.ObjectPage
+			? UI.IsEditable
+			: converterContext.getTemplateType() === TemplateType.ListReport;
 	//MassEdit is visible
 	// If
 	//		- there is no static restrictions set to false
@@ -504,19 +532,64 @@ export function getMassEditVisibility(
 	//		- and the selectionMode is relevant
 	//	Then MassEdit is always visible in LR or dynamically visible in OP according to ui>Editable and hiddenAnnotation
 	//  Button is hidden for all other cases
-	return ifElse(
-		and(not(and(isConstant(isPathUpdatable), equal(isPathUpdatable, false))), bIsRelevantSelectionMode, bMassEditEnabledInManifest),
-		ifElse(
-			converterContext.getTemplateType() === TemplateType.ObjectPage,
-			and(equal(UI.IsEditable, true), not(isUpdateHidden)),
-			converterContext.getTemplateType() === TemplateType.ListReport
-		),
-		false
+	return and(
+		not(and(isConstant(pathUpdatableExpression), equal(pathUpdatableExpression, false))),
+		bMassEditEnabledInManifest,
+		templateBindingExpression,
+		not(isUpdateHidden)
 	);
 }
 
 /**
- * Gets binding expressions for the property enabled of the action Create.
+ * Gets the binding expression for the property enabled of the creationRow.
+ *
+ * @param {ConverterContext} converterContext
+ * @param {StandardActionsContext} standardActionsContext
+ * @param {Expression<boolean>} creationRowVisibility
+ * @returns {Expression<boolean> }
+ */
+export function getCreationRowEnablement(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext,
+	creationRowVisibility: Expression<boolean>
+): Expression<boolean> {
+	const restrictionsInsertable = isPathInsertable(converterContext.getDataModelObjectPath(), {
+		ignoreTargetCollection: true,
+		authorizeUnresolvable: true,
+		pathVisitor: (path: string, navigationPaths: string[]) => {
+			if (path.indexOf("/") === 0) {
+				path = singletonPathVisitor(path, converterContext.getConvertedTypes(), navigationPaths);
+				return path;
+			}
+			const navigationProperties = converterContext.getDataModelObjectPath().navigationProperties;
+			if (navigationProperties) {
+				const partner = navigationProperties[navigationProperties.length - 1].partner;
+				if (partner) {
+					path = `${partner}/${path}`;
+				}
+			}
+			return path;
+		}
+	});
+	const isInsertable =
+		restrictionsInsertable._type === "Unresolvable"
+			? isPathInsertable(converterContext.getDataModelObjectPath(), {
+					pathVisitor: (path: string) => singletonPathVisitor(path, converterContext.getConvertedTypes(), [])
+			  })
+			: restrictionsInsertable;
+
+	return and(
+		creationRowVisibility,
+		isInsertable,
+		or(
+			!standardActionsContext.tableManifestConfiguration.disableAddRowButtonForEmptyData,
+			formatResult([bindingExpression("creationRowFieldValidity", "internal")], tableFormatters.validateCreationRowFields)
+		)
+	);
+}
+
+/**
+ * Gets the binding expression for the property enabled of the action Create.
  *
  * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
@@ -531,21 +604,16 @@ export function getCreateEnablement(
 	const isInsertable = standardActionsContext.restrictions.isInsertable.expression;
 	const CollectionType = converterContext.resolveAbsolutePath<any>(standardActionsContext.collectionPath).target?._type;
 	return and(
-		not(equal(createVisibility, constant(false))),
-		ifElse(
+		createVisibility,
+		or(
 			CollectionType === "EntitySet",
-			true,
-			ifElse(
-				converterContext.getTemplateType() !== TemplateType.ObjectPage,
-				isInsertable,
-				and(isInsertable, equal(bindingExpression("/editMode", "ui"), "Editable"))
-			)
+			and(isInsertable, or(converterContext.getTemplateType() !== TemplateType.ObjectPage, UI.IsEditable))
 		)
 	);
 }
 
 /**
- * Gets binding expressions for the property enabled of the action Delete.
+ * Gets the binding expression for the property enabled of the action Delete.
  *
  * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
@@ -559,22 +627,21 @@ export function getDeleteEnablement(
 ): Expression<boolean> {
 	const isDeletable = standardActionsContext.restrictions.isDeletable.expression;
 	const isOnlyDynamicOnCurrentEntity =
-		standardActionsContext.restrictions.isDeletable.isOnlyCurrentEntityExpression && !isConstant(isDeletable);
+		!isConstant(isDeletable) && standardActionsContext.restrictions.isDeletable.navigationExpression._type === "Unresolvable";
 	const numberOfSelectedContexts = bindingExpression("numberOfSelectedContexts", "internal");
 	const numberOfDeletableContexts = bindingExpression("deletableContexts", "internal");
 	const numberOfUnSavedContexts = bindingExpression("unSavedContexts", "internal");
 
 	return and(
-		not(equal(deleteVisibility, constant(false))),
+		deleteVisibility,
 		ifElse(
 			or(converterContext.getTemplateType() !== TemplateType.ObjectPage, isOnlyDynamicOnCurrentEntity),
-			ifElse(
+			and(
 				or(
 					and(notEqual(numberOfDeletableContexts, undefined), greaterThan(length(numberOfDeletableContexts), 0)),
 					and(notEqual(numberOfUnSavedContexts, undefined), greaterThan(length(numberOfUnSavedContexts), 0))
 				),
-				bindingExpression("deleteEnabled", "internal"),
-				false
+				bindingExpression("deleteEnabled", "internal")
 			),
 			and(notEqual(numberOfSelectedContexts, 0), isDeletable)
 		)
@@ -582,28 +649,67 @@ export function getDeleteEnablement(
 }
 
 /**
- * Gets binding expressions for the property enabled of the action MassEdit.
+ * Gets the binding expression for the property enabled of the action Paste.
+ *
+ * @param {Expression<boolean>} pasteVisibility
+ * @param {Expression<boolean>} createEnablement
+ * @returns {Expression<boolean> }
+ */
+export function getPasteEnablement(pasteVisibility: Expression<boolean>, createEnablement: Expression<boolean>): Expression<boolean> {
+	return and(pasteVisibility, createEnablement);
+}
+
+/**
+ * Gets the binding expression for the property enabled of the action MassEdit.
  *
+ * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
  * @param {Expression<boolean>} massEditVisibility
  * @returns {Expression<boolean> }
  */
 export function getMassEditEnablement(
+	converterContext: ConverterContext,
 	standardActionsContext: StandardActionsContext,
 	massEditVisibility: Expression<boolean>
 ): Expression<boolean> {
-	const isPathUpdatable = standardActionsContext.restrictions.isUpdatable.expression;
+	const pathUpdatableExpression = standardActionsContext.restrictions.isUpdatable.expression;
 	const isOnlyDynamicOnCurrentEntity: any =
-		standardActionsContext.restrictions.isUpdatable.isOnlyCurrentEntityExpression && !isConstant(isPathUpdatable);
-	const numberOfSelectedContexts = greaterOrEqual(bindingExpression("numberOfSelectedContexts", "internal"), 2);
-	const numberOfUpdatableContexts = greaterOrEqual(length(bindingExpression("updatableContexts", "internal")), 2);
-
-	return and(
-		not(equal(massEditVisibility, constant(false))),
-		ifElse(
-			isOnlyDynamicOnCurrentEntity,
-			and(numberOfSelectedContexts, numberOfUpdatableContexts),
-			and(numberOfSelectedContexts, isPathUpdatable)
-		)
+		!isConstant(pathUpdatableExpression) &&
+		standardActionsContext.restrictions.isUpdatable.navigationExpression._type === "Unresolvable";
+	const numberOfSelectedContexts = greaterOrEqual(bindingExpression("numberOfSelectedContexts", "internal"), 1);
+	const numberOfUpdatableContexts = greaterOrEqual(length(bindingExpression("updatableContexts", "internal")), 1);
+	const bIsDraftSupported = isDraftSupported(converterContext);
+	const bDisplayMode = isInDisplayMode(converterContext);
+
+	// numberOfUpdatableContexts needs to be added to the binding in case
+	// 1. Update is dependent on current entity property (isOnlyDynamicOnCurrentEntity is true).
+	// 2. The table is read only and draft enabled(like LR), in this case only active contexts can be mass edited.
+	//    So, update depends on 'IsActiveEntity' value which needs to be checked runtime.
+	const runtimeBinding = ifElse(
+		or(and(bDisplayMode, bIsDraftSupported), isOnlyDynamicOnCurrentEntity),
+		and(numberOfSelectedContexts, numberOfUpdatableContexts),
+		and(numberOfSelectedContexts)
 	);
+
+	return and(massEditVisibility, ifElse(isOnlyDynamicOnCurrentEntity, runtimeBinding, and(runtimeBinding, pathUpdatableExpression)));
+}
+
+/**
+ * Tells if the table in template is in display mode.
+ *
+ * @param {ConverterContext} converterContext
+ * @param {ViewPathConfiguration} viewConfiguration
+ * @returns {boolean}
+ */
+export function isInDisplayMode(converterContext: ConverterContext, viewConfiguration?: ViewPathConfiguration): boolean {
+	const templateType = converterContext.getTemplateType();
+	if (
+		templateType === TemplateType.ListReport ||
+		templateType === TemplateType.AnalyticalListPage ||
+		(viewConfiguration && converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration))
+	) {
+		return true;
+	}
+	// updatable will be handled at the property level
+	return false;
 }