@sapui5/sap.fe.core 1.121.2 → 1.123.0

package/src/sap/fe/core/controllerextensions/editFlow/TransactionHelper.ts

@@ -3,12 +3,12 @@ import type { LineItem } from "@sap-ux/vocabularies-types/vocabularies/UI";
 import Log from "sap/base/Log";
 import type ResourceBundle from "sap/base/i18n/ResourceBundle";
 import deepClone from "sap/base/util/deepClone";
-import type { ActionParameterInfo } from "sap/fe/core/ActionRuntime";
-import ActionRuntime from "sap/fe/core/ActionRuntime";
 import type AppComponent from "sap/fe/core/AppComponent";
 import type { FEView } from "sap/fe/core/BaseController";
 import CommonUtils from "sap/fe/core/CommonUtils";
 import type ResourceModel from "sap/fe/core/ResourceModel";
+import type { ExitDialogEvent } from "sap/fe/core/UIProvider";
+import { getCoreUIFactory } from "sap/fe/core/UIProvider";
 import BusyLocker from "sap/fe/core/controllerextensions/BusyLocker";
 import type MessageHandler from "sap/fe/core/controllerextensions/MessageHandler";
 import type { BindContextParameters } from "sap/fe/core/controllerextensions/editFlow/draft";
@@ -18,13 +18,15 @@ import operations from "sap/fe/core/controllerextensions/editFlow/operations";
 import sticky from "sap/fe/core/controllerextensions/editFlow/sticky";
 import messageHandling from "sap/fe/core/controllerextensions/messageHandler/messageHandling";
 import { getInvolvedDataModelObjects } from "sap/fe/core/converters/MetaModelConverter";
+import { isDataFieldForAction } from "sap/fe/core/converters/annotations/DataField";
 import type { DeleteOption, DeleteParameters } from "sap/fe/core/helpers/DeleteHelper";
 import deleteHelper from "sap/fe/core/helpers/DeleteHelper";
 import FPMHelper from "sap/fe/core/helpers/FPMHelper";
+import { getCreatePopupFields } from "sap/fe/core/helpers/MetaModelFunction";
 import type { InternalModelContext } from "sap/fe/core/helpers/ModelHelper";
 import ModelHelper from "sap/fe/core/helpers/ModelHelper";
-import { getResourceModel } from "sap/fe/core/helpers/ResourceModelHelper";
-import { generate } from "sap/fe/core/helpers/StableIdHelper";
+import PromiseKeeper from "sap/fe/core/helpers/PromiseKeeper";
+import toES6Promise from "sap/fe/core/helpers/ToES6Promise";
 import { isNavigationProperty } from "sap/fe/core/helpers/TypeGuards";
 import FELibrary from "sap/fe/core/library";
 import Button from "sap/m/Button";
@@ -36,31 +38,20 @@ import Popover from "sap/m/Popover";
 import Text from "sap/m/Text";
 import VBox from "sap/m/VBox";
 import type Event from "sap/ui/base/Event";
-import type ManagedObject from "sap/ui/base/ManagedObject";
 import type Control from "sap/ui/core/Control";
-import Fragment from "sap/ui/core/Fragment";
 import Library from "sap/ui/core/Lib";
 import Messaging from "sap/ui/core/Messaging";
-import XMLTemplateProcessor from "sap/ui/core/XMLTemplateProcessor";
 import coreLibrary from "sap/ui/core/library";
 import type Message from "sap/ui/core/message/Message";
 import type View from "sap/ui/core/mvc/View";
-import XMLPreprocessor from "sap/ui/core/util/XMLPreprocessor";
-import type FormElement from "sap/ui/layout/form/FormElement";
-import type Field from "sap/ui/mdc/Field";
-import type MultiValueField from "sap/ui/mdc/MultiValueField";
 import type MultiValueFieldItem from "sap/ui/mdc/field/MultiValueFieldItem";
 import type Binding from "sap/ui/model/Binding";
 import type Context from "sap/ui/model/Context";
-import JSONModel from "sap/ui/model/json/JSONModel";
 import type ODataV4Context from "sap/ui/model/odata/v4/Context";
 import type ODataListBinding from "sap/ui/model/odata/v4/ODataListBinding";
 import type { ODataListBinding$CreateCompletedEvent } from "sap/ui/model/odata/v4/ODataListBinding";
 import type ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
 import type ODataModel from "sap/ui/model/odata/v4/ODataModel";
