@sapui5/sap.fe.core 1.121.2 → 1.123.0

package/src/sap/fe/core/helpers/PasteHelper.ts

@@ -3,11 +3,14 @@ import type PageController from "sap/fe/core/PageController";
 import type TableAPI from "sap/fe/macros/table/TableAPI";
 import MessageBox from "sap/m/MessageBox";
 import Library from "sap/ui/core/Lib";
+import Messaging from "sap/ui/core/Messaging";
+import type Message from "sap/ui/core/message/Message";
 import type { PasteHelperParseResult } from "sap/ui/core/util/PasteHelper";
 import * as CorePasteHelper from "sap/ui/core/util/PasteHelper";
 import type Table from "sap/ui/mdc/Table";
 import type { PropertyInfo } from "sap/ui/mdc/Table";
 import type TableDelegate from "sap/ui/mdc/TableDelegate";
+import type Column from "sap/ui/mdc/table/Column";
 import type Context from "sap/ui/model/Context";
 import type ODataV4Context from "sap/ui/model/odata/v4/Context";
 
@@ -16,6 +19,13 @@ export type customValidationMessage = {
 	messageTarget?: string;
 };
 
+type PasteInformation = {
+	rows: ODataV4Context[];
+	columns: Column[];
+	updatedRowCount: number;
+	numberOfNewCreationRows: number;
+};
+
 const getInfoForEntityProperty = function (propertyPath: any, rowBindingPath: any, metaContext: any, metaModel: any): any {
 	const property = metaContext.getProperty(propertyPath),
 		formatOptions = { parseKeepsEmptyString: true },
@@ -72,7 +82,14 @@ const PasteHelper = {
 		}
 		return errorMessage;
 	},
