@sapui5/sap.fe.core 1.97.0 → 1.99.1

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

@@ -0,0 +1,655 @@
+import ConverterContext from "../../../ConverterContext";
+import {
+	and,
+	annotationExpression,
+	bindingExpression,
+	BindingExpression,
+	compileBinding,
+	constant,
+	equal,
+	length,
+	Expression,
+	greaterOrEqual,
+	ifElse,
+	isBinding,
+	isConstant,
+	not,
+	notEqual,
+	or,
+	greaterThan
+} from "sap/fe/core/helpers/BindingExpression";
+import { CreationMode, NavigationSettingsConfiguration, 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";
+
+export type StandardActionConfigType = {
+	isTemplated?: BindingExpression<boolean>;
+	visible: BindingExpression<boolean>;
+	enabled: BindingExpression<boolean>;
+};
+
+type ExpressionRestrictionsType = {
+	expression: Expression<boolean>;
+	isOnlyCurrentEntityExpression: boolean;
+};
+type StandardActionsRestrictionsType = Record<string, ExpressionRestrictionsType>;
+
+export type StandardActionsContext = {
+	collectionPath: string;
+	hiddenAnnotation: {
+		create: Expression<boolean>;
+		"delete": Expression<boolean>;
+		update: Expression<boolean>;
+	};
+	isExternalCreateConfigured: boolean;
+	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} navigationSettings
+ * @param {TableControlConfiguration} tableManifestConfiguration
+ * @param {ViewPathConfiguration} viewConfiguration
+ * @returns  The context for table actions
+ */
+
+export function generateStandardActionsContext(
+	converterContext: ConverterContext,
+	navigationSettings: NavigationSettingsConfiguration,
+	tableManifestConfiguration: TableControlConfiguration,
+	viewConfiguration?: ViewPathConfiguration
+): StandardActionsContext {
+	return {
+		collectionPath: getTargetObjectPath(converterContext.getDataModelObjectPath()),
+		hiddenAnnotation: {
+			create: isActionAnnotatedHidden(converterContext, "CreateHidden"),
+			"delete": isActionAnnotatedHidden(converterContext, "DeleteHidden"),
+			update: isActionAnnotatedHidden(converterContext, "UpdateHidden")
+		},
+		isExternalCreateConfigured: isExternalCreateConfigured(navigationSettings),
+		isDraftOrStickySupported: isDraftOrStickySupported(converterContext),
+		isViewWithMultipleVisualizations: viewConfiguration
+			? converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration)
+			: false,
+		newAction: getNewAction(converterContext),
+		tableManifestConfiguration: tableManifestConfiguration,
+		restrictions: getRestrictions(converterContext)
+	};
+}
+
+/**
+ * Checks if an external created is configured for the navigation.
+ *
+ * @param {NavigationSettingsConfiguration} navigationSettings
+ * @returns {boolean}
+ */
+export function isExternalCreateConfigured(navigationSettings: NavigationSettingsConfiguration): boolean {
+	const navigation = navigationSettings?.create;
+	return (navigation && navigation.outbound && navigation.outboundDetail) !== undefined;
+}
+
+/**
+ * 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
+ * @returns {Expression<boolean>}
+ */
+export function isActionAnnotatedHidden(converterContext: ConverterContext, sAnnotationTerm: string): 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[dataModelObjectPath.navigationProperties.length - 1].name]
+			: [];
+	return currentEntitySet
+		? annotationExpression(
+				((currentEntitySet?.annotations.UI as any)?.[sAnnotationTerm] as PropertyAnnotationValue<boolean>) || false,
+				visitedNavigationPaths,
+				undefined,
+				(path: string) => singletonPathVisitor(path, converterContext, 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]),
+			isOnlyCurrentEntityExpression: !!(defFunction.apply(null, [dataModelObjectPath, undefined, true]) as any)
+				?.currentEntityRestriction
+		};
+	});
+	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.isExternalCreateConfigured) && !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))
+	};
+}
+
+/**
+ * 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
+ * @returns {Expression<boolean> }
+ */
+export function getCreateTemplating(
+	standardActionsContext: StandardActionsContext,
+	createVisibility: Expression<boolean>
+): 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
+
+	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))))
+				)
+			)
+		)
+	);
+}
+
+/**
+ * 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)));
+}
+
+/**
+ * Gets the binding expression for the property visible of the action Create.
+ *
+ * @param {ConverterContext} converterContext
+ * @param {StandardActionsContext} standardActionsContext
+ * @returns {Expression<boolean> }
+ */
+export function getCreateVisibility(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext
+): Expression<boolean> {
+	const isInsertable = standardActionsContext.restrictions.isInsertable.expression;
+	const isCreateHidden = 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.isExternalCreateConfigured,
+		ifElse(
+			converterContext.getTemplateType() === TemplateType.ListReport,
+			not(isCreateHidden),
+			and(not(isCreateHidden), 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,
+				ifElse(isBinding(isCreateHidden), not(isCreateHidden), true),
+				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")),
+					ifElse(isBinding(isDeleteHidden), not(isDeleteHidden), true)
+				)
+			)
+		)
+	);
+}
+
+/**
+ * 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 ifElse(
+		and(
+			notEqual(standardActionsContext.tableManifestConfiguration.enablePaste, false),
+			createVisibility,
+			isInsertUpdateActionsTemplated
+		),
+		[TemplateType.ListReport, TemplateType.AnalyticalListPage].indexOf(converterContext.getTemplateType()) === -1 &&
+			standardActionsContext.restrictions.isInsertable.expression,
+		false
+	);
+}
+
+/**
+ * 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 ifElse(
+		and(not(and(isConstant(pathUpdatableExpression), equal(pathUpdatableExpression, false))), bMassEditEnabledInManifest),
+		and(templateBindingExpression, not(isUpdateHidden)),
+		false
+	);
+}
+
+/**
+ * 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,
+		ifElse(
+			CollectionType === "EntitySet",
+			true,
+			ifElse(
+				converterContext.getTemplateType() !== TemplateType.ObjectPage,
+				isInsertable,
+				and(isInsertable, 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 =
+		standardActionsContext.restrictions.isDeletable.isOnlyCurrentEntityExpression && !isConstant(isDeletable);
+	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),
+			ifElse(
+				or(
+					and(notEqual(numberOfDeletableContexts, undefined), greaterThan(length(numberOfDeletableContexts), 0)),
+					and(notEqual(numberOfUnSavedContexts, undefined), greaterThan(length(numberOfUnSavedContexts), 0))
+				),
+				bindingExpression("deleteEnabled", "internal"),
+				false
+			),
+			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 =
+		standardActionsContext.restrictions.isUpdatable.isOnlyCurrentEntityExpression && !isConstant(pathUpdatableExpression);
+	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;
+}