@sapui5/sap.fe.core 1.97.0 → 1.100.0

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

@@ -0,0 +1,718 @@
+import ConverterContext from "../../../ConverterContext";
+import {
+	and,
+	annotationExpression,
+	bindingExpression,
+	BindingExpression,
+	compileBinding,
+	constant,
+	equal,
+	length,
+	Expression,
+	greaterOrEqual,
+	ifElse,
+	isBinding,
+	isConstant,
+	not,
+	notEqual,
+	or,
+	greaterThan,
+	formatResult
+} from "sap/fe/core/helpers/BindingExpression";
+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>;
+	visible: BindingExpression<boolean>;
+	enabled: BindingExpression<boolean>;
+};
+
+type ExpressionRestrictionsType = {
+	expression: Expression<boolean>;
+	navigationExpression: Expression<boolean>;
+};
+type StandardActionsRestrictionsType = Record<string, ExpressionRestrictionsType>;
+
+export type StandardActionsContext = {
+	collectionPath: string;
+	hiddenAnnotation: {
+		create: Expression<boolean>;
+		"delete": Expression<boolean>;
+		update: Expression<boolean>;
+	};
+	creationMode: CreationMode;
+	isDraftOrStickySupported: boolean;
+	isViewWithMultipleVisualizations: boolean;
+	newAction?: {
+		name?: string;
+		available?: Expression<boolean>;
+	};
+	tableManifestConfiguration: TableControlConfiguration;
+	restrictions: StandardActionsRestrictionsType;
+};
+
+/**
+ * Generates the context for the standard actions.
+ *
+ * @param {ConverterContext} converterContext
+ * @param {NavigationSettingsConfiguration} creationMode
+ * @param {TableControlConfiguration} tableManifestConfiguration
+ * @param {ViewPathConfiguration} viewConfiguration
+ * @returns  The context for table actions
+ */
+export function generateStandardActionsContext(
+	converterContext: ConverterContext,
+	creationMode: CreationMode,
+	tableManifestConfiguration: TableControlConfiguration,
+	viewConfiguration?: ViewPathConfiguration
+): StandardActionsContext {
+	return {
+		collectionPath: getTargetObjectPath(converterContext.getDataModelObjectPath()),
+		hiddenAnnotation: {
+			create: isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.CreateHidden),
+			"delete": isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.DeleteHidden),
+			update: isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.UpdateHidden)
+		},
+		creationMode: creationMode,
+		isDraftOrStickySupported: isDraftOrStickySupported(converterContext),
+		isViewWithMultipleVisualizations: viewConfiguration
+			? converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration)
+			: false,
+		newAction: getNewAction(converterContext),
+		tableManifestConfiguration: tableManifestConfiguration,
+		restrictions: getRestrictions(converterContext)
+	};
+}
+
+/**
+ * Checks if draft is supported.
+ *
+ * @param {ConverterContext} converterContext
+ * @returns {boolean}
+ */
+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);
+}
+
+/**
+ * Checks if sticky or draft is supported.
+ *
+ * @param {ConverterContext} converterContext
+ * @returns {boolean}
+ */
+export function isDraftOrStickySupported(converterContext: ConverterContext): boolean {
+	const bIsDraftSupported = isDraftSupported(converterContext);
+	const bIsStickySessionSupported = converterContext.getDataModelObjectPath().startingEntitySet?.annotations?.Session
+		?.StickySessionSupported
+		? true
+		: false;
+
+	return bIsDraftSupported || bIsStickySessionSupported;
+}
+
+/**
+ * Gets the configured newAction into annotation.
+ *
+ * @param {ConverterContext} converterContext
+ * @returns {any}
+ */
+export function getNewAction(converterContext: ConverterContext): any {
+	const currentEntitySet = converterContext.getEntitySet();
+	const newActionName: BindingExpression<string> = (
+		currentEntitySet?.annotations?.Common?.DraftRoot?.NewAction ||
+		currentEntitySet?.annotations?.Session?.StickySessionSupported?.NewAction
+	)?.toString();
+	if (newActionName) {
+		let availableProperty: any = converterContext?.getEntityType().actions[newActionName]?.annotations?.Core?.OperationAvailable;
+		availableProperty = availableProperty !== undefined ? availableProperty : true;
+		return {
+			name: newActionName,
+			available: annotationExpression(availableProperty)
+		};
+	}
+	return undefined;
+}
+
+/**
+ * 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,
+	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 && bWithNavigationPath
+			? [dataModelObjectPath.navigationProperties[dataModelObjectPath.navigationProperties.length - 1].name]
+			: [];
+	const actionAnnotationValue =
+		((currentEntitySet?.annotations.UI as any)?.[sAnnotationTerm] as PropertyAnnotationValue<boolean>) || false;
+
+	return currentEntitySet
+		? annotationExpression(actionAnnotationValue, visitedNavigationPaths, undefined, (path: string) =>
+				singletonPathVisitor(path, converterContext.getConvertedTypes(), visitedNavigationPaths)
+		  )
+		: constant(false);
+}
+
+/**
+ * Gets the annotated restrictions for the actions.
+ *
+ * @param {ConverterContext} converterContext
+ * @returns {StandardActionsRestrictionsType}
+ */
+export function getRestrictions(converterContext: ConverterContext): StandardActionsRestrictionsType {
+	const dataModelObjectPath = converterContext.getDataModelObjectPath();
+	const restrictionsDef = [
+		{
+			key: "isInsertable",
+			"function": isPathInsertable
+		},
+		{
+			key: "isUpdatable",
+			"function": isPathUpdatable
+		},
+		{
+			key: "isDeletable",
+			"function": isPathDeletable
+		}
+	];
+	const result: Record<string, ExpressionRestrictionsType> = {};
+	restrictionsDef.forEach(function(def) {
+		const defFunction = def["function"];
+		result[def.key] = {
+			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;
+}
+
+/**
+ * Checks if templating for insert/update actions is mandatory.
+ *
+ * @param {StandardActionsContext} standardActionsContext
+ * @param {boolean} isDraftOrSticky
+ * @param {boolean} isCreateAlwaysHidden
+ * @returns {boolean}
+ */
+export function getInsertUpdateActionsTemplating(
+	standardActionsContext: StandardActionsContext,
+	isDraftOrSticky: boolean,
+	isCreateAlwaysHidden: boolean
+): boolean {
+	return (isDraftOrSticky || standardActionsContext.creationMode === CreationMode.External) && !isCreateAlwaysHidden;
+}
+
+/**
+ * Gets the binding expressions for the properties of the action Create.
+ *
+ * @param {ConverterContext} converterContext
+ * @param {StandardActionsContext} standardActionsContext
+ * @returns {StandardActionConfigType}
+ */
+export function getStandardActionCreate(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext
+): StandardActionConfigType {
+	const createVisibility = getCreateVisibility(converterContext, standardActionsContext);
+	return {
+		isTemplated: compileBinding(getCreateTemplating(standardActionsContext, createVisibility)),
+		visible: compileBinding(createVisibility),
+		enabled: compileBinding(getCreateEnablement(converterContext, standardActionsContext, createVisibility))
+	};
+}
+
+/**
+ * Gets the binding expressions for the properties of the action Delete.
+ *
+ * @param {ConverterContext} converterContext
+ * @param {StandardActionsContext} standardActionsContext
+ * @returns {StandardActionConfigType}
+ */
+export function getStandardActionDelete(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext
+): StandardActionConfigType {
+	const deleteVisibility = getDeleteVisibility(converterContext, standardActionsContext);
+
+	return {
+		isTemplated: compileBinding(getDefaultTemplating(deleteVisibility)),
+		visible: compileBinding(deleteVisibility),
+		enabled: compileBinding(getDeleteEnablement(converterContext, standardActionsContext, deleteVisibility))
+	};
+}
+
+/**
+ * @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,
+	isInsertUpdateActionsTemplated: boolean
+): StandardActionConfigType {
+	const createVisibility = getCreateVisibility(converterContext, standardActionsContext);
+	const createEnablement = getCreateEnablement(converterContext, standardActionsContext, createVisibility);
+	const pasteVisibility = getPasteVisibility(converterContext, standardActionsContext, createVisibility, isInsertUpdateActionsTemplated);
+	return {
+		visible: compileBinding(pasteVisibility),
+		enabled: compileBinding(getPasteEnablement(pasteVisibility, createEnablement))
+	};
+}
+
+/**
+ * Gets the binding expressions for the properties of the action MassEdit.
+ *
+ * @param {ConverterContext} converterContext
+ * @param {StandardActionsContext} standardActionsContext
+ * @returns {StandardActionConfigType}
+ */
+export function getStandardActionMassEdit(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext
+): StandardActionConfigType {
+	const massEditVisibility = getMassEditVisibility(converterContext, standardActionsContext);
+
+	return {
+		isTemplated: compileBinding(getDefaultTemplating(massEditVisibility)),
+		visible: compileBinding(massEditVisibility),
+		enabled: compileBinding(getMassEditEnablement(converterContext, standardActionsContext, massEditVisibility))
+	};
+}
+
+/**
+ * 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>,
+	isForCreationRow = false
+): Expression<boolean> {
+	//Templating of Create Button is not done:
+	// 	 - 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 and(
+		//XNOR gate
+		or(
+			and(isForCreationRow, standardActionsContext.creationMode === CreationMode.CreationRow),
+			and(!isForCreationRow, standardActionsContext.creationMode !== CreationMode.CreationRow)
+		),
+		or(not(isConstant(createVisibility)), createVisibility)
+	);
+}
+
+/**
+ * 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 or(not(isConstant(actionVisibility)), actionVisibility);
+}
+
+/**
+ * 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,
+	isForCreationRow = false
+): Expression<boolean> {
+	const isInsertable = standardActionsContext.restrictions.isInsertable.expression;
+	const isCreateHidden = isForCreationRow
+		? isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.CreateHidden, false)
+		: standardActionsContext.hiddenAnnotation.create;
+	const newAction = standardActionsContext.newAction;
+
+	//Create Button is visible:
+	// 	 - If the creation mode is external
+	//      - If we're on the list report and create is not hidden
+	//		- Otherwise this depends on the value of the the UI.IsEditable
+	//   - Otherwise
+	// 	 	- If we're on the list report ->
+	// 	 		- If UI.CreateHidden points to a property path -> provide a negated binding to this path
+	// 	 		- Otherwise, create is visible
+	// 	 	- Otherwise
+	// 	  	 - This depends on the value of the the UI.IsEditable
+	return ifElse(
+		standardActionsContext.creationMode === CreationMode.External,
+		and(not(isCreateHidden), or(converterContext.getTemplateType() === TemplateType.ListReport, UI.IsEditable)),
+		ifElse(
+			or(
+				and(isConstant(newAction?.available), equal(newAction?.available, false)),
+				and(isConstant(isInsertable), equal(isInsertable, false), !newAction),
+				and(isConstant(isCreateHidden), equal(isCreateHidden, true)),
+				standardActionsContext.isViewWithMultipleVisualizations,
+				converterContext.getTemplateType() === TemplateType.AnalyticalListPage
+			),
+			false,
+			ifElse(
+				converterContext.getTemplateType() === TemplateType.ListReport,
+				or(not(isBinding(isCreateHidden)), not(isCreateHidden)),
+				and(not(isCreateHidden), UI.IsEditable)
+			)
+		)
+	);
+}
+
+/**
+ * Gets the binding expression for the property visible of the action Delete.
+ *
+ * @param {ConverterContext} converterContext
+ * @param {StandardActionsContext} standardActionsContext
+ * @returns {Expression<boolean> }
+ */
+export function getDeleteVisibility(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext
+): Expression<boolean> {
+	const isDeleteHidden = standardActionsContext.hiddenAnnotation.delete;
+	const pathDeletableExpression = standardActionsContext.restrictions.isDeletable.expression;
+
+	//Delete Button is visible:
+	// 	 Prerequisites:
+	//	 - If we're not on multiple visualizations configuration or ALP
+	//
+	//   - If restrictions on deletable set to false -> not visible
+	//   - Otherwise
+	//			- If UI.DeleteHidden is true -> not visible
+	//			- Otherwise
+	// 	 			- If we're on OP -> depending of the editMode and restrictions on deletable
+	//				- Otherwise
+	//				 	- If UI.DeleteHidden points to a property path -> provide a negated binding to this path
+	//	 	 		 	- Otherwise, delete is visible
+
+	return ifElse(
+		or(standardActionsContext.isViewWithMultipleVisualizations, converterContext.getTemplateType() === TemplateType.AnalyticalListPage),
+		false,
+		ifElse(
+			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")),
+					not(and(isBinding(isDeleteHidden), isDeleteHidden))
+				)
+			)
+		)
+	);
+}
+
+/**
+ * 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>,
+	isInsertUpdateActionsTemplated: boolean
+): Expression<boolean> {
+	// 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 and(
+		notEqual(standardActionsContext.tableManifestConfiguration.enablePaste, false),
+		createVisibility,
+		isInsertUpdateActionsTemplated,
+		[TemplateType.ListReport, TemplateType.AnalyticalListPage].indexOf(converterContext.getTemplateType()) === -1,
+		standardActionsContext.restrictions.isInsertable.expression
+	);
+}
+
+/**
+ * Gets the binding expression for the property visible of the action MassEdit.
+ *
+ * @param {ConverterContext} converterContext
+ * @param {StandardActionsContext} standardActionsContext
+ * @returns {Expression<boolean> }
+ */
+export function getMassEditVisibility(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext
+): Expression<boolean> {
+	const isUpdateHidden = standardActionsContext.hiddenAnnotation.update,
+		pathUpdatableExpression = standardActionsContext.restrictions.isUpdatable.expression,
+		bMassEditEnabledInManifest: boolean = standardActionsContext.tableManifestConfiguration?.enableMassEdit || false;
+	const templateBindingExpression =
+		converterContext.getTemplateType() === TemplateType.ObjectPage
+			? equal(UI.IsEditable, true)
+			: converterContext.getTemplateType() === TemplateType.ListReport;
+	//MassEdit is visible
+	// If
+	//		- there is no static restrictions set to false
+	//		- and enableMassEdit is not set to false into the manifest
+	//		- 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 and(
+		not(and(isConstant(pathUpdatableExpression), equal(pathUpdatableExpression, false))),
+		bMassEditEnabledInManifest,
+		templateBindingExpression,
+		not(isUpdateHidden)
+	);
+}
+
+/**
+ * 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
+ * @param {Expression<boolean>} createVisibility
+ * @returns {Expression<boolean> }
+ */
+export function getCreateEnablement(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext,
+	createVisibility: Expression<boolean>
+): Expression<boolean> {
+	const isInsertable = standardActionsContext.restrictions.isInsertable.expression;
+	const CollectionType = converterContext.resolveAbsolutePath<any>(standardActionsContext.collectionPath).target?._type;
+	return and(
+		createVisibility,
+		or(
+			CollectionType === "EntitySet",
+			and(
+				isInsertable,
+				or(converterContext.getTemplateType() !== TemplateType.ObjectPage, equal(bindingExpression("/editMode", "ui"), "Editable"))
+			)
+		)
+	);
+}
+
+/**
+ * Gets the binding expression for the property enabled of the action Delete.
+ *
+ * @param {ConverterContext} converterContext
+ * @param {StandardActionsContext} standardActionsContext
+ * @param {Expression<boolean>} deleteVisibility
+ * @returns {Expression<boolean> }
+ */
+export function getDeleteEnablement(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext,
+	deleteVisibility: Expression<boolean>
+): Expression<boolean> {
+	const isDeletable = standardActionsContext.restrictions.isDeletable.expression;
+	const isOnlyDynamicOnCurrentEntity =
+		!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(
+		deleteVisibility,
+		ifElse(
+			or(converterContext.getTemplateType() !== TemplateType.ObjectPage, isOnlyDynamicOnCurrentEntity),
+			and(
+				or(
+					and(notEqual(numberOfDeletableContexts, undefined), greaterThan(length(numberOfDeletableContexts), 0)),
+					and(notEqual(numberOfUnSavedContexts, undefined), greaterThan(length(numberOfUnSavedContexts), 0))
+				),
+				bindingExpression("deleteEnabled", "internal")
+			),
+			and(notEqual(numberOfSelectedContexts, 0), isDeletable)
+		)
+	);
+}
+
+/**
+ * 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 pathUpdatableExpression = standardActionsContext.restrictions.isUpdatable.expression;
+	const isOnlyDynamicOnCurrentEntity: any =
+		!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;
+}