@sapui5/sap.fe.core 1.141.2 → 1.142.1

package/src/sap/fe/core/converters/controls/Common/Table.ts

@@ -28,6 +28,7 @@ import {
 	getExpressionFromAnnotation,
 	ifElse,
 	isConstant,
+	isExpressionStaticallyResolvable,
 	not,
 	or,
 	pathInModel,
@@ -50,6 +51,7 @@ import type {
 } from "sap/fe/core/converters/controls/Common/Action";
 import {
 	addCollaborationCondition,
+	addSeparators,
 	dataFieldIsCopyAction,
 	getActionsFromManifest,
 	getAnnotationMenuActionItems,
@@ -141,6 +143,9 @@ import {
 	isInDisplayMode
 } from "./table/StandardActions";
 
+import type { EntityTypeAnnotations_Aggregation } from "@sap-ux/vocabularies-types/vocabularies/Aggregation_Edm";
+import type { EntityTypeAnnotations_Hierarchy } from "@sap-ux/vocabularies-types/vocabularies/Hierarchy_Edm";
+
 type UploadTableSettings = {
 	stream: string;
 	fileName?: string;
@@ -380,8 +385,6 @@ export function getTableActions(
 	navigationSettings?: NavigationSettingsConfiguration
 ): CombinedAction {
 	// 1. Get actions from annotations
-	const isCollaborationEnabled = ModelHelper.isCollaborationDraftSupportedFromConverterContext(converterContext);
-
 	const tableActions = getTableAnnotationActions(lineItemAnnotation, visualizationPath, converterContext);
 	// 2. Get actions from manifest
 	const manifestActions = getActionsFromManifest(
@@ -438,7 +441,9 @@ export function getTableActions(
 		position: OverrideType.overwrite,
 		menu: OverrideType.overwrite,
 		priority: OverrideType.overwrite,
-		group: OverrideType.overwrite
+		group: OverrideType.overwrite,
+		overflowGroup: OverrideType.overwrite,
+		disableStrictHandling: OverrideType.overwrite
 	};
 	// 3. Get all annotation menu items
 	const annotationMenuActionItems = getAnnotationMenuActionItems(annotationActions);
@@ -457,12 +462,16 @@ export function getTableActions(
 	prepareMenuActions(actions, overwrittenMenuActionItems);
 	// 8. Remove duplicate actions which are menu items
 	actions = removeDuplicateActions(actions);
-	// 9. Hide menus where all menu items are hidden
-	actions = getVisibilityEnablementMenuActions(actions);
-	// 10. Add the collaboration condition for actions other than navigation
-	if (isCollaborationEnabled) {
+	// 9. Add the collaboration condition for actions other than navigation
+	if (ModelHelper.isCollaborationDraftSupportedFromConverterContext(converterContext)) {
 		addCollaborationCondition(actions);
 	}
+	// 10. Hide menus where all menu items are hidden
+	actions = getVisibilityEnablementMenuActions(actions);
+	// 11. Add separators based on actionGroups configuration
+	const overflowGroupsConfig =
+		converterContext.getManifestControlConfiguration<TableManifestConfiguration>(visualizationPath)?.overflowGroups;
+	actions = addSeparators(actions, overflowGroupsConfig) as CustomAction[];
 
 	return {
 		actions: actions,
@@ -973,8 +982,7 @@ function getCurrentEntitySetUpdatablePath(converterContext: ConverterContext<Pag
 	const updatable = restrictions.isUpdatable;
 	const isOnlyDynamicOnCurrentEntity = !isConstant(updatable.expression) && updatable.navigationExpression._type === "Unresolvable";
 	const updatableExpression = entitySet?.annotations.Capabilities?.UpdateRestrictions?.Updatable;
-	const updatablePropertyPath = isPathAnnotationExpression(updatableExpression) && updatableExpression.path;
-	return isOnlyDynamicOnCurrentEntity ? (updatablePropertyPath as string) : "";
+	return isOnlyDynamicOnCurrentEntity && isPathAnnotationExpression(updatableExpression) ? updatableExpression.path : "";
 }
 /**
  * Method to retrieve all property paths assigned to the Core.OperationAvailable annotation.
@@ -1239,8 +1247,7 @@ export function getSelectionMode(
 	visualizationPath: string,
 	converterContext: ConverterContext<PageContextPathTarget>,
 	isEntitySet: boolean,
-	targetCapabilities: TableCapabilityRestriction,
-	deleteButtonVisibilityExpression?: BindingToolkitExpression<boolean>,
+	deleteButtonVisibilityExpression: BindingToolkitExpression<boolean>,
 	massEditVisibilityExpression: BindingToolkitExpression<boolean> = constant(false),
 	cutButtonVisibilityExpression: BindingToolkitExpression<boolean> = constant(false)
 ): string | undefined {
@@ -1248,25 +1255,30 @@ export function getSelectionMode(
 	const tableType = tableManifestSettings.tableSettings?.type;
 	let selectionMode = tableManifestSettings.tableSettings?.selectionMode;
 
-	// The collapse/Expand action of a tree table is a bound action, as a result, a tree table should always have a selection mode to "Multi" when no selectionMode has been set in the manifest
+	// NEW: derive deletable from path expression instead of targetCapabilities.isDeletable
+	let pathDeletableExpression = isPathDeletable(converterContext.getDataModelObjectPath());
+	if (!isExpressionStaticallyResolvable(pathDeletableExpression)) {
+		// dynamic (depends on path/singleton) -> treat as "potentially deletable"
+		pathDeletableExpression = constant(true);
+	}
+	const deletableStaticFalse = isConstant(pathDeletableExpression) && pathDeletableExpression.value === false;
+
+	// TreeTable: default to Multi if not set
 	if (tableType === "TreeTable" && !selectionMode) {
 		return SelectionMode.Multi;
 	}
 
 	// If the selection mode is forced to 'None' in the manifest/macro table parameters, we keep it unless here is a delete button
 	if (!lineItemAnnotation || selectionMode === SelectionMode.None) {
-		if (targetCapabilities.isDeletable && deleteButtonVisibilityExpression) {
-			return compileExpression(ifElse(deleteButtonVisibilityExpression, constant(SelectionMode.Multi), constant(SelectionMode.None)));
-		}
-		return SelectionMode.None;
+		return compileExpression(ifElse(deleteButtonVisibilityExpression, constant(SelectionMode.Multi), constant(SelectionMode.None)));
 	}
 	if (selectionMode === SelectionMode.ForceMulti) {
 		return SelectionMode.Multi;
 	} else if (selectionMode === SelectionMode.ForceSingle) {
 		return SelectionMode.Single;
 	}
-	let aHiddenBindingExpressions: BindingToolkitExpression<boolean>[] = [],
-		aVisibleBindingExpressions: BindingToolkitExpression<boolean>[] = [];
+	let hiddenBindingExpressions: BindingToolkitExpression<boolean>[] = [],
+		visibleBindingExpressions: BindingToolkitExpression<boolean>[] = [];
 	const manifestActions = getActionsFromManifest(
 		converterContext.getManifestControlConfiguration<TableManifestConfiguration>(visualizationPath).actions,
 		converterContext,
@@ -1279,11 +1291,11 @@ export function getSelectionMode(
 		isParentDeletable = isPathDeletable(converterContext.getDataModelObjectPath());
 		parentEntitySetDeletable = isParentDeletable ? compileExpression(isParentDeletable, true) : isParentDeletable;
 	}
-	const bMassEditEnabled: boolean = !isConstant(massEditVisibilityExpression) || massEditVisibilityExpression.value !== false;
+	const massEditEnabled: boolean = !isConstant(massEditVisibilityExpression) || massEditVisibilityExpression.value !== false;
 	if (!selectionMode || selectionMode === SelectionMode.Auto) {
 		selectionMode = SelectionMode.Multi;
 	}
-	if (bMassEditEnabled) {
+	if (massEditEnabled) {
 		// Override default selection mode when mass edit is visible
 		selectionMode = selectionMode === SelectionMode.Single ? SelectionMode.Single : SelectionMode.Multi;
 	}
@@ -1293,25 +1305,24 @@ export function getSelectionMode(
 	) {
 		return selectionMode;
 	}
-	aHiddenBindingExpressions = getUIHiddenExpForActionsRequiringContext(
+	hiddenBindingExpressions = getUIHiddenExpForActionsRequiringContext(
 		lineItemAnnotation,
 		converterContext.getEntityType(),
 		converterContext.getDataModelObjectPath()
 	);
-	aVisibleBindingExpressions = getVisibleExpForCustomActionsRequiringContext(manifestActions.actions);
+	visibleBindingExpressions = getVisibleExpForCustomActionsRequiringContext(manifestActions.actions);
 	// No action requiring a context:
 	if (
-		aHiddenBindingExpressions.length === 0 &&
-		aVisibleBindingExpressions.length === 0 &&
-		(cutButtonVisibilityExpression || deleteButtonVisibilityExpression || bMassEditEnabled)
+		hiddenBindingExpressions.length === 0 &&
+		visibleBindingExpressions.length === 0 &&
+		(cutButtonVisibilityExpression || deleteButtonVisibilityExpression || massEditEnabled)
 	) {
 		if (!isEntitySet) {
-			// Example: OP case
-			if (targetCapabilities.isDeletable || parentEntitySetDeletable !== "false" || bMassEditEnabled) {
-				// Building expression for delete and mass edit
+			// OP case:
+			if (!deletableStaticFalse || parentEntitySetDeletable !== "false" || massEditEnabled) {
 				const buttonVisibilityExpression = or(
 					cutButtonVisibilityExpression || true,
-					deleteButtonVisibilityExpression || true, // default delete visibility as true
+					deleteButtonVisibilityExpression,
 					massEditVisibilityExpression
 				);
 				return compileExpression(
@@ -1322,23 +1333,19 @@ export function getSelectionMode(
 					ifElse(cutButtonVisibilityExpression, constant(SelectionMode.Single), constant(SelectionMode.None))
 				);
 			}
-			// EntitySet deletable:
-		} else if (bMassEditEnabled) {
-			// example: LR scenario
-			return selectionMode;
-		} else if (targetCapabilities.isDeletable && deleteButtonVisibilityExpression) {
-			return compileExpression(ifElse(deleteButtonVisibilityExpression, constant(selectionMode), constant(SelectionMode.None)));
-			// EntitySet not deletable:
 		} else {
-			return SelectionMode.None;
+			// EntitySet case:
+			return compileExpression(
+				ifElse(or(massEditEnabled, deleteButtonVisibilityExpression), constant(selectionMode), constant(SelectionMode.None))
+			);
 		}
 		// There are actions requiring a context:
 	} else if (!isEntitySet) {
-		// Example: OP case
-		if (targetCapabilities.isDeletable || parentEntitySetDeletable !== "false" || bMassEditEnabled) {
+		// OP case:
+		if (!deletableStaticFalse || parentEntitySetDeletable !== "false" || massEditEnabled) {
 			// Use selectionMode in edit mode if delete is enabled or mass edit is visible
 			const editModebuttonVisibilityExpression = ifElse(
-				bMassEditEnabled && !targetCapabilities.isDeletable,
+				massEditEnabled && deletableStaticFalse,
 				massEditVisibilityExpression,
 				constant(true)
 			);
@@ -1347,7 +1354,7 @@ export function getSelectionMode(
 					and(UI.IsEditable, editModebuttonVisibilityExpression),
 					constant(selectionMode),
 					ifElse(
-						or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions)),
+						or(...hiddenBindingExpressions.concat(visibleBindingExpressions)),
 						constant(selectionMode),
 						constant(SelectionMode.None)
 					)
@@ -1356,23 +1363,23 @@ export function getSelectionMode(
 		} else {
 			return compileExpression(
 				ifElse(
-					or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions)),
+					or(...hiddenBindingExpressions.concat(visibleBindingExpressions)),
 					constant(selectionMode),
 					constant(SelectionMode.None)
 				)
 			);
 		}
-		//EntitySet deletable:
-	} else if (targetCapabilities.isDeletable || bMassEditEnabled) {
-		// Example: LR scenario
-		return selectionMode;
-		//EntitySet not deletable:
+		// EntitySet
 	} else {
 		return compileExpression(
 			ifElse(
-				or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions), massEditVisibilityExpression),
+				or(massEditEnabled, deleteButtonVisibilityExpression),
 				constant(selectionMode),
-				constant(SelectionMode.None)
+				ifElse(
+					or(...hiddenBindingExpressions.concat(visibleBindingExpressions), massEditVisibilityExpression),
+					constant(selectionMode),
+					constant(SelectionMode.None)
+				)
 			)
 		);
 	}
@@ -1469,6 +1476,7 @@ function getDataFieldAnnotationAction(
 				text: dataField.Label?.toString(),
 				visible: compileExpression(visibleExpression(dataField, converterContext)),
 				isAIOperation: isMenuAIOperation(dataField.Actions) === true || undefined,
+				isNavigable: true,
 				menu: dataField.Actions.map((action) => getDataFieldAnnotationAction(action, converterContext))
 			} as AnnotationActionGroup;
 		default:
@@ -2115,14 +2123,12 @@ export function getTableAnnotationConfiguration(
 	const hasAbsolutePath = navigationPropertyPath.length === 0;
 	const p13nMode = getP13nMode(visualizationPath, converterContext, tableManifestConfiguration);
 	const id = navigationPropertyPath ? getTableID(visualizationPath) : getTableID(converterContext.getContextPath(), "LineItem");
-	const targetCapabilities = getCapabilityRestriction(converterContext);
 	const navigationTargetPath = getNavigationTargetPath(converterContext, navigationPropertyPath);
 	const selectionMode = getSelectionMode(
 		lineItemAnnotation,
 		visualizationPath,
 		converterContext,
 		hasAbsolutePath,
-		targetCapabilities,
 		standardActionsConfiguration.deleteButtonVisibilityExpression,
 		standardActionsConfiguration.massEditButtonVisibilityExpression,
 		standardActionsConfiguration.cutButtonVisibilityExpression
@@ -2422,10 +2428,13 @@ function _useEnabledExpression(dataField: DataFieldForActionTypes, sEntityType:
 function updateTreeTableManifestConfiguration(
 	tableConfiguration: TableControlConfiguration,
 	tableSettings: TableManifestSettingsConfiguration,
-	converterContext: ConverterContext
+	converterContext: ConverterContext,
+	lineItemAnnotation: LineItem | undefined
 ): void {
 	const dataModelObjectPath = converterContext.getDataModelObjectPath();
-	tableConfiguration.hierarchyQualifier = tableSettings.hierarchyQualifier;
+	const entityType = converterContext.getAnnotationEntityType(lineItemAnnotation);
+
+	tableConfiguration.hierarchyQualifier = getHierarchyQualifier(entityType, tableSettings);
 	const hierarchyParentNavigationPropertyPath = getHierarchyParentNavigationPropertyPath(
 		dataModelObjectPath,
 		tableConfiguration.hierarchyQualifier!
@@ -2493,6 +2502,31 @@ export function getCustomFunctionInfo(
 	return { moduleName, methodName };
 }
 
+/**
+ * Gets the hierarchy qualifier from the manifest or the annotations.
+ * @param entityType The entity type of the table
+ * @param tableSettings The table configuration
+ * @returns the hierarchy qualifier or undefined if not found
+ */
+
+function getHierarchyQualifier(entityType: EntityType, tableSettings: TableManifestSettingsConfiguration): string | undefined {
+	if (tableSettings.hierarchyQualifier) {
+		return tableSettings.hierarchyQualifier;
+	}
+	const aggregationAnnotation = entityType.annotations?.Aggregation as EntityTypeAnnotations_Aggregation & { _keys?: string[] };
+	const hierarchyAnnotation = entityType.annotations?.Hierarchy as EntityTypeAnnotations_Hierarchy & { _keys?: string[] };
+	// We only check the hierarchyQualifier from the manifest when the tree table is specifically set, otherwise we get it from the annotations
+	// if both annotations have the same qualifier, use it
+	// If there is no qualifier or different qualifiers, the hierarchyQualifier remains undefined
+	// Note: In case of multiple hierarchies with the same qualifier, the first one found will be used
+	const qualifiedName = hierarchyAnnotation?._keys?.find(
+		(key) => key.includes("RecursiveHierarchy#") && aggregationAnnotation?._keys?.includes(key)
+	);
+	if (qualifiedName) {
+		return (hierarchyAnnotation as Record<string, { qualifier?: string }>)[qualifiedName]?.qualifier;
+	}
+}
+
 /**
  * Retrieve the table control configuration optimistic batch information.
  * @param tableManifestSettings The table configuration
@@ -2595,7 +2629,7 @@ export function getTableManifestConfiguration(
 		: {};
 	const customValidationFunction = tableSettings.creationMode?.customValidationFunction;
 	const exportRequestSize = tableSettings.exportRequestSize;
-	const tableType = getTableType(converterContext, tableManifestSettings);
+	const tableType = getTableType(converterContext, tableManifestSettings, lineItemAnnotation);
 	const analyticalConfiguration = tableSettings.analyticalConfiguration;
 	// By default, paste is enabled on an ObjectPage and on a ListReport with a draft TreeTable
 	const enablePaste =
@@ -2678,7 +2712,7 @@ export function getTableManifestConfiguration(
 	tableConfiguration.selectionChange = tableSettings.selectionChange;
 	tableConfiguration.rowPress = tableSettings.rowPress;
 	if (tableType === "TreeTable") {
-		updateTreeTableManifestConfiguration(tableConfiguration, tableSettings, converterContext);
+		updateTreeTableManifestConfiguration(tableConfiguration, tableSettings, converterContext, lineItemAnnotation);
 	}
 
 	if (tableSettings.headerVisible !== undefined) {
@@ -2694,12 +2728,32 @@ export function getTableManifestConfiguration(
 
 function getTableType(
 	converterContext: ConverterContext<PageContextPathTarget>,
-	tableManifestSettings?: TableManifestConfiguration
+	tableManifestSettings?: TableManifestConfiguration,
+	lineItemAnnotation?: LineItem
 ): TableType {
 	if (tableManifestSettings?.tableSettings?.type) {
 		// in case the application specified a table type we will use this one
 		return tableManifestSettings.tableSettings.type;
 	}
+	const entityType = converterContext.getAnnotationEntityType(lineItemAnnotation);
+	const aggregationHelper = new AggregationHelper(entityType, converterContext);
+	const requiredAllowedTransformations = ["filter", "identity", "orderby", "skip", "top", "groupby", "aggregate", "concat"];
+
+	if (
+		aggregationHelper.isAnalyticsSupported() &&
+		requiredAllowedTransformations.every(
+			(transformation: string) => aggregationHelper.getAllowedTransformations()?.includes(transformation)
+		)
+	) {
+		return "AnalyticalTable";
+	}
+
+	const hierarchyAnnotation = entityType.annotations?.Hierarchy as EntityTypeAnnotations_Hierarchy & { _keys?: string[] };
+	const aggregationAnnotation = entityType.annotations?.Aggregation as EntityTypeAnnotations_Aggregation & { _keys?: string[] };
+	if (hierarchyAnnotation?._keys?.some((key) => key.includes("RecursiveHierarchy#") && aggregationAnnotation?._keys?.includes(key))) {
+		// Check if there is at least one RecursiveHierarchy qualifier is present in both hierarchyAnnotation and aggregationAnnotation annotations
+		return "TreeTable";
+	}
 
 	// default is the ResponsiveTable
 	return "ResponsiveTable";