-import { isDataFieldForAction } from "../../converters/annotations/DataField";
-import { getNonComputedVisibleFields, getRequiredPropertiesFromInsertRestrictions } from "../../helpers/MetaModelFunction";
-import toES6Promise from "../../helpers/ToES6Promise";
 
 const CreationMode = FELibrary.CreationMode;
 const ProgrammingModel = FELibrary.ProgrammingModel;
@@ -222,12 +213,42 @@ class TransactionHelper {
 		const dataForCreation = initialData ?? {};
 
 		if (this.isListBindingHierarchical(listBinding)) {
+			let listBindingForCreation: ODataListBinding;
 			if (options.parentContext?.isExpanded() === false) {
 				// If the parent context already has children and is collapsed, we expand it first
 				await listBinding.expand(options.parentContext);
 			}
-			Object.assign(dataForCreation, { "@$ui5.node.parent": options.parentContext });
-			return listBinding.create(dataForCreation, true);
+
+			if (listBinding.isRelative()) {
+				Object.assign(dataForCreation, { "@$ui5.node.parent": options.parentContext });
+				listBindingForCreation = listBinding;
+			} else {
+				// Absolute binding: creation from the ListReport
+				// We use a temporary flat listBinding for the creation, to avoid adding the new context in the table (we don't want to display it until it's saved)
+				const model = listBinding.getModel();
+				const metaModel = model.getMetaModel();
+				listBindingForCreation = model.bindList(listBinding.getPath(), undefined, undefined, undefined, {
+					$$groupId: listBinding.getGroupId(),
+					$$updateGroupId: listBinding.getUpdateGroupId()
+				});
+
+				// Add the parent path in the initial data if a parent is provided
+				if (options.parentContext) {
+					const objectPath = getInvolvedDataModelObjects(metaModel.getMetaContext(listBinding.getPath()));
+					const hierarchyQualifier = (listBinding.getAggregation() as { hierarchyQualifier: string }).hierarchyQualifier;
+					const parentNavigation =
+						objectPath.targetEntityType.annotations.Aggregation?.[`RecursiveHierarchy#${hierarchyQualifier}`]
+							?.ParentNavigationProperty.value;
+					if (!parentNavigation) {
+						throw new Error(`Cannot find parent navigation property for ${listBinding.getPath()}`);
+					}
+					const parentBindingData: Record<string, string> = {};
+					parentBindingData[`${parentNavigation}@odata.bind`] = options.parentContext.getPath().replace(/^\//, ""); // Remove leading "/" from the path
+					Object.assign(dataForCreation, parentBindingData);
+				}
+			}
+
+			return listBindingForCreation.create(dataForCreation, true);
 		} else {
 			return listBinding.create(dataForCreation, true, options.createAtEnd, options.createInactive);
 		}
@@ -237,9 +258,9 @@ class TransactionHelper {
 		const metaModel = listBinding.getModel().getMetaModel();
 		const metaPath = metaModel.getMetaPath(listBinding.getHeaderContext()!.getPath());
 
-		const nonComputedVisibleFields = getNonComputedVisibleFields(metaModel, metaPath, appComponent);
+		const nonComputedVisibleFields = getCreatePopupFields(metaModel, metaPath, appComponent);
 		// Do not consider fields for which we provide some initial data
-		return nonComputedVisibleFields.filter((fieldName) => {
+		return nonComputedVisibleFields.filter((fieldName: string) => {
 			return !(fieldName in (createData ?? {}));
 		});
 	}
@@ -442,25 +463,24 @@ class TransactionHelper {
 					? this.getCreationParameters(mainListBinding, initialData, appComponent)
 					: [];
 				if (nonComputedVisibleKeyFields.length > 0) {
-					const onKeyFieldResult = await this._launchDialogWithKeyFields(
+					newDocumentContext = await this.createWithDialog(
 						mainListBinding,
 						nonComputedVisibleKeyFields,
-						model,
 						parameters,
 						appComponent,
 						messageHandler
 					);
-					newDocumentContext = onKeyFieldResult.newContext;
 				} else {
 					newDocumentContext = await this.createDocumentContext(mainListBinding, parameters);
 					if (!parameters.inactive) {
-						await this.onAfterCreateCompletion(mainListBinding, newDocumentContext, parameters);
+						await this.waitForCreateCompletion(newDocumentContext, parameters.keepTransientContextOnFailed === true);
 					}
 				}
 				return newDocumentContext;
 			} catch (error: unknown) {
-				Log.error("Error while creating the new document", error as string);
-				throw error;
+				const msg = typeof error === "string" ? error : (error as Error).message ?? error;
+				Log.error("Error while creating the new document", msg);
+				throw msg;
 			}
 		}
 	}
@@ -951,6 +971,7 @@ class TransactionHelper {
 	 * @param mParameters.internalModelContext
 	 * @param mParameters.groupId
 	 * @param mParameters.defaultValuesExtensionFunction
+	 * @param [mParameters.ignoreETag] If specified, the action is called without ETag handling
 	 * @param oView Contains the object of the current view
 	 * @param appComponent The appComponent
 	 * @param messageHandler The message handler extension
@@ -979,6 +1000,7 @@ class TransactionHelper {
 			internalModelContext?: InternalModelContext | null;
 			groupId?: string;
 			defaultValuesExtensionFunction?: string;
+			ignoreETag?: boolean;
 		},
 		oView: View | null,
 		appComponent: AppComponent,
@@ -1046,7 +1068,8 @@ class TransactionHelper {
 					defaultValuesExtensionFunction: mParameters.defaultValuesExtensionFunction,
 					selectedItems: mParameters.contexts as ODataV4Context[],
 					disableStrictHandling,
-					groupId: mParameters.groupId
+					groupId: mParameters.groupId,
+					ignoreETag: mParameters.ignoreETag
 				});
 			} else {
 				oResult = await operations.callActionImport(sActionName, oModel, appComponent, {
@@ -1055,6 +1078,7 @@ class TransactionHelper {
 					skipParameterDialog: mParameters.skipParameterDialog,
 					bindingParameters: mBindingParameters,
 					entitySetName: mParameters.entitySetName,
+					additionalSideEffect: mSideEffectsParameters,
 					onSubmitted: () => {
 						this.busyLock(appComponent);
 					},
@@ -1065,7 +1089,8 @@ class TransactionHelper {
 					internalModelContext: mParameters.internalModelContext,
 					operationAvailableMap: mParameters.operationAvailableMap,
 					messageHandler: messageHandler,
-					bObjectPage: mParameters.bObjectPage
+					bObjectPage: mParameters.bObjectPage,
+					ignoreETag: mParameters.ignoreETag
 				});
 			}
 
@@ -1191,11 +1216,10 @@ class TransactionHelper {
 		});
 	}
 
-	async _launchDialogWithKeyFields(
-		oListBinding: ODataListBinding,
-		mFields: string[],
-		oModel: ODataModel,
-		mParameters: {
+	async createWithDialog(
+		listBinding: ODataListBinding,
+		fieldNames: string[],
+		parameters: {
 			parentControl?: Control;
 			data?: Record<string, unknown>;
 			bIsCreateDialog?: boolean;
@@ -1208,307 +1232,155 @@ class TransactionHelper {
 		},
 		appComponent: AppComponent,
 		messageHandler: MessageHandler
-	): Promise<{ newContext?: ODataV4Context }> {
-		let oDialog: Dialog;
-		const oParentControl = mParameters.parentControl;
+	): Promise<ODataV4Context> {
+		const model = listBinding.getModel() as ODataModel;
+		const metaModel = model.getMetaModel();
+		const listMetaPath = metaModel.getMetaPath(listBinding.getResolvedPath()!);
 
-		// Crate a fake (transient) listBinding and context, just for the binding context of the dialog
-		const oTransientListBinding = oModel.bindList(oListBinding.getPath(), oListBinding.getContext(), [], [], {
+		// Create a fake (transient) listBinding and context, just for the binding context of the dialog
+		const transientListBinding = model.bindList(listBinding.getPath(), listBinding.getContext(), undefined, undefined, {
 			$$updateGroupId: "submitLater"
 		});
-		oTransientListBinding.refreshInternal = function (): void {
+		transientListBinding.refreshInternal = function (): void {
 			/* */
 		};
-		const oTransientContext = oTransientListBinding.create(mParameters.data, true);
-
-		return new Promise<{ newContext?: ODataV4Context }>(async (resolve, reject) => {
-			const sFragmentName = "sap/fe/core/controls/NonComputedVisibleKeyFieldsDialog";
-			const oFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, "fragment"),
-				resourceModel = getResourceModel(oParentControl!),
-				oMetaModel = oModel.getMetaModel(),
-				aImmutableFields: Context[] = [],
-				sPath = (oListBinding.isRelative() ? oListBinding.getResolvedPath() : oListBinding.getPath()) as string,
-				oEntitySetContext = oMetaModel.createBindingContext(sPath) as Context,
-				sMetaPath = oMetaModel.getMetaPath(sPath);
-			for (const i in mFields) {
-				aImmutableFields.push(oMetaModel.createBindingContext(`${sMetaPath}/${mFields[i]}`)!);
+		const transientContext = transientListBinding.create(parameters.data, true);
+		const fieldMetaContexts = fieldNames.map((name) => {
+			return metaModel.createBindingContext(`${listMetaPath}/${name}`) as Context;
+		});
+
+		const createDialog = getCoreUIFactory().newCreateDialog(transientContext, fieldNames, appComponent, parameters.parentControl);
+
+		try {
+			await CommonUtils.setUserDefaults(
+				appComponent,
+				fieldMetaContexts,
+				transientContext,
+				false,
+				parameters.createAction,
+				parameters.data
+			);
+			createDialog.openDialog();
+		} catch (e) {
+			await messageHandler.showMessages();
+			throw e;
+		}
+
+		const resultPromiseKeeper = new PromiseKeeper<ODataV4Context>();
+
+		const onExitDialog = async (event: ExitDialogEvent): Promise<void> => {
+			if (!event.getParameter("accept")) {
+				// User has cancelled creation: destry the transient list binding and close the dialog
+				transientListBinding.destroy();
+				createDialog.closeDialog();
+				resultPromiseKeeper.reject(FELibrary.Constants.CancelActionDialog);
+				return;
 			}
-			const oImmutableCtxModel = new JSONModel(aImmutableFields);
-			const oImmutableCtx = oImmutableCtxModel.createBindingContext("/");
-			const aRequiredProperties = getRequiredPropertiesFromInsertRestrictions(sMetaPath, oMetaModel);
-			const oRequiredPropertyPathsCtxModel = new JSONModel(aRequiredProperties);
-			const oRequiredPropertyPathsCtx = oRequiredPropertyPathsCtxModel.createBindingContext("/");
-			const oNewFragment = await XMLPreprocessor.process(
-				oFragment,
-				{ name: sFragmentName },
-				{
-					bindingContexts: {
-						entitySet: oEntitySetContext,
-						fields: oImmutableCtx,
-						requiredProperties: oRequiredPropertyPathsCtx
-					},
-					models: {
-						entitySet: oEntitySetContext.getModel(),
-						fields: oImmutableCtx.getModel(),
-						metaModel: oMetaModel,
-						requiredProperties: oRequiredPropertyPathsCtxModel
+
+			createDialog.setBusy(true);
+			parameters.bIsCreateDialog = true;
+			try {
+				const transientData = transientContext.getObject();
+				let createData: Record<string, unknown> = {};
+				Object.keys(transientData).forEach((propertyPath) => {
+					const oProperty = metaModel.getObject(`${listMetaPath}/${propertyPath}`);
+					// Ensure navigation properties are not part of the payload, as deep create not supported
+					// And remove any property starting by @$ui5 as they are not property created by filling the form
+					if (oProperty && oProperty.$kind !== "NavigationProperty" && !propertyPath?.startsWith("@$ui5")) {
+						createData[propertyPath] = transientData[propertyPath];
 					}
-				}
-			);
-			const _removeMessagesForActionParamter = (messageControlId: string): void => {
-				const allMessages = Messaging.getMessageModel().getData();
-				// also remove messages assigned to inner controls, but avoid removing messages for different paramters (with name being substring of another parameter name)
-				const relevantMessages = allMessages.filter((msg: Message) =>
-					msg.getControlIds().some((controlId: string) => controlId.includes(messageControlId))
-				);
-				Messaging.removeMessages(relevantMessages);
-			};
-			let actionParameterInfos: ActionParameterInfo[];
-
-			const oController = {
-				/*
-					fired on focus out from field or on selecting a value from the valuehelp.
-					the create button (Continue) is always enabled.
-					liveChange is not fired when value is added from valuehelp.
-					value validation is done for create button.
-				*/
-				handleChange: async (event: Event<{ id: string; promise: Promise<string> }>): Promise<void> => {
-					const fieldId = event.getParameter("id");
-					const field = event.getSource();
-					const actionParameterInfo = actionParameterInfos.find(
-						(actionParameterInfo) => actionParameterInfo.field === field
-					) as ActionParameterInfo;
-					_removeMessagesForActionParamter(fieldId);
-					actionParameterInfo.validationPromise = event.getParameter("promise");
+				});
+
+				if (parameters.beforeCreateCallBack) {
+					//beforeCreateCallBack expects createParameters of type any[]
+					const createDataAsArray = Object.entries(createData).map(([key, value]) => ({ [key]: value }));
 					try {
-						actionParameterInfo.value = await actionParameterInfo.validationPromise;
-						actionParameterInfo.hasError = false;
+						await toES6Promise(
+							parameters.beforeCreateCallBack({
+								contextPath: listBinding.getPath(),
+								createParameters: createDataAsArray
+							})
+						);
 					} catch (error) {
-						delete actionParameterInfo.value;
-						actionParameterInfo.hasError = true;
+						Log.error("Error while creating the new document", error as string);
+						throw FELibrary.Constants.OnBeforeCreateFailed;
 					}
-				},
-				/*
-					fired on key press. the create button the create button (Continue) is always enabled.
-					liveChange is not fired when value is added from valuehelp.
-					value validation is done for create button.
-				*/
-				handleLiveChange: (event: Event<{ id: string }>): void => {
-					const fieldId = event.getParameter("id");
-					_removeMessagesForActionParamter(fieldId);
+					createData = createDataAsArray.reduce((result, currentObject) => {
+						return { ...result, ...currentObject };
+					}, {});
 				}
-			};
-
-			const oDialogContent: Control = (await Fragment.load({
-				definition: oNewFragment as unknown as string,
-				controller: oController
-			})) as Control;
-			let oResult: { error: string } | { response: { newContext?: ODataV4Context } };
-			let isDialogConfirmed = false;
-			oDialog = new Dialog(generate(["CreateDialog", sMetaPath]), {
-				title: resourceModel.getText("C_TRANSACTION_HELPER_SAPFE_ACTION_CREATE"),
-				content: [oDialogContent],
-				contentWidth: "20rem",
-				beginButton: new Button({
-					text: resourceModel.getText("C_TRANSACTION_HELPER_SAPFE_ACTION_CREATE_BUTTON"),
-					type: "Emphasized",
-
-					press: async (_Event: unknown): Promise<void> => {
-						/* Validation of mandatory and value state for action parameters */
-						if (!(await ActionRuntime.validateProperties(actionParameterInfos, resourceModel))) {
-							return;
-						}
-
-						BusyLocker.lock(oDialog);
-						mParameters.bIsCreateDialog = true;
-						try {
-							const transientData = oTransientContext.getObject();
-							let createData: Record<string, unknown> = {};
-							Object.keys(transientData).forEach(function (sPropertyPath: string) {
-								const oProperty = oMetaModel.getObject(`${sMetaPath}/${sPropertyPath}`);
-								// ensure navigation properties are not part of the payload, deep create not supported
-								if (oProperty && oProperty.$kind === "NavigationProperty") {
-									return;
-								}
-								// Remove any property starting by @$ui5 as they are not property created by filling the form
-								if (sPropertyPath?.startsWith("@$ui5")) {
-									return;
-								}
-								createData[sPropertyPath] = transientData[sPropertyPath];
-							});
-							if (mParameters.beforeCreateCallBack) {
-								//beforeCreateCallBack expects createParameters of type any[]
-								const parameters = Object.entries(createData).map(([key, value]) => ({ [key]: value }));
-								try {
-									await toES6Promise(
-										mParameters.beforeCreateCallBack({
-											contextPath: oListBinding && oListBinding.getPath(),
-											createParameters: parameters
-										})
-									);
-								} catch (error) {
-									Log.error("Error while creating the new document", error as string);
-									throw FELibrary.Constants.OnBeforeCreateFailed;
-								}
-								createData = parameters.reduce((result, currentObject) => {
-									return { ...result, ...currentObject };
-								}, {});
-							}
-							if (Object.keys(createData).length > 0) {
-								appComponent.getModel("ui").setProperty(UiModelConstants.DocumentModified, true);
-							}
-							const oNewDocumentContext = await this.createContext(oListBinding, createData, {
-								createAtEnd: !!mParameters.createAtEnd,
-								createInactive: !!mParameters.inactive,
-								parentContext: mParameters.parentContext
-							});
-
-							const oPromise = this.onAfterCreateCompletion(oListBinding, oNewDocumentContext, mParameters);
-							const promiseResponse = await oPromise;
-							if (!promiseResponse || !promiseResponse.bKeepDialogOpen) {
-								const oResponse: { newContext?: ODataV4Context } = promiseResponse ?? {};
-								oDialog.setBindingContext(null as unknown as ODataV4Context);
-								oResponse.newContext = oNewDocumentContext;
-								isDialogConfirmed = true;
-								oResult = { response: oResponse };
-								oDialog.close();
-							}
-						} catch (oError: unknown) {
-							// in case of creation failed, dialog should stay open - to achieve the same, nothing has to be done (like in case of success with bKeepDialogOpen)
-							if (oError !== FELibrary.Constants.CreationFailed && oError != FELibrary.Constants.OnBeforeCreateFailed) {
-								// other errors are not expected
-								oResult = { error: oError as string };
-								oDialog.close();
-							}
-						} finally {
-							BusyLocker.unlock(oDialog);
-							messageHandler.showMessages();
-						}
-					}
-				}),
-				endButton: new Button({
-					text: resourceModel.getText("C_COMMON_ACTION_PARAMETER_DIALOG_CANCEL"),
-					press: function (): void {
-						oResult = { error: FELibrary.Constants.CancelActionDialog };
-						oDialog.close();
-					}
-				}),
-				beforeClose: function (): void {
-					/* When the dialog is cancelled, messages need to be removed in case the same action should be executed again */
-					for (const actionParameterInfo of actionParameterInfos) {
-						const fieldId = actionParameterInfo.field.getId();
-						_removeMessagesForActionParamter(fieldId);
-					}
-					// show footer as per UX guidelines when dialog is not open
-					(oDialog.getBindingContext("internal") as InternalModelContext)?.setProperty("isCreateDialogOpen", false);
-					oDialog.destroy();
-					oTransientListBinding.destroy();
-					//rejected/resolved the promis returned by _launchDialogWithKeyFields
-					//as soon as the dialog is closed. Without waiting for the dialog's
-					//animation to finish
-					if (isDialogConfirmed) {
-						resolve((oResult as { response: { newContext?: ODataV4Context } }).response);
-					} else {
-						reject((oResult as { error: string })?.error ?? FELibrary.Constants.CancelActionDialog);
-					}
+				if (Object.keys(createData).length > 0) {
+					appComponent.getModel("ui").setProperty(UiModelConstants.DocumentModified, true);
 				}
-			});
-			const aFormElements = (
-				(oDialogContent?.getAggregation("form") as ManagedObject).getAggregation("formContainers") as ManagedObject[]
-			)[0].getAggregation("formElements") as FormElement[];
+				const newContext = await this.createContext(listBinding, createData, {
+					createAtEnd: parameters.createAtEnd,
+					createInactive: parameters.inactive,
+					parentContext: parameters.parentContext
+				});
 
-			if (oParentControl && oParentControl.addDependent) {
-				// if there is a parent control specified add the dialog as dependent
-				oParentControl.addDependent(oDialog);
+				const creationSuccess = await this.waitForCreateCompletion(newContext, parameters.keepTransientContextOnFailed === true);
+				if (creationSuccess) {
+					transientListBinding.destroy();
+					createDialog.closeDialog();
+					resultPromiseKeeper.resolve(newContext);
+				}
+			} catch (error: unknown) {
+				// in case of creation failed, dialog should stay open - to achieve the same, nothing has to be done (like in case of success with bKeepDialogOpen)
+				if (error !== FELibrary.Constants.CreationFailed && error != FELibrary.Constants.OnBeforeCreateFailed) {
+					// other errors are not expected
+					transientListBinding.destroy();
+					createDialog.closeDialog();
+					resultPromiseKeeper.reject(error as string | Error);
+				}
+			} finally {
+				createDialog.setBusy(false);
+				messageHandler.showMessages();
 			}
+		};
 
-			oDialog.setBindingContext(oTransientContext);
+		createDialog.attachExitDialog({}, onExitDialog);
 
-			try {
-				await CommonUtils.setUserDefaults(
-					appComponent,
-					aImmutableFields,
-					oTransientContext,
-					false,
-					mParameters.createAction,
-					mParameters.data
-				);
-				actionParameterInfos = aFormElements.map((parameterField): ActionParameterInfo => {
-					const field: Field | MultiValueField = parameterField.getFields()[0] as Field | MultiValueField;
-					const isMultiValue = field.isA<MultiValueField>("sap.ui.mdc.MultiValueField");
-					return {
-						parameter: parameterField,
-						isMultiValue: isMultiValue,
-						field: field,
-						value: isMultiValue ? field.getItems() : field.getValue(),
-						validationPromise: undefined,
-						hasError: false
-					};
-				});
-				// footer must not be visible when the dialog is open as per UX guidelines
-				(oDialog.getBindingContext("internal") as InternalModelContext).setProperty("isCreateDialogOpen", true);
-				oDialog.open();
-			} catch (oError: unknown) {
-				await messageHandler.showMessages();
-				throw oError;
-			}
-		});
+		return resultPromiseKeeper.promise;
 	}
 
-	async onAfterCreateCompletion(
-		oListBinding: ODataListBinding,
-		oNewDocumentContext: ODataV4Context,
-		mParameters: {
-			keepTransientContextOnFailed?: boolean;
-		}
-	): Promise<{ bKeepDialogOpen: boolean; newContext?: ODataV4Context } | void> {
-		let fnResolve: Function;
-		const oPromise = new Promise<boolean>((resolve) => {
-			fnResolve = resolve;
-		});
-
-		const fnCreateCompleted = (oEvent: ODataListBinding$CreateCompletedEvent): void => {
-			const oContext = oEvent.getParameter("context"),
-				bSuccess = oEvent.getParameter("success");
-			if (oContext === oNewDocumentContext) {
-				oListBinding.detachCreateCompleted(fnCreateCompleted, this);
-				fnResolve(bSuccess);
+	/**
+	 * Waits for the creation of a context to be finished.
+	 *
+	 * @param newContext The context being created
+	 * @param keepTransientContextOnFailed
+	 * @returns True if the creation was successful
+	 */
+	async waitForCreateCompletion(newContext: ODataV4Context, keepTransientContextOnFailed: boolean): Promise<boolean> {
+		const promiseKeeper = new PromiseKeeper<boolean>();
+		const parentListBinding = newContext.getBinding() as ODataListBinding;
+
+		const onCreateCompleted = (event: ODataListBinding$CreateCompletedEvent): void => {
+			const createdContext = event.getParameter("context");
+			const success = event.getParameter("success");
+			if (createdContext === newContext) {
+				parentListBinding.detachCreateCompleted(onCreateCompleted);
+				promiseKeeper.resolve(success === true);
 			}
 		};
-		const fnSafeContextCreated = (): void => {
-			(oNewDocumentContext.created() ?? Promise.resolve())
-				.then(undefined, function () {
-					Log.trace("transient creation context deleted");
-				})
-				.catch(function (contextError: unknown) {
+
+		parentListBinding.attachCreateCompleted(onCreateCompleted);
+
+		const creationSuccessful = await promiseKeeper.promise;
+		if (!creationSuccessful) {
+			if (!keepTransientContextOnFailed) {
+				// Cancel the pending POST and delete the context in the listBinding
+				(newContext.created() ?? Promise.resolve()).catch(function (contextError: unknown) {
 					Log.trace("transient creation context deletion error", contextError as string);
 				});
-		};
-
-		oListBinding.attachCreateCompleted(fnCreateCompleted, this);
-
-		return oPromise.then(
-			async (
-				bSuccess: boolean
-			): Promise<{
-				bKeepDialogOpen: boolean;
-				newContext?: ODataV4Context;
-			} | void> => {
-				if (!bSuccess) {
-					if (!mParameters.keepTransientContextOnFailed) {
-						// Cancel the pending POST and delete the context in the listBinding
-						fnSafeContextCreated(); // To avoid a 'request cancelled' error in the console
-						oListBinding.resetChanges();
-						oListBinding.getModel().resetChanges(oListBinding.getUpdateGroupId());
-
-						throw FELibrary.Constants.CreationFailed;
-					}
-					return { bKeepDialogOpen: true };
-				} else {
-					return oNewDocumentContext.created();
-				}
+				parentListBinding.resetChanges();
+				parentListBinding.getModel().resetChanges(parentListBinding.getUpdateGroupId());
+				throw FELibrary.Constants.CreationFailed;
 			}
-		);
+			return false;
+		} else {
+			await newContext.created();
+			return true;
+		}
 	}
 
 	/**