@sapui5/sap.fe.core 1.97.0 → 1.100.0

package/src/sap/fe/core/controllerextensions/EditFlow.ts

@@ -0,0 +1,1672 @@
+import ControllerExtension from "sap/ui/core/mvc/ControllerExtension";
+import OverrideExecution from "sap/ui/core/mvc/OverrideExecution";
+import Log from "sap/base/Log";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import BusyLocker from "sap/fe/core/BusyLocker";
+import FELibrary from "sap/fe/core/library";
+import ODataListBinding from "sap/ui/model/odata/v4/ODataListBinding";
+import SemanticKeyHelper from "sap/fe/core/helpers/SemanticKeyHelper";
+import EditState from "sap/fe/core/helpers/EditState";
+import Message from "sap/ui/core/message/Message";
+import coreLibrary from "sap/ui/core/library";
+import ModelHelper, { InternalModelContext } from "sap/fe/core/helpers/ModelHelper";
+import { Extensible, Final, Public, UI5Class } from "sap/fe/core/helpers/ClassSupport";
+import ControllerExtensionMetadata from "sap/fe/core/controllerextensions/ControllerExtensionMetadata";
+import PageController from "sap/fe/core/PageController";
+import ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
+import Table from "sap/ui/mdc/Table";
+import Context from "sap/ui/model/odata/v4/Context";
+import ResourceBundle from "sap/base/i18n/ResourceBundle";
+import Control from "sap/ui/core/Control";
+import { send } from "sap/fe/core/actions/collaboration/ActivitySync";
+import { Activity } from "sap/fe/core/actions/collaboration/CollaborationCommon";
+import ODataModel from "sap/ui/model/odata/v4/ODataModel";
+import FlexibleColumnLayout from "sap/f/FlexibleColumnLayout";
+import NavContainer from "sap/m/NavContainer";
+
+const CreationMode = FELibrary.CreationMode,
+	ProgrammingModel = FELibrary.ProgrammingModel,
+	Constants = FELibrary.Constants,
+	DraftStatus = FELibrary.DraftStatus,
+	EditMode = FELibrary.EditMode,
+	MessageType = coreLibrary.MessageType;
+/**
+ * A controller extension offering hooks into the edit flow of the application
+ *
+ * @hideconstructor
+ * @public
+ * @since 1.90.0
+ */
+@UI5Class("sap.fe.core.controllerextensions.EditFlow", ControllerExtensionMetadata)
+class EditFlow extends ControllerExtension {
+	private base!: PageController;
+
+	//////////////////////////////////////
+	// Public methods
+	//////////////////////////////////////
+
+	private fnDirtyStateProvider?: Function;
+	private fnHandleSessionTimeout?: Function;
+	private mPatchPromises?: any;
+	private _fnStickyDiscardAfterNavigation?: Function;
+
+	/**
+	 * Creates a draft document for an existing active document.
+	 *
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {object} oContext Context of the active document
+	 * @returns {Promise} Promise resolves once the editable document is available
+	 * @alias sap.fe.core.controllerextensions.EditFlow#editDocument
+	 * @public
+	 * @since 1.90.0
+	 */
+	@Public
+	@Final
+	editDocument(oContext: Context): Promise<any> {
+		const bDraftNavigation = true;
+		const transactionHelper = this._getTransactionHelper();
+
+		return this.base.editFlow
+			.onBeforeEdit({ context: oContext })
+			.then(transactionHelper.editDocument.bind(transactionHelper, oContext, this.getView(), this._getMessageHandler()))
+			.then((oNewDocumentContext: any) => {
+				const sProgrammingModel = this._getProgrammingModel(oContext);
+
+				if (sProgrammingModel === ProgrammingModel.Sticky) {
+					this._getInternalModel().setProperty("/sessionOn", true);
+				}
+				if (oNewDocumentContext) {
+					this._setEditMode(EditMode.Editable, false);
+					this._getMessageHandler().showMessageDialog();
+
+					if (oNewDocumentContext !== oContext) {
+						return this._handleNewContext(oNewDocumentContext, true, false, bDraftNavigation, true).then(() => {
+							if (sProgrammingModel === ProgrammingModel.Sticky) {
+								// The stickyOn handler must be set after the navigation has been done,
+								// as the URL may change in the case of FCL
+								this._handleStickyOn(oNewDocumentContext);
+							}
+						});
+					}
+				}
+			})
+			.catch(function(oError: any) {
+				Log.error("Error while editing the document", oError);
+			});
+	}
+	@Public
+	@Final
+	deleteMultipleDocuments(aContexts: any, mParameters: any) {
+		if (mParameters) {
+			mParameters.beforeDeleteCallBack = this.base.editFlow.onBeforeDelete;
+		} else {
+			mParameters = {
+				beforeDeleteCallBack: this.base.editFlow.onBeforeDelete
+			};
+		}
+		return (this.base.getView().getController() as PageController)._editFlow.deleteMultipleDocuments(aContexts, mParameters);
+	}
+
+	/**
+	 * Updates the draft status and displays the error messages if there are errors during an update.
+	 *
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {object} oContext Context of the updated field
+	 * @param {object} oPromise Promise to determine when the update operation is completed. The promise should be resolved when the update operation is completed, so the draft status can be updated.
+	 * @returns {Promise} Promise resolves once draft status has been updated
+	 * @alias sap.fe.core.controllerextensions.EditFlow#updateDocument
+	 * @public
+	 * @since 1.90.0
+	 */
+	@Public
+	@Final
+	updateDocument(oContext: object, oPromise: Promise<any>): Promise<void> {
+		const transactionHelper = this._getTransactionHelper(),
+			oBindingContext = this.getView().getBindingContext(),
+			bIsDraft = this._getProgrammingModel(oContext) === ProgrammingModel.Draft;
+
+		this._getMessageHandler().removeTransitionMessages();
+		return this._syncTask(() => {
+			if (oBindingContext) {
+				transactionHelper.handleDocumentModifications();
+				EditState.setEditStateDirty();
+
+				if (bIsDraft) {
+					this._setDraftStatus(DraftStatus.Saving);
+				}
+			}
+			this._getMessageHandler().removeTransitionMessages();
+
+			return oPromise
+				.then(
+					() => {
+						if (bIsDraft && oBindingContext) {
+							const oMetaModel = oBindingContext.getModel().getMetaModel() as ODataMetaModel,
+								sEntitySetName = (oMetaModel as any).getMetaContext(oBindingContext.getPath()).getObject("@sapui.name"),
+								aSemanticKeys = SemanticKeyHelper.getSemanticKeys(oMetaModel, sEntitySetName);
+							if (aSemanticKeys && aSemanticKeys.length) {
+								const oCurrentSemanticMapping = (this.base.getAppComponent() as any)
+										.getRoutingService()
+										.getLastSemanticMapping(),
+									sCurrentSemanticPath = oCurrentSemanticMapping && oCurrentSemanticMapping.semanticPath,
+									sChangedPath = SemanticKeyHelper.getSemanticPath(oBindingContext, true);
+
+								if (sCurrentSemanticPath !== sChangedPath) {
+									return this._handleNewContext(oBindingContext, true, false, true).then(() => {
+										this._setDraftStatus(DraftStatus.Saved);
+									});
+								} else {
+									this._setDraftStatus(DraftStatus.Saved);
+								}
+							} else {
+								this._setDraftStatus(DraftStatus.Saved);
+							}
+						}
+					},
+					() => {
+						if (bIsDraft && oBindingContext) {
+							this._setDraftStatus(DraftStatus.Clear);
+						}
+					}
+				)
+				.catch(function(oError: any) {
+					Log.error("Error while updating the document", oError);
+				})
+				.finally(() => {
+					this._getMessageHandler().showMessages();
+				});
+		});
+	}
+
+	// Internal only params ---
+	// * @param {string} mParameters.creationMode The creation mode using one of the following:
+	// *                    Sync - the creation is triggered and once the document is created, the navigation is done
+	// *                    Async - the creation and the navigation to the instance are done in parallel
+	// *                    Deferred - the creation is done on the target page
+	// *                    CreationRow - The creation is done inline async so the user is not blocked
+	// mParameters.creationRow Instance of the creation row - (TODO: get rid but use list bindings only)
+
+	// eslint-disable-next-line jsdoc/require-param
+	/**
+	 * Creates a new document.
+	 *
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {sap.ui.model.odata.v4.ODataListBinding|string} vListBinding  ODataListBinding object or the binding path for a temporary list binding
+	 * @param {map} mInParameters Contains the following attributes:
+	 * @param {string} mInParameters.creationMode The creation mode using one of the following:
+	 *                    NewPage - the created document is shown in a new page, depending on whether metadata 'Sync', 'Async' or 'Deferred' is used
+	 *                    Inline - The creation is done inline (in a table)
+	 *                    External - The creation is done in a different application specified via the parameter 'outbound'
+	 * @param {string} mInParameters.outbound The navigation target where the document is created in case of creationMode 'External'
+	 * @param {boolean} mInParameters.createAtEnd Specifies if the new entry should be created at the top or bottom of a table in case of creationMode 'Inline'
+	 * @returns {Promise} Promise resolves once the object has been created
+	 * @alias sap.fe.core.controllerextensions.EditFlow#createDocument
+	 * @public
+	 * @since 1.90.0
+	 */
+	@Public
+	@Final
+	createDocument(
+		vListBinding: ODataListBinding | string,
+		mInParameters: {
+			creationMode: string;
+			outbound?: string;
+			createAtEnd?: boolean;
+		}
+	): Promise<void> {
+		const transactionHelper = this._getTransactionHelper(),
+			oLockObject = this._getGlobalUIModel();
+		let oTable: Table;
+		let iCountTableItems = 0;
+		let mParameters: any = mInParameters;
+		const oResourceBundle = (this.getView().getController() as any).oResourceBundle;
+		const bShouldBusyLock =
+			!mParameters ||
+			(mParameters.creationMode !== CreationMode.Inline &&
+				mParameters.creationMode !== CreationMode.CreationRow &&
+				mParameters.creationMode !== CreationMode.External);
+		let oExecCustomValidation = Promise.resolve([]);
+		const oAppComponent = CommonUtils.getAppComponent(this.getView());
+		oAppComponent.getRouterProxy().removeIAppStateKey();
+
+		if (mParameters.creationMode === CreationMode.External) {
+			// Create by navigating to an external target
+			// TODO: Call appropriate function (currently using the same as for outbound chevron nav, and without any context - 3rd param)
+			return this._syncTask().then(() => {
+				const oController = this.getView().getController(),
+					sCreatePath = ModelHelper.getAbsoluteMetaPathForListBinding(this.getView(), vListBinding);
+
+				(oController as any).handlers.onChevronPressNavigateOutBound(oController, mParameters.outbound, undefined, sCreatePath);
+			});
+		}
+
+		if (mParameters.creationMode === CreationMode.CreationRow && mParameters.creationRow) {
+			const oCreationRowObjects = mParameters.creationRow.getBindingContext().getObject();
+			delete oCreationRowObjects["@$ui5.context.isTransient"];
+			oTable = mParameters.creationRow.getParent();
+			oExecCustomValidation = transactionHelper.validateDocument(
+				oTable.getBindingContext(),
+				{
+					data: oCreationRowObjects,
+					customValidationFunction: (oTable.getCreationRow() as any).data("customValidationFunction")
+				},
+				this.base.getView()
+			);
+
+			// disableAddRowButtonForEmptyData is set to false in manifest converter (Table.ts) if customValidationFunction exists
+			if ((oTable.getCreationRow() as any).data("disableAddRowButtonForEmptyData") === "true") {
+				const oInternalModelContext = oTable.getBindingContext("internal") as InternalModelContext;
+				oInternalModelContext.setProperty("creationRowFieldValidity", {});
+			}
+		}
+
+		if (mParameters.creationMode === CreationMode.Inline && mParameters.tableId) {
+			oTable = this.getView().byId(mParameters.tableId) as Table;
+		}
+
+		/**
+		 * @param {sap.ui.model.odata.v4.ODataListBinding} oListBinding
+		 * @param {object} oCreationPromise
+		 */
+		const handleSideEffects = (oListBinding: any, oCreationPromise: Promise<Context>) => {
+			oCreationPromise
+				.then(function(oNewContext: any) {
+					// transient contexts are reliably removed once oNewContext.created() is resolved
+					return oNewContext.created();
+				})
+				.then(() => {
+					const oBindingContext = this.getView().getBindingContext() as Context;
+					// if there are transient contexts, we must avoid requesting side effects
+					// this is avoid a potential list refresh, there could be a side effect that refreshes the list binding
+					// if list binding is refreshed, transient contexts might be lost
+					if (!CommonUtils.hasTransientContext(oListBinding)) {
+						const oAppComponent = CommonUtils.getAppComponent(this.getView());
+						oAppComponent
+							.getSideEffectsService()
+							.requestSideEffectsForNavigationProperty(oListBinding.getPath(), oBindingContext);
+					}
+				})
+				.catch(function(oError: any) {
+					Log.error("Error while creating the document", oError);
+				});
+		};
+
+		/**
+		 * @param {Array} aValidationMessages Error messages from custom validation function
+		 */
+		const createCustomValidationMessages = (aValidationMessages: any[]) => {
+			const sCustomValidationFunction = oTable && (oTable.getCreationRow() as any).data("customValidationFunction");
+			const mCustomValidity = oTable && oTable.getBindingContext("internal")?.getProperty("creationRowCustomValidity");
+			const oMessageManager = sap.ui.getCore().getMessageManager();
+			const aCustomMessages: any[] = [];
+			let oFieldControl;
+			let sTarget: string;
+
+			// Remove existing CustomValidation message
+			oMessageManager
+				.getMessageModel()
+				.getData()
+				.forEach(function(oMessage: any) {
+					if (oMessage.code === sCustomValidationFunction) {
+						oMessageManager.removeMessages(oMessage);
+					}
+				});
+
+			aValidationMessages.forEach((oValidationMessage: any) => {
+				// Handle Bound CustomValidation message
+				if (oValidationMessage.messageTarget) {
+					oFieldControl = sap.ui.getCore().getControl(mCustomValidity[oValidationMessage.messageTarget].fieldId) as Control;
+					sTarget = oFieldControl.getBindingContext()?.getPath() + "/" + oFieldControl.getBindingPath("value");
+					// Add validation message if still not exists
+					if (
+						oMessageManager
+							.getMessageModel()
+							.getData()
+							.filter(function(oMessage: any) {
+								return oMessage.target === sTarget;
+							}).length === 0
+					) {
+						oMessageManager.addMessages(
+							new Message({
+								message: oValidationMessage.messageText,
+								processor: this.getView().getModel(),
+								type: MessageType.Error,
+								code: sCustomValidationFunction,
+								technical: false,
+								persistent: false,
+								target: sTarget
+							})
+						);
+					}
+					// Add controlId in order to get the focus handling of the error popover runable
+					const aExistingValidationMessages = oMessageManager
+						.getMessageModel()
+						.getData()
+						.filter(function(oMessage: any) {
+							return oMessage.target === sTarget;
+						});
+					aExistingValidationMessages[0].addControlId(mCustomValidity[oValidationMessage.messageTarget].fieldId);
+
+					// Handle Unbound CustomValidation message
+				} else {
+					aCustomMessages.push({
+						code: sCustomValidationFunction,
+						text: oValidationMessage.messageText,
+						persistent: true,
+						type: MessageType.Error
+					});
+				}
+			});
+
+			if (aCustomMessages.length > 0) {
+				this._getMessageHandler().showMessageDialog({
+					customMessages: aCustomMessages
+				});
+			}
+		};
+
+		bShouldBusyLock && BusyLocker.lock(oLockObject);
+		return this._syncTask(oExecCustomValidation)
+			.then((aValidationMessages: any) => {
+				if (aValidationMessages.length > 0) {
+					createCustomValidationMessages(aValidationMessages);
+					Log.error("Custom Validation failed");
+					// if custom validation fails, we leave the method immediately
+					return;
+				}
+
+				let sProgrammingModel: string;
+				let oListBinding: any;
+
+				mParameters = mParameters || {};
+
+				if (vListBinding && typeof vListBinding === "object") {
+					// we already get a list binding use this one
+					oListBinding = vListBinding;
+				} else if (typeof vListBinding === "string") {
+					oListBinding = new (ODataListBinding as any)(this.getView().getModel(), vListBinding);
+					mParameters.creationMode = CreationMode.Sync;
+					delete mParameters.createAtEnd;
+				} else {
+					throw new Error("Binding object or path expected");
+				}
+
+				const oModel = oListBinding.getModel();
+				iCountTableItems = oListBinding.iMaxLength || 0;
+				const sCreationMode = mParameters.creationMode;
+
+				return Promise.resolve(this._getProgrammingModel(oListBinding))
+					.then((programmingModel: any) => {
+						sProgrammingModel = programmingModel;
+						if (sCreationMode && sCreationMode !== CreationMode.NewPage) {
+							// use the passed creation mode
+							return sCreationMode;
+						} else {
+							const oMetaModel = oModel.getMetaModel();
+							// NewAction is not yet supported for NavigationProperty collection
+							if (!oListBinding.isRelative()) {
+								const sPath = oListBinding.getPath(),
+									// if NewAction with parameters is present, then creation is 'Deferred'
+									// in the absence of NewAction or NewAction with parameters, creation is async
+									sNewAction =
+										sProgrammingModel === ProgrammingModel.Draft
+											? oMetaModel.getObject(sPath + "@com.sap.vocabularies.Common.v1.DraftRoot/NewAction")
+											: oMetaModel.getObject(
+													sPath + "@com.sap.vocabularies.Session.v1.StickySessionSupported/NewAction"
+											  );
+								if (sNewAction) {
+									const aParameters = oMetaModel.getObject("/" + sNewAction + "/@$ui5.overload/0/$Parameter") || [];
+									// binding parameter (eg: _it) is not considered
+									if (aParameters.length > 1) {
+										return CreationMode.Deferred;
+									}
+								}
+							}
+							const sMetaPath = oMetaModel.getMetaPath(oListBinding.getHeaderContext().getPath());
+							const aNonComputedVisibleKeyFields = CommonUtils.getNonComputedVisibleFields(
+								oMetaModel,
+								sMetaPath,
+								this.getView()
+							);
+							if (aNonComputedVisibleKeyFields.length > 0) {
+								return CreationMode.Deferred;
+							}
+							return CreationMode.Async;
+						}
+					})
+					.then((sCreationMode: any) => {
+						let oCreation: any;
+						let mArgs: any;
+						const oCreationRow = mParameters.creationRow;
+						let oCreationRowContext: any;
+						let oValidationCheck = Promise.resolve();
+						let oPayload: any;
+						let sMetaPath: string;
+						const oMetaModel = oModel.getMetaModel();
+						const oRoutingListener = this._getRoutingListener();
+
+						if (sCreationMode !== CreationMode.Deferred) {
+							if (sCreationMode === CreationMode.CreationRow) {
+								oCreationRowContext = oCreationRow.getBindingContext();
+								sMetaPath = oMetaModel.getMetaPath(oCreationRowContext.getPath());
+								// prefill data from creation row
+								oPayload = oCreationRowContext.getObject();
+								mParameters.data = {};
+								Object.keys(oPayload).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;
+									}
+									mParameters.data[sPropertyPath] = oPayload[sPropertyPath];
+								});
+								oValidationCheck = this._checkForValidationErrors(/*oCreationRowContext*/);
+							}
+							if (sCreationMode === CreationMode.CreationRow || sCreationMode === CreationMode.Inline) {
+								mParameters.keepTransientContextOnFailed = false; // currently not fully supported
+								// busy handling shall be done locally only
+								mParameters.busyMode = "Local";
+
+								// take care on message handling, draft indicator (in case of draft)
+								// Attach the create sent and create completed event to the object page binding so that we can react
+								this._handleCreateEvents(oListBinding);
+							}
+
+							oCreation = oValidationCheck.then(() => {
+								if (!mParameters.parentControl) {
+									mParameters.parentControl = this.getView();
+								}
+								mParameters.beforeCreateCallBack = this.base.editFlow.onBeforeCreate;
+								return transactionHelper.createDocument(
+									oListBinding,
+									mParameters,
+									oResourceBundle,
+									this._getMessageHandler(),
+									false,
+									this.getView()
+								);
+							});
+						}
+
+						let oNavigation;
+						switch (sCreationMode) {
+							case CreationMode.Deferred:
+								oNavigation = oRoutingListener.navigateForwardToContext(oListBinding, {
+									bDeferredContext: true,
+									editable: true,
+									bForceFocus: true
+								});
+								break;
+							case CreationMode.Async:
+								oNavigation = oRoutingListener.navigateForwardToContext(oListBinding, {
+									asyncContext: oCreation,
+									editable: true,
+									bForceFocus: true
+								});
+								break;
+							case CreationMode.Sync:
+								mArgs = {
+									editable: true,
+									bForceFocus: true
+								};
+								if (sProgrammingModel == ProgrammingModel.Sticky || mParameters.createAction) {
+									mArgs.transient = true;
+								}
+								oNavigation = oCreation.then(function(oNewDocumentContext: any) {
+									if (!oNewDocumentContext) {
+										const oResourceBundle = sap.ui.getCore().getLibraryResourceBundle("sap.fe.core") as ResourceBundle;
+										return oRoutingListener.navigateToMessagePage(
+											oResourceBundle.getText("C_COMMON_SAPFE_DATA_RECEIVED_ERROR"),
+											{
+												title: oResourceBundle.getText("C_COMMON_SAPFE_ERROR"),
+												description: oResourceBundle.getText("C_EDITFLOW_SAPFE_CREATION_FAILED_DESCRIPTION")
+											}
+										);
+									} else {
+										return oRoutingListener.navigateForwardToContext(oNewDocumentContext, mArgs);
+									}
+								});
+								break;
+							case CreationMode.Inline:
+								handleSideEffects(oListBinding, oCreation);
+								this._syncTask(oCreation);
+								break;
+							case CreationMode.CreationRow:
+								// the creation row shall be cleared once the validation check was successful and
+								// therefore the POST can be sent async to the backend
+								oNavigation = oValidationCheck
+									.then(function() {
+										const oCreationRowListBinding = oCreationRowContext.getBinding();
+
+										if (!mParameters.bSkipSideEffects) {
+											handleSideEffects(oListBinding, oCreation);
+										}
+
+										const oNewTransientContext = oCreationRowListBinding.create();
+										oCreationRow.setBindingContext(oNewTransientContext);
+
+										// this is needed to avoid console errors TO be checked with model colleagues
+										oNewTransientContext.created().catch(function() {
+											Log.trace("transient fast creation context deleted");
+										});
+										return oCreationRowContext.delete("$direct");
+									})
+									.catch((oError: any) => {
+										// Reset busy indicator after a validation error
+										if (BusyLocker.isLocked(this.getView().getModel("ui"))) {
+											BusyLocker.unlock(this.getView().getModel("ui"));
+										}
+										Log.error("CreationRow navigation error: ", oError);
+									});
+								break;
+							default:
+								oNavigation = Promise.reject("Unhandled creationMode " + sCreationMode);
+								break;
+						}
+
+						if (sProgrammingModel === ProgrammingModel.Sticky) {
+							this._getInternalModel().setProperty("/sessionOn", true);
+						}
+						const bIsNewPageCreation =
+							mParameters.creationMode !== CreationMode.CreationRow && mParameters.creationMode !== CreationMode.Inline;
+						if (oCreation) {
+							return Promise.all([oCreation, oNavigation])
+								.then((aParams: [any, any]) => {
+									if (bIsNewPageCreation) {
+										this._setEditMode(EditMode.Editable, bIsNewPageCreation);
+									} else {
+										this._setEditMode(EditMode.Editable);
+									}
+									const oNewDocumentContext = aParams[0];
+									if (oNewDocumentContext) {
+										EditState.setEditStateDirty();
+										send(this.getView(), Activity.Create, oNewDocumentContext);
+										if (sProgrammingModel === ProgrammingModel.Sticky) {
+											this._handleStickyOn(oNewDocumentContext);
+										}
+									}
+								})
+								.catch(function(oError: any) {
+									if (oError && (oError.navigateBackFromTransientState || oError == Constants.CancelActionDialog)) {
+										oRoutingListener.navigateBackFromTransientState();
+									}
+
+									return Promise.reject(oError);
+								});
+						}
+					});
+			})
+			.finally(function() {
+				if (oTable && oTable.isA("sap.ui.mdc.Table")) {
+					const fnFocusOrScroll =
+						mParameters.creationMode === CreationMode.Inline ? oTable.focusRow.bind(oTable) : oTable.scrollToIndex.bind(oTable);
+					oTable.getRowBinding().attachEventOnce("change", function() {
+						switch (mParameters.createAtEnd) {
+							case true:
+								if (oTable.data("tableType") === "ResponsiveTable" && oTable.getThreshold()) {
+									fnFocusOrScroll(oTable.getThreshold(), true);
+								} else {
+									fnFocusOrScroll(iCountTableItems, true);
+								}
+								break;
+							case false:
+								fnFocusOrScroll(0, true);
+								break;
+						}
+					});
+				}
+				bShouldBusyLock && BusyLocker.unlock(oLockObject);
+			});
+	}
+
+	/**
+	 * This function can be used to intercept the 'Save' action. You can execute custom coding in this function.
+	 * The framework waits for the returned promise to be resolved before continuing the 'Save' action.
+	 * If you reject the promise, the 'Save' action is stopped and the user stays in edit mode.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 * @param {object} mParameters Object containing the parameters passed to onBeforeSave
+	 * @param {sap.ui.model.odata.v4.Context} mParameters.context Page context that is going to be saved.
+	 * @returns {Promise} A promise to be returned by the overridden method. If resolved, the 'Save' action is triggered. If rejected, the 'Save' action is not triggered and the user stays in edit mode.
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeSave
+	 * @public
+	 * @experimental As of version 1.90.0
+	 * @since 1.90.0
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	onBeforeSave(mParameters?: { context?: Context }): Promise<void> {
+		// to be overridden
+		return Promise.resolve();
+	}
+	/**
+	 * This function can be used to intercept the 'Create' action. You can execute custom coding in this function.
+	 * The framework waits for the returned promise to be resolved before continuing the 'Create' action.
+	 * If you reject the promise, the 'Create' action is stopped.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 * @param {map} mParameters Object containing the parameters passed to onBeforeCreate
+	 * @param {string} mParameters.contextPath Path pointing to the context on which Create action is triggered
+	 * @param {Array} mParameters.createParameters Array of values that are filled in the Action Parameter Dialog
+	 * @returns {Promise} A promise to be returned by the overridden method. If resolved, the 'Create' action is triggered. If rejected, the 'Create' action is not triggered.
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeCreate
+	 * @public
+	 * @experimental As of version 1.98.0
+	 * @since 1.98.0
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	onBeforeCreate(mParameters?: { contextPath?: string; createParameters?: any[] }): Promise<void> {
+		// to be overridden
+		return Promise.resolve();
+	}
+	/**
+	 * This function can be used to intercept the 'Edit' action. You can execute custom coding in this function.
+	 * The framework waits for the returned promise to be resolved before continuing the 'Edit' action.
+	 * If you reject the promise, the 'Edit' action is stopped and the user stays in display mode.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 * @param {object} mParameters Object containing the parameters passed to onBeforeEdit
+	 * @param {sap.ui.model.odata.v4.Context} mParameters.context Page context that is going to be edited.
+	 * @returns {Promise} A promise to be returned by the overridden method. If resolved, the 'Edit' action is triggered. If rejected, the 'Edit' action is not triggered and the user stays in display mode.
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeEdit
+	 * @public
+	 * @experimental As of version 1.98.0
+	 * @since 1.98.0
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	onBeforeEdit(mParameters?: { context?: Context }): Promise<void> {
+		// to be overridden
+		return Promise.resolve();
+	}
+	/**
+	 * This function can be used to intercept the 'Discard' action. You can execute custom coding in this function.
+	 * The framework waits for the returned promise to be resolved before continuing the 'Discard' action.
+	 * If you reject the promise, the 'Discard' action is stopped and the user stays in edit mode.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 * @param {object} mParameters Object containing the parameters passed to onBeforeDiscard
+	 * @param {sap.ui.model.odata.v4.Context} mParameters.context Page context that is going to be discarded.
+	 * @returns {Promise} A promise to be returned by the overridden method. If resolved, the 'Discard' action is triggered. If rejected, the 'Discard' action is not triggered and the user stays in edit mode.
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeDiscard
+	 * @public
+	 * @experimental As of version 1.98.0
+	 * @since 1.98.0
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	onBeforeDiscard(mParameters?: { context?: Context }): Promise<void> {
+		// to be overridden
+		return Promise.resolve();
+	}
+	/**
+	 * This function can be used to intercept the 'Delete' action. You can execute custom coding in this function.
+	 * The framework waits for the returned promise to be resolved before continuing the 'Delete' action.
+	 * If you reject the promise, the 'Delete' action is stopped.
+	 *
+	 * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+	 * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+	 * @param {object} mParameters Object containing the parameters passed to onBeforeDelete
+	 * @param {Array} mParameters.contexts An array of contexts that are going to be deleted
+	 * @returns {Promise} A promise to be returned by the overridden method. If resolved, the 'Delete' action is triggered. If rejected, the 'Delete' action is not triggered.
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeDelete
+	 * @public
+	 * @experimental As of version 1.98.0
+	 * @since 1.98.0
+	 */
+	@Public
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	onBeforeDelete(mParameters?: { contexts?: Context[] }): Promise<void> {
+		// to be overridden
+		return Promise.resolve();
+	}
+
+	// Internal only params ---
+	// @param {boolean} mParameters.bExecuteSideEffectsOnError Indicates whether SideEffects need to be ignored when user clicks on Save during an Inline creation
+	// @param {object} mParameters.bindings List bindings of the tables in the view.
+	// Both of the above parameters are for the same purpose. User can enter some information in the creation row(s) but does not 'Add row', instead clicks Save.
+	// There can be more than one in the view.
+
+	// eslint-disable-next-line jsdoc/require-param
+	/**
+	 * Saves a new document after checking it.
+	 *
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {object} oContext  Context of the editable document
+	 * @returns {Promise} Promise resolves once save is complete
+	 * @alias sap.fe.core.controllerextensions.EditFlow#saveDocument
+	 * @public
+	 * @since 1.90.0
+	 */
+	@Public
+	@Final
+	saveDocument(oContext: Context, mParameters: any): Promise<void> {
+		mParameters = mParameters || {};
+		const bExecuteSideEffectsOnError = mParameters.bExecuteSideEffectsOnError || undefined;
+		const bDraftNavigation = true;
+		const transactionHelper = this._getTransactionHelper();
+		const oResourceBundle = (this.getView().getController() as any).oResourceBundle;
+		const aBindings = mParameters.bindings;
+		// first of all wait until all key-match-requests are done
+		return (
+			this._syncTask()
+				// submit any open changes if there any (although there are validation/parse errors)
+				.then(this._submitOpenChanges.bind(this, oContext))
+				// check if there are any validation/parse errors
+				.then(this._checkForValidationErrors.bind(this, oContext))
+				.then(this.base.editFlow.onBeforeSave.bind(this, { context: oContext }))
+				// and finally if all user changes are submitted and valid save the document
+				.then(
+					transactionHelper.saveDocument.bind(
+						transactionHelper,
+						oContext,
+						oResourceBundle,
+						bExecuteSideEffectsOnError,
+						aBindings,
+						this._getMessageHandler()
+					)
+				)
+				.then((oActiveDocumentContext: any) => {
+					const sProgrammingModel = this._getProgrammingModel(oContext);
+
+					this._removeContextsFromPages();
+					if (sProgrammingModel === ProgrammingModel.Sticky) {
+						this._getInternalModel().setProperty("/sessionOn", false);
+						this._handleStickyOff(/*oContext*/);
+					}
+
+					send(this.getView(), Activity.Activate, oActiveDocumentContext);
+
+					this._setEditMode(EditMode.Display, false);
+					this._getMessageHandler().showMessageDialog();
+
+					if (oActiveDocumentContext !== oContext) {
+						this._handleNewContext(oActiveDocumentContext, false, false, bDraftNavigation, true);
+					}
+				})
+				.catch(function(oError: any) {
+					Log.error("Error while saving the document", oError);
+					return Promise.reject(oError);
+				})
+		);
+	}
+	@Public
+	@Final
+	toggleDraftActive(oContext: any) {
+		const oContextData = oContext.getObject();
+		let bEditable: boolean;
+		const bIsDraft = oContext && this._getProgrammingModel(oContext) === ProgrammingModel.Draft;
+		const oToggleContext = oContext
+			.getModel()
+			.bindContext(oContext.getPath() + "/SiblingEntity")
+			.getBoundContext();
+
+		//toggle between draft and active document is only available for edit drafts and active documents with draft)
+		if (
+			!bIsDraft ||
+			!(
+				(!oContextData.IsActiveEntity && oContextData.HasActiveEntity) ||
+				(oContextData.IsActiveEntity && oContextData.HasDraftEntity)
+			)
+		) {
+			return;
+		}
+
+		if (!oContextData.IsActiveEntity && oContextData.HasActiveEntity) {
+			//start Point: edit draft
+			bEditable = false;
+		} else if (oContextData.IsActiveEntity && oContextData.HasDraftEntity) {
+			// start point active document
+			bEditable = true;
+		}
+		oToggleContext
+			.requestCanonicalPath()
+			.then(function(sCanonicalPath: any) {
+				// We use the canonical path for the navigation instead of the semantic path, as the
+				// semantic key values may have changed between the draft and the active version (BCP 2170216142)
+				return oToggleContext
+					.getModel()
+					.bindContext(sCanonicalPath)
+					.getBoundContext();
+			})
+			.then((oToggleContext: any) => {
+				this._setEditMode(bEditable ? EditMode.Editable : EditMode.Display, false); //switch to edit mode only if a draft is available
+				this._handleNewContext(oToggleContext, bEditable, true, true, true);
+			})
+			.catch(function(err: any) {
+				return Promise.reject("Error in EditFlow.toggleDraftActive:" + err);
+			});
+	}
+
+	// Internal only params ---
+	// @param {sap.m.Button} mParameters.cancelButton - Currently this is passed as cancelButton internally (replaced by mParameters.control in the JSDoc below). Currently it is also mandatory.
+	// Plan - This should not be mandatory. If not provided, we should have a default that can act as reference control for the discard popover OR we can show a dialog instead of a popover.
+
+	/**
+	 * Discard the editable document.
+	 *
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {object} oContext  Context of the editable document
+	 * @param {map} mParameters Can contain the following attributes:
+	 * @param {object} mParameters.control This is the control used to open the discard popover
+	 * @param {boolean} mParameters.skipDiscardPopover Optional, supresses the discard popover and allows custom handling
+	 * @returns {Promise} Promise resolves once editable document has been discarded
+	 * @alias sap.fe.core.controllerextensions.EditFlow#cancelDocument
+	 * @public
+	 * @since 1.90.0
+	 */
+	@Public
+	@Final
+	cancelDocument(oContext: object, mParameters: { control: object; skipDiscardPopover?: boolean }): Promise<void> {
+		const transactionHelper = this._getTransactionHelper(),
+			oResourceBundle = (this.getView().getController() as any).oResourceBundle;
+		const mInParameters: any = mParameters;
+		mInParameters.cancelButton = mParameters.control || mInParameters.cancelButton;
+		mInParameters.beforeCancelCallBack = this.base.editFlow.onBeforeDiscard;
+		return this._syncTask()
+			.then(
+				transactionHelper.cancelDocument.bind(transactionHelper, oContext, mParameters, oResourceBundle, this._getMessageHandler())
+			)
+			.then((oActiveDocumentContext: any) => {
+				const bDraftNavigation = true,
+					sProgrammingModel = this._getProgrammingModel(oContext);
+
+				this._removeContextsFromPages();
+				if (sProgrammingModel === ProgrammingModel.Sticky) {
+					this._getInternalModel().setProperty("/sessionOn", false);
+					this._handleStickyOff(/*oContext*/);
+				}
+
+				send(this.getView(), Activity.Discard, oActiveDocumentContext);
+
+				this._setEditMode(EditMode.Display, false);
+				this._setDraftStatus(DraftStatus.Clear);
+
+				//in case of a new document, the value of hasActiveEntity is returned. navigate back.
+				if (!oActiveDocumentContext) {
+					EditState.setEditStateDirty();
+					return mInParameters.skipBackNavigation ? undefined : this._getRoutingListener().navigateBackFromContext(oContext);
+				} else if (sProgrammingModel === ProgrammingModel.Draft) {
+					// We need to load the semantic keys of the active context, as we need them
+					// for the navigation
+					return this._fetchSemanticKeyValues(oActiveDocumentContext).then(() => {
+						// We force the recreation of the context, so that it's created and bound in the same microtask,
+						// so that all properties are loaded together by autoExpandSelect, so that when switching back to Edit mode
+						// $$inheritExpandSelect takes all loaded properties into account (BCP 2070462265)
+						if (mInParameters.skipBindingToView) {
+							return oActiveDocumentContext;
+						} else {
+							return this._handleNewContext(oActiveDocumentContext, false, true, bDraftNavigation, true);
+						}
+					});
+				} else {
+					//active context is returned in case of cancel of existing document
+					return this._handleNewContext(oActiveDocumentContext, false, false, bDraftNavigation, true);
+				}
+			})
+			.catch(function(oError: any) {
+				Log.error("Error while discarding the document", oError);
+			});
+	}
+
+	// Internal only params ---
+	// @param {string} mParameters.entitySetName Name of the EntitySet to which the object belongs
+
+	/**
+	 * Deletes the document.
+	 *
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {object} oContext  Context of the document
+	 * @param {object} mInParameters Can contain the following attributes:
+	 * @param {string} mInParameters.title Title of the object being deleted
+	 * @param {string} mInParameters.description Description of the object being deleted
+	 * @returns {Promise} Promise resolves once document has been deleted
+	 * @alias sap.fe.core.controllerextensions.EditFlow#deleteDocument
+	 * @public
+	 * @since 1.90.0
+	 */
+	@Public
+	@Final
+	deleteDocument(oContext: Context, mInParameters: { title: string; description: string }): Promise<void> {
+		const oAppComponent = CommonUtils.getAppComponent(this.getView());
+		const sPath = oContext.getPath();
+		let mParameters: any = mInParameters;
+		if (!mParameters) {
+			mParameters = {
+				bFindActiveContexts: false
+			};
+		} else {
+			mParameters.bFindActiveContexts = false;
+		}
+		mParameters.beforeDeleteCallBack = this.base.editFlow.onBeforeDelete;
+		return this._deleteDocumentTransaction(oContext, mParameters)
+			.then(() => {
+				// Single objet deletion is triggered from an OP header button (not from a list)
+				// --> Mark UI dirty and navigate back to dismiss the OP
+				EditState.setEditStateDirty();
+
+				send(this.getView(), Activity.Delete, sPath);
+
+				this._getRoutingListener().navigateBackFromContext(oContext);
+				// After delete is successfull, we need to dettch the setBackNavigation Methods
+				if (oAppComponent) {
+					oAppComponent.getShellServices().setBackNavigation();
+				}
+			})
+			.catch(function(oError: any) {
+				Log.error("Error while deleting the document", oError);
+			});
+	}
+
+	/**
+	 * Submit the current set of changes and navigate back.
+	 *
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {object} oContext  Context of the document
+	 * @returns {Promise} Promise resolves once the changes have been saved
+	 * @alias sap.fe.core.controllerextensions.EditFlow#applyDocument
+	 * @public
+	 * @since 1.90.0
+	 */
+	@Public
+	@Final
+	applyDocument(oContext: object): Promise<void> {
+		const oLockObject = this._getGlobalUIModel();
+		BusyLocker.lock(oLockObject);
+		return (
+			this._submitOpenChanges(oContext)
+				// check if there are any validation/parse errors
+				.then(this._checkForValidationErrors.bind(this, oContext))
+				.then(() => {
+					this._getMessageHandler().showMessageDialog();
+					this._getRoutingListener().navigateBackFromContext(oContext);
+					return true;
+				})
+				.finally(function() {
+					if (BusyLocker.isLocked(oLockObject)) {
+						BusyLocker.unlock(oLockObject);
+					}
+				})
+		);
+	}
+
+	// Internal only params ---
+	// @param {boolean} [mParameters.bStaticAction] Boolean value for static action, undefined for other actions
+	// @param {boolean} [mParameters.isNavigable] Boolean value indicating whether navigation is required after the action has been executed
+	// Currently the parameter isNavigable is used internally and should be changed to requiresNavigation as it is a more apt name for this param
+
+	/**
+	 * Invokes an action (bound or unbound) and tracks the changes so that other pages can be refreshed and show the updated data upon navigation.
+	 *
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {string} sActionName The name of the action to be called
+	 * @param {object} mInParameters Contains the following attributes:
+	 * @param {sap.ui.model.odata.v4.Context} mInParameters.contexts For a bound action, a context or an array with contexts for which the action is to be called must be provided
+	 * @param {sap.ui.model.odata.v4.ODataModel} mInParameters.model For an unbound action, an instance of an OData V4 model must be provided
+	 * @param {boolean} mInParameters.requiresNavigation Boolean value indicating whether navigation is required after the action has been executed. Navigation takes place to the context returned by the action
+	 * @param {string} mInParameters.label A human-readable label for the action. This is needed in case the action has a parameter and a parameter dialog is shown to the user. The label will be used for the title of the dialog and for the confirmation button
+	 * @param {string} mInParameters.invocationGrouping Mode how actions are to be called: 'ChangeSet' to put all action calls into one changeset, 'Isolated' to put them into separate changesets
+	 * @param {object} mExtraParams PRIVATE
+	 * @returns {Promise}
+	 * @alias sap.fe.core.controllerextensions.EditFlow#invokeAction
+	 * @public
+	 * @since 1.90.0
+	 * @final
+	 **/
+	@Public
+	@Final
+	invokeAction(
+		sActionName: string,
+		mInParameters?: {
+			contexts?: Context | Context[];
+			model?: ODataModel;
+			requiresNavigation?: boolean;
+			label?: string;
+			invocationGrouping?: string;
+		},
+		mExtraParams?: any
+	): Promise<void> {
+		let oControl: any;
+		const transactionHelper = this._getTransactionHelper();
+		let oCurrentControl;
+		let oBindingContext;
+		let aParts;
+		let sOverloadEntityType;
+		let oCurrentActionCallBacks: any;
+		const oView = this.getView();
+
+		let mParameters: any = mInParameters || {};
+
+		// Due to a mistake the invokeAction in the extensionAPI had a different API than this one.
+		// The one from the extensionAPI doesn't exist anymore as we expose the full edit flow now but
+		// due to compatibility reasons we still need to support the old signature
+		if ((mParameters.isA && mParameters.isA("sap.ui.model.odata.v4.Context")) || Array.isArray(mParameters) || arguments.length === 3) {
+			const contexts = mParameters;
+			mParameters = mExtraParams || {};
+			if (contexts) {
+				mParameters.contexts = contexts;
+			} else {
+				mParameters.model = this.getView().getModel();
+			}
+		}
+
+		mParameters.isNavigable = mParameters.requiresNavigation || mParameters.isNavigable;
+
+		if (!mParameters.parentControl) {
+			mParameters.parentControl = this.getView();
+		}
+
+		if (mParameters.controlId) {
+			oControl = this.getView().byId(mParameters.controlId);
+			if (oControl) {
+				// TODO: currently this selected contexts update is done within the operation, should be moved out
+				mParameters.internalModelContext = oControl.getBindingContext("internal");
+			}
+		} else {
+			mParameters.internalModelContext = oView.getBindingContext("internal");
+		}
+
+		if (sActionName && sActionName.indexOf("(") > -1) {
+			// get entity type of action overload and remove it from the action path
+			// Example sActionName = "<ActionName>(Collection(<OverloadEntityType>))"
+			// sActionName = aParts[0] --> <ActionName>
+			// sOverloadEntityType = aParts[2] --> <OverloadEntityType>
+			aParts = sActionName.split("(");
+			sActionName = aParts[0];
+			sOverloadEntityType = (aParts[aParts.length - 1] as any).replaceAll(")", "");
+		}
+
+		if (mParameters.bStaticAction) {
+			if (oControl.isTableBound()) {
+				mParameters.contexts = oControl.getRowBinding().getHeaderContext();
+			} else {
+				const sBindingPath = oControl.data("rowsBindingInfo").path,
+					oListBinding = new (ODataListBinding as any)(this.getView().getModel(), sBindingPath);
+				mParameters.contexts = oListBinding.getHeaderContext();
+			}
+
+			if (sOverloadEntityType) {
+				const sTableContextEntityType = mParameters.contexts
+					.getModel()
+					.getMetaModel()
+					.getMetaContext(mParameters.contexts.getPath())
+					.getObject("$Type");
+				if (sOverloadEntityType !== sTableContextEntityType) {
+					// search for context in control tree hierarchy
+					oCurrentControl = oControl;
+					while (oCurrentControl) {
+						oBindingContext = oCurrentControl.getBindingContext();
+						if (
+							oBindingContext &&
+							oBindingContext
+								.getModel()
+								.getMetaModel()
+								.getMetaContext(oBindingContext.getPath())
+								.getObject("$Type") === sOverloadEntityType
+						) {
+							mParameters.contexts = oBindingContext;
+							break;
+						} else {
+							// check parent
+							oCurrentControl = oCurrentControl.getParent();
+						}
+					}
+					// context was not found in UI hierarchy going straight upwards - try to find it in SubSections
+					if (!oCurrentControl) {
+						const oActionOverloadContext = this._getActionOverloadContextFromSubSections(oControl, sOverloadEntityType);
+						if (oActionOverloadContext !== undefined) {
+							mParameters.contexts = oActionOverloadContext;
+						}
+					}
+
+					if (!mParameters.contexts) {
+						return Promise.reject("Context not found for entity type " + sOverloadEntityType);
+					}
+				}
+			}
+
+			if (mParameters.enableAutoScroll) {
+				oCurrentActionCallBacks = this._createActionPromise(sActionName, oControl.sId);
+			}
+		}
+
+		if (mParameters.isNavigable) {
+			mParameters.bGetBoundContext = false;
+		} else {
+			mParameters.bGetBoundContext = true;
+		}
+		// Need to know that the action is called from ObjectPage for changeSet Isolated workaround
+		mParameters.bObjectPage = (oView.getViewData() as any).converterType === "ObjectPage";
+		return this._syncTask()
+			.then(transactionHelper.callAction.bind(transactionHelper, sActionName, mParameters, this.getView(), this._getMessageHandler()))
+			.then((oResponse: any) => {
+				// if the returned context for the bound action is different than the context on which action was called,
+				// refresh the corresponding list binding
+				if (mParameters.contexts) {
+					return this._refreshListIfRequired(
+						this._getActionResponseDataAndKeys(sActionName, oResponse),
+						mParameters.contexts[0]
+					).then(function() {
+						return oResponse;
+					});
+				}
+			})
+			.then((oResponse: any) => {
+				send(this.getView(), Activity.Action, mParameters.contexts);
+
+				if (oCurrentActionCallBacks) {
+					oCurrentActionCallBacks.fResolver(oResponse);
+				}
+				/*
+					 We set the (upper) pages to dirty after an execution of an action
+					 TODO: get rid of this workaround
+					 This workaround is only needed as long as the model does not support the synchronization.
+					 Once this is supported we don't need to set the pages to dirty anymore as the context itself
+					 is already refreshed (it's just not reflected in the object page)
+					 we explicitly don't call this method from the list report but only call it from the object page
+					 as if it is called in the list report it's not needed - as we anyway will remove this logic
+					 we can live with this
+					 we need a context to set the upper pages to dirty - if there are more than one we use the
+					 first one as they are anyway siblings
+					 */
+				if (mParameters.contexts) {
+					EditState.setEditStateDirty();
+					this._getInternalModel().setProperty("/sCustomAction", sActionName);
+				}
+				if (mParameters.isNavigable) {
+					let vContext = oResponse;
+					if (Array.isArray(vContext) && vContext.length === 1) {
+						vContext = vContext[0];
+					}
+					if (vContext && !Array.isArray(vContext)) {
+						const oMetaModel = oView.getModel().getMetaModel() as ODataMetaModel;
+						const sContextMetaPath = oMetaModel.getMetaPath(vContext.getPath());
+						const oActionContext = Array.isArray(mParameters.contexts) ? mParameters.contexts[0] : mParameters.contexts;
+						const sActionContextMetaPath = oActionContext && oMetaModel.getMetaPath(oActionContext.getPath());
+						if (sContextMetaPath != undefined && sContextMetaPath === sActionContextMetaPath) {
+							if (oActionContext.getPath() !== vContext.getPath()) {
+								this._getRoutingListener().navigateForwardToContext(vContext, {
+									noHistoryEntry: false
+								});
+							} else {
+								Log.info("Navigation to the same context is not allowed");
+							}
+						}
+					}
+				}
+			})
+			.catch(function(err: any) {
+				if (oCurrentActionCallBacks) {
+					oCurrentActionCallBacks.fRejector();
+				}
+				if (err == Constants.CancelActionDialog) {
+					return Promise.reject("Dialog cancelled.");
+				} else {
+					return Promise.reject("Error in EditFlow.invokeAction:" + err);
+				}
+			});
+	}
+
+	/**
+	 * Secured execution of the given function. Ensures that the function is only executed when certain conditions are fulfilled.
+	 *
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {Function} fnFunction The function to be executed. Should return a promise that is settled after completion of the execution. If nothing is returned, immediate completion is assumed.
+	 * @param {object} mParameters Definitions of the preconditions to be checked before execution
+	 * @param {object} mParameters.busy Defines the busy indicator
+	 * @param {boolean} mParameters.busy.set Triggers a busy indicator when the function is executed.
+	 * @param {boolean} mParameters.busy.check Executes function only if application isn't busy.
+	 * @param {boolean} mParameters.updatesDocument This operation updates the current document without using the bound model and context. As a result, the draft status is updated if a draft document exists, and the user has to confirm the cancellation of the editing process.
+	 * @returns {Promise} A promise that is rejected if the execution is prohibited and resolved by the promise returned by the fnFunction.
+	 * @alias sap.fe.core.controllerextensions.EditFlow#securedExecution
+	 * @public
+	 * @experimental As of version 1.90.0
+	 * @since 1.90.0
+	 */
+	@Public
+	@Final
+	securedExecution(
+		fnFunction: Function,
+		mParameters?: {
+			busy?: {
+				set?: boolean;
+				check?: boolean;
+			};
+			updatesDocument?: boolean;
+		}
+	): Promise<void> {
+		const bBusySet = mParameters && mParameters.busy && mParameters.busy.set !== undefined ? mParameters.busy.set : true,
+			bBusyCheck = mParameters && mParameters.busy && mParameters.busy.check !== undefined ? mParameters.busy.check : true,
+			bUpdatesDocument = (mParameters && (mParameters as any).updatesDocument) || false,
+			oLockObject = this._getGlobalUIModel(),
+			oContext = this.base.getView().getBindingContext(),
+			bIsDraft = oContext && this._getProgrammingModel(oContext) === ProgrammingModel.Draft;
+
+		if (bBusyCheck && BusyLocker.isLocked(oLockObject)) {
+			return Promise.reject("Application already busy therefore execution rejected");
+		}
+
+		// we have to set busy and draft indicator immediately also the function might be executed later in queue
+		if (bBusySet) {
+			BusyLocker.lock(oLockObject);
+		}
+		if (bUpdatesDocument && bIsDraft) {
+			this._setDraftStatus(DraftStatus.Saving);
+		}
+
+		this._getMessageHandler().removeTransitionMessages();
+
+		return this._syncTask(fnFunction)
+			.then(() => {
+				if (bUpdatesDocument) {
+					this._getTransactionHelper().handleDocumentModifications();
+					EditState.setEditStateDirty();
+					if (bIsDraft) {
+						this._setDraftStatus(DraftStatus.Saved);
+					}
+				}
+			})
+			.catch((oError: any) => {
+				if (bUpdatesDocument && bIsDraft) {
+					this._setDraftStatus(DraftStatus.Clear);
+				}
+				return Promise.reject(oError);
+			})
+			.finally(() => {
+				if (bBusySet) {
+					BusyLocker.unlock(oLockObject);
+				}
+				return this._getMessageHandler().showMessageDialog();
+			});
+	}
+
+	/**
+	 * Handles the patchSent event: register document modification.
+	 *
+	 * @param oEvent
+	 */
+	@Public
+	handlePatchSent(oEvent: any) {
+		this.mPatchPromises = this.mPatchPromises ? this.mPatchPromises : {};
+		// do this for every unique object (eg: every table) so that each associated promise is fulfilled at the end
+		const oPatchPromise = new Promise((resolve, reject) => {
+			this.mPatchPromises[oEvent.getSource()] = {
+				resolvePatchPromise: resolve,
+				rejectPatchPromise: reject
+			};
+		});
+		this.updateDocument(oEvent.getSource(), oPatchPromise);
+	}
+
+	/**
+	 * Handles the patchCompleted event: resolves or rejects document modification.
+	 *
+	 * @param oEvent
+	 */
+	@Public
+	handlePatchCompleted(oEvent: any) {
+		const bSuccess = oEvent.getParameter("success");
+		if (bSuccess) {
+			this.mPatchPromises[oEvent.getSource()].resolvePatchPromise();
+		} else {
+			this.mPatchPromises[oEvent.getSource()].rejectPatchPromise();
+		}
+		delete this.mPatchPromises[oEvent.getSource()];
+	}
+
+	//////////////////////////////////////
+	// Private methods
+	//////////////////////////////////////
+
+	/*
+			 TO BE CHECKED / DISCUSSED
+			 _createMultipleDocuments and deleteMultiDocument - couldn't we combine them with create and delete document?
+			 _createActionPromise and deleteCurrentActionPromise -> next step
+
+			 */
+
+	_setEditMode(sEditMode: any, bCreationMode?: boolean) {
+		(this.base.getView().getController() as PageController)._editFlow.setEditMode(sEditMode, bCreationMode);
+	}
+
+	_setDraftStatus(sDraftState: any) {
+		(this.base.getView().getController() as PageController)._editFlow.setDraftStatus(sDraftState);
+	}
+
+	_getRoutingListener() {
+		return (this.base.getView().getController() as PageController)._editFlow.getRoutingListener();
+	}
+
+	_getGlobalUIModel() {
+		return (this.base.getView().getController() as PageController)._editFlow.getGlobalUIModel();
+	}
+	_syncTask(vTask?: any) {
+		return (this.base.getView().getController() as PageController)._editFlow.syncTask(vTask);
+	}
+
+	_getProgrammingModel(oContext: any) {
+		return (this.base.getView().getController() as PageController)._editFlow.getProgrammingModel(oContext);
+	}
+
+	_deleteDocumentTransaction(oContext: any, mParameters: any) {
+		return (this.base.getView().getController() as PageController)._editFlow.deleteDocumentTransaction(oContext, mParameters);
+	}
+
+	_handleCreateEvents(oBinding: any) {
+		(this.base.getView().getController() as PageController)._editFlow.handleCreateEvents(oBinding);
+	}
+
+	_getTransactionHelper() {
+		return (this.base.getView().getController() as PageController)._editFlow.getTransactionHelper();
+	}
+
+	_getInternalModel() {
+		return (this.base.getView().getController() as PageController)._editFlow.getInternalModel();
+	}
+
+	/**
+	 * Creates a new promise to wait for an action to be executed
+	 *
+	 * @function
+	 * @name _createActionPromise
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 *
+	 * @returns {Function} The resolver function which can be used to externally resolve the promise
+	 */
+
+	_createActionPromise(sActionName: any, sControlId: any) {
+		return (this.base.getView().getController() as PageController)._editFlow.createActionPromise(sActionName, sControlId);
+	}
+
+	_getCurrentActionPromise() {
+		return (this.base.getView().getController() as PageController)._editFlow.getCurrentActionPromise();
+	}
+
+	_deleteCurrentActionPromise() {
+		return (this.base.getView().getController() as PageController)._editFlow.deleteCurrentActionPromise();
+	}
+
+	_getMessageHandler() {
+		return (this.base.getView().getController() as PageController)._editFlow.getMessageHandler();
+	}
+
+	/**
+	 * @function
+	 * @name _getActionResponseDataAndKeys
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {string} sActionName The name of the action that is executed
+	 * @param {object} oResponse The bound action's response data or response context
+	 * @returns {object} Object with data and names of the key fields of the response
+	 */
+	_getActionResponseDataAndKeys(sActionName: string, oResponse: object) {
+		return (this.base.getView().getController() as PageController)._editFlow.getActionResponseDataAndKeys(sActionName, oResponse);
+	}
+
+	_submitOpenChanges(oContext: any) {
+		const oModel = oContext.getModel(),
+			oLockObject = this._getGlobalUIModel();
+		//Currently we are using only 1 updateGroupId, hence submitting the batch directly here
+		return oModel
+			.submitBatch("$auto")
+			.then(function() {
+				if (oModel.hasPendingChanges("$auto")) {
+					// the submit was not successful
+					return Promise.reject("submit of open changes failed");
+				}
+			})
+			.finally(function() {
+				if (BusyLocker.isLocked(oLockObject)) {
+					BusyLocker.unlock(oLockObject);
+				}
+			});
+	}
+
+	_handleStickyOn(oContext: Context) {
+		return (this.base.getView().getController() as PageController)._editFlow.handleStickyOn(oContext);
+	}
+
+	_handleStickyOff() {
+		return (this.base.getView().getController() as PageController)._editFlow.handleStickyOff();
+	}
+
+	_onBackNavigationInSession() {
+		return (this.base.getView().getController() as PageController)._editFlow.onBackNavigationInSession();
+	}
+
+	_discardStickySession(oContext: Context) {
+		return (this.base.getView().getController() as PageController)._editFlow.discardStickySession(oContext);
+	}
+
+	_handleNewContext(oContext: any, bEditable: boolean, bRecreateContext: boolean, bDraftNavigation: boolean, bForceFocus?: boolean) {
+		EditState.setEditStateDirty();
+
+		return this._getRoutingListener().navigateToContext(oContext, {
+			checkNoHashChange: true,
+			editable: bEditable,
+			bPersistOPScroll: true,
+			bRecreateContext: bRecreateContext,
+			bDraftNavigation: bDraftNavigation,
+			showPlaceholder: false,
+			bForceFocus: bForceFocus
+		});
+	}
+
+	/**
+	 * Checks if there are validation (parse) errors for controls bound to a given context
+	 *
+	 * @function
+	 * @name _checkForValidationErrors
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @returns {Promise} Promise resolves if there are no validation errors, and rejects if there are validation errors
+	 */
+
+	_checkForValidationErrors() {
+		return this._syncTask().then(() => {
+			const sViewId = this.base.getView().getId();
+			const aMessages = sap.ui
+				.getCore()
+				.getMessageManager()
+				.getMessageModel()
+				.getData();
+			let oControl;
+			let oMessage;
+
+			if (!aMessages.length) {
+				return Promise.resolve("No validation errors found");
+			}
+
+			for (let i = 0; i < aMessages.length; i++) {
+				oMessage = aMessages[i];
+				if (oMessage.validation) {
+					oControl = sap.ui.getCore().byId(oMessage.getControlId());
+					while (oControl) {
+						if (oControl.getId() === sViewId) {
+							return Promise.reject("validation errors exist");
+						}
+						oControl = oControl.getParent();
+					}
+				}
+			}
+		});
+	}
+
+	/**
+	 * @function
+	 * @name _refreshListIfRequired
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {object} oResponse The response of the bound action and the names of the key fields
+	 * @param {sap.ui.model.odata.v4.Context} oContext The bound context on which the action was executed
+	 * @returns {Promise} Always resolves to param oResponse
+	 */
+	_refreshListIfRequired(oResponse: any, oContext: Context) {
+		if (!oContext || !oResponse || !oResponse.oData) {
+			return Promise.resolve();
+		}
+		const oBinding = oContext.getBinding();
+		// refresh only lists
+		if (oBinding && oBinding.isA("sap.ui.model.odata.v4.ODataListBinding")) {
+			const oContextData = oResponse.oData;
+			const aKeys = oResponse.keys;
+			const oCurrentData = oContext.getObject();
+			let bReturnedContextIsSame = true;
+			// ensure context is in the response
+			if (Object.keys(oContextData).length) {
+				// check if context in response is different than the bound context
+				bReturnedContextIsSame = aKeys.every(function(sKey: any) {
+					return oCurrentData[sKey] === oContextData[sKey];
+				});
+				if (!bReturnedContextIsSame) {
+					return new Promise<void>(resolve => {
+						if ((oBinding as any).isRoot()) {
+							oBinding.attachEventOnce("dataReceived", function() {
+								resolve();
+							});
+							oBinding.refresh();
+						} else {
+							const oAppComponent = CommonUtils.getAppComponent(this.getView());
+							oAppComponent
+								.getSideEffectsService()
+								.requestSideEffects([{ $NavigationPropertyPath: oBinding.getPath() }], oBinding.getContext() as Context)
+								.then(
+									function() {
+										resolve();
+									},
+									function() {
+										Log.error("Error while refreshing the table");
+										resolve();
+									}
+								)
+								.catch(function(e: any) {
+									Log.error("Error while refreshing the table", e);
+								});
+						}
+					});
+				}
+			}
+		}
+		// resolve with oResponse to not disturb the promise chain afterwards
+		return Promise.resolve();
+	}
+
+	_fetchSemanticKeyValues(oContext: any) {
+		const oMetaModel = oContext.getModel().getMetaModel(),
+			sEntitySetName = oMetaModel.getMetaContext(oContext.getPath()).getObject("@sapui.name"),
+			aSemanticKeys = SemanticKeyHelper.getSemanticKeys(oMetaModel, sEntitySetName);
+
+		if (aSemanticKeys && aSemanticKeys.length) {
+			const aRequestPromises = aSemanticKeys.map(function(oKey: any) {
+				return oContext.requestObject(oKey.$PropertyPath);
+			});
+
+			return Promise.all(aRequestPromises);
+		} else {
+			return Promise.resolve();
+		}
+	}
+
+	// Ugly Workaround to overcome mdc field issue, we remove the binding context before
+	// switching to display mode to avoid the field reads additional values for non existing
+	// drafts or sticky sessions in the backend
+	_removeContextsFromPages() {
+		let aPages: any[] = [];
+		const oAppComponent = CommonUtils.getAppComponent(this.getView());
+
+		if (oAppComponent._isFclEnabled()) {
+			const oFCL = oAppComponent.getRootContainer() as FlexibleColumnLayout;
+			aPages = aPages.concat(oFCL.getMidColumnPages() || []);
+			aPages = aPages.concat(oFCL.getEndColumnPages() || []);
+		} else {
+			const oNavContainer = oAppComponent.getRootContainer() as NavContainer;
+			aPages = oNavContainer.getPages() || [];
+		}
+
+		aPages.forEach(function(oPage: any) {
+			if (oPage.isA("sap.ui.core.ComponentContainer")) {
+				oPage = oPage.getComponentInstance(); // The binding context is set at the component level, not the component container
+			}
+
+			if (oPage.getBindingContext()) {
+				oPage.setBindingContext(null);
+			}
+		});
+	}
+
+	_getActionOverloadContextFromSubSections(oControl: any, sOverloadEntityType: string) {
+		let oCurrentControl: any;
+
+		function _checkActions(aActions: Array<object>) {
+			let oActionBindingContext: any;
+			try {
+				aActions.forEach(function(oAction: any) {
+					oActionBindingContext = oAction.getBindingContext();
+					if (
+						oActionBindingContext
+							.getModel()
+							.getMetaModel()
+							.getMetaContext(oActionBindingContext.getPath())
+							.getObject("$Type") === sOverloadEntityType
+					) {
+						throw "context found - stop actions loop";
+					}
+				});
+				return undefined;
+			} catch (e) {
+				return oActionBindingContext;
+			}
+		}
+
+		function _checkSubSections(aSubSections: Array<object>) {
+			let oActionBindingContext: any;
+			try {
+				aSubSections.forEach(function(oSubSection: any) {
+					if (oActionBindingContext) {
+						throw "context found - stop SubSections loop";
+					}
+					const aActions = oSubSection.getAggregation("actions");
+					oActionBindingContext = _checkActions(aActions);
+				});
+				return oActionBindingContext ? oActionBindingContext : undefined;
+			} catch (e) {
+				return oActionBindingContext;
+			}
+		}
+
+		try {
+			if (oControl === undefined) {
+				throw new Error("input parameter oControl undefined when trying to determine the action overload context");
+			}
+
+			oCurrentControl = oControl;
+			while (!oCurrentControl.isA("sap.uxap.ObjectPageSection")) {
+				oCurrentControl = oCurrentControl.getParent();
+			}
+
+			if (!oCurrentControl) {
+				throw new Error("ObjectPageSection not found in UI hierarchy");
+			} else {
+				const aSubSections = oCurrentControl.getAggregation("subSections");
+				return _checkSubSections(aSubSections);
+			}
+		} catch (error) {
+			Log.info(error);
+			return undefined;
+		}
+	}
+}
+
+export default EditFlow;