-	getColumnInfo: async function (table: Table): Promise<PasteColumnInfo[]> {
+	/**
+	 * Get details about table columns.
+	 *
+	 * @param table The table which contains the columns to be analyzed
+	 * @param columns A list of columns to be analyzed. If undefined, all columns from the table are analyzed
+	 * @returns An array of objects providing details about columns.
+	 */
+	getColumnInfo: async function (table: Table, columns?: Column[]): Promise<PasteColumnInfo[]> {
 		const model = table.getRowBinding().getModel(),
 			metaModel = model.getMetaModel(),
 			rowBindingPath = model.resolve(table.getRowBinding().getPath(), table.getRowBinding().getContext()),
@@ -83,7 +100,7 @@ const PasteHelper = {
 				...propertyInfo.map((property: PropertyInfo) => ({ [property.name]: property }))
 			);
 			const columnInfos: PasteColumnInfo[] = [];
-			table.getColumns().forEach((column) => {
+			(columns ?? table.getColumns()).forEach((column) => {
 				const infoProperty = propertyInfoDict[column.getPropertyKey()];
 				// Check if it's a complex property (property associated to multiple simple properties)
 				if (infoProperty.propertyInfos) {
@@ -128,8 +145,16 @@ const PasteHelper = {
 	},
 	getInfoForEntityProperty: getInfoForEntityProperty,
 
-	parsePastedData: async function (rawData: unknown[][], table: Table): Promise<Record<string, unknown>[]> {
-		return this.getColumnInfo(table)
+	/**
+	 * Transform an array of data by parsing it into an array of objects, facilitating the mapping of columns and data.
+	 *
+	 * @param rawData The table which contains the columns to be analyzed
+	 * @param table The table which receives the data
+	 * @param columns A list of columns to be used to map the data. If undefined, all table columns are used
+	 * @returns A collection of objects that associates data with corresponding columns.
+	 */
+	parsePastedData: async function (rawData: unknown[][], table: Table, columns?: Column[]): Promise<Record<string, unknown>[]> {
+		return this.getColumnInfo(table, columns)
 			.then(function (pasteInfos: any[]) {
 				// Check if we have data for at least the first editable column
 				const pastedColumnCount = rawData.length ? rawData[0].length : 0;
@@ -155,6 +180,216 @@ const PasteHelper = {
 				}
 			});
 	},
+
+	/**
+	 * Update an array of contexts.
+	 *
+	 * @param contexts Array of contexts to be updated
+	 * @param data Array of object containing the data to be used to update the contexts
+	 * @returns Promise
+	 */
+	_updateContexts: async function (contexts: (ODataV4Context | undefined)[], data: Record<string, unknown>[]): Promise<void> {
+		let index = 0;
+		const setPropertyPromises = [];
+		for (const row of data) {
+			const rowContext = contexts[index++];
+			if (rowContext) {
+				for (const key in row) {
+					setPropertyPromises.push(rowContext.setProperty(key, row[key]));
+				}
+			}
+		}
+		await Promise.allSettled(setPropertyPromises);
+	},
+
+	/**
+	 *  Get information about the paste operation on ResponsiveTable.
+	 * @param rawData
+	 * @param cellSelection
+	 * @param cellSelection.columns
+	 * @param cellSelection.rows
+	 * @param posFirstSelectedRow
+	 * @param table
+	 * @returns Objet containing Information about the pasting operation
+	 */
+	getPasteInformationForReponsiveTable: function (
+		rawData: string[][],
+		cellSelection: { columns: Column[]; rows: ODataV4Context[] },
+		posFirstSelectedRow: number,
+		table: Table
+	): PasteInformation {
+		let numberOfNewCreationRows = 0;
+		const posFirstInlineCreationRowInTable = table
+			.getRowBinding()
+			.getCurrentContexts()
+			.findIndex((context) => context.isTransient());
+		const rows = cellSelection.rows;
+		let updatedRowCount = 0;
+		const columns =
+			cellSelection.columns.length > 1
+				? cellSelection.columns
+				: table.getColumns().slice(table.getColumns().indexOf(cellSelection.columns[0]));
+
+		// only one cell is selected
+		if (cellSelection.columns.length === 1 && cellSelection.rows.length === 1) {
+			// check if the inline creation row is in the targeted range
+			if (
+				posFirstSelectedRow <= posFirstInlineCreationRowInTable &&
+				posFirstSelectedRow + rawData.length > posFirstInlineCreationRowInTable
+			) {
+				numberOfNewCreationRows = rawData.length - (posFirstInlineCreationRowInTable - posFirstSelectedRow) - 1;
+				updatedRowCount = rawData.length;
+			} else {
+				// the inline creation row is not in the targeted range
+				numberOfNewCreationRows = 0;
+				updatedRowCount = rawData.length;
+			}
+		} else {
+			// multiple cells are selected
+			const lastInlineCreationRowInSelection = rows.filter((context) => context.isTransient())?.pop();
+			const posLastInlineCreationRowInSelection = lastInlineCreationRowInSelection
+				? rows.indexOf(lastInlineCreationRowInSelection)
+				: -1;
+			updatedRowCount = Math.min(rawData.length, cellSelection.rows.length);
+			// check if the inline creation row is in the selected range
+			if (posLastInlineCreationRowInSelection > -1) {
+				updatedRowCount = posLastInlineCreationRowInSelection === cellSelection.rows.length - 1 ? rawData.length : updatedRowCount;
+				numberOfNewCreationRows =
+					posLastInlineCreationRowInSelection === cellSelection.rows.length - 1
+						? rawData.length - posLastInlineCreationRowInSelection - 1
+						: 0;
+			}
+		}
+		return { rows, columns, updatedRowCount, numberOfNewCreationRows };
+	},
+
+	/**
+	 *  Get information about the paste operation on GridTable.
+	 * @param rawData
+	 * @param cellSelection
+	 * @param cellSelection.columns
+	 * @param cellSelection.rows
+	 * @param posFirstSelectedRow
+	 * @param table
+	 * @returns Objet containing Information about the pasting operation
+	 */
+	getPasteInformationForGridTable: function (
+		rawData: string[][],
+		cellSelection: { columns: Column[]; rows: ODataV4Context[] },
+		posFirstSelectedRow: number,
+		table: Table
+	): PasteInformation {
+		let numberOfNewCreationRows = 0;
+		const rows = cellSelection.rows;
+		let updatedRowCount = 0;
+		const tableRowcCount = table.getRowBinding().getLength();
+		let columns =
+			cellSelection.columns.length > 1
+				? cellSelection.columns
+				: table.getColumns().slice(table.getColumns().indexOf(cellSelection.columns[0]));
+		if (cellSelection.columns.length === 1 && cellSelection.rows.length === 1) {
+			numberOfNewCreationRows =
+				posFirstSelectedRow + rawData.length > tableRowcCount ? posFirstSelectedRow + rawData.length - tableRowcCount : 0;
+			columns = table.getColumns().slice(table.getColumns().indexOf(cellSelection.columns[0]));
+			updatedRowCount = rawData.length;
+		} else {
+			// multiple cells are selected
+			numberOfNewCreationRows =
+				posFirstSelectedRow + rows.length >= tableRowcCount ? posFirstSelectedRow + rawData.length - tableRowcCount : 0;
+			updatedRowCount = numberOfNewCreationRows === 0 ? Math.min(rawData.length, cellSelection.rows.length) : rawData.length;
+		}
+		return { rows, columns, updatedRowCount, numberOfNewCreationRows };
+	},
+
+	/**
+	 *  Get information about the paste operation.
+	 * @param rawData
+	 * @param cellSelection
+	 * @param cellSelection.columns
+	 * @param cellSelection.rows
+	 * @param posFirstSelectedRow
+	 * @param table
+	 * @returns Objet containing Information about the pasting operation
+	 */
+	getPasteInformation: function (
+		rawData: string[][],
+		cellSelection: { columns: Column[]; rows: ODataV4Context[] },
+		posFirstSelectedRow: number,
+		table: Table
+	): PasteInformation | null {
+		let pasteInformation: PasteInformation | null = null;
+
+		switch (table.data("tableType")) {
+			case "GridTable":
+				pasteInformation = this.getPasteInformationForGridTable(rawData, cellSelection, posFirstSelectedRow, table);
+				break;
+			case "ResponsiveTable":
+				pasteInformation = this.getPasteInformationForReponsiveTable(rawData, cellSelection, posFirstSelectedRow, table);
+				break;
+			default:
+				Log.warning(`Paste operation is not supported for table type ${table.data("tableType")}`);
+		}
+
+		return pasteInformation;
+	},
+
+	/**
+	 * Paste data into a table using a selection of column and rows.
+	 *
+	 * @param rawData The data to be pasted into the table
+	 * @param cellSelection The columns and the rows to be updated
+	 * @param cellSelection.columns The columns to be updated
+	 * @param cellSelection.rows The rows to be updated
+	 * @param table The table
+	 * @returns Object containing information about the paste
+	 */
+	pasteRangeData: async function (
+		rawData: string[][],
+		cellSelection: { columns: Column[]; rows: ODataV4Context[] },
+		table: Table
+	): Promise<
+		| {
+				updatedRowCount: number;
+				updatedColCount: number;
+				numberOfNewCreationRows: number;
+				posFirstInlineCreationRow: number | undefined;
+		  }
+		| undefined
+	> {
+		const posFirstSelectedRow = cellSelection.rows[0].getIndex()!;
+
+		const pasteInfo = this.getPasteInformation(rawData, cellSelection, posFirstSelectedRow, table);
+		if (!pasteInfo) return;
+
+		const parsedData = await this.parsePastedData(rawData, table, pasteInfo.columns);
+		if (parsedData.length > 0) {
+			if (pasteInfo.numberOfNewCreationRows > 0) {
+				await (table.getParent() as TableAPI).createEmptyRows(
+					table.getRowBinding(),
+					table,
+					false,
+					pasteInfo.numberOfNewCreationRows,
+					true
+				);
+			}
+
+			//load missing rows if needed including the newly created rows
+			pasteInfo.rows = await table.getRowBinding().requestContexts(posFirstSelectedRow, pasteInfo.updatedRowCount);
+			await this._updateContexts(pasteInfo.rows, parsedData);
+
+			// focusing on the first available creation row
+			const posFirstInlineCreationRow = pasteInfo.rows.find((context) => context.isTransient())?.getIndex();
+			if (posFirstInlineCreationRow) {
+				table.focusRow(posFirstInlineCreationRow);
+			}
+			return {
+				updatedRowCount: pasteInfo.updatedRowCount,
+				updatedColCount: Object.keys(parsedData[0]).length,
+				numberOfNewCreationRows: pasteInfo.numberOfNewCreationRows < 0 ? 0 : pasteInfo.numberOfNewCreationRows,
+				posFirstInlineCreationRow
+			};
+		}
+	},
 	pasteData: async function (rawData: string[][], table: Table, controller: PageController): Promise<Context[] | undefined> {
 		const editFlow = controller.editFlow;
 		const tableDefinition = (table.getParent() as TableAPI).getTableDefinition();
@@ -190,15 +425,32 @@ const PasteHelper = {
 				return aData;
 			})
 			.then(async (aValidatedData): Promise<Context[] | undefined> => {
-				return aValidatedData.length > 0
-					? editFlow.createMultipleDocuments(
-							table.getRowBinding(),
-							aValidatedData,
-							tableDefinition?.control?.createAtEnd,
-							true,
-							(controller as any).editFlow.onBeforeCreate
-					  )
-					: undefined;
+				// remove the last transient context if it exists
+				const transientContexts = table
+					.getRowBinding()
+					.getCurrentContexts()
+					.filter((context) => context.isTransient());
+				const lastTransientContext = transientContexts.pop();
+				//check if the last transient context has an error message
+				const lastTransientContextHasErrorMessage = !!Messaging.getMessageModel()
+					.getData()
+					.find((message: Message) => lastTransientContext && message.getTargets()[0].includes(lastTransientContext.getPath()));
+				const newContexts =
+					aValidatedData.length > 0
+						? await editFlow.createMultipleDocuments(
+								table.getRowBinding(),
+								aValidatedData,
+								tableDefinition?.control?.createAtEnd,
+								true,
+								controller.editFlow.onBeforeCreate
+						  )
+						: undefined;
+				// if the last transient context has no error message, delete it and recreate a new one at the last position
+				if (lastTransientContext && !lastTransientContextHasErrorMessage) {
+					lastTransientContext?.delete();
+					await (table.getParent() as TableAPI).createEmptyRows(table.getRowBinding(), table, false, 1);
+				}
+				return newContexts;
 			})
 			.catch((oError) => {
 				Log.error("Error while pasting data", oError);

package/src/sap/fe/core/helpers/PromiseKeeper.js

@@ -0,0 +1,66 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2024 SAP SE. All rights reserved
+ */
+sap.ui.define([], function () {
+  "use strict";
+
+  var _exports = {};
+  /**
+   * Helper class that allows to create a Promise and resolve it "from the outside".
+   *
+   * For example, to return a string promise that is resolved when an event is fired:
+   * <code>
+   * 		const keeper = new PromiseKeeper<string>();
+   * 		eventProvider.attachEvent('myEvent', () => {
+   * 			keeper.resolve("I'm resolved!!");
+   * 		});
+   *
+   * 		return keeper.promise;
+   * </code>
+   */
+  let PromiseKeeper = /*#__PURE__*/function () {
+    /**
+     * The Promise wrapped by the PromiseKeeper
+     */
+
+    function PromiseKeeper() {
+      this.promise = new Promise((resolve, reject) => {
+        this.resolver = resolve;
+        this.rejector = reject;
+      });
+    }
+
+    /**
+     * Resolves the wrapped Promise.
+     *
+     * @param result The resolved value.
+     */
+    _exports = PromiseKeeper;
+    var _proto = PromiseKeeper.prototype;
+    _proto.resolve = function resolve(result) {
+      if (this.resolver) {
+        this.resolver(result);
+      }
+    }
+
+    /**
+     * Rejects the wrapped Promise. The promise is always rejected using an Error object.
+     *
+     * @param error The error or error message for the rejection.
+     */;
+    _proto.reject = function reject(error) {
+      if (this.rejector) {
+        if (error === undefined || typeof error === "string") {
+          this.rejector(new Error(error));
+        } else {
+          this.rejector(error);
+        }
+      }
+    };
+    return PromiseKeeper;
+  }();
+  _exports = PromiseKeeper;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/sap/fe/core/helpers/PromiseKeeper.ts

@@ -0,0 +1,56 @@
+/**
+ * Helper class that allows to create a Promise and resolve it "from the outside".
+ *
+ * For example, to return a string promise that is resolved when an event is fired:
+ * <code>
+ * 		const keeper = new PromiseKeeper<string>();
+ * 		eventProvider.attachEvent('myEvent', () => {
+ * 			keeper.resolve("I'm resolved!!");
+ * 		});
+ *
+ * 		return keeper.promise;
+ * </code>
+ */
+export default class PromiseKeeper<Type> {
+	private resolver?: (result: Type) => void;
+
+	private rejector?: (error: Error) => void;
+
+	/**
+	 * The Promise wrapped by the PromiseKeeper
+	 */
+	public readonly promise: Promise<Type>;
+
+	constructor() {
+		this.promise = new Promise<Type>((resolve, reject) => {
+			this.resolver = resolve;
+			this.rejector = reject;
+		});
+	}
+
+	/**
+	 * Resolves the wrapped Promise.
+	 *
+	 * @param result The resolved value.
+	 */
+	resolve(result: Type): void {
+		if (this.resolver) {
+			this.resolver(result);
+		}
+	}
+
+	/**
+	 * Rejects the wrapped Promise. The promise is always rejected using an Error object.
+	 *
+	 * @param error The error or error message for the rejection.
+	 */
+	reject(error?: string | Error): void {
+		if (this.rejector) {
+			if (error === undefined || typeof error === "string") {
+				this.rejector(new Error(error));
+			} else {
+				this.rejector(error);
+			}
+		}
+	}
+}

package/src/sap/fe/core/helpers/SemanticKeyHelper.js

@@ -17,6 +17,21 @@ sap.ui.define(["sap/base/Log"], function (Log) {
         semanticKeys: aSemanticKeys
       };
     },
+    /**
+     * Returns a stringified version of a list of key values, e.g. [{name:"aa", value:1}, {name:"bb", value:"foo"}] --> "aa=1,bb='foo'".
+     *
+     * @param valuePairs
+     * @param typeMetadata
+     * @returns String
+     */
+    getPathContent(valuePairs, typeMetadata) {
+      const singleKey = valuePairs.length === 1;
+      return valuePairs.map(valuePair => {
+        const keyValue = valuePair.value;
+        const encodedKeyValue = typeMetadata[valuePair.name].$Type === "Edm.String" ? `'${encodeURIComponent(keyValue)}'` : keyValue;
+        return singleKey ? encodedKeyValue : `${valuePair.name}=${encodedKeyValue}`;
+      }).join(",");
+    },
     getSemanticPath: function (oContext) {
       let bStrict = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
       const oMetaModel = oContext.getModel().getMetaModel(),
@@ -28,28 +43,24 @@ sap.ui.define(["sap/base/Log"], function (Log) {
       } else {
         sTechnicalPath = oContext.getPath();
       }
-      if (this._isPathForSemantic(sTechnicalPath) && oSemanticObjectInformation.semanticKeys) {
+      if (this._isPathForSemantic(sTechnicalPath) && oSemanticObjectInformation.semanticKeys && oSemanticObjectInformation.semanticKeys.length !== 0) {
         const aSemanticKeys = oSemanticObjectInformation.semanticKeys;
         const oEntityType = oMetaModel.getObject("/" + oMetaModel.getObject(`/${sEntitySetName}`).$Type);
         try {
-          const sSemanticKeysPart = aSemanticKeys.map(function (oSemanticKey) {
-            const sPropertyPath = oSemanticKey.$PropertyPath;
-            let sKeyValue = oContext.getProperty(sPropertyPath);
-            if (sKeyValue === undefined || sKeyValue === null) {
-              throw new Error(`Couldn't resolve semantic key value for ${sPropertyPath}`);
-            } else {
-              if (oEntityType[sPropertyPath].$Type === "Edm.String") {
-                sKeyValue = `'${encodeURIComponent(sKeyValue)}'`;
-              }
-              if (aSemanticKeys.length > 1) {
-                // Several semantic keys --> path should be entitySet(key1=value1, key2=value2, ...)
-                // Otherwise we keep entitySet(keyValue)
-                sKeyValue = `${sPropertyPath}=${sKeyValue}`;
-              }
-              return sKeyValue;
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const keyValues = aSemanticKeys.map(semanticKey => {
+            const keyName = semanticKey.$PropertyPath;
+            const keyValue = oContext.getProperty(keyName);
+            if (keyValue === undefined || keyValue === null) {
+              throw new Error(`Couldn't resolve semantic key value for ${keyName}`);
             }
-          }).join(",");
-          sSemanticPath = `/${sEntitySetName}(${sSemanticKeysPart})`;
+            return {
+              name: keyName,
+              value: keyValue
+            };
+          });
+          const semanticKeysPart = this.getPathContent(keyValues, oEntityType);
+          sSemanticPath = `/${sEntitySetName}(${semanticKeysPart})`;
         } catch (e) {
           Log.info(e);
         }
@@ -67,4 +78,4 @@ sap.ui.define(["sap/base/Log"], function (Log) {
   };
   return SemanticKeyHelper;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["SemanticKeyHelper","getSemanticKeys","oMetaModel","sEntitySetName","getObject","getSemanticObjectInformation","oSemanticObject","aSemanticKeys","semanticObject","semanticKeys","getSemanticPath","oContext","bStrict","getModel","getMetaModel","getMetaContext","getPath","oSemanticObjectInformation","sTechnicalPath","sSemanticPath","isA","isRelative","getHeaderContext","_isPathForSemantic","oEntityType","$Type","sSemanticKeysPart","map","oSemanticKey","sPropertyPath","$PropertyPath","sKeyValue","getProperty","undefined","Error","encodeURIComponent","length","join","e","Log","info","sPath","test"],"sourceRoot":".","sources":["SemanticKeyHelper.ts"],"sourcesContent":["import type { PropertyPath } from \"@sap-ux/vocabularies-types\";\nimport type { SemanticObject } from \"@sap-ux/vocabularies-types/vocabularies/Common\";\nimport Log from \"sap/base/Log\";\nimport type ODataV4Context from \"sap/ui/model/odata/v4/Context\";\nimport type ODataListBinding from \"sap/ui/model/odata/v4/ODataListBinding\";\nimport type ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport type { ExpandPathType, MetaModelType } from \"types/metamodel_types\";\n\ntype SemanticObjectInformation = {\n\tsemanticObject?: MetaModelType<SemanticObject>;\n\tsemanticKeys?: ExpandPathType<PropertyPath>[];\n};\nconst SemanticKeyHelper = {\n\tgetSemanticKeys: function (oMetaModel: ODataMetaModel, sEntitySetName: string): ExpandPathType<PropertyPath>[] | undefined {\n\t\treturn oMetaModel.getObject(`/${sEntitySetName}/@com.sap.vocabularies.Common.v1.SemanticKey`);\n\t},\n\tgetSemanticObjectInformation: function (oMetaModel: ODataMetaModel, sEntitySetName: string): SemanticObjectInformation {\n\t\tconst oSemanticObject = oMetaModel.getObject(`/${sEntitySetName}/@com.sap.vocabularies.Common.v1.SemanticObject`) as\n\t\t\t| MetaModelType<SemanticObject>\n\t\t\t| undefined;\n\t\tconst aSemanticKeys = this.getSemanticKeys(oMetaModel, sEntitySetName);\n\t\treturn {\n\t\t\tsemanticObject: oSemanticObject,\n\t\t\tsemanticKeys: aSemanticKeys\n\t\t};\n\t},\n\tgetSemanticPath: function (oContext: ODataV4Context, bStrict = false): string | undefined {\n\t\tconst oMetaModel = oContext.getModel().getMetaModel(),\n\t\t\tsEntitySetName = oMetaModel.getMetaContext(oContext.getPath()).getObject(\"@sapui.name\"),\n\t\t\toSemanticObjectInformation = this.getSemanticObjectInformation(oMetaModel, sEntitySetName);\n\t\tlet sTechnicalPath, sSemanticPath;\n\n\t\tif (oContext.isA<ODataListBinding>(\"sap.ui.model.odata.v4.ODataListBinding\") && oContext.isRelative()) {\n\t\t\tsTechnicalPath = oContext.getHeaderContext()!.getPath();\n\t\t} else {\n\t\t\tsTechnicalPath = oContext.getPath();\n\t\t}\n\n\t\tif (this._isPathForSemantic(sTechnicalPath) && oSemanticObjectInformation.semanticKeys) {\n\t\t\tconst aSemanticKeys = oSemanticObjectInformation.semanticKeys;\n\t\t\tconst oEntityType = oMetaModel.getObject(\"/\" + oMetaModel.getObject(`/${sEntitySetName}`).$Type);\n\n\t\t\ttry {\n\t\t\t\tconst sSemanticKeysPart = aSemanticKeys\n\t\t\t\t\t.map(function (oSemanticKey) {\n\t\t\t\t\t\tconst sPropertyPath = oSemanticKey.$PropertyPath;\n\t\t\t\t\t\tlet sKeyValue = oContext.getProperty(sPropertyPath);\n\n\t\t\t\t\t\tif (sKeyValue === undefined || sKeyValue === null) {\n\t\t\t\t\t\t\tthrow new Error(`Couldn't resolve semantic key value for ${sPropertyPath}`);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tif (oEntityType[sPropertyPath].$Type === \"Edm.String\") {\n\t\t\t\t\t\t\t\tsKeyValue = `'${encodeURIComponent(sKeyValue)}'`;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif (aSemanticKeys.length > 1) {\n\t\t\t\t\t\t\t\t// Several semantic keys --> path should be entitySet(key1=value1, key2=value2, ...)\n\t\t\t\t\t\t\t\t// Otherwise we keep entitySet(keyValue)\n\t\t\t\t\t\t\t\tsKeyValue = `${sPropertyPath}=${sKeyValue}`;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn sKeyValue;\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t\t\t.join(\",\");\n\n\t\t\t\tsSemanticPath = `/${sEntitySetName}(${sSemanticKeysPart})`;\n\t\t\t} catch (e) {\n\t\t\t\tLog.info(e as string);\n\t\t\t}\n\t\t}\n\n\t\treturn bStrict ? sSemanticPath : sSemanticPath || sTechnicalPath;\n\t},\n\n\t// ==============================\n\t// INTERNAL METHODS\n\t// ==============================\n\n\t_isPathForSemantic: function (sPath: string): boolean {\n\t\t// Only path on root objects allow semantic keys, i.e. sPath = xxx(yyy)\n\t\treturn /^[^()]+\\([^()]+\\)$/.test(sPath);\n\t}\n};\n\nexport default SemanticKeyHelper;\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["SemanticKeyHelper","getSemanticKeys","oMetaModel","sEntitySetName","getObject","getSemanticObjectInformation","oSemanticObject","aSemanticKeys","semanticObject","semanticKeys","getPathContent","valuePairs","typeMetadata","singleKey","length","map","valuePair","keyValue","value","encodedKeyValue","name","$Type","encodeURIComponent","join","getSemanticPath","oContext","bStrict","getModel","getMetaModel","getMetaContext","getPath","oSemanticObjectInformation","sTechnicalPath","sSemanticPath","isA","isRelative","getHeaderContext","_isPathForSemantic","oEntityType","keyValues","semanticKey","keyName","$PropertyPath","getProperty","undefined","Error","semanticKeysPart","e","Log","info","sPath","test"],"sourceRoot":".","sources":["SemanticKeyHelper.ts"],"sourcesContent":["import type { PropertyPath } from \"@sap-ux/vocabularies-types\";\nimport type { SemanticObject } from \"@sap-ux/vocabularies-types/vocabularies/Common\";\nimport Log from \"sap/base/Log\";\nimport type ODataV4Context from \"sap/ui/model/odata/v4/Context\";\nimport type ODataListBinding from \"sap/ui/model/odata/v4/ODataListBinding\";\nimport type ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport type { ExpandPathType, MetaModelType } from \"types/metamodel_types\";\n\ntype SemanticObjectInformation = {\n\tsemanticObject?: MetaModelType<SemanticObject>;\n\tsemanticKeys?: ExpandPathType<PropertyPath>[];\n};\nconst SemanticKeyHelper = {\n\tgetSemanticKeys: function (oMetaModel: ODataMetaModel, sEntitySetName: string): ExpandPathType<PropertyPath>[] | undefined {\n\t\treturn oMetaModel.getObject(`/${sEntitySetName}/@com.sap.vocabularies.Common.v1.SemanticKey`);\n\t},\n\tgetSemanticObjectInformation: function (oMetaModel: ODataMetaModel, sEntitySetName: string): SemanticObjectInformation {\n\t\tconst oSemanticObject = oMetaModel.getObject(`/${sEntitySetName}/@com.sap.vocabularies.Common.v1.SemanticObject`) as\n\t\t\t| MetaModelType<SemanticObject>\n\t\t\t| undefined;\n\t\tconst aSemanticKeys = this.getSemanticKeys(oMetaModel, sEntitySetName);\n\t\treturn {\n\t\t\tsemanticObject: oSemanticObject,\n\t\t\tsemanticKeys: aSemanticKeys\n\t\t};\n\t},\n\t/**\n\t * Returns a stringified version of a list of key values, e.g. [{name:\"aa\", value:1}, {name:\"bb\", value:\"foo\"}] --> \"aa=1,bb='foo'\".\n\t *\n\t * @param valuePairs\n\t * @param typeMetadata\n\t * @returns String\n\t */\n\tgetPathContent(valuePairs: { name: string; value: unknown }[], typeMetadata: Record<string, { $Type: string }>): string {\n\t\tconst singleKey = valuePairs.length === 1;\n\t\treturn valuePairs\n\t\t\t.map((valuePair) => {\n\t\t\t\tconst keyValue = valuePair.value;\n\t\t\t\tconst encodedKeyValue =\n\t\t\t\t\ttypeMetadata[valuePair.name].$Type === \"Edm.String\" ? `'${encodeURIComponent(keyValue as string)}'` : keyValue;\n\t\t\t\treturn singleKey ? encodedKeyValue : `${valuePair.name}=${encodedKeyValue}`;\n\t\t\t})\n\t\t\t.join(\",\");\n\t},\n\tgetSemanticPath: function (oContext: ODataV4Context, bStrict = false): string | undefined {\n\t\tconst oMetaModel = oContext.getModel().getMetaModel(),\n\t\t\tsEntitySetName = oMetaModel.getMetaContext(oContext.getPath()).getObject(\"@sapui.name\"),\n\t\t\toSemanticObjectInformation = this.getSemanticObjectInformation(oMetaModel, sEntitySetName);\n\t\tlet sTechnicalPath, sSemanticPath;\n\n\t\tif (oContext.isA<ODataListBinding>(\"sap.ui.model.odata.v4.ODataListBinding\") && oContext.isRelative()) {\n\t\t\tsTechnicalPath = oContext.getHeaderContext()!.getPath();\n\t\t} else {\n\t\t\tsTechnicalPath = oContext.getPath();\n\t\t}\n\n\t\tif (\n\t\t\tthis._isPathForSemantic(sTechnicalPath) &&\n\t\t\toSemanticObjectInformation.semanticKeys &&\n\t\t\toSemanticObjectInformation.semanticKeys.length !== 0\n\t\t) {\n\t\t\tconst aSemanticKeys = oSemanticObjectInformation.semanticKeys;\n\t\t\tconst oEntityType = oMetaModel.getObject(\"/\" + oMetaModel.getObject(`/${sEntitySetName}`).$Type);\n\n\t\t\ttry {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t\t\t\tconst keyValues = aSemanticKeys.map((semanticKey) => {\n\t\t\t\t\tconst keyName = semanticKey.$PropertyPath;\n\t\t\t\t\tconst keyValue = oContext.getProperty(keyName);\n\t\t\t\t\tif (keyValue === undefined || keyValue === null) {\n\t\t\t\t\t\tthrow new Error(`Couldn't resolve semantic key value for ${keyName}`);\n\t\t\t\t\t}\n\t\t\t\t\treturn { name: keyName, value: keyValue };\n\t\t\t\t});\n\t\t\t\tconst semanticKeysPart = this.getPathContent(keyValues, oEntityType);\n\n\t\t\t\tsSemanticPath = `/${sEntitySetName}(${semanticKeysPart})`;\n\t\t\t} catch (e) {\n\t\t\t\tLog.info(e as string);\n\t\t\t}\n\t\t}\n\n\t\treturn bStrict ? sSemanticPath : sSemanticPath || sTechnicalPath;\n\t},\n\n\t// ==============================\n\t// INTERNAL METHODS\n\t// ==============================\n\n\t_isPathForSemantic: function (sPath: string): boolean {\n\t\t// Only path on root objects allow semantic keys, i.e. sPath = xxx(yyy)\n\t\treturn /^[^()]+\\([^()]+\\)$/.test(sPath);\n\t}\n};\n\nexport default SemanticKeyHelper;\n"],"mappings":"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"}

package/src/sap/fe/core/helpers/SemanticKeyHelper.ts

@@ -24,6 +24,24 @@ const SemanticKeyHelper = {
 			semanticKeys: aSemanticKeys
 		};
 	},
+	/**
+	 * Returns a stringified version of a list of key values, e.g. [{name:"aa", value:1}, {name:"bb", value:"foo"}] --> "aa=1,bb='foo'".
+	 *
+	 * @param valuePairs
+	 * @param typeMetadata
+	 * @returns String
+	 */
+	getPathContent(valuePairs: { name: string; value: unknown }[], typeMetadata: Record<string, { $Type: string }>): string {
+		const singleKey = valuePairs.length === 1;
+		return valuePairs
+			.map((valuePair) => {
+				const keyValue = valuePair.value;
+				const encodedKeyValue =
+					typeMetadata[valuePair.name].$Type === "Edm.String" ? `'${encodeURIComponent(keyValue as string)}'` : keyValue;
+				return singleKey ? encodedKeyValue : `${valuePair.name}=${encodedKeyValue}`;
+			})
+			.join(",");
+	},
 	getSemanticPath: function (oContext: ODataV4Context, bStrict = false): string | undefined {
 		const oMetaModel = oContext.getModel().getMetaModel(),
 			sEntitySetName = oMetaModel.getMetaContext(oContext.getPath()).getObject("@sapui.name"),
@@ -36,33 +54,27 @@ const SemanticKeyHelper = {
 			sTechnicalPath = oContext.getPath();
 		}
 
-		if (this._isPathForSemantic(sTechnicalPath) && oSemanticObjectInformation.semanticKeys) {
+		if (
+			this._isPathForSemantic(sTechnicalPath) &&
+			oSemanticObjectInformation.semanticKeys &&
+			oSemanticObjectInformation.semanticKeys.length !== 0
+		) {
 			const aSemanticKeys = oSemanticObjectInformation.semanticKeys;
 			const oEntityType = oMetaModel.getObject("/" + oMetaModel.getObject(`/${sEntitySetName}`).$Type);
 
 			try {
-				const sSemanticKeysPart = aSemanticKeys
-					.map(function (oSemanticKey) {
-						const sPropertyPath = oSemanticKey.$PropertyPath;
-						let sKeyValue = oContext.getProperty(sPropertyPath);
-
-						if (sKeyValue === undefined || sKeyValue === null) {
-							throw new Error(`Couldn't resolve semantic key value for ${sPropertyPath}`);
-						} else {
-							if (oEntityType[sPropertyPath].$Type === "Edm.String") {
-								sKeyValue = `'${encodeURIComponent(sKeyValue)}'`;
-							}
-							if (aSemanticKeys.length > 1) {
-								// Several semantic keys --> path should be entitySet(key1=value1, key2=value2, ...)
-								// Otherwise we keep entitySet(keyValue)
-								sKeyValue = `${sPropertyPath}=${sKeyValue}`;
-							}
-							return sKeyValue;
-						}
-					})
-					.join(",");
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
+				const keyValues = aSemanticKeys.map((semanticKey) => {
+					const keyName = semanticKey.$PropertyPath;
+					const keyValue = oContext.getProperty(keyName);
+					if (keyValue === undefined || keyValue === null) {
+						throw new Error(`Couldn't resolve semantic key value for ${keyName}`);
+					}
+					return { name: keyName, value: keyValue };
+				});
+				const semanticKeysPart = this.getPathContent(keyValues, oEntityType);
 
-				sSemanticPath = `/${sEntitySetName}(${sSemanticKeysPart})`;
+				sSemanticPath = `/${sEntitySetName}(${semanticKeysPart})`;
 			} catch (e) {
 				Log.info(e as string);
 			}