@sapui5/sap.fe.core 1.110.0 → 1.111.0

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

@@ -14,11 +14,12 @@ import type { SemanticKey } from "@sap-ux/vocabularies-types/vocabularies/Common
 import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import type { EntitySetAnnotations_Common } from "@sap-ux/vocabularies-types/vocabularies/Common_Edm";
 import type { EntitySetAnnotations_Session } from "@sap-ux/vocabularies-types/vocabularies/Session_Edm";
-import type {
+import {
 	CriticalityType,
 	DataField,
 	DataFieldAbstractTypes,
 	DataFieldForAction,
+	DataFieldForActionTypes,
 	DataFieldForAnnotation,
 	DataFieldForIntentBasedNavigation,
 	DataFieldTypes,
@@ -28,9 +29,10 @@ import type {
 	LineItem,
 	PresentationVariantType,
 	SelectionVariantType,
-	SelectOptionType
+	SelectOptionType,
+	UIAnnotationTerms,
+	UIAnnotationTypes
 } from "@sap-ux/vocabularies-types/vocabularies/UI";
-import { UIAnnotationTypes } from "@sap-ux/vocabularies-types/vocabularies/UI";
 import {
 	collectRelatedProperties,
 	collectRelatedPropertiesRecursively,
@@ -42,14 +44,17 @@ import {
 	isDataFieldTypes,
 	isDataPointFromDataFieldDefault
 } from "sap/fe/core/converters/annotations/DataField";
-import type {
-	AnnotationAction,
+import {
 	BaseAction,
 	CombinedAction,
 	CustomAction,
-	OverrideTypeAction
+	dataFieldIsCopyAction,
+	getActionsFromManifest,
+	getCopyAction,
+	isActionNavigable,
+	OverrideTypeAction,
+	removeDuplicateActions
 } from "sap/fe/core/converters/controls/Common/Action";
-import { getActionsFromManifest, isActionNavigable, removeDuplicateActions } from "sap/fe/core/converters/controls/Common/Action";
 import { Entity, UI } from "sap/fe/core/converters/helpers/BindingHelper";
 import type { ConfigurableObject, CustomElement } from "sap/fe/core/converters/helpers/ConfigurableObject";
 import { insertCustomElements, OverrideType, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
@@ -57,11 +62,13 @@ import { IssueCategory, IssueCategoryType, IssueSeverity, IssueType } from "sap/
 import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
 import tableFormatters from "sap/fe/core/formatters/TableFormatter";
 import { MessageType } from "sap/fe/core/formatters/TableFormatterTypes";
-import type { BindingToolkitExpression, CompiledBindingToolkitExpression } from "sap/fe/core/helpers/BindingToolkit";
 import {
 	and,
+	BindingToolkitExpression,
+	CompiledBindingToolkitExpression,
 	compileExpression,
 	constant,
+	EDM_TYPE_MAPPING,
 	equal,
 	formatResult,
 	getExpressionFromAnnotation,
@@ -82,8 +89,7 @@ import {
 	isPathSearchable,
 	isPathUpdatable
 } from "sap/fe/core/templating/DataModelPathHelper";
-import type { DisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
-import { EDM_TYPE_MAPPING, getDisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
+import { getDisplayMode, type DisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
 import { getNonSortablePropertiesRestrictions } from "sap/fe/core/templating/EntitySetHelper";
 import {
 	getAssociatedCurrencyProperty,
@@ -93,9 +99,10 @@ import {
 	isPathExpression,
 	isProperty
 } from "sap/fe/core/templating/PropertyHelper";
-import { isCollectionField } from "sap/fe/core/templating/UIFormatters";
-import { mDefaultTypeForEdmType } from "sap/fe/macros/DelegateUtil";
+import { isMultiValueField } from "sap/fe/core/templating/UIFormatters";
+import { DefaultTypeForEdmType } from "sap/fe/core/type/EDM";
 import ActionHelper from "sap/fe/macros/internal/helpers/ActionHelper";
+import Core from "sap/ui/core/Core";
 import type ConverterContext from "../../ConverterContext";
 import { AggregationHelper } from "../../helpers/Aggregation";
 import { isReferencePropertyStaticallyHidden } from "../../helpers/DataFieldHelper";
@@ -174,6 +181,8 @@ export type TableAnnotationConfiguration = {
 	create: CreateBehavior | CreateBehaviorExternal;
 	title: string;
 	searchable: boolean;
+
+	inlineCreationRowsHiddenInEditMode?: boolean;
 };
 
 /**
@@ -235,6 +244,7 @@ export type TableControlConfiguration = {
 	enableFullScreen: boolean;
 	showRowCount: boolean;
 	inlineCreationRowCount?: number;
+	inlineCreationRowsHiddenInEditMode?: boolean;
 	enableMassEdit: boolean | undefined;
 	enableAutoColumnWidth: boolean;
 	dataStateIndicatorFilter: string | undefined;
@@ -288,6 +298,7 @@ export type CustomBasedTableColumn = BaseTableColumn & {
 	isNavigable: boolean;
 	sortable: boolean;
 	visualSettings: { widthCalculation: null };
+	properties?: string[]; //We need the properties relativePath to be added to the $Select request for exporting
 };
 
 // Properties derived from Manifest to override Annotation configurations
@@ -318,7 +329,7 @@ export type configType = {
 	formatOptions: configTypeformatOptions;
 	typeInstance?: InstanceType<any>;
 	baseType?: string;
-	className?: keyof typeof mDefaultTypeForEdmType;
+	className?: keyof typeof DefaultTypeForEdmType;
 };
 
 export type exportSettings = Partial<{
@@ -368,6 +379,21 @@ export type AnnotationTableColumn = AnnotationTableColumnForOverride & {
 	isPartOfLineItem?: boolean; // temporary indicator to only allow filtering on navigation properties when they're part of a line item
 	additionalLabels?: string[];
 	exportDataPointTargetValue?: string;
+	aggregatable?: boolean;
+	extension?: ExtensionForAnalytics;
+};
+
+export type ExtensionForAnalytics = {
+	customAggregate?: {
+		contextDefiningProperties?: string[];
+	};
+};
+
+export type TechnicalColumn = AnnotationTableColumn & {
+	extension?: {
+		technicallyGroupable: boolean;
+		technicallyAggregatable: boolean;
+	};
 };
 
 export type VisualSettings = {
@@ -526,60 +552,60 @@ export const getAggregateDefinitionsFromEntityType = function (
 
 	// Keep a set of all currency/unit properties, as we don't want to consider them as aggregates
 	// They are aggregates for technical reasons (to manage multi-units situations) but it doesn't make sense from a user standpoint
-	const mCurrencyOrUnitProperties = new Set();
-	tableColumns.forEach((oColumn) => {
-		const oTableColumn = oColumn as AnnotationTableColumn;
-		if (oTableColumn.unit) {
-			mCurrencyOrUnitProperties.add(oTableColumn.unit);
+	const currencyOrUnitProperties = new Set();
+	tableColumns.forEach((column) => {
+		const tableColumn = column as AnnotationTableColumn;
+		if (tableColumn.unit) {
+			currencyOrUnitProperties.add(tableColumn.unit);
 		}
 	});
 
-	const aCustomAggregateAnnotations = aggregationHelper.getCustomAggregateDefinitions();
-	const mRawDefinitions: Record<string, string[]> = {};
+	const customAggregateAnnotations = aggregationHelper.getCustomAggregateDefinitions();
+	const definitions: Record<string, string[]> = {};
 
-	aCustomAggregateAnnotations.forEach((annotation) => {
-		const oAggregatedProperty = aggregationHelper._entityType.entityProperties.find((oProperty) => {
-			return oProperty.name === annotation.qualifier;
+	customAggregateAnnotations.forEach((annotation) => {
+		const aggregatedProperty = aggregationHelper._entityType.entityProperties.find((property) => {
+			return property.name === annotation.qualifier;
 		});
 
-		if (oAggregatedProperty) {
-			const aContextDefiningProperties = annotation.annotations?.Aggregation?.ContextDefiningProperties;
-			mRawDefinitions[oAggregatedProperty.name] = aContextDefiningProperties
-				? aContextDefiningProperties.map((oCtxDefProperty) => {
-						return oCtxDefProperty.value;
+		if (aggregatedProperty) {
+			const contextDefiningProperties = annotation.annotations?.Aggregation?.ContextDefiningProperties;
+			definitions[aggregatedProperty.name] = contextDefiningProperties
+				? contextDefiningProperties.map((ctxDefProperty) => {
+						return ctxDefProperty.value;
 				  })
 				: [];
 		}
 	});
-	const mResult: Record<string, AggregateData> = {};
+	const result: Record<string, AggregateData> = {};
 
-	tableColumns.forEach((oColumn) => {
-		const oTableColumn = oColumn as AnnotationTableColumn;
-		if (oTableColumn.propertyInfos === undefined && oTableColumn.relativePath) {
-			const aRawContextDefiningProperties = mRawDefinitions[oTableColumn.relativePath];
+	tableColumns.forEach((column) => {
+		const tableColumn = column as AnnotationTableColumn;
+		if (tableColumn.propertyInfos === undefined && tableColumn.relativePath) {
+			const rawContextDefiningProperties = definitions[tableColumn.relativePath];
 
-			// Ignore aggregates corresponding to currencies or units of measure and dummy created property for datapoint target Value
-			if (aRawContextDefiningProperties && !mCurrencyOrUnitProperties.has(oTableColumn.name)) {
-				mResult[oTableColumn.name] = {
+			// Ignore aggregates corresponding to currencies or units of measure
+			if (rawContextDefiningProperties && !currencyOrUnitProperties.has(tableColumn.name)) {
+				result[tableColumn.name] = {
 					defaultAggregate: {},
-					relativePath: oTableColumn.relativePath
+					relativePath: tableColumn.relativePath
 				};
-				const aContextDefiningProperties: string[] = [];
-				aRawContextDefiningProperties.forEach((contextDefiningPropertyName) => {
+				const contextDefiningProperties: string[] = [];
+				rawContextDefiningProperties.forEach((contextDefiningPropertyName) => {
 					const foundColumn = findColumnFromPath(contextDefiningPropertyName);
 					if (foundColumn) {
-						aContextDefiningProperties.push(foundColumn.name);
+						contextDefiningProperties.push(foundColumn.name);
 					}
 				});
 
-				if (aContextDefiningProperties.length) {
-					mResult[oTableColumn.name].defaultAggregate.contextDefiningProperties = aContextDefiningProperties;
+				if (contextDefiningProperties.length) {
+					result[tableColumn.name].defaultAggregate.contextDefiningProperties = contextDefiningProperties;
 				}
 			}
 		}
 	});
 
-	return mResult;
+	return result;
 };
 
 /**
@@ -605,6 +631,7 @@ export function updateTableVisualizationForType(
 			tableVisualization.enable$select = false;
 			tableVisualization.enable$$getKeepAliveContext = false;
 			tableVisualization.aggregates = aggregatesDefinitions;
+			_updatePropertyInfosWithAggregatesDefinitions(tableVisualization);
 
 			const allowedTransformations = aggregationHelper.getAllowedTransformations();
 			tableVisualization.enableAnalyticsSearch = allowedTransformations ? allowedTransformations.indexOf("search") >= 0 : true;
@@ -749,6 +776,7 @@ export function createTableVisualization(
 	const operationAvailableMap = getOperationAvailableMap(lineItemAnnotation, converterContext);
 	const semanticKeysAndHeaderInfoTitle = getSemanticKeysAndTitleInfo(converterContext);
 	const tableActions = getTableActions(lineItemAnnotation, visualizationPath, converterContext, navigationSettings);
+
 	const oVisualization: TableVisualization = {
 		type: VisualizationType.Table,
 		annotation: getTableAnnotationConfiguration(
@@ -1254,22 +1282,58 @@ export function getSelectionMode(
 function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPath: string, converterContext: ConverterContext) {
 	const tableActions: BaseAction[] = [];
 	const hiddenTableActions: BaseAction[] = [];
-	if (lineItemAnnotation) {
-		lineItemAnnotation.forEach((dataField: DataFieldAbstractTypes) => {
-			let tableAction: AnnotationAction | undefined;
-			if (
+
+	const copyDataField = getCopyAction(
+		lineItemAnnotation.filter((dataField) => {
+			return dataFieldIsCopyAction(dataField as DataFieldForActionTypes);
+		}) as DataFieldForActionTypes[]
+	);
+
+	if (copyDataField) {
+		tableActions.push({
+			type: ActionType.Copy,
+			annotationPath: converterContext.getEntitySetBasedAnnotationPath(copyDataField.fullyQualifiedName),
+			key: KeyHelper.generateKeyFromDataField(copyDataField),
+			enabled: compileExpression(equal(pathInModel("numberOfSelectedContexts", "internal"), 1)),
+			visible: compileExpression(
+				not(
+					equal(
+						getExpressionFromAnnotation(
+							copyDataField.annotations?.UI?.Hidden,
+							[],
+							undefined,
+							converterContext.getRelativeModelPathFunction()
+						),
+						true
+					)
+				)
+			),
+			text: copyDataField.Label?.toString() ?? Core.getLibraryResourceBundle("sap.fe.core").getText("C_COMMON_COPY"),
+			isNavigable: true
+		});
+	}
+
+	lineItemAnnotation
+		.filter((dataField) => {
+			return !dataFieldIsCopyAction(dataField as DataFieldForAction);
+		})
+		.forEach((dataField: DataFieldAbstractTypes) => {
+			if (dataField.annotations?.UI?.Hidden?.valueOf() === true) {
+				hiddenTableActions.push({
+					type: ActionType.Default,
+					key: KeyHelper.generateKeyFromDataField(dataField)
+				});
+			} else if (
 				isDataFieldForActionAbstract(dataField) &&
-				!(dataField.annotations?.UI?.Hidden?.valueOf() === true) &&
-				!dataField.Inline &&
-				!dataField.Determining
+				dataField.Inline?.valueOf() !== true &&
+				dataField.Determining?.valueOf() !== true
 			) {
-				const key = KeyHelper.generateKeyFromDataField(dataField);
 				switch (dataField.$Type) {
-					case "com.sap.vocabularies.UI.v1.DataFieldForAction":
-						tableAction = {
+					case UIAnnotationTypes.DataFieldForAction:
+						tableActions.push({
 							type: ActionType.DataFieldForAction,
 							annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
-							key: key,
+							key: KeyHelper.generateKeyFromDataField(dataField),
 							visible: compileExpression(
 								not(
 									equal(
@@ -1284,14 +1348,14 @@ function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPa
 								)
 							),
 							isNavigable: true
-						};
+						});
 						break;
 
-					case "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation":
-						tableAction = {
+					case UIAnnotationTypes.DataFieldForIntentBasedNavigation:
+						tableActions.push({
 							type: ActionType.DataFieldForIntentBasedNavigation,
 							annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
-							key: key,
+							key: KeyHelper.generateKeyFromDataField(dataField),
 							visible: compileExpression(
 								not(
 									equal(
@@ -1305,25 +1369,17 @@ function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPa
 									)
 								)
 							)
-						};
+						});
 						break;
 					default:
 						break;
 				}
-			} else if (dataField.annotations?.UI?.Hidden?.valueOf() === true) {
-				hiddenTableActions.push({
-					type: ActionType.Default,
-					key: KeyHelper.generateKeyFromDataField(dataField)
-				});
-			}
-			if (tableAction) {
-				tableActions.push(tableAction);
 			}
 		});
-	}
+
 	return {
-		tableActions: tableActions,
-		hiddenTableActions: hiddenTableActions
+		tableActions,
+		hiddenTableActions
 	};
 }
 
@@ -2064,6 +2120,49 @@ const _getAnnotationColumnName = function (dataField: DataFieldAbstractTypes) {
 	}
 };
 
+/**
+ * Creates a PropertyInfo for the identified additional property for the ALP table use-case.
+ *
+ * For e.g. If UI.Hidden points to a property, include this technical property in the additionalProperties of ComplexPropertyInfo object.
+ *
+ * @param name The name of the property to be created.
+ * @param columns The list of columns created for LineItems and Properties of entityType from the table visualization.
+ * @returns The propertyInfo of the technical property to be added to the list of columns.
+ * @private
+ */
+
+const createTechnicalProperty = function (name: string, columns: TableColumn[], relatedAdditionalPropertyNameMap: Record<string, string>) {
+	const key = `Property_Technical::${name}`;
+	// Validate if the technical property hasn't yet been created on previous iterations.
+	const columnExists = columns.find((column) => column.key === key);
+	// Retrieve the simple property used by the hidden annotation, it will be used as a base for the mandatory attributes of newly created technical property. For e.g. relativePath
+	const additionalProperty =
+		!columnExists && (columns.find((column) => column.name === name && !column.propertyInfos) as AnnotationTableColumn)!;
+	if (additionalProperty) {
+		const technicalColumn: TechnicalColumn = {
+			key: key,
+			type: ColumnType.Annotation,
+			label: additionalProperty.label,
+			annotationPath: additionalProperty.annotationPath,
+			availability: AvailabilityType.Hidden,
+			name: key,
+			relativePath: additionalProperty.relativePath,
+			sortable: false,
+			isGroupable: false,
+			isKey: false,
+			exportSettings: null,
+			caseSensitive: false,
+			aggregatable: false,
+			extension: {
+				technicallyGroupable: true,
+				technicallyAggregatable: true
+			}
+		};
+		columns.push(technicalColumn);
+		relatedAdditionalPropertyNameMap[name] = technicalColumn.name;
+	}
+};
+
 /**
  * Determines if the data field labels have to be displayed in the table.
  *
@@ -2136,7 +2235,7 @@ const _sliceAtSlash = function (path: string, isLastSlash: boolean, isLastPart:
 const _isColumnMultiValued = function (dataField: DataFieldAbstractTypes, converterContext: ConverterContext): boolean {
 	if (isDataFieldTypes(dataField) && isPathExpression(dataField.Value)) {
 		const propertyObjectPath = enhanceDataModelPath(converterContext.getDataModelObjectPath(), dataField.Value.path);
-		return isCollectionField(propertyObjectPath);
+		return isMultiValueField(propertyObjectPath);
 	} else {
 		return false;
 	}
@@ -2438,7 +2537,7 @@ const getColumnsFromAnnotations = function (
 			const isGroup: boolean = groupPath != relativePath;
 			const sLabel: string | undefined = getLabel(lineItem, isGroup);
 			const name = _getAnnotationColumnName(lineItem);
-			const isFieldGroupColumn: boolean = groupPath.indexOf("@com.sap.vocabularies.UI.v1.FieldGroup") > -1;
+			const isFieldGroupColumn: boolean = groupPath.indexOf(`@${UIAnnotationTerms.FieldGroup}`) > -1;
 			const showDataFieldsLabel: boolean = isFieldGroupColumn
 				? _getShowDataFieldsLabel(name, visualizationPath, converterContext)
 				: false;
@@ -2479,7 +2578,7 @@ const getColumnsFromAnnotations = function (
 
 			const propertyTypeConfig = dataType && getTypeConfig(lineItem, dataType);
 			const typeConfig: configType = {
-				className: dataType as keyof typeof mDefaultTypeForEdmType,
+				className: dataType as keyof typeof DefaultTypeForEdmType,
 				formatOptions: {
 					...formatOptions,
 					...propertyTypeConfig?.formatOptions
@@ -2720,7 +2819,8 @@ const getColumnsFromManifest = function (
 				isGroupable: false,
 				isNavigable: false,
 				sortable: false,
-				visualSettings: { widthCalculation: null }
+				visualSettings: { widthCalculation: null },
+				properties: manifestColumn.properties
 			};
 			if (propertyInfos) {
 				_updateLinkedPropertiesOnCustomColumns(propertyInfos, annotationColumns);
@@ -2943,6 +3043,43 @@ function getGroupConditions(
 	}
 	return groupConditions;
 }
+/**
+ * Updates the column's propertyInfos of a analytical table integrating all extensions and binding-relevant property info part.
+ *
+ * @param tableVisualization The visualization to be updated
+ */
+
+function _updatePropertyInfosWithAggregatesDefinitions(tableVisualization: TableVisualization) {
+	const relatedAdditionalPropertyNameMap: Record<string, string> = {};
+	tableVisualization.columns.forEach((column) => {
+		column = column as AnnotationTableColumn;
+		const aggregatablePropertyName = Object.keys(tableVisualization.aggregates!).find((aggregate) => aggregate === column.name);
+		if (aggregatablePropertyName) {
+			const aggregatablePropertyDefinition = tableVisualization.aggregates![aggregatablePropertyName];
+			column.aggregatable = true;
+			column.extension = {
+				customAggregate: aggregatablePropertyDefinition.defaultAggregate ?? {}
+			};
+		}
+		if (column.additionalPropertyInfos?.length) {
+			column.additionalPropertyInfos.forEach((additionalPropertyInfo) => {
+				// Create propertyInfo for each additional property.
+				// The new property 'name' has been prefixed with 'Property_Technical::' for uniqueness and it has been named technical property as it requires dedicated MDC attributes (technicallyGroupable and technicallyAggregatable).
+				createTechnicalProperty(additionalPropertyInfo, tableVisualization.columns, relatedAdditionalPropertyNameMap);
+			});
+		}
+	});
+	tableVisualization.columns.forEach((column) => {
+		column = column as AnnotationTableColumn;
+		if (column.additionalPropertyInfos) {
+			column.additionalPropertyInfos = column.additionalPropertyInfos.map(
+				(propertyInfo) => relatedAdditionalPropertyNameMap[propertyInfo] ?? propertyInfo
+			);
+			// Add additional properties to the complex property using the hidden annotation.
+			column.propertyInfos = column.propertyInfos?.concat(column.additionalPropertyInfos);
+		}
+	});
+}
 
 /**
  * Returns a JSON string containing Presentation Variant aggregate conditions.
@@ -3247,8 +3384,7 @@ function _getFilters(
 	}
 	return {
 		quickFilters: {
-			enabled:
-				converterContext.getTemplateType() === TemplateType.ListReport ? "{= ${pageInternal>hasPendingFilters} !== true}" : true,
+			enabled: converterContext.getTemplateType() !== TemplateType.ListReport,
 			showCounts: tableSettings?.quickVariantSelection?.showCounts,
 			paths: quickFilterPaths
 		}
@@ -3344,6 +3480,7 @@ export function getTableManifestConfiguration(
 		multiSelectMode: _getMultiSelectMode(tableSettings, tableType, converterContext),
 		selectionLimit: _getTableSelectionLimit(tableSettings),
 		inlineCreationRowCount: _getTableInlineCreationRowCount(tableSettings),
+		inlineCreationRowsHiddenInEditMode: tableSettings?.creationMode?.inlineCreationRowsHiddenInEditMode ?? false,
 		showRowCount: !tableSettings?.quickVariantSelection?.showCounts && !_manifestWrapper.getViewConfiguration()?.showCounts,
 		type: tableType,
 		useCondensedTableLayout: condensedTableLayout && isCondensedTableLayoutCompliant,
@@ -3387,7 +3524,7 @@ export function getTypeConfig(oProperty: Property | DataFieldAbstractTypes, data
 					: undefined,
 			isDigitSequence:
 				propertyTypeConfig.type === "sap.ui.model.odata.type.String" &&
-				oTargetMapping.constraints?.["@com.sap.vocabularies.Common.v1.IsDigitSequence"] &&
+				oTargetMapping.constraints?.[`@${CommonAnnotationTerms.IsDigitSequence}`] &&
 				oProperty.annotations?.Common?.IsDigitSequence
 					? true
 					: undefined