@sapui5/sap.fe.core 1.97.0 → 1.100.0

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

@@ -0,0 +1,783 @@
+import ControllerExtension from "sap/ui/core/mvc/ControllerExtension";
+import OverrideExecution from "sap/ui/core/mvc/OverrideExecution";
+import TransactionHelper from "sap/fe/core/TransactionHelper";
+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 EditState from "sap/fe/core/helpers/EditState";
+import { Extensible, Final, Override, Private, Public, UI5Class } from "sap/fe/core/helpers/ClassSupport";
+import ControllerExtensionMetadata from "sap/fe/core/controllerextensions/ControllerExtensionMetadata";
+import AppComponent from "sap/fe/core/AppComponent";
+import PageController from "sap/fe/core/PageController";
+import JSONModel from "sap/ui/model/json/JSONModel";
+import Table from "sap/ui/mdc/Table";
+import Dialog from "sap/m/Dialog";
+import Button from "sap/m/Button";
+import Text from "sap/m/Text";
+import Model from "sap/ui/model/Model";
+import sticky from "sap/fe/core/actions/sticky";
+import View from "sap/ui/core/mvc/View";
+import { send } from "sap/fe/core/actions/collaboration/ActivitySync";
+import { Activity } from "sap/fe/core/actions/collaboration/CollaborationCommon";
+import Context from "sap/ui/model/odata/v4/Context";
+
+const ProgrammingModel = FELibrary.ProgrammingModel,
+	DraftStatus = FELibrary.DraftStatus,
+	EditMode = FELibrary.EditMode,
+	CreationMode = FELibrary.CreationMode;
+
+@UI5Class("sap.fe.core.controllerextensions.InternalEditFlow", ControllerExtensionMetadata)
+class InternalEditFlow extends ControllerExtension {
+	private base!: PageController;
+	private _oAppComponent!: AppComponent;
+	private _pTasks: any;
+	private oActionPromise?: Promise<any>;
+	private _oTransactionHelper?: TransactionHelper;
+	private fnDirtyStateProvider?: Function;
+	private fnHandleSessionTimeout?: Function;
+	private fnStickyDiscardAfterNavigation?: Function;
+	@Override()
+	onInit() {
+		this._oAppComponent = this.base.getAppComponent();
+	}
+
+	/**
+	 * Override to set the creation mode.
+	 *
+	 * @param bCreationMode
+	 * @memberof sap.fe.core.controllerextensions.InternalEditFlow
+	 * @alias sap.fe.core.controllerextensions.InternalEditFlow#setCreationMode
+	 * @since 1.90.0
+	 */
+	@Private
+	@Extensible(OverrideExecution.After)
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	setCreationMode(bCreationMode: boolean) {
+		// to be overridden
+	}
+	@Public
+	@Final
+	createMultipleDocuments(oListBinding: any, aData: any, bCreateAtEnd: any, bFromCopyPaste: any, beforeCreateCallBack: any) {
+		const transactionHelper = this.getTransactionHelper(),
+			oLockObject = this.getGlobalUIModel(),
+			oResourceBundle = (this.getView().getController() as any).oResourceBundle;
+
+		BusyLocker.lock(oLockObject);
+		return this.syncTask()
+			.then(function() {
+				const onBeforeCreatePromise = beforeCreateCallBack
+					? beforeCreateCallBack({ contextPath: oListBinding && oListBinding.getPath() })
+					: Promise.resolve();
+				return onBeforeCreatePromise;
+			})
+			.then(() => {
+				const oModel = oListBinding.getModel(),
+					oMetaModel = oModel.getMetaModel();
+				let sMetaPath: string;
+
+				if (oListBinding.getContext()) {
+					sMetaPath = oMetaModel.getMetaPath(oListBinding.getContext().getPath() + "/" + oListBinding.getPath());
+				} else {
+					sMetaPath = oMetaModel.getMetaPath(oListBinding.getPath());
+				}
+
+				this.handleCreateEvents(oListBinding);
+
+				// Iterate on all items and store the corresponding creation promise
+				const aCreationPromises = aData.map((mPropertyValues: any) => {
+					const mParameters: any = { data: {} };
+
+					mParameters.keepTransientContextOnFailed = false; // currently not fully supported
+					mParameters.busyMode = "None";
+					mParameters.creationMode = CreationMode.CreationRow;
+					mParameters.parentControl = this.getView();
+					mParameters.createAtEnd = bCreateAtEnd;
+
+					// Remove navigation properties as we don't support deep create
+					for (const sPropertyPath in mPropertyValues) {
+						const oProperty = oMetaModel.getObject(sMetaPath + "/" + sPropertyPath);
+						if (oProperty && oProperty.$kind !== "NavigationProperty" && mPropertyValues[sPropertyPath]) {
+							mParameters.data[sPropertyPath] = mPropertyValues[sPropertyPath];
+						}
+					}
+
+					return transactionHelper.createDocument(
+						oListBinding,
+						mParameters,
+						oResourceBundle,
+						this.getMessageHandler(),
+						bFromCopyPaste,
+						this.getView()
+					);
+				});
+
+				return Promise.all(aCreationPromises);
+			})
+			.then(function(aContexts: any) {
+				// transient contexts are reliably removed once oNewContext.created() is resolved
+				return Promise.all(
+					aContexts.map(function(oNewContext: any) {
+						return oNewContext.created();
+					})
+				);
+			})
+			.then(() => {
+				const oBindingContext = this.getView().getBindingContext();
+
+				// 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)) {
+					this._oAppComponent
+						.getSideEffectsService()
+						.requestSideEffectsForNavigationProperty(oListBinding.getPath(), oBindingContext as Context);
+				}
+			})
+			.catch(function(err: any) {
+				Log.error("Error while creating multiple documents.");
+				return Promise.reject(err);
+			})
+			.finally(function() {
+				BusyLocker.unlock(oLockObject);
+			});
+	}
+	@Public
+	@Final
+	deleteMultipleDocuments(aContexts: any, mParameters: any) {
+		const oRoutingListener = this.getRoutingListener(),
+			oLockObject = this.getGlobalUIModel();
+		const oTable = this.getView().byId(mParameters.controlId) as Table;
+		if (!oTable || !oTable.isA("sap.ui.mdc.Table")) {
+			throw new Error("parameter controlId missing or incorrect");
+		}
+		const oListBinding = oTable.getRowBinding() as any;
+		mParameters.bFindActiveContexts = true;
+		BusyLocker.lock(oLockObject);
+		return this.deleteDocumentTransaction(aContexts, mParameters)
+			.then(() => {
+				let oResult;
+
+				// Multiple object deletion is triggered from a list
+				// First clear the selection in the table as it's not valid any more
+				(oTable as any).clearSelection();
+
+				// Then refresh the list-binding (LR), or require side-effects (OP)
+				const oBindingContext = this.getView().getBindingContext();
+				if (oListBinding.isRoot()) {
+					// keep promise chain pending until refresh of listbinding is completed
+					oResult = new Promise<void>(resolve => {
+						oListBinding.attachEventOnce("dataReceived", function() {
+							resolve();
+						});
+					});
+					oListBinding.refresh();
+				} else if (oBindingContext) {
+					// 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)) {
+						this._oAppComponent
+							.getSideEffectsService()
+							.requestSideEffectsForNavigationProperty(oListBinding.getPath(), oBindingContext as Context);
+					}
+				}
+
+				// deleting at least one object should also set the UI to dirty
+				EditState.setEditStateDirty();
+
+				send(this.getView(), Activity.Delete, aContexts);
+
+				// Finally, check if the current state can be impacted by the deletion, i.e. if there's
+				// an OP displaying a deleted object. If yes navigate back to dismiss the OP
+				for (let index = 0; index < aContexts.length; index++) {
+					if (oRoutingListener.isCurrentStateImpactedBy(aContexts[index])) {
+						oRoutingListener.navigateBackFromContext(aContexts[index]);
+						break;
+					}
+				}
+
+				return oResult;
+			})
+			.catch(function(oError: any) {
+				Log.error("Error while deleting the document(s)", oError);
+			})
+			.finally(function() {
+				BusyLocker.unlock(oLockObject);
+			});
+	}
+
+	/**
+	 * Decides if a document is to be shown in display or edit mode.
+	 *
+	 * @function
+	 * @name _computeEditMode
+	 * @memberof sap.fe.core.controllerextensions.InternalEditFlow
+	 * @param {sap.ui.model.odata.v4.Context} oContext The context to be displayed or edited
+	 * @returns {Promise} Promise resolves once the edit mode is computed
+	 */
+
+	@Public
+	@Final
+	computeEditMode(oContext: any) {
+		const sCustomAction = this.getInternalModel().getProperty("/sCustomAction");
+		return Promise.resolve(
+			(() => {
+				const sProgrammingModel = this.getProgrammingModel(oContext);
+
+				if (sProgrammingModel === ProgrammingModel.Draft) {
+					this.setDraftStatus(DraftStatus.Clear);
+
+					return oContext
+						.requestObject("IsActiveEntity")
+						.then((bIsActiveEntity: any) => {
+							if (bIsActiveEntity === false) {
+								// in case the document is draft set it in edit mode
+								this.setEditMode(EditMode.Editable);
+								return oContext.requestObject("HasActiveEntity").then((bHasActiveEntity: any) => {
+									this.setEditMode(undefined, !bHasActiveEntity);
+								});
+							} else {
+								// active document, stay on display mode
+								this.setEditMode(EditMode.Display, false);
+							}
+						})
+						.catch(function(oError: any) {
+							Log.error("Error while determining the editMode for draft", oError);
+							throw oError;
+						});
+				} else if (sProgrammingModel === ProgrammingModel.Sticky) {
+					if (sCustomAction && sCustomAction !== "" && this._hasNewActionForSticky(oContext, this.getView(), sCustomAction)) {
+						this.getTransactionHelper()._bCreateMode = true;
+						this.getTransactionHelper().handleDocumentModifications();
+						this.setEditMode(EditMode.Editable, true);
+						EditState.setEditStateDirty();
+						this.handleStickyOn(oContext);
+						this.getInternalModel().setProperty("/sCustomAction", "");
+					}
+				}
+			})()
+		);
+	}
+
+	/**
+	 * Sets the edit mode.
+	 *
+	 * @param {string} sEditMode
+	 * @param {boolean} bCreationMode CreateMode flag to identify the creation mode
+	 */
+	@Public
+	@Final
+	setEditMode(sEditMode?: string, bCreationMode: boolean = false) {
+		// at this point of time it's not meant to release the edit flow for freestyle usage therefore we can
+		// rely on the global UI model to exist
+		const oGlobalModel = this.getGlobalUIModel();
+
+		if (sEditMode) {
+			oGlobalModel.setProperty("/editMode", sEditMode, undefined, true);
+			oGlobalModel.setProperty("/isEditable", sEditMode === "Editable", undefined, true);
+		}
+
+		if (bCreationMode !== undefined) {
+			// Since setCreationMode is public in EditFlow and can be overriden, make sure to call it via the controller
+			// to ensure any overrides are taken into account
+			this.setCreationMode(bCreationMode);
+		}
+	}
+
+	@Public
+	@Final
+	setDraftStatus(sDraftState: any) {
+		// at this point of time it's not meant to release the edit flow for freestyle usage therefore we can
+		// rely on the global UI model to exist
+		(this.base.getView().getModel("ui") as JSONModel).setProperty("/draftStatus", sDraftState, undefined, true);
+	}
+
+	@Public
+	@Final
+	getRoutingListener() {
+		// at this point of time it's not meant to release the edit flow for FPM custom pages and the routing
+		// listener is not yet public therefore keep the logic here for now
+
+		if (this.base._routing) {
+			return this.base._routing;
+		} else {
+			throw new Error("Edit Flow works only with a given routing listener");
+		}
+	}
+
+	@Public
+	@Final
+	getGlobalUIModel(): JSONModel {
+		// at this point of time it's not meant to release the edit flow for freestyle usage therefore we can
+		// rely on the global UI model to exist
+		return this.base.getView().getModel("ui") as JSONModel;
+	}
+
+	/**
+	 * Performs a task in sync with other tasks created via this function.
+	 * Returns the promise chain of the task.
+	 *
+	 * @function
+	 * @name sap.fe.core.controllerextensions.EditFlow#syncTask
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @static
+	 * @param {Promise|Function} [vTask] Optional, a promise or function to be executed synchronously
+	 * @returns {Promise} Promise resolves once the task is completed
+	 *
+	 * @ui5-restricted
+	 * @final
+	 */
+	@Public
+	@Final
+	syncTask(vTask?: Function | Promise<any>) {
+		let fnNewTask;
+		if (vTask instanceof Promise) {
+			fnNewTask = function() {
+				return vTask;
+			};
+		} else if (typeof vTask === "function") {
+			fnNewTask = vTask;
+		}
+
+		this._pTasks = this._pTasks || Promise.resolve();
+		if (!!fnNewTask) {
+			this._pTasks = this._pTasks.then(fnNewTask).catch(function() {
+				return Promise.resolve();
+			});
+		}
+
+		return this._pTasks;
+	}
+
+	@Public
+	@Final
+	getProgrammingModel(oContext: any): typeof ProgrammingModel {
+		return this.getTransactionHelper().getProgrammingModel(oContext);
+	}
+
+	@Public
+	@Final
+	deleteDocumentTransaction(oContext: any, mParameters: any) {
+		const oResourceBundle = (this.getView().getController() as any).oResourceBundle,
+			transactionHelper = this.getTransactionHelper();
+
+		mParameters = mParameters || {};
+
+		// TODO: this setting and removing of contexts shouldn't be in the transaction helper at all
+		// for the time being I kept it and provide the internal model context to not break something
+		mParameters.internalModelContext = mParameters.controlId
+			? sap.ui
+					.getCore()
+					.byId(mParameters.controlId)
+					?.getBindingContext("internal")
+			: null;
+
+		return this.syncTask()
+			.then(
+				transactionHelper.deleteDocument.bind(transactionHelper, oContext, mParameters, oResourceBundle, this.getMessageHandler())
+			)
+			.then(() => {
+				this.getInternalModel().setProperty("/sessionOn", false);
+			})
+			.catch(function(oError: any) {
+				return Promise.reject(oError);
+			});
+	}
+
+	/**
+	 * Handles the create event: shows messages and in case of a draft, updates the draft indicator.
+	 *
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 * @param {object} oBinding OData list binding object
+	 */
+	@Public
+	@Final
+	handleCreateEvents(oBinding: any) {
+		const transactionHelper = this.getTransactionHelper();
+
+		this.setDraftStatus(DraftStatus.Clear);
+
+		oBinding = (oBinding.getBinding && oBinding.getBinding()) || oBinding;
+		const sProgrammingModel = this.getProgrammingModel(oBinding);
+
+		oBinding.attachEvent("createSent", () => {
+			transactionHelper.handleDocumentModifications();
+			if (sProgrammingModel === ProgrammingModel.Draft) {
+				this.setDraftStatus(DraftStatus.Saving);
+			}
+		});
+		oBinding.attachEvent("createCompleted", (oEvent: any) => {
+			const bSuccess = oEvent.getParameter("success");
+			if (sProgrammingModel === ProgrammingModel.Draft) {
+				this.setDraftStatus(bSuccess ? DraftStatus.Saved : DraftStatus.Clear);
+			}
+			this.getMessageHandler().showMessageDialog();
+		});
+	}
+
+	@Public
+	@Final
+	getTransactionHelper() {
+		if (!this._oTransactionHelper) {
+			// currently also the transaction helper is locking therefore passing lock object
+			this._oTransactionHelper = new TransactionHelper(this._oAppComponent, this.getGlobalUIModel());
+		}
+
+		return this._oTransactionHelper;
+	}
+
+	@Public
+	@Final
+	getInternalModel(): JSONModel {
+		return this.base.getView().getModel("internal") as JSONModel;
+	}
+
+	/**
+	 * 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
+	 */
+
+	@Public
+	@Final
+	createActionPromise(sActionName: any, sControlId: any) {
+		let fResolver, fRejector;
+		this.oActionPromise = new Promise((resolve, reject) => {
+			fResolver = resolve;
+			fRejector = reject;
+		}).then((oResponse: any) => {
+			return Object.assign({ controlId: sControlId }, this.getActionResponseDataAndKeys(sActionName, oResponse));
+		});
+		return { fResolver: fResolver, fRejector: fRejector };
+	}
+
+	/**
+	 * Gets the getCurrentActionPromise object.
+	 *
+	 * @function
+	 * @name _getCurrentActionPromise
+	 * @memberof sap.fe.core.controllerextensions.EditFlow
+	 *
+	 * @returns {Promise} Returns the promise
+	 */
+	@Public
+	@Final
+	getCurrentActionPromise() {
+		return this.oActionPromise;
+	}
+
+	@Public
+	@Final
+	deleteCurrentActionPromise() {
+		this.oActionPromise = undefined;
+	}
+
+	/**
+	 * @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
+	 */
+	@Public
+	@Final
+	getActionResponseDataAndKeys(sActionName: string, oResponse: any) {
+		if (Array.isArray(oResponse)) {
+			if (oResponse.length === 1) {
+				oResponse = oResponse[0];
+			} else {
+				return null;
+			}
+		}
+		if (!oResponse) {
+			return null;
+		}
+		const oView = this.getView(),
+			oMetaModel = (oView.getModel().getMetaModel() as any).getData(),
+			sActionReturnType =
+				oMetaModel && oMetaModel[sActionName] && oMetaModel[sActionName][0] && oMetaModel[sActionName][0].$ReturnType
+					? oMetaModel[sActionName][0].$ReturnType.$Type
+					: null,
+			aKey = sActionReturnType && oMetaModel[sActionReturnType] ? oMetaModel[sActionReturnType].$Key : null;
+
+		return {
+			oData: oResponse.getObject(),
+			keys: aKey
+		};
+	}
+
+	@Public
+	@Final
+	getMessageHandler() {
+		// at this point of time it's not meant to release the edit flow for FPM custom pages therefore keep
+		// the logic here for now
+
+		if (this.base.messageHandler) {
+			return this.base.messageHandler;
+		} else {
+			throw new Error("Edit Flow works only with a given message handler");
+		}
+	}
+
+	@Public
+	@Final
+	handleStickyOn(oContext: any) {
+		const oAppComponent = CommonUtils.getAppComponent(this.getView());
+
+		try {
+			if (oAppComponent === undefined || oContext === undefined) {
+				throw new Error("undefined AppComponent or Context for function handleStickyOn");
+			}
+
+			if (!oAppComponent.getRouterProxy().hasNavigationGuard()) {
+				const sHashTracker = oAppComponent.getRouterProxy().getHash(),
+					oInternalModel = this.getInternalModel();
+
+				// Set a guard in the RouterProxy
+				// A timeout is necessary, as with deferred creation the hashChanger is not updated yet with
+				// the new hash, and the guard cannot be found in the managed history of the router proxy
+				setTimeout(function() {
+					oAppComponent.getRouterProxy().setNavigationGuard();
+				}, 0);
+
+				// Setting back navigation on shell service, to get the dicard message box in case of sticky
+				oAppComponent.getShellServices().setBackNavigation(this.onBackNavigationInSession.bind(this));
+
+				this.fnDirtyStateProvider = this._registerDirtyStateProvider(oAppComponent, oInternalModel, sHashTracker);
+				oAppComponent.getShellServices().registerDirtyStateProvider(this.fnDirtyStateProvider);
+
+				// handle session timeout
+				const i18nModel = this.getView().getModel("sap.fe.i18n");
+				this.fnHandleSessionTimeout = this._attachSessionTimeout(this, i18nModel);
+				(this.getView().getModel() as any).attachSessionTimeout(this.fnHandleSessionTimeout);
+
+				this.fnStickyDiscardAfterNavigation = this._attachRouteMatched(this, oContext, oAppComponent);
+				oAppComponent.getRoutingService().attachRouteMatched(this.fnStickyDiscardAfterNavigation);
+			}
+		} catch (error) {
+			Log.info(error);
+			return undefined;
+		}
+		return true;
+	}
+
+	@Public
+	@Final
+	handleStickyOff() {
+		const oAppComponent = CommonUtils.getAppComponent(this.getView());
+		try {
+			if (oAppComponent === undefined) {
+				throw new Error("undefined AppComponent for function handleStickyOff");
+			}
+
+			if (oAppComponent && oAppComponent.getRouterProxy) {
+				// If we have exited from the app, CommonUtils.getAppComponent doesn't return a
+				// sap.fe.core.AppComponent, hence the 'if' above
+				oAppComponent.getRouterProxy().discardNavigationGuard();
+			}
+
+			if (this.fnDirtyStateProvider) {
+				oAppComponent.getShellServices().deregisterDirtyStateProvider(this.fnDirtyStateProvider);
+				this.fnDirtyStateProvider = undefined;
+			}
+
+			if (this.getView().getModel() && this.fnHandleSessionTimeout) {
+				(this.getView().getModel() as any).detachSessionTimeout(this.fnHandleSessionTimeout);
+			}
+
+			oAppComponent.getRoutingService().detachRouteMatched(this.fnStickyDiscardAfterNavigation);
+			this.fnStickyDiscardAfterNavigation = undefined;
+
+			this.getTransactionHelper()._bCreateMode = false;
+			this.setEditMode(EditMode.Display, false);
+
+			if (oAppComponent) {
+				// If we have exited from the app, CommonUtils.getAppComponent doesn't return a
+				// sap.fe.core.AppComponent, hence the 'if' above
+				oAppComponent.getShellServices().setBackNavigation();
+			}
+		} catch (error) {
+			Log.info(error);
+			return undefined;
+		}
+		return true;
+	}
+
+	/**
+	 * @description Method to display a 'discard' popover when exiting a sticky session.
+	 *
+	 * @function
+	 * @name onBackNavigationInSession
+	 * @memberof sap.fe.core.controllerextensions.InternalEditFlow
+	 */
+	@Public
+	@Final
+	onBackNavigationInSession() {
+		const oView = this.getView(),
+			oAppComponent = CommonUtils.getAppComponent(oView),
+			oRouterProxy = oAppComponent.getRouterProxy();
+
+		if (oRouterProxy.checkIfBackIsOutOfGuard()) {
+			const oBindingContext = oView && oView.getBindingContext();
+
+			CommonUtils.processDataLossConfirmation(
+				() => {
+					this.discardStickySession(oBindingContext);
+					history.back();
+				},
+				oView,
+				this.getProgrammingModel(oBindingContext)
+			);
+
+			return;
+		}
+		history.back();
+	}
+
+	@Public
+	@Final
+	discardStickySession(oContext: any) {
+		sticky.discardDocument(oContext);
+		this.handleStickyOff();
+	}
+
+	_hasNewActionForSticky(oContext: any, oView: View, sCustomAction: string) {
+		try {
+			if (oContext === undefined || oView === undefined) {
+				throw new Error("Invalid input parameters for function _hasNewActionForSticky");
+			}
+
+			const oMetaModel = oView.getModel().getMetaModel(),
+				sMetaPath = oContext.getPath().substring(0, oContext.getPath().indexOf("(")),
+				oStickySession = oMetaModel.getObject(sMetaPath + "@com.sap.vocabularies.Session.v1.StickySessionSupported");
+
+			if (oStickySession && oStickySession.NewAction && oStickySession.NewAction === sCustomAction) {
+				return true;
+			} else if (oStickySession && oStickySession.AdditionalNewActions) {
+				return sCustomAction ===
+					oStickySession.AdditionalNewActions.find(function(sAdditionalAction: string) {
+						return sAdditionalAction === sCustomAction;
+					})
+					? true
+					: false;
+			} else {
+				return false;
+			}
+		} catch (error) {
+			Log.info(error);
+			return undefined;
+		}
+	}
+
+	_registerDirtyStateProvider(oAppComponent: AppComponent, oInternalModel: JSONModel, sHashTracker: string) {
+		return function fnDirtyStateProvider(oNavigationContext: any) {
+			try {
+				if (oNavigationContext === undefined) {
+					throw new Error("Invalid input parameters for function fnDirtyStateProvider");
+				}
+
+				const sTargetHash = oNavigationContext.innerAppRoute,
+					oRouterProxy = oAppComponent.getRouterProxy();
+				let sLclHashTracker = "";
+				let bDirty: boolean;
+				const bSessionON = oInternalModel.getProperty("/sessionOn");
+
+				if (!bSessionON) {
+					// If the sticky session was terminated before hand.
+					// Eexample in case of navigating away from application using IBN.
+					return undefined;
+				}
+
+				if (!oRouterProxy.isNavigationFinalized()) {
+					// If navigation is currently happening in RouterProxy, it's a transient state
+					// (not dirty)
+					bDirty = false;
+					sLclHashTracker = sTargetHash;
+				} else if (sHashTracker === sTargetHash) {
+					// the hash didn't change so either the user attempts to refresh or to leave the app
+					bDirty = true;
+				} else if (oRouterProxy.checkHashWithGuard(sTargetHash) || oRouterProxy.isGuardCrossAllowedByUser()) {
+					// the user attempts to navigate within the root object
+					// or crossing the guard has already been allowed by the RouterProxy
+					sLclHashTracker = sTargetHash;
+					bDirty = false;
+				} else {
+					// the user attempts to navigate within the app, for example back to the list report
+					bDirty = true;
+				}
+
+				if (bDirty) {
+					// the FLP doesn't call the dirty state provider anymore once it's dirty, as they can't
+					// change this due to compatibility reasons we set it back to not-dirty
+					setTimeout(function() {
+						oAppComponent.getShellServices().setDirtyFlag(false);
+					}, 0);
+				} else {
+					sHashTracker = sLclHashTracker;
+				}
+
+				return bDirty;
+			} catch (error) {
+				Log.info(error);
+				return undefined;
+			}
+		};
+	}
+
+	_attachSessionTimeout(oContext: any, i18nModel: Model) {
+		const that = oContext;
+
+		return function fnHandleSessionTimeout() {
+			try {
+				if (oContext === undefined) {
+					throw new Error("Context missing for function fnHandleSessionTimeout");
+				}
+				// remove transient messages since we will showing our own message
+				that.getMessageHandler().removeTransitionMessages();
+
+				const oDialog = new Dialog({
+					title: "{sap.fe.i18n>C_EDITFLOW_OBJECT_PAGE_SESSION_EXPIRED_DIALOG_TITLE}",
+					state: "Warning",
+					content: new Text({ text: "{sap.fe.i18n>C_EDITFLOW_OBJECT_PAGE_SESSION_EXPIRED_DIALOG_MESSAGE}" }),
+					beginButton: new Button({
+						text: "{sap.fe.i18n>C_COMMON_DIALOG_OK}",
+						type: "Emphasized",
+						press: function() {
+							// remove sticky handling after navigation since session has already been terminated
+							that.handleStickyOff();
+							that.getRoutingListener().navigateBackFromContext(oContext);
+						}
+					}),
+					afterClose: function() {
+						oDialog.destroy();
+					}
+				});
+				oDialog.addStyleClass("sapUiContentPadding");
+				oDialog.setModel(i18nModel, "sap.fe.i18n");
+				that.getView().addDependent(oDialog);
+				oDialog.open();
+			} catch (error) {
+				Log.info(error);
+				return undefined;
+			}
+			return true;
+		};
+	}
+
+	_attachRouteMatched(oFnContext: any, oContext: any, oAppComponent: AppComponent) {
+		return function fnStickyDiscardAfterNavigation() {
+			const sCurrentHash = oAppComponent.getRouterProxy().getHash();
+			// either current hash is empty so the user left the app or he navigated away from the object
+			if (!sCurrentHash || !oAppComponent.getRouterProxy().checkHashWithGuard(sCurrentHash)) {
+				oFnContext.discardStickySession(oContext);
+			}
+		};
+	}
+}
+
+export default InternalEditFlow;