@sapui5/sap.fe.core 1.98.0 → 1.99.0

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

@@ -0,0 +1,1706 @@
+import draft from "sap/fe/core/actions/draft";
+import sticky from "sap/fe/core/actions/sticky";
+import operations from "sap/fe/core/actions/operations";
+import JSONModel from "sap/ui/model/json/JSONModel";
+import Popover from "sap/m/Popover";
+import VBox from "sap/m/VBox";
+import CheckBox from "sap/m/CheckBox";
+import Text from "sap/m/Text";
+import Button from "sap/m/Button";
+import MessageToast from "sap/m/MessageToast";
+import Dialog from "sap/m/Dialog";
+import Log from "sap/base/Log";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import BusyLocker from "sap/fe/core/BusyLocker";
+import XMLPreprocessor from "sap/ui/core/util/XMLPreprocessor";
+import XMLTemplateProcessor from "sap/ui/core/XMLTemplateProcessor";
+import Fragment from "sap/ui/core/Fragment";
+import MessageBox from "sap/m/MessageBox";
+import ModelHelper, { InternalModelContext } from "sap/fe/core/helpers/ModelHelper";
+import FELibrary, { ProgrammingModel as ProgrammingModelType } from "sap/fe/core/library";
+import coreLibrary from "sap/ui/core/library";
+import messageHandling from "sap/fe/core/actions/messageHandling";
+import { AppComponent } from "sap/fe/core";
+import ResourceBundle from "sap/base/i18n/ResourceBundle";
+import ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
+import View from "sap/ui/core/mvc/View";
+import FPMHelper from "sap/fe/core/helpers/FPMHelper";
+
+const CreationMode = FELibrary.CreationMode;
+const ProgrammingModel = FELibrary.ProgrammingModel;
+const ValueState = coreLibrary.ValueState;
+/* Make sure that the mParameters is not the oEvent */
+function getParameters(mParameters: any) {
+	if (mParameters && mParameters.getMetadata && mParameters.getMetadata().getName() === "sap.ui.base.Event") {
+		mParameters = {};
+	}
+	return mParameters || {};
+}
+
+class TransactionHelper {
+	_oAppComponent: AppComponent;
+	oLockObject: any;
+	sProgrammingModel?: ProgrammingModelType;
+	_bIsModified: boolean = false;
+	_bCreateMode: boolean = false;
+	_bContinueDiscard: boolean = false;
+	_oPopover!: Popover;
+	constructor(oAppComponent: AppComponent, oLockObject: any) {
+		this._oAppComponent = oAppComponent;
+		this.oLockObject = oLockObject;
+	}
+	getProgrammingModel(oContext: any) {
+		if (!this.sProgrammingModel && oContext) {
+			let sPath;
+			if (oContext.isA("sap.ui.model.odata.v4.Context")) {
+				sPath = oContext.getPath();
+			} else {
+				sPath = oContext.isRelative() ? oContext.getResolvedPath() : oContext.getPath();
+			}
+			if (ModelHelper.isDraftSupported(oContext.getModel().getMetaModel(), sPath)) {
+				this.sProgrammingModel = ProgrammingModel.Draft;
+			} else if (ModelHelper.isStickySessionSupported(oContext.getModel().getMetaModel())) {
+				this.sProgrammingModel = ProgrammingModel.Sticky;
+			} else {
+				// as the transaction helper is a singleton we don't store the non draft as the user could
+				// start with a non draft child page and navigates back to a draft enabled one
+				return ProgrammingModel.NonDraft;
+			}
+		}
+		return this.sProgrammingModel;
+	}
+
+	/**
+	 * Validates a document.
+	 *
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @static
+	 * @param {sap.ui.model.odata.v4.Context} oContext Context of the document to be validated
+	 * @param {object} [mParameters] Can contain the following attributes:
+	 * * @param {object} [mParameters.data] A map of data that should be validated
+	 * * @param {string} [mParameters.customValidationFunction] A string representing the path to the validation function
+	 * @param {object} oView Contains the object of the current view
+	 * @returns {Promise} Promise resolves with result of the custom validation function
+	 * @ui5-restricted
+	 * @final
+	 */
+	validateDocument(oContext: any, mParameters: any, oView: View): Promise<any> {
+		const sCustomValidationFunction = mParameters && mParameters.customValidationFunction;
+		if (sCustomValidationFunction) {
+			const sModule = sCustomValidationFunction.substring(0, sCustomValidationFunction.lastIndexOf(".") || -1).replace(/\./gi, "/"),
+				sFunctionName = sCustomValidationFunction.substring(
+					sCustomValidationFunction.lastIndexOf(".") + 1,
+					sCustomValidationFunction.length
+				),
+				mData = mParameters.data;
+			delete mData["@$ui5.context.isTransient"];
+			return FPMHelper.validationWrapper(sModule, sFunctionName, mData, oView, oContext);
+		}
+		return Promise.resolve([]);
+	}
+
+	/**
+	 * Creates a new document.
+	 *
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @static
+	 * @param {sap.ui.model.odata.v4.ODataListBinding} oMainListBinding OData V4 ListBinding object
+	 * @param {object} [mInParameters] Optional, can contain the following attributes:
+	 * @param {map} [mInParameters.data] A map of data that should be sent within the POST
+	 * @param {string} [mInParameters.busyMode] Global (default), Local, None TODO: to be refactored
+	 * @param {map} [mInParameters.keepTransientContextOnFailed] If set, the context stays in the list if the POST failed and POST will be repeated with the next change
+	 * @param oResourceBundle
+	 * @param messageHandler
+	 * @param bFromCopyPaste
+	 * @param oView The current view
+	 * @returns {Promise} Promise resolves with new binding context
+	 * @ui5-restricted
+	 * @final
+	 */
+	createDocument(
+		oMainListBinding: any,
+		mInParameters: { data?: any; busyMode?: string | undefined; keepTransientContextOnFailed?: any } | undefined,
+		oResourceBundle: any,
+		messageHandler: any,
+		bFromCopyPaste: any,
+		oView: any
+	) {
+		// eslint-disable-next-line @typescript-eslint/no-this-alias
+		const that = this,
+			oModel = oMainListBinding.getModel(),
+			oMetaModel = oModel.getMetaModel(),
+			sMetaPath = oMetaModel.getMetaPath(oMainListBinding.getHeaderContext().getPath()),
+			sCreateHash = this._getAppComponent()
+				.getRouterProxy()
+				.getHash(),
+			oComponentData = this._getAppComponent().getComponentData(),
+			oStartupParameters = (oComponentData && oComponentData.startupParameters) || {},
+			sNewAction = !oMainListBinding.isRelative()
+				? this._getNewAction(oStartupParameters, sCreateHash, oMetaModel, sMetaPath)
+				: undefined;
+		let oCreationPromise;
+		const mBindingParameters: any = { "$$patchWithoutSideEffects": true };
+		const sMessagesPath = oMetaModel.getObject(sMetaPath + "/@com.sap.vocabularies.Common.v1.Messages/$Path");
+		let sBusyPath = "/busy";
+		let sFunctionName =
+			oMetaModel.getObject(sMetaPath + "@com.sap.vocabularies.Common.v1.DefaultValuesFunction") ||
+			oMetaModel.getObject(
+				ModelHelper.getTargetEntitySet(oMetaModel.getContext(sMetaPath)) + "@com.sap.vocabularies.Common.v1.DefaultValuesFunction"
+			);
+		let bFunctionOnNavProp;
+		let oNewDocumentContext: any;
+		if (sFunctionName) {
+			if (
+				oMetaModel.getObject(sMetaPath + "@com.sap.vocabularies.Common.v1.DefaultValuesFunction") &&
+				ModelHelper.getTargetEntitySet(oMetaModel.getContext(sMetaPath)) !== sMetaPath
+			) {
+				bFunctionOnNavProp = true;
+			} else {
+				bFunctionOnNavProp = false;
+			}
+		}
+		if (sMessagesPath) {
+			mBindingParameters["$select"] = sMessagesPath;
+		}
+		const mParameters = getParameters(mInParameters);
+		if (!oMainListBinding) {
+			return Promise.reject("Binding required for new document creation");
+		}
+		const sProgrammingModel = this.getProgrammingModel(oMainListBinding);
+		if (sProgrammingModel !== ProgrammingModel.Draft && sProgrammingModel !== ProgrammingModel.Sticky) {
+			return Promise.reject("Create document only allowed for draft or sticky session supported services");
+		}
+		if (mParameters.busyMode === "Local") {
+			// in case of local busy mode we use the list binding name
+			// there's no APY yet so we have to use the .sId TODO provide a public method?
+			sBusyPath = "/busyLocal/" + oMainListBinding.sId;
+		}
+		mParameters.beforeCreateCallBack = bFromCopyPaste ? null : mParameters.beforeCreateCallBack;
+		BusyLocker.lock(this.oLockObject, sBusyPath);
+		const oResourceBundleCore = sap.ui.getCore().getLibraryResourceBundle("sap.fe.core");
+		if (sNewAction) {
+			oCreationPromise = this.callAction(
+				sNewAction,
+				{
+					contexts: oMainListBinding.getHeaderContext(),
+					showActionParameterDialog: true,
+					label: this._getSpecificCreateActionDialogLabel(
+						oMetaModel,
+						sMetaPath,
+						sNewAction,
+						oResourceBundleCore as ResourceBundle
+					),
+					bindingParameters: mBindingParameters,
+					parentControl: mParameters.parentControl,
+					bIsCreateAction: true
+				},
+				null,
+				messageHandler
+			);
+		} else {
+			const bIsNewPageCreation =
+				mParameters.creationMode !== CreationMode.CreationRow && mParameters.creationMode !== CreationMode.Inline;
+			const aNonComputedVisibleKeyFields = bIsNewPageCreation
+				? CommonUtils.getNonComputedVisibleFields(oMetaModel, sMetaPath, oView)
+				: [];
+			sFunctionName = bFromCopyPaste ? null : sFunctionName;
+			let sFunctionPath, oFunctionContext;
+			if (sFunctionName) {
+				//bound to the source entity:
+				if (bFunctionOnNavProp) {
+					sFunctionPath =
+						oMainListBinding.getContext() &&
+						oMetaModel.getMetaPath(oMainListBinding.getContext().getPath()) + "/" + sFunctionName;
+					oFunctionContext = oMainListBinding.getContext();
+				} else {
+					sFunctionPath =
+						oMainListBinding.getHeaderContext() &&
+						oMetaModel.getMetaPath(oMainListBinding.getHeaderContext().getPath()) + "/" + sFunctionName;
+					oFunctionContext = oMainListBinding.getHeaderContext();
+				}
+			}
+			const oFunction = sFunctionPath && oMetaModel.createBindingContext(sFunctionPath);
+			if (oFunction && oFunction.getObject() && oFunction.getObject()[0].$IsBound) {
+				oCreationPromise = operations.callBoundFunction(sFunctionName, oFunctionContext, oModel);
+			} else {
+				oCreationPromise = operations.callFunctionImport(sFunctionName, oModel);
+			}
+
+			oCreationPromise = oCreationPromise
+				.then(function(oContext: any) {
+					if (oContext) {
+						return oContext.getObject();
+					} else {
+						return undefined;
+					}
+				})
+				.catch(function(oError: any) {
+					Log.error("Error while executing the function " + sFunctionName, oError);
+					throw oError;
+				})
+				.then(function(oData: any) {
+					mParameters.data = oData ? Object.assign({}, oData, mParameters.data) : mParameters.data;
+					if (mParameters.data) {
+						delete mParameters.data["@odata.context"];
+					}
+					if (aNonComputedVisibleKeyFields.length > 0) {
+						const oTransientListBinding = oModel.bindList(oMainListBinding.getPath(), oMainListBinding.getContext(), [], [], {
+							$$updateGroupId: "submitLater"
+						});
+						oTransientListBinding.refreshInternal = function() {
+							/* */
+						};
+						oNewDocumentContext = oTransientListBinding.create(mParameters.data, true);
+						return that._launchDialogWithKeyFields(
+							oMainListBinding,
+							oTransientListBinding,
+							oNewDocumentContext,
+							aNonComputedVisibleKeyFields,
+							oModel,
+							mParameters,
+							messageHandler
+						);
+					} else {
+						let onBeforeCreatePromise;
+						if (mParameters.beforeCreateCallBack) {
+							onBeforeCreatePromise = mParameters.beforeCreateCallBack({
+								contextPath: oMainListBinding && oMainListBinding.getPath()
+							});
+						} else {
+							onBeforeCreatePromise = Promise.resolve();
+						}
+						return onBeforeCreatePromise.then(function() {
+							oNewDocumentContext = oMainListBinding.create(mParameters.data, true, mParameters.createAtEnd);
+							return that.onAfterCreateCompletion(oMainListBinding, oNewDocumentContext, mParameters);
+						});
+					}
+				})
+				.catch(function(oError: any) {
+					Log.error("Error while creating the new document", oError);
+					throw oError;
+				});
+		}
+		return oCreationPromise
+			.then(function(oResult: any) {
+				if (!oMainListBinding.isRelative()) {
+					// the create mode shall currently only be set on creating a root document
+					that._bCreateMode = true;
+				}
+				oNewDocumentContext = oNewDocumentContext || (oResult && oResult.response);
+				// TODO: where does this one coming from???
+				if (oResult && oResult.bConsiderDocumentModified) {
+					that.handleDocumentModifications();
+				}
+				return messageHandler.showMessageDialog().then(function() {
+					return oNewDocumentContext;
+				});
+			})
+			.catch(function(oError: any) {
+				return messageHandler.showMessageDialog().then(function() {
+					// for instance, on cancel of create dialog, the promise is rejected
+					// a return here would restore the promise chain and result in errors while routing
+					// solution -  reject here as well
+					if (oError && oError.bDeleteTransientContext && oNewDocumentContext.isTransient()) {
+						// This is a workaround suggested by model as Context.delete results in an error
+						// TODO: remove the $direct once model resolves this issue
+						// this line shows the expected console error Uncaught (in promise) Error: Request canceled: POST Travel; group: submitLater
+						oNewDocumentContext.delete("$direct");
+					}
+					return Promise.reject(oError);
+				});
+			})
+			.finally(function() {
+				BusyLocker.unlock(that.oLockObject, sBusyPath);
+			});
+	}
+	/**
+	 * Find the active contexts of the documents, only for the draft roots.
+	 *
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @static
+	 * @param {sap.ui.model.odata.v4.Context[]} aContexts Contexts Either one context or an array with contexts to be deleted
+	 * @param bFindActiveContexts
+	 * @returns {Array} Array of the active contexts
+	 */
+	findActiveDraftRootContexts(aContexts: any[], bFindActiveContexts: any) {
+		if (!bFindActiveContexts) {
+			return Promise.resolve();
+		}
+		const activeContexts = aContexts.reduce(function(aResult: any, oContext: any) {
+			const oMetaModel = oContext.getModel().getMetaModel();
+			const sMetaPath = oMetaModel.getMetaPath(oContext.getPath());
+			if (oMetaModel.getObject(sMetaPath + "@com.sap.vocabularies.Common.v1.DraftRoot")) {
+				const bIsActiveEntity = oContext.getObject().IsActiveEntity,
+					bHasActiveEntity = oContext.getObject().HasActiveEntity;
+				if (!bIsActiveEntity && bHasActiveEntity) {
+					const oActiveContext = oContext
+						.getModel()
+						.bindContext(oContext.getPath() + "/SiblingEntity")
+						.getBoundContext();
+					aResult.push(oActiveContext);
+				}
+			}
+			return aResult;
+		}, []);
+		return Promise.all(
+			activeContexts.map(function(oContext: any) {
+				return oContext.requestCanonicalPath().then(
+					function() {
+						return oContext;
+					},
+					function() {
+						return;
+					}
+				);
+			})
+		);
+	}
+	afterDeleteProcess(mParameters: any, checkBox: any, aContexts: any, oResourceBundle: any) {
+		const oInternalModelContext = mParameters.internalModelContext;
+		if (oInternalModelContext && oInternalModelContext.getProperty("deleteEnabled") != undefined) {
+			if (checkBox.isCheckBoxVisible === true && checkBox.isCheckBoxSelected === false) {
+				//if unsaved objects are not deleted then we need to set the enabled to true and update the model data for next deletion
+				oInternalModelContext.setProperty("deleteEnabled", true);
+				const obj = Object.assign(oInternalModelContext.getObject(), {});
+				obj.selectedContexts = obj.selectedContexts.filter(function(element: any) {
+					return obj.deletableContexts.indexOf(element) === -1;
+				});
+				obj.deletableContexts = [];
+				obj.selectedContexts = [];
+				obj.numberOfSelectedContexts = obj.selectedContexts.length;
+				oInternalModelContext.setProperty("", obj);
+			} else {
+				oInternalModelContext.setProperty("deleteEnabled", false);
+				oInternalModelContext.setProperty("selectedContexts", []);
+				oInternalModelContext.setProperty("numberOfSelectedContexts", 0);
+			}
+		}
+		if (aContexts.length === 1) {
+			MessageToast.show(
+				CommonUtils.getTranslatedText(
+					"C_TRANSACTION_HELPER_OBJECT_PAGE_DELETE_TOAST_SINGULAR",
+					oResourceBundle,
+					null,
+					mParameters.entitySetName
+				)
+			);
+		} else {
+			MessageToast.show(
+				CommonUtils.getTranslatedText(
+					"C_TRANSACTION_HELPER_OBJECT_PAGE_DELETE_TOAST_PLURAL",
+					oResourceBundle,
+					null,
+					mParameters.entitySetName
+				)
+			);
+		}
+	}
+	/**
+	 * Delete one or multiple document(s).
+	 *
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @static
+	 * @param {sap.ui.model.odata.v4.Context} vContexts Contexts Either one context or an array with contexts to be deleted
+	 * @param {object} mParameters Optional, can contain the following attributes:
+	 * @param {string} mParameters.title Title of the object to be deleted
+	 * @param {string} mParameters.description Description of the object to be deleted
+	 * @param {integer} mParameters.numberOfSelectedContexts Number of objects selected
+	 * @param {boolean} mParameters.noDialog To disable the confirmation dialog
+	 * @param oResourceBundle
+	 * @param messageHandler
+	 * @returns {Promise}
+	 */
+	deleteDocument(vContexts: any, mParameters: any, oResourceBundle: any, messageHandler: any) {
+		let fnReject: Function,
+			fnResolve: Function,
+			aDeletableContexts: any[] = [],
+			isCheckBoxVisible = false,
+			isLockedTextVisible = false,
+			cannotBeDeletedTextVisible = false,
+			isCheckBoxSelected: boolean,
+			bDialogConfirmed = false;
+		// eslint-disable-next-line @typescript-eslint/no-this-alias
+		const that = this,
+			oResourceBundleCore = sap.ui.getCore().getLibraryResourceBundle("sap.fe.core") as ResourceBundle;
+		let aParams;
+		let oDeleteMessage: any = {
+			title: oResourceBundleCore.getText("C_COMMON_OBJECT_PAGE_DELETE")
+		};
+		BusyLocker.lock(this.oLockObject);
+		if (!Array.isArray(vContexts)) {
+			vContexts = [vContexts];
+		}
+		Promise.resolve(this.getProgrammingModel(vContexts[0]))
+			.then(function(sProgrammingModel: any) {
+				if (mParameters) {
+					if (!mParameters.numberOfSelectedContexts) {
+						if (sProgrammingModel === ProgrammingModel.Draft) {
+							for (let i = 0; i < vContexts.length; i++) {
+								const oContextData = vContexts[i].getObject();
+								if (
+									oContextData.IsActiveEntity === true &&
+									oContextData.HasDraftEntity === true &&
+									oContextData.DraftAdministrativeData &&
+									oContextData.DraftAdministrativeData.InProcessByUser &&
+									!oContextData.DraftAdministrativeData.DraftIsCreatedByMe
+								) {
+									MessageBox.show(
+										CommonUtils.getTranslatedText(
+											"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_SINGLE_OBJECT_LOCKED",
+											oResourceBundle
+										),
+										{
+											title: oResourceBundleCore.getText("C_COMMON_OBJECT_PAGE_DELETE"),
+											onClose: fnReject
+										}
+									);
+									return;
+								}
+							}
+						}
+						mParameters = getParameters(mParameters);
+						if (mParameters.title) {
+							aParams = [mParameters.title, mParameters.description];
+							oDeleteMessage.text = CommonUtils.getTranslatedText(
+								"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO",
+								oResourceBundle,
+								aParams,
+								mParameters.entitySetName
+							);
+						} else {
+							oDeleteMessage.text = CommonUtils.getTranslatedText(
+								"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_SINGULAR",
+								oResourceBundle
+							);
+						}
+						aDeletableContexts = vContexts;
+					} else {
+						oDeleteMessage = {
+							title: oResourceBundleCore.getText("C_COMMON_OBJECT_PAGE_DELETE")
+						};
+						if (mParameters.numberOfSelectedContexts === 1 && mParameters.numberOfSelectedContexts === vContexts.length) {
+							aDeletableContexts = vContexts;
+							oDeleteMessage.text = CommonUtils.getTranslatedText(
+								"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_SINGULAR",
+								oResourceBundle,
+								null,
+								mParameters.entitySetName
+							);
+						} else if (mParameters.numberOfSelectedContexts === 1 && mParameters.unSavedContexts.length === 1) {
+							//only one unsaved object
+							aDeletableContexts = mParameters.unSavedContexts;
+							const draftAdminData = aDeletableContexts[0].getObject()["DraftAdministrativeData"];
+							let sLastChangedByUser = "";
+							if (draftAdminData) {
+								sLastChangedByUser =
+									draftAdminData["LastChangedByUserDescription"] || draftAdminData["LastChangedByUser"] || "";
+							}
+							aParams = [sLastChangedByUser];
+							oDeleteMessage.text = CommonUtils.getTranslatedText(
+								"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_UNSAVED_CHANGES",
+								oResourceBundle,
+								aParams
+							);
+						} else if (mParameters.numberOfSelectedContexts === mParameters.unSavedContexts.length) {
+							//only multiple unsaved objects
+							aDeletableContexts = mParameters.unSavedContexts;
+							oDeleteMessage.text = CommonUtils.getTranslatedText(
+								"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_UNSAVED_CHANGES_MULTIPLE_OBJECTS",
+								oResourceBundle
+							);
+						} else if (
+							mParameters.numberOfSelectedContexts ===
+							vContexts.concat(mParameters.unSavedContexts.concat(mParameters.lockedContexts)).length
+						) {
+							//only unsaved, locked ,deletable objects but not non-deletable objects
+							aDeletableContexts = vContexts.concat(mParameters.unSavedContexts);
+							oDeleteMessage.text =
+								aDeletableContexts.length === 1
+									? CommonUtils.getTranslatedText(
+											"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_SINGULAR",
+											oResourceBundle,
+											null,
+											mParameters.entitySetName
+									  )
+									: CommonUtils.getTranslatedText(
+											"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_PLURAL",
+											oResourceBundle,
+											null,
+											mParameters.entitySetName
+									  );
+						} else {
+							//if non-deletable objects exists along with any of unsaved ,deletable objects
+							aDeletableContexts = vContexts.concat(mParameters.unSavedContexts);
+							cannotBeDeletedTextVisible = true;
+							oDeleteMessage.text =
+								aDeletableContexts.length === 1
+									? CommonUtils.getTranslatedText(
+											"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_SINGULAR_NON_DELETABLE",
+											oResourceBundle,
+											null,
+											mParameters.entitySetName
+									  )
+									: CommonUtils.getTranslatedText(
+											"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_PLURAL_NON_DELETABLE",
+											oResourceBundle,
+											null,
+											mParameters.entitySetName
+									  );
+							oDeleteMessage.nonDeletableText = CommonUtils.getTranslatedText(
+								"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_FEW_OBJECTS_NON_DELETABLE",
+								oResourceBundle,
+								[
+									mParameters.numberOfSelectedContexts - vContexts.concat(mParameters.unSavedContexts).length,
+									mParameters.numberOfSelectedContexts
+								]
+							);
+						}
+						if (mParameters.lockedContexts.length == 1) {
+							//setting the locked text if locked objects exist
+							isLockedTextVisible = true;
+							oDeleteMessage.nonDeletableText = CommonUtils.getTranslatedText(
+								"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_ONE_OBJECT_LOCKED",
+								oResourceBundle,
+								[mParameters.numberOfSelectedContexts]
+							);
+						}
+						if (mParameters.lockedContexts.length > 1) {
+							//setting the locked text if locked objects exist
+							isLockedTextVisible = true;
+							oDeleteMessage.nonDeletableText = CommonUtils.getTranslatedText(
+								"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_FEW_OBJECTS_LOCKED",
+								oResourceBundle,
+								[mParameters.lockedContexts.length, mParameters.numberOfSelectedContexts]
+							);
+						}
+						if (
+							mParameters.unSavedContexts.length > 0 &&
+							mParameters.unSavedContexts.length !== mParameters.numberOfSelectedContexts
+						) {
+							if (
+								(cannotBeDeletedTextVisible || isLockedTextVisible) &&
+								aDeletableContexts.length === mParameters.unSavedContexts.length
+							) {
+								//if only unsaved and either or both of locked and non-deletable objects exist then we hide the check box
+								isCheckBoxVisible = false;
+								aDeletableContexts = mParameters.unSavedContexts;
+								if (mParameters.unSavedContexts.length === 1) {
+									oDeleteMessage.text = CommonUtils.getTranslatedText(
+										"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_UNSAVED_AND_FEW_OBJECTS_LOCKED_SINGULAR",
+										oResourceBundle
+									);
+								} else {
+									oDeleteMessage.text = CommonUtils.getTranslatedText(
+										"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_UNSAVED_AND_FEW_OBJECTS_LOCKED_PLURAL",
+										oResourceBundle
+									);
+								}
+							} else {
+								if (mParameters.unSavedContexts.length === 1) {
+									oDeleteMessage.checkBoxText = CommonUtils.getTranslatedText(
+										"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_FEW_OBJECTS_UNSAVED_SINGULAR",
+										oResourceBundle
+									);
+								} else {
+									oDeleteMessage.checkBoxText = CommonUtils.getTranslatedText(
+										"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_FEW_OBJECTS_UNSAVED_PLURAL",
+										oResourceBundle
+									);
+								}
+								isCheckBoxVisible = true;
+							}
+						}
+						if (cannotBeDeletedTextVisible && isLockedTextVisible) {
+							//if both locked and non-deletable objects exist along with deletable objects
+							if (mParameters.unSavedContexts.length > 1) {
+								oDeleteMessage.nonDeletableText = CommonUtils.getTranslatedText(
+									"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_FEW_OBJECTS_LOCKED_AND_NON_DELETABLE",
+									oResourceBundle,
+									[
+										mParameters.numberOfSelectedContexts -
+											vContexts.concat(mParameters.unSavedContexts).length -
+											mParameters.lockedContexts.length,
+										mParameters.lockedContexts.length,
+										mParameters.numberOfSelectedContexts
+									]
+								);
+							}
+							if (mParameters.unSavedContexts.length == 1) {
+								oDeleteMessage.nonDeletableText = CommonUtils.getTranslatedText(
+									"C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_ONE_OBJECT_LOCKED_AND_NON_DELETABLE",
+									oResourceBundle,
+									[
+										mParameters.numberOfSelectedContexts -
+											vContexts.concat(mParameters.unSavedContexts).length -
+											mParameters.lockedContexts.length,
+										mParameters.numberOfSelectedContexts
+									]
+								);
+							}
+						}
+					}
+				}
+				let oNonDeletableMessageTextControl, oDeleteMessageTextControl;
+				const oContent = new VBox({
+					items: [
+						(oNonDeletableMessageTextControl = new Text({
+							text: oDeleteMessage.nonDeletableText,
+							visible: isLockedTextVisible || cannotBeDeletedTextVisible
+						})),
+						(oDeleteMessageTextControl = new Text({
+							text: oDeleteMessage.text
+						})),
+						new CheckBox({
+							text: oDeleteMessage.checkBoxText,
+							selected: true,
+							select: function(oEvent: any) {
+								const selected = oEvent.getSource().getSelected();
+								if (selected) {
+									aDeletableContexts = vContexts.concat(mParameters.unSavedContexts);
+									isCheckBoxSelected = true;
+								} else {
+									aDeletableContexts = vContexts;
+									isCheckBoxSelected = false;
+								}
+							},
+							visible: isCheckBoxVisible
+						})
+					]
+				});
+				const sTitle = oResourceBundleCore.getText("C_COMMON_OBJECT_PAGE_DELETE");
+				const fnConfirm = function() {
+					bDialogConfirmed = true;
+					BusyLocker.lock(that.oLockObject);
+					const aContexts = aDeletableContexts;
+					let onBeforeDeletePromise;
+					if (mParameters.beforeDeleteCallBack) {
+						onBeforeDeletePromise = mParameters.beforeDeleteCallBack({ contexts: aContexts });
+					} else {
+						onBeforeDeletePromise = Promise.resolve();
+					}
+					return onBeforeDeletePromise
+						.then(that.findActiveDraftRootContexts.bind(that, aContexts, mParameters.bFindActiveContexts))
+						.then(function(activeContexts: any) {
+							//make sure to fetch the active contexts before deleting the drafts
+							return Promise.all(
+								aContexts.map(function(oContext: any) {
+									//delete the draft
+									return draft.deleteDraft(oContext);
+								})
+							)
+								.catch(function(oError: any) {
+									return messageHandler.showMessages().then(function() {
+										// re-throw error to enforce rejecting the general promise
+										throw oError;
+									});
+								})
+								.then(function() {
+									const checkBox = {
+										"isCheckBoxVisible": isCheckBoxVisible,
+										"isCheckBoxSelected": isCheckBoxSelected
+									};
+									if (activeContexts && activeContexts.length) {
+										return Promise.all(
+											activeContexts.map(function(oContext: any) {
+												return oContext.delete();
+											})
+										).then(function() {
+											that.afterDeleteProcess(mParameters, checkBox, aContexts, oResourceBundle);
+											return messageHandler.showMessageDialog().then(fnResolve);
+										});
+									} else {
+										that.afterDeleteProcess(mParameters, checkBox, aContexts, oResourceBundle);
+										return messageHandler.showMessageDialog().then(fnResolve);
+									}
+								});
+						})
+						.catch(function() {
+							fnReject();
+						})
+						.finally(function() {
+							BusyLocker.unlock(that.oLockObject);
+						});
+				};
+				const oDialog = new Dialog({
+					title: sTitle,
+					state: "Warning",
+					content: [oContent],
+					ariaLabelledBy: oNonDeletableMessageTextControl.getVisible()
+						? [oNonDeletableMessageTextControl, oDeleteMessageTextControl]
+						: oDeleteMessageTextControl,
+					beginButton: new Button({
+						text: oResourceBundleCore.getText("C_COMMON_OBJECT_PAGE_DELETE"),
+						type: "Emphasized",
+						press: function() {
+							oDialog.close();
+							return fnConfirm();
+						}
+					}),
+					endButton: new Button({
+						text: CommonUtils.getTranslatedText("C_COMMON_OBJECT_PAGE_CANCEL", oResourceBundle),
+						press: function() {
+							oDialog.close();
+						}
+					}),
+					afterClose: function() {
+						oDialog.destroy();
+						// if dialog is closed unconfirmed (e.g. via "Cancel" or Escape button), ensure to reject promise
+						if (!bDialogConfirmed) {
+							fnReject();
+						}
+					}
+				} as any);
+				if (mParameters.noDialog) {
+					return fnConfirm();
+				} else {
+					oDialog.addStyleClass("sapUiContentPadding");
+					oDialog.open();
+				}
+			})
+			.finally(function() {
+				BusyLocker.unlock(that.oLockObject);
+			})
+			.catch(function() {
+				Log.warning("Couldn't get Programming model");
+				fnReject();
+			});
+		return new Promise(function(resolve: (value: any) => void, reject: (reason?: any) => void) {
+			fnReject = reject;
+			fnResolve = resolve;
+		});
+	}
+	/**
+	 * Edits a document.
+	 *
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @static
+	 * @param {sap.ui.model.odata.v4.Context} oContext Context of the active document
+	 * @param {boolean} bPrepareOnEdit Also call the 'prepare' action for draft-based documents
+	 * @param {object} oView Object of current view
+	 * @param messageHandler
+	 * @returns {Promise} Promise resolves with the new draft context in case of draft programming model
+	 * @ui5-restricted
+	 * @final
+	 */
+	editDocument(oContext: any, bPrepareOnEdit: boolean, oView: object, messageHandler: any) {
+		// eslint-disable-next-line @typescript-eslint/no-this-alias
+		const that = this;
+		const sProgrammingModel = this.getProgrammingModel(oContext);
+		let oEditPromise;
+		if (!oContext) {
+			return Promise.reject(new Error("Binding context to active document is required"));
+		}
+		this._bIsModified = false;
+		BusyLocker.lock(that.oLockObject);
+		// before triggering the edit action we'll have to remove all bound transition messages
+		messageHandler.removeTransitionMessages();
+		if (sProgrammingModel === ProgrammingModel.Draft) {
+			oEditPromise = draft.createDraftFromActiveDocument(oContext, this._getAppComponent(), {
+				bPreserveChanges: true,
+				bPrepareOnEdit: bPrepareOnEdit,
+				oView: oView
+			} as any);
+		} else if (sProgrammingModel === ProgrammingModel.Sticky) {
+			oEditPromise = sticky.editDocumentInStickySession(oContext);
+		} else {
+			BusyLocker.unlock(that.oLockObject);
+			return Promise.reject(new Error("Edit is only allowed for draft or sticky session supported services"));
+		}
+		return oEditPromise
+			.then(function(oNewContext: any) {
+				that._bCreateMode = false;
+				return messageHandler.showMessageDialog().then(function() {
+					return oNewContext;
+				});
+			})
+			.catch(function(err: any) {
+				return messageHandler.showMessages().then(function() {
+					return Promise.reject(err);
+				});
+			})
+			.finally(function() {
+				BusyLocker.unlock(that.oLockObject);
+			});
+	}
+	/**
+	 * Cancel 'edit' mode of a document.
+	 *
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @static
+	 * @param {sap.ui.model.odata.v4.Context} oContext Context of the document to be canceled or deleted
+	 * @param {object} [mInParameters] Optional, can contain the following attributes:
+	 * @param {sap.m.Button} mInParameters.cancelButton Cancel Button of the discard popover (mandatory for now)
+	 * @param {boolean} mInParameters.skipDiscardPopover Optional, supresses the discard popover incase of draft applications while navigating out of OP
+	 * @param oResourceBundle
+	 * @param messageHandler
+	 * @returns {Promise} Promise resolves with ???
+	 * @ui5-restricted
+	 * @final
+	 */
+	cancelDocument(
+		oContext: any,
+		mInParameters: { cancelButton: any; skipDiscardPopover: boolean } | undefined,
+		oResourceBundle: any,
+		messageHandler: any
+	) {
+		// eslint-disable-next-line @typescript-eslint/no-this-alias
+		const that = this;
+		let sProgrammingModel: ProgrammingModelType;
+		//context must always be passed - mandatory parameter
+		if (!oContext) {
+			return Promise.reject("No context exists. Pass a meaningful context");
+		}
+		BusyLocker.lock(that.oLockObject);
+		const mParameters = getParameters(mInParameters);
+		const oParamsContext = oContext,
+			oCancelButton = mParameters.cancelButton,
+			oModel = oParamsContext.getModel();
+		let onBeforeCancelPromise, sCanonicalPath: string;
+		return Promise.resolve(this.getProgrammingModel(oContext))
+			.then(function(sPModel: any) {
+				sProgrammingModel = sPModel;
+				if (sPModel === ProgrammingModel.Draft) {
+					const draftDataContext = oModel.bindContext(oParamsContext.getPath() + "/DraftAdministrativeData").getBoundContext();
+					if (!that._bIsModified) {
+						return draftDataContext.requestObject().then(function(draftAdminData: any) {
+							if (draftAdminData) {
+								that._bIsModified = !(draftAdminData.CreationDateTime === draftAdminData.LastChangeDateTime);
+							}
+						});
+					}
+				}
+			})
+			.then(function() {
+				if (!mParameters.skipDiscardPopover) {
+					return that._showDiscardPopover(oCancelButton, that._bIsModified, oResourceBundle);
+				} else {
+					return Promise.resolve();
+				}
+			})
+			.then(function() {
+				if (mParameters.beforeCancelCallBack) {
+					onBeforeCancelPromise = mParameters.beforeCancelCallBack({ context: oContext });
+				} else {
+					onBeforeCancelPromise = Promise.resolve();
+				}
+				return onBeforeCancelPromise;
+			})
+			.then(function() {
+				// eslint-disable-next-line default-case
+				switch (sProgrammingModel) {
+					case ProgrammingModel.Draft:
+						return oParamsContext.requestObject("HasActiveEntity").then(function(bHasActiveEntity: any) {
+							let oDeletePromise;
+							if (!bHasActiveEntity) {
+								if (oParamsContext && oParamsContext.hasPendingChanges()) {
+									oParamsContext.getBinding().resetChanges();
+								}
+								oDeletePromise = draft.deleteDraft(oParamsContext);
+								return oDeletePromise;
+							} else {
+								let oActiveContext = oModel.bindContext(oParamsContext.getPath() + "/SiblingEntity").getBoundContext();
+								return oActiveContext
+									.requestCanonicalPath()
+									.then(
+										function(sPath: any) {
+											sCanonicalPath = sPath;
+											if (oParamsContext && oParamsContext.hasPendingChanges()) {
+												oParamsContext.getBinding().resetChanges();
+											}
+											oDeletePromise = draft.deleteDraft(oParamsContext);
+											return oDeletePromise;
+										},
+										function() {
+											draft.deleteDraft(oParamsContext);
+											return;
+										}
+									)
+									.then(function() {
+										//oParamsContext.delete() in the previous promise doesnt return anything upon success.
+										if (!sCanonicalPath) {
+											return;
+										}
+										if (oActiveContext.getPath() !== sCanonicalPath) {
+											// the active context is using the sibling entity - this path is not accessible anymore as we deleted the draft
+											// document - therefore we need to create a new context with the canonical path
+											oActiveContext = oModel.bindContext(sCanonicalPath).getBoundContext();
+										}
+										return oActiveContext;
+									});
+							}
+						});
+					case ProgrammingModel.Sticky:
+						return sticky.discardDocument(oContext).then(function(oContext: any) {
+							if (oContext) {
+								if (oContext.hasPendingChanges()) {
+									oContext.getBinding().resetChanges();
+								}
+								if (!that._bCreateMode) {
+									oContext.refresh();
+									return oContext;
+								}
+							}
+							return false;
+						});
+					default:
+						return Promise.reject("Cancel document only allowed for draft or sticky session supported services");
+				}
+			})
+			.then(function(context: any) {
+				that._bIsModified = false;
+				// remove existing bound transition messages
+				messageHandler.removeTransitionMessages();
+				// show unbound messages
+				return messageHandler.showMessages().then(function() {
+					return context;
+				});
+			})
+			.catch(function(err: any) {
+				return messageHandler.showMessages().then(function() {
+					return Promise.reject(err);
+				});
+			})
+			.finally(function() {
+				BusyLocker.unlock(that.oLockObject);
+			});
+	}
+	/**
+	 * Saves the document.
+	 *
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @static
+	 * @param {sap.ui.model.odata.v4.Context} oContext Context of the document to be saved
+	 * @param oResourceBundle
+	 * @param bExecuteSideEffectsOnError
+	 * @param aBindings
+	 * @param messageHandler
+	 * @returns {Promise} Promise resolves with ???
+	 * @ui5-restricted
+	 * @final
+	 */
+	saveDocument(oContext: any, oResourceBundle: any, bExecuteSideEffectsOnError: any, aBindings: any, messageHandler: any) {
+		// eslint-disable-next-line @typescript-eslint/no-this-alias
+		const that = this;
+		const sProgrammingModel = this.getProgrammingModel(oContext);
+		let oSavePromise;
+		if (!oContext) {
+			return Promise.reject(new Error("Binding context to draft document is required"));
+		}
+		// in case of saving / activating the bound transition messages shall be removed before the PATCH/POST
+		// is sent to the backend
+		messageHandler.removeTransitionMessages();
+		BusyLocker.lock(that.oLockObject);
+		if (sProgrammingModel === ProgrammingModel.Draft) {
+			oSavePromise = draft.activateDocument(oContext, this._getAppComponent(), {});
+		} else if (sProgrammingModel === ProgrammingModel.Sticky) {
+			oSavePromise = sticky.activateDocument(oContext);
+		} else {
+			BusyLocker.unlock(that.oLockObject);
+			return Promise.reject(new Error("Save is only allowed for draft or sticky session supported services"));
+		}
+		return oSavePromise
+			.then(function(oActiveDocument: any) {
+				const bNewObject =
+					that.sProgrammingModel === ProgrammingModel.Sticky ? that._bCreateMode : !oContext.getObject().HasActiveEntity;
+				MessageToast.show(
+					bNewObject
+						? CommonUtils.getTranslatedText("C_TRANSACTION_HELPER_OBJECT_CREATED", oResourceBundle)
+						: CommonUtils.getTranslatedText("C_TRANSACTION_HELPER_OBJECT_SAVED", oResourceBundle)
+				);
+				that._bIsModified = false;
+				return messageHandler.showMessageDialog().then(function() {
+					return oActiveDocument;
+				});
+			})
+			.catch(function(err: any) {
+				if (aBindings && aBindings.length > 0) {
+					/* The sideEffects are executed only for table items in transient state */
+					aBindings.forEach(function(oListBinding: any) {
+						if (!CommonUtils.hasTransientContext(oListBinding) && bExecuteSideEffectsOnError) {
+							const oAppComponent = that._getAppComponent();
+							oAppComponent.getSideEffectsService().requestSideEffectsForNavigationProperty(oListBinding.getPath(), oContext);
+						}
+					});
+				}
+				return messageHandler.showMessages().then(function() {
+					return Promise.reject(err);
+				});
+			})
+			.finally(function() {
+				BusyLocker.unlock(that.oLockObject);
+			});
+	}
+	/**
+	 * Calls a bound or unbound action.
+	 *
+	 * @function
+	 * @static
+	 * @name sap.fe.core.TransactionHelper.callAction
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @param {string} sActionName The name of the action to be called
+	 * @param {map} [mParameters] Contains the following attributes:
+	 * @param {sap.ui.model.odata.v4.Context} [mParameters.contexts] Mandatory for a bound action: Either one context or an array with contexts for which the action is to be called
+	 * @param {sap.ui.model.odata.v4.ODataModel} [mParameters.model] Mandatory for an unbound action: An instance of an OData V4 model
+	 * @param {string} [mParameters.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 {string} [mParameters.label] A human-readable label for the action
+	 * @param {boolean} [mParameters.bGetBoundContext] If specified, the action promise returns the bound context
+	 * @param {object} oView Contains the object of the current view
+	 * @param messageHandler
+	 * @returns {Promise} Promise resolves with an array of response objects (TODO: to be changed)
+	 * @ui5-restricted
+	 * @final
+	 **/
+	callAction(sActionName: string, mParameters: any, oView: View | null, messageHandler: any) {
+		mParameters = getParameters(mParameters);
+		// eslint-disable-next-line @typescript-eslint/no-this-alias
+		const that = this;
+		let oContext, oModel: any, oPromise;
+		const mBindingParameters = mParameters.bindingParameters;
+		if (!sActionName) {
+			return Promise.reject("Provide name of action to be executed");
+		}
+		// action imports are not directly obtained from the metaModel by it is present inside the entityContainer
+		// and the acions it refers to present outside the entitycontainer, hence to obtain kind of the action
+		// split() on its name was required
+		const sName = sActionName.split("/")[1];
+		sActionName = sName || sActionName;
+		oContext = sName ? undefined : mParameters.contexts;
+		//checking whether the context is an array with more than 0 length or not an array(create action)
+		if (oContext && ((Array.isArray(oContext) && oContext.length) || !Array.isArray(oContext))) {
+			oContext = Array.isArray(oContext) ? oContext[0] : oContext;
+			oModel = oContext.getModel();
+		}
+		if (mParameters.model) {
+			oModel = mParameters.model;
+		}
+		if (!oModel) {
+			return Promise.reject("Pass a context for a bound action or pass the model for an unbound action");
+		}
+		// get the binding parameters $select and $expand for the side effect on this action
+		// also gather additional property paths to be requested such as text associations
+		const oAppComponent = that._getAppComponent();
+		const mSideEffectsParameters = oAppComponent.getSideEffectsService().getODataActionSideEffects(sActionName, oContext) || {};
+		if (oContext && oModel) {
+			oPromise = new Promise<void>(function(resolve, reject) {
+				let oApplicableContextDialog: Dialog;
+				const oController = {
+					onClose: function() {
+						// User cancels action
+						oApplicableContextDialog.close();
+						resolve();
+					},
+					onContinue: function() {
+						// Users continues the action with the bound contexts
+						oApplicableContextDialog.close();
+						resolve(mParameters.applicableContext);
+					}
+				};
+				const fnOpenAndFillDialog = function() {
+					let oDialogContent;
+					const nNotApplicable = mParameters.notApplicableContext.length,
+						aNotApplicableItems = [];
+					for (let i = 0; i < mParameters.notApplicableContext.length; i++) {
+						oDialogContent = mParameters.notApplicableContext[i].getObject();
+						aNotApplicableItems.push(oDialogContent);
+					}
+					const oNotApplicableItemsModel = new JSONModel(aNotApplicableItems);
+					const oTotals = new JSONModel({ total: nNotApplicable, label: mParameters.label });
+					oApplicableContextDialog.setModel(oNotApplicableItemsModel, "notApplicable");
+					oApplicableContextDialog.setModel(oTotals, "totals");
+					oApplicableContextDialog.open();
+				};
+				if (mParameters.notApplicableContext && mParameters.notApplicableContext.length >= 1) {
+					// Show the contexts that are not applicable and will not therefore be processed
+					const sFragmentName = "sap.fe.core.controls.ActionPartial";
+					const oDialogFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, "fragment");
+					const oMetaModel = oModel.getMetaModel();
+					const sCanonicalPath = mParameters.contexts[0].getCanonicalPath();
+					const sEntitySet = sCanonicalPath.substr(0, sCanonicalPath.indexOf("(")) + "/";
+					const oDialogLabelModel = new JSONModel({
+						title: mParameters.label
+					});
+					Promise.resolve(
+						XMLPreprocessor.process(
+							oDialogFragment,
+							{ name: sFragmentName },
+							{
+								bindingContexts: {
+									entityType: oMetaModel.createBindingContext(sEntitySet),
+									label: oDialogLabelModel.createBindingContext("/")
+								},
+								models: {
+									entityType: oMetaModel,
+									metaModel: oMetaModel,
+									label: oDialogLabelModel
+								}
+							}
+						)
+					)
+						.then(function(oFragment: any) {
+							return Fragment.load({ definition: oFragment, controller: oController });
+						})
+						.then(function(oPopover: any) {
+							oApplicableContextDialog = oPopover;
+							mParameters.parentControl.addDependent(oPopover);
+							fnOpenAndFillDialog();
+						})
+						.catch(reject);
+				} else {
+					resolve(mParameters.contexts);
+				}
+			}).then(function(contextToProcess: any) {
+				if (contextToProcess) {
+					return operations.callBoundAction(sActionName, contextToProcess, oModel, oAppComponent, {
+						invocationGrouping: mParameters.invocationGrouping,
+						label: mParameters.label,
+						showActionParameterDialog: true,
+						mBindingParameters: mBindingParameters,
+						entitySetName: mParameters.entitySetName,
+						additionalSideEffect: mSideEffectsParameters,
+						onSubmitted: function() {
+							messageHandler.removeTransitionMessages();
+							BusyLocker.lock(that.oLockObject);
+						},
+						onResponse: function() {
+							BusyLocker.unlock(that.oLockObject);
+						},
+						parentControl: mParameters.parentControl,
+						internalModelContext: mParameters.internalModelContext,
+						operationAvailableMap: mParameters.operationAvailableMap,
+						bIsCreateAction: mParameters.bIsCreateAction,
+						bGetBoundContext: mParameters.bGetBoundContext,
+						bObjectPage: mParameters.bObjectPage,
+						messageHandler: messageHandler,
+						defaultValuesExtensionFunction: mParameters.defaultValuesExtensionFunction
+					});
+				} else {
+					return null;
+				}
+			});
+		} else {
+			// TODO: confirm if action import needs side effects.
+			oPromise = operations.callActionImport(sActionName, oModel, oAppComponent, {
+				label: mParameters.label,
+				showActionParameterDialog: true,
+				bindingParameters: mBindingParameters,
+				entitySetName: mParameters.entitySetName,
+				onSubmitted: function() {
+					BusyLocker.lock(that.oLockObject);
+				},
+				onResponse: function() {
+					BusyLocker.unlock(that.oLockObject);
+				},
+				parentControl: mParameters.parentControl,
+				internalModelContext: mParameters.internalModelContext,
+				operationAvailableMap: mParameters.operationAvailableMap,
+				messageHandler: messageHandler,
+				bObjectPage: mParameters.bObjectPage
+			});
+		}
+		return oPromise
+			.then(function(oResult: any) {
+				// Succeeded
+				return that._handleActionResponse(messageHandler, mParameters, sActionName).then(function() {
+					return oResult;
+				});
+			})
+			.catch(function(err: any) {
+				return that._handleActionResponse(messageHandler, mParameters, sActionName).then(function() {
+					return Promise.reject(err);
+				});
+			});
+	}
+	/**
+	 * Handles messages for action call.
+	 *
+	 * @function
+	 * @name sap.fe.core.TransactionHelper#_handleActionResponse
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @param messageHandler
+	 * @param {object} mParameters Parameters to be considered for the action.
+	 * @param {string} sActionName The name of the action to be called
+	 * @returns {Promise} Promise after message dialog is opened if required.
+	 * @ui5-restricted
+	 * @final
+	 */
+	_handleActionResponse(messageHandler: any, mParameters: any, sActionName: string) {
+		const aTransientMessages = messageHandling.getMessages(true, true);
+		if (aTransientMessages.length > 0 && mParameters && mParameters.internalModelContext) {
+			mParameters.internalModelContext.setProperty("sActionName", mParameters.label ? mParameters.label : sActionName);
+		}
+		return messageHandler.showMessages();
+	}
+	/**
+	 * Handles validation errors for the 'discard' action.
+	 *
+	 * @function
+	 * @name sap.fe.core.TransactionHelper#handleValidationError
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @static
+	 * @ui5-restricted
+	 * @final
+	 */
+	handleValidationError() {
+		const oMessageManager = (sap.ui.getCore() as any).getMessageManager(),
+			errorToRemove = oMessageManager
+				.getMessageModel()
+				.getData()
+				.filter(function(error: any) {
+					// only needs to handle validation messages, technical and persistent errors needs not to be checked here.
+					if (error.validation) {
+						return error;
+					}
+				});
+		oMessageManager.removeMessages(errorToRemove);
+	}
+	/**
+	 * Shows a popover if it needs to be shown.
+	 * TODO: Popover is shown if user has modified any data.
+	 * TODO: Popover is shown if there's a difference from draft admin data.
+	 * @static
+	 * @name sap.fe.core.TransactionHelper._showDiscardPopover
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @param {sap.ui.core.Control} oCancelButton The control which will open the popover
+	 * @param bIsModified
+	 * @param oResourceBundle
+	 * @returns {Promise} Promise resolves if user confirms discard, rejects if otherwise, rejects if no control passed to open popover
+	 * @ui5-restricted
+	 * @final
+	 */
+	_showDiscardPopover(oCancelButton: any, bIsModified: any, oResourceBundle: any) {
+		// TODO: Implement this popover as a fragment as in v2??
+		// eslint-disable-next-line @typescript-eslint/no-this-alias
+		const that = this;
+		that._bContinueDiscard = false;
+		// to be implemented
+		return new Promise<void>(function(resolve, reject) {
+			if (!oCancelButton) {
+				reject("Cancel button not found");
+			}
+			//Show popover only when data is changed.
+			if (bIsModified) {
+				const fnOnAfterDiscard = function() {
+					oCancelButton.setEnabled(true);
+					if (that._bContinueDiscard) {
+						resolve();
+					} else {
+						reject("Discard operation was rejected. Document has not been discarded");
+					}
+					that._oPopover.detachAfterClose(fnOnAfterDiscard);
+				};
+				if (!that._oPopover) {
+					const oText = new Text({
+							//This text is the same as LR v2.
+							//TODO: Display message provided by app developer???
+							text: CommonUtils.getTranslatedText("C_TRANSACTION_HELPER_DRAFT_DISCARD_MESSAGE", oResourceBundle)
+						}),
+						oButton = new Button({
+							text: CommonUtils.getTranslatedText("C_TRANSACTION_HELPER_DRAFT_DISCARD_BUTTON", oResourceBundle),
+							width: "100%",
+							press: function() {
+								that.handleValidationError();
+								that._bContinueDiscard = true;
+								that._oPopover.close();
+							},
+							ariaLabelledBy: oText
+						} as any);
+					that._oPopover = new Popover({
+						showHeader: false,
+						placement: "Top",
+						content: [
+							new VBox({
+								items: [oText, oButton]
+							})
+						],
+						beforeOpen: function() {
+							// make sure to NOT trigger multiple cancel flows
+							oCancelButton.setEnabled(false);
+							that._oPopover.setInitialFocus(oButton);
+						}
+					});
+					that._oPopover.addStyleClass("sapUiContentPadding");
+				}
+				that._oPopover.attachAfterClose(fnOnAfterDiscard);
+				that._oPopover.openBy(oCancelButton, false);
+			} else {
+				that.handleValidationError();
+				resolve();
+			}
+		});
+	}
+	/**
+	 * Sets the document to modified state on patch event.
+	 *
+	 * @function
+	 * @static
+	 * @name sap.fe.core.TransactionHelper.handleDocumentModifications
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @ui5-restricted
+	 * @final
+	 */
+	handleDocumentModifications() {
+		this._bIsModified = true;
+	}
+	/**
+	 * Retrieves the owner component.
+	 *
+	 * @function
+	 * @static
+	 * @private
+	 * @name sap.fe.core.TransactionHelper._getOwnerComponent
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @returns {sap.fe.core.AppComponent} The app component
+	 * @ui5-restricted
+	 * @final
+	 **/
+	_getAppComponent() {
+		return this._oAppComponent;
+	}
+	_launchDialogWithKeyFields(
+		oListBinding: any,
+		oTransientListBinding: any,
+		oTransientContext: any,
+		mFields: any,
+		oModel: any,
+		mParameters: any,
+		messageHandler: any
+	) {
+		// eslint-disable-next-line @typescript-eslint/no-this-alias
+		const that = this;
+		let oDialog: Dialog;
+		const oParentControl = mParameters.parentControl,
+			bSuccess = false;
+		return new Promise(function(resolve: (value: any) => void, reject: (reason?: any) => void) {
+			const sFragmentName = "sap/fe/core/controls/NonComputedVisibleKeyFieldsDialog";
+			const oFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, "fragment"),
+				oResourceBundle = oParentControl.getController().oResourceBundle,
+				oMetaModel = oModel.getMetaModel(),
+				aImmutableFields: any[] = [],
+				oAppComponent = that._getAppComponent(),
+				sPath = oListBinding.isRelative() ? oListBinding.getResolvedPath() : oListBinding.getPath(),
+				oEntitySetContext = oMetaModel.createBindingContext(sPath),
+				sMetaPath = oMetaModel.getMetaPath(sPath);
+			for (const i in mFields) {
+				aImmutableFields.push(oMetaModel.createBindingContext(sMetaPath + "/" + mFields[i]));
+			}
+			const oImmutableCtxModel = new JSONModel(aImmutableFields);
+			const oImmutableCtx = oImmutableCtxModel.createBindingContext("/");
+			return Promise.resolve(
+				XMLPreprocessor.process(
+					oFragment,
+					{ name: sFragmentName },
+					{
+						bindingContexts: {
+							entitySet: oEntitySetContext,
+							fields: oImmutableCtx
+						},
+						models: {
+							entitySet: oEntitySetContext.getModel(),
+							fields: oImmutableCtx.getModel(),
+							metaModel: oMetaModel
+						}
+					}
+				)
+			).then(function(oFragment: any) {
+				let aFormElements: any[] = [];
+				const mFieldValueMap: any = {};
+				let oCreateButton: Button;
+				const validateRequiredProperties = function() {
+					return Promise.all(
+						aFormElements
+							.map(function(oFormElement: any) {
+								return oFormElement.getFields()[0];
+							})
+							.filter(function(oField: any) {
+								return oField.getRequired();
+							})
+							.map(function(oField: any) {
+								const sFieldId = oField.getId();
+								if (sFieldId in mFieldValueMap) {
+									return Promise.resolve(mFieldValueMap[sFieldId])
+										.then(function(vValue: any) {
+											return vValue;
+										})
+										.catch(function() {
+											return undefined;
+										});
+								}
+								return oField.getValueState() === ValueState.Error ? undefined : oField.getValue();
+							})
+					)
+						.then(function(aResults: any[]) {
+							return aResults.every(function(vValue: any) {
+								return vValue !== undefined && vValue !== null && vValue !== "";
+							});
+						})
+						.catch(function() {
+							return false;
+						})
+						.then(function(bEnabled: boolean) {
+							oCreateButton.setEnabled(bEnabled);
+						});
+				};
+				const oController = {
+					/*
+    									fired on focus out from field or on selecting a value from the valuehelp.
+    									the create button is enabled when a value is added.
+    									liveChange is not fired when value is added from valuehelp.
+    									value validation is not done for create button enablement.
+    								*/
+					handleChange: function(oEvent: any) {
+						messageHandler.removeTransitionMessages();
+						const oField = oEvent.getSource();
+						const sFieldId = oEvent.getParameter("id");
+						const oFieldPromise = oEvent.getParameter("promise");
+						if (oFieldPromise) {
+							mFieldValueMap[sFieldId] = oFieldPromise.then(function() {
+								return oField.getValue();
+							});
+						}
+						validateRequiredProperties();
+					},
+					/*
+    									fired on key press. the create button is enabled when a value is added.
+    									liveChange is not fired when value is added from valuehelp.
+    									value validation is not done for create button enablement.
+    								*/
+					handleLiveChange: function(oEvent: any) {
+						const sFieldId = oEvent.getParameter("id");
+						const vValue = oEvent.getParameter("value");
+						mFieldValueMap[sFieldId] = vValue;
+						validateRequiredProperties();
+					}
+				};
+				return Fragment.load({
+					definition: oFragment,
+					controller: oController
+				}).then(function(oDialogContent: any) {
+					oDialog = new Dialog({
+						title: CommonUtils.getTranslatedText("C_TRANSACTION_HELPER_SAPFE_ACTION_CREATE", oResourceBundle),
+						content: [oDialogContent],
+						beginButton: {
+							text: CommonUtils.getTranslatedText("C_TRANSACTION_HELPER_SAPFE_ACTION_CREATE_BUTTON", oResourceBundle),
+							type: "Emphasized",
+							press: function(oEvent: any) {
+								const oCreateButton = oEvent.getSource();
+								oCreateButton.setEnabled(false);
+								BusyLocker.lock(oDialog);
+								return Promise.all(
+									Object.keys(mFieldValueMap).map(function(sKey: string) {
+										return mFieldValueMap[sKey].then(function(oValue: any) {
+											const oDialogValue: any = {};
+											oDialogValue[sKey] = oValue;
+											return oDialogValue;
+										});
+									})
+								)
+									.then(function(aValues: any[]) {
+										let onBeforeCreatePromise;
+										if (mParameters.beforeCreateCallBack) {
+											onBeforeCreatePromise = mParameters.beforeCreateCallBack({
+												contextPath: oListBinding && oListBinding.getPath(),
+												createParameters: aValues
+											});
+										} else {
+											onBeforeCreatePromise = Promise.resolve();
+										}
+										return onBeforeCreatePromise;
+									})
+									.then(function() {
+										const oPromise = that.onAfterCreateCompletion(
+											oTransientListBinding,
+											oTransientContext,
+											mParameters
+										);
+										oModel.submitBatch("submitLater");
+										return oPromise;
+									})
+									.then(function(oResponse: any) {
+										oDialog.setBindingContext(null as any);
+										oDialog.close();
+										resolve(oResponse);
+									})
+									.catch(function(oError: any) {
+										reject(oError);
+									})
+									.finally(function() {
+										BusyLocker.unlock(oDialog);
+										oCreateButton.setEnabled(true);
+										return messageHandler.showMessages();
+									});
+							}
+						},
+						endButton: {
+							text: CommonUtils.getTranslatedText("C_COMMON_ACTION_PARAMETER_DIALOG_CANCEL", oResourceBundle),
+							press: function() {
+								oDialog.close();
+							}
+						},
+						afterClose: function() {
+							// show footer as per UX guidelines when dialog is not open
+							(oDialog.getBindingContext("internal") as InternalModelContext)?.setProperty("isCreateDialogOpen", false);
+							oDialog.destroy();
+							if (!bSuccess) {
+								reject({
+									bDeleteTransientContext: true
+								});
+							}
+						}
+					} as any);
+					aFormElements = oDialogContent
+						.getAggregation("form")
+						.getAggregation("formContainers")[0]
+						.getAggregation("formElements");
+					if (oParentControl && oParentControl.addDependent) {
+						// if there is a parent control specified add the dialog as dependent
+						oParentControl.addDependent(oDialog);
+					}
+					oCreateButton = oDialog.getBeginButton();
+					oDialog.setBindingContext(oTransientContext);
+					return CommonUtils.setUserDefaults(
+						oAppComponent,
+						aImmutableFields,
+						oTransientContext,
+						false,
+						mParameters.createAction,
+						mParameters.data
+					)
+						.then(function() {
+							validateRequiredProperties();
+							// 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(function(oError: any) {
+							return messageHandler.showMessages().then(function() {
+								return Promise.reject(oError);
+							});
+						});
+				});
+			});
+		});
+	}
+	onAfterCreateCompletion(oListBinding: any, oNewDocumentContext: any, mParameters: any) {
+		let fnResolve: Function, fnReject: Function;
+		const oPromise = new Promise(function(resolve, reject) {
+			fnResolve = resolve;
+			fnReject = reject;
+		});
+		// eslint-disable-next-line @typescript-eslint/no-this-alias
+		const that = this;
+		// Workaround suggested by OData model v4 colleagues
+		const fnCreateCompleted = function(oEvent: any) {
+			const oContext = oEvent.getParameter("context"),
+				bSuccess = oEvent.getParameter("success");
+			if (oContext === oNewDocumentContext) {
+				oListBinding.detachCreateCompleted(fnCreateCompleted, that);
+				if (!bSuccess) {
+					const oError: any = { bDeleteTransientContext: false };
+					if (!mParameters.keepTransientContextOnFailed) {
+						// the context is deleted
+						oError.bDeleteTransientContext = true;
+						// this is needed to avoid console errors TO be checked with model colleagues
+						oContext
+							.created()
+							.then(undefined, function() {
+								Log.trace("transient creation context deleted");
+							})
+							.catch(function(oError: any) {
+								Log.trace("transient creation context deletion error", oError);
+							});
+						// if current state is transient (...), browser will come back to previous state
+						oError.navigateBackFromTransientState = true;
+					}
+					fnReject(oError);
+				} else {
+					fnResolve();
+				}
+			}
+		};
+		oListBinding.attachCreateCompleted(fnCreateCompleted, this);
+		return oPromise;
+	}
+	/**
+	 * Retrieves the name of the NewAction to be executed.
+	 *
+	 * @function
+	 * @static
+	 * @private
+	 * @name sap.fe.core.TransactionHelper._getNewAction
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @param {object} oStartupParameters Startup parameters of the application
+	 * @param {string} sCreateHash Hash to be checked for action type
+	 * @param {object} oMetaModel The MetaModel used to check for NewAction parameter
+	 * @param {string} sMetaPath The MetaPath
+	 * @returns {string} The name of the action
+	 * @ui5-restricted
+	 * @final
+	 **/
+	_getNewAction(oStartupParameters: any, sCreateHash: string, oMetaModel: ODataMetaModel, sMetaPath: string) {
+		let sNewAction;
+
+		if (oStartupParameters && oStartupParameters.preferredMode && sCreateHash.indexOf("i-action=createWith") > -1) {
+			const sPreferredMode = oStartupParameters.preferredMode[0];
+			sNewAction =
+				sPreferredMode.indexOf("createWith:") > -1 ? sPreferredMode.substr(sPreferredMode.lastIndexOf(":") + 1) : undefined;
+		} else {
+			sNewAction =
+				oMetaModel && oMetaModel.getObject !== undefined
+					? oMetaModel.getObject(sMetaPath + "@com.sap.vocabularies.Session.v1.StickySessionSupported/NewAction") ||
+					  oMetaModel.getObject(sMetaPath + "@com.sap.vocabularies.Common.v1.DraftRoot/NewAction")
+					: undefined;
+		}
+		return sNewAction;
+	}
+	/**
+	 * Retrieves the label for the title of a specific create action dialog, e.g. Create Sales Order from Quotation.
+	 *
+	 * The following priority is applied:
+	 * 1. label of line-item annotation.
+	 * 2. label annotated in the action.
+	 * 3. "Create" as a constant from i18n.
+	 *
+	 * @function
+	 * @static
+	 * @private
+	 * @name sap.fe.core.TransactionHelper._getSpecificCreateActionDialogLabel
+	 * @memberof sap.fe.core.TransactionHelper
+	 * @param {object} oMetaModel The MetaModel used to check for the NewAction parameter
+	 * @param {string} sMetaPath The MetaPath
+	 * @param {string} sNewAction Contains the name of the action to be executed
+	 * @param {object} oResourceBundleCore ResourceBundle to access the default Create label
+	 * @returns {string} The label for the Create Action Dialog
+	 * @ui5-restricted
+	 * @final
+	 **/
+	_getSpecificCreateActionDialogLabel(
+		oMetaModel: ODataMetaModel,
+		sMetaPath: string,
+		sNewAction: string,
+		oResourceBundleCore: ResourceBundle
+	) {
+		const fnGetLabelFromLineItemAnnotation = function() {
+			if (oMetaModel && oMetaModel.getObject(sMetaPath + "/@com.sap.vocabularies.UI.v1.LineItem")) {
+				const iLineItemIndex = oMetaModel
+					.getObject(sMetaPath + "/@com.sap.vocabularies.UI.v1.LineItem")
+					.findIndex(function(oLineItem: any) {
+						const aLineItemAction = oLineItem.Action ? oLineItem.Action.split("(") : undefined;
+						return aLineItemAction ? aLineItemAction[0] === sNewAction : false;
+					});
+				return iLineItemIndex > -1
+					? oMetaModel.getObject(sMetaPath + "/@com.sap.vocabularies.UI.v1.LineItem")[iLineItemIndex].Label
+					: undefined;
+			} else {
+				return undefined;
+			}
+		};
+
+		return (
+			fnGetLabelFromLineItemAnnotation() ||
+			(oMetaModel && oMetaModel.getObject(sMetaPath + "/" + sNewAction + "@com.sap.vocabularies.Common.v1.Label")) ||
+			(oResourceBundleCore && oResourceBundleCore.getText("C_TRANSACTION_HELPER_SAPFE_ACTION_CREATE"))
+		);
+	}
+}
+
+export default TransactionHelper;