@sapui5/sap.fe.core 1.99.0 → 1.101.1

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

@@ -0,0 +1,1001 @@
+import Log from "sap/base/Log";
+import ActivitySync from "sap/fe/core/actions/collaboration/ActivitySync";
+import draft from "sap/fe/core/actions/draft";
+import AppComponent from "sap/fe/core/AppComponent";
+import BusyLocker from "sap/fe/core/BusyLocker";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import {
+	defineUI5Class,
+	EnhanceWithUI5,
+	extensible,
+	finalExtension,
+	methodOverride,
+	publicExtension
+} from "sap/fe/core/helpers/ClassSupport";
+import EditState from "sap/fe/core/helpers/EditState";
+import ModelHelper from "sap/fe/core/helpers/ModelHelper";
+import SemanticKeyHelper from "sap/fe/core/helpers/SemanticKeyHelper";
+import FELibrary from "sap/fe/core/library";
+import PageController from "sap/fe/core/PageController";
+import RouterProxy from "sap/fe/core/RouterProxy";
+import { RoutingService } from "sap/fe/core/services/RoutingServiceFactory";
+import TemplateComponent from "sap/fe/core/TemplateComponent";
+import Event from "sap/ui/base/Event";
+import Component from "sap/ui/core/Component";
+import Core from "sap/ui/core/Core";
+import ControllerExtension from "sap/ui/core/mvc/ControllerExtension";
+import OverrideExecution from "sap/ui/core/mvc/OverrideExecution";
+import View from "sap/ui/core/mvc/View";
+import Router from "sap/ui/core/routing/Router";
+import Filter from "sap/ui/model/Filter";
+import FilterOperator from "sap/ui/model/FilterOperator";
+import JSONModel from "sap/ui/model/json/JSONModel";
+import Context from "sap/ui/model/odata/v4/Context";
+import { CoreEx } from "types/extension_types";
+
+/**
+ * {@link sap.ui.core.mvc.ControllerExtension Controller extension}
+ *
+ * @namespace
+ * @alias sap.fe.core.controllerextensions.InternalRouting
+ *
+ * @private
+ * @since 1.74.0
+ */
+@defineUI5Class("sap.fe.core.controllerextensions.InternalRouting")
+class InternalRouting extends ControllerExtension {
+	private base!: PageController;
+	private _oView!: View;
+	private _oAppComponent!: AppComponent;
+	private _oPageComponent!: EnhanceWithUI5<TemplateComponent> | null;
+	private _oRouter!: Router;
+	private _oRoutingService!: RoutingService;
+	private _oRouterProxy!: RouterProxy;
+	private _fnRouteMatchedBound!: Function;
+	private _oTargetInformation: any;
+
+	@methodOverride()
+	onExit() {
+		this._oRoutingService && this._oRoutingService.detachRouteMatched(this._fnRouteMatchedBound);
+	}
+
+	@methodOverride()
+	onInit() {
+		this._oView = this.base.getView();
+		this._oAppComponent = CommonUtils.getAppComponent(this._oView);
+		this._oPageComponent = Component.getOwnerComponentFor(this._oView) as EnhanceWithUI5<TemplateComponent>;
+		this._oRouter = this._oAppComponent.getRouter();
+		this._oRouterProxy = (this._oAppComponent as any).getRouterProxy();
+
+		if (!this._oAppComponent || !this._oPageComponent) {
+			throw new Error("Failed to initialize controler extension 'sap.fe.core.controllerextesions.InternalRouting");
+		}
+
+		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-ignore
+		if (this._oAppComponent === this._oPageComponent) {
+			// The view isn't hosted in a dedicated UIComponent, but directly in the app
+			// --> just keep the view
+			this._oPageComponent = null;
+		}
+
+		this._oAppComponent
+			.getService("routingService")
+			.then((oRoutingService: RoutingService) => {
+				this._oRoutingService = oRoutingService;
+				this._fnRouteMatchedBound = this._onRouteMatched.bind(this);
+				this._oRoutingService.attachRouteMatched(this._fnRouteMatchedBound);
+				this._oTargetInformation = oRoutingService.getTargetInformationFor(this._oPageComponent || this._oView);
+			})
+			.catch(function () {
+				throw new Error("This controller extension cannot work without a 'routingService' on the main AppComponent");
+			});
+	}
+
+	/**
+	 * Triggered every time this controller is a navigation target.
+	 */
+	@publicExtension()
+	@extensible(OverrideExecution.After)
+	onRouteMatched() {
+		/**/
+	}
+
+	@publicExtension()
+	@extensible(OverrideExecution.After)
+	onRouteMatchedFinished() {
+		/**/
+	}
+
+	@publicExtension()
+	@extensible(OverrideExecution.After)
+	onBeforeBinding(oBindingContext: any, mParameters?: any) {
+		const oRouting = (this.base.getView().getController() as any).routing;
+		if (oRouting && oRouting.onBeforeBinding) {
+			oRouting.onBeforeBinding(oBindingContext, mParameters);
+		}
+	}
+
+	@publicExtension()
+	@extensible(OverrideExecution.After)
+	onAfterBinding(oBindingContext: any, mParameters?: any) {
+		(this._oAppComponent as any).getRootViewController().onContextBoundToView(oBindingContext);
+		const oRouting = (this.base.getView().getController() as any).routing;
+		if (oRouting && oRouting.onAfterBinding) {
+			oRouting.onAfterBinding(oBindingContext, mParameters);
+		}
+	}
+
+	///////////////////////////////////////////////////////////
+	// Methods triggering a navigation after a user action
+	// (e.g. click on a table row, button, etc...)
+	///////////////////////////////////////////////////////////
+
+	/**
+	 * Navigates to the specified navigation target.
+	 *
+	 * @param {sap.ui.model.odata.v4.Context} oContext Context instance
+	 * @param {string} sNavigationTargetName Navigation target name
+	 * @param {object} oSemanticObject Semantic object
+	 * @param {boolean} bPreserveHistory True to force the new URL to be added at the end of the browser history (no replace)
+	 * @ui5-restricted
+	 */
+	@publicExtension()
+	navigateToTarget(oContext: any, sNavigationTargetName: string, oSemanticObject?: object, bPreserveHistory?: boolean) {
+		const oNavigationConfiguration =
+			this._oPageComponent &&
+			this._oPageComponent.getNavigationConfiguration &&
+			this._oPageComponent.getNavigationConfiguration(sNavigationTargetName);
+		if (oNavigationConfiguration) {
+			const oDetailRoute = oNavigationConfiguration.detail;
+			const sRouteName = oDetailRoute.route;
+			const mParameterMapping = oDetailRoute.parameters;
+			this._oRoutingService.navigateTo(oContext, sRouteName, mParameterMapping, bPreserveHistory);
+		} else {
+			this._oRoutingService.navigateTo(oContext, null, null, bPreserveHistory);
+		}
+		this._oView.getViewData();
+	}
+
+	/**
+	 * Navigates to the specified navigation target route.
+	 *
+	 * @param {string} sTargetRouteName Name of the target route
+	 * @param {object} [oParameters] Parameters to be used with route to create the target hash
+	 * @returns {Promise} Promise that is resolved when the navigation is finalized
+	 * @ui5-restricted
+	 */
+	@publicExtension()
+	navigateToRoute(sTargetRouteName: string, oParameters?: object) {
+		return this._oRoutingService.navigateToRoute(sTargetRouteName, oParameters);
+	}
+
+	/**
+	 * Navigates to a specific context.
+	 *
+	 * @param {sap.ui.model.odata.v4.Context} oContext The context to be navigated to
+	 * @param {object} [mParameters] Optional navigation parameters
+	 * @returns {Promise} Promise resolved when the navigation has been triggered
+	 *
+	 * @ui5-restricted
+	 */
+	@publicExtension()
+	@finalExtension()
+	navigateToContext(oContext: any, mParameters?: any): Promise<void> {
+		const oContextInfo: any = {};
+		mParameters = mParameters || {};
+
+		if (oContext.isA("sap.ui.model.odata.v4.ODataListBinding")) {
+			if (mParameters.asyncContext) {
+				// the context is either created async (Promise)
+				// We need to activate the routeMatchSynchro on the RouterProxy to avoid that
+				// the subsequent call to navigateToContext conflicts with the current one
+				this._oRouterProxy.activateRouteMatchSynchronization();
+
+				mParameters.asyncContext
+					.then((oContext: any) => {
+						// once the context is returned we navigate into it
+						this.navigateToContext(oContext, {
+							checkNoHashChange: mParameters.checkNoHashChange,
+							editable: mParameters.editable,
+							bPersistOPScroll: mParameters.bPersistOPScroll,
+							updateFCLLevel: mParameters.updateFCLLevel,
+							bForceFocus: mParameters.bForceFocus,
+							bNavigateToSiblingEntity: mParameters.bNavigateToSiblingEntity
+						});
+					})
+					.catch(function (oError: any) {
+						Log.error("Error with the async context", oError);
+					});
+			} else if (!mParameters.bDeferredContext) {
+				// Navigate to a list binding not yet supported
+				throw "navigation to a list binding is not yet supported";
+			}
+		}
+
+		if (mParameters.callExtension) {
+			const oInternalModel = this._oView.getModel("internal") as JSONModel;
+			oInternalModel.setProperty("/paginatorCurrentContext", null);
+
+			oContextInfo.sourceBindingContext = oContext.getObject();
+			oContextInfo.bindingContext = oContext;
+			if (mParameters.oEvent) {
+				oContextInfo.oEvent = mParameters.oEvent;
+			}
+			// Storing the selected context to use it in internal route navigation if neccessary.
+			const bOverrideNav = (this.base.getView().getController() as any).routing.onBeforeNavigation(oContextInfo);
+			if (bOverrideNav) {
+				oInternalModel.setProperty("/paginatorCurrentContext", oContext);
+				return Promise.resolve();
+			}
+		}
+		mParameters.FCLLevel = this._getFCLLevel();
+
+		return this._oRoutingService.navigateToContext(oContext, mParameters, this._oView.getViewData(), this._oTargetInformation);
+	}
+
+	/**
+	 * Navigates backwards from a context.
+	 *
+	 * @param {sap.ui.model.odata.v4.Context} oContext Context to be navigated from
+	 * @param {object} [mParameters] Optional navigation parameters
+	 * @returns {Promise} Promise resolved when the navigation has been triggered
+	 *
+	 * @ui5-restricted
+	 */
+	@publicExtension()
+	@finalExtension()
+	navigateBackFromContext(oContext: any, mParameters?: any) {
+		mParameters = mParameters || {};
+		mParameters.updateFCLLevel = -1;
+
+		return this.navigateToContext(oContext, mParameters);
+	}
+
+	/**
+	 * Navigates forwards to a context.
+	 *
+	 * @param {sap.ui.model.odata.v4.Context} oContext Context to be navigated to
+	 * @param {object} mParameters Optional navigation parameters
+	 * @returns {Promise} Promise resolved when the navigation has been triggered
+	 *
+	 * @ui5-restricted
+	 */
+	@publicExtension()
+	@finalExtension()
+	navigateForwardToContext(oContext: any, mParameters?: any) {
+		if (this._oView.getBindingContext("internal")?.getProperty("messageFooterContainsErrors") === true) {
+			return Promise.resolve();
+		}
+		mParameters = mParameters || {};
+		mParameters.updateFCLLevel = 1;
+
+		return this.navigateToContext(oContext, mParameters);
+	}
+
+	/**
+	 * Navigates back in history if the current hash corresponds to a transient state.
+	 */
+	@publicExtension()
+	@finalExtension()
+	navigateBackFromTransientState() {
+		const sHash = this._oRouterProxy.getHash();
+
+		// if triggered while navigating to (...), we need to navigate back
+		if (sHash.indexOf("(...)") !== -1) {
+			this._oRouterProxy.navBack();
+		}
+	}
+
+	@publicExtension()
+	@finalExtension()
+	navigateToMessagePage(sErrorMessage: any, mParameters: any) {
+		mParameters = mParameters || {};
+		if (this._oRouterProxy.getHash().indexOf("i-action=create") > -1) {
+			return this._oRouterProxy.navToHash(this._oRoutingService.getDefaultCreateHash());
+		} else {
+			mParameters.FCLLevel = this._getFCLLevel();
+
+			return (this._oAppComponent as any).getRootViewController().displayMessagePage(sErrorMessage, mParameters);
+		}
+	}
+
+	/**
+	 * Checks if one of the current views on the screen is bound to a given context.
+	 *
+	 * @param {sap.ui.model.odata.v4.Context} oContext
+	 * @returns {boolean}
+	 *
+	 * @ui5-restricted
+	 */
+	@publicExtension()
+	@finalExtension()
+	isCurrentStateImpactedBy(oContext: any) {
+		return this._oRoutingService.isCurrentStateImpactedBy(oContext);
+	}
+
+	///////////////////////////////////////////////////////////
+	// Methods to bind the page when a route is matched
+	///////////////////////////////////////////////////////////
+
+	/**
+	 * Called when a route is matched.
+	 * Builds the binding context from the navigation parameters, and bind the page accordingly.
+	 *
+	 * @param {object} oEvent
+	 *
+	 * @ui5-restricted
+	 */
+	_onRouteMatched(oEvent: Event) {
+		// Check if the target for this view is part of the event targets
+		const aTargets = oEvent.getParameter("routeInformation") && oEvent.getParameter("routeInformation").targets;
+		if (!aTargets || aTargets.indexOf(this._oTargetInformation.targetName) === -1) {
+			return;
+		}
+
+		// Retrieve the binding context pattern
+		let sTarget;
+		if (this._oPageComponent && this._oPageComponent.getBindingContextPattern) {
+			sTarget = this._oPageComponent.getBindingContextPattern();
+		}
+		sTarget = sTarget || this._oTargetInformation.contextPattern;
+
+		if (sTarget === null || sTarget === undefined) {
+			// Don't do this if we already got sTarget == '', which is a valid target pattern
+			sTarget = oEvent.getParameter("routePattern");
+		}
+		sTarget = sTarget.replace(":?query:", "");
+
+		// Replace the parameters by their values in the binding context pattern
+		const mArguments = (oEvent.getParameters() as any).arguments;
+		let bDeferred = false;
+		const oNavigationParameters = oEvent.getParameter("navigationInfo");
+
+		for (const sKey in mArguments) {
+			const sValue = mArguments[sKey];
+			if (sValue === "..." && sTarget.indexOf("{" + sKey + "}") >= 0) {
+				bDeferred = true;
+				// Sometimes in preferredMode = create, the edit button is shown in background when the
+				// action parameter dialog shows up, setting bTargetEditable passes editable as true
+				// to onBeforeBinding in _bindTargetPage function
+				oNavigationParameters.bTargetEditable = true;
+			}
+			sTarget = sTarget.replace("{" + sKey + "}", sValue);
+		}
+		if (mArguments["?query"] && mArguments["?query"].hasOwnProperty("i-action")) {
+			oNavigationParameters.bActionCreate = true;
+		}
+
+		// the binding target is always absolute
+		if (sTarget && sTarget[0] !== "/") {
+			sTarget = "/" + sTarget;
+		}
+
+		this.onRouteMatched();
+
+		const oModel = this._oView.getModel();
+		let oOut;
+		if (bDeferred) {
+			oOut = this._bindDeferred(sTarget, oNavigationParameters);
+		} else {
+			oOut = this._bindPage(sTarget, oModel, oNavigationParameters);
+		}
+		// eslint-disable-next-line promise/catch-or-return
+		oOut.finally(() => {
+			this.onRouteMatchedFinished();
+		});
+
+		(this._oAppComponent as any).getRootViewController().updateUIStateForView(this._oView, this._getFCLLevel());
+	}
+
+	/**
+	 * Deferred binding (during object creation).
+	 *
+	 * @param {string} sTargetPath The path to the deffered context
+	 * @param {object} oNavigationParameters Navigation parameters
+	 * @returns {Promise}
+	 * @ui5-restricted
+	 */
+	_bindDeferred(sTargetPath: string, oNavigationParameters: any) {
+		this.onBeforeBinding(null, { editable: oNavigationParameters.bTargetEditable });
+
+		if (oNavigationParameters.bDeferredContext || !oNavigationParameters.oAsyncContext) {
+			// either the context shall be created in the target page (deferred Context) or it shall
+			// be created async but the user refreshed the page / bookmarked this URL
+			// TODO: currently the target component creates this document but we shall move this to
+			// a central place
+			if (this._oPageComponent && this._oPageComponent.createDeferredContext) {
+				this._oPageComponent.createDeferredContext(
+					sTargetPath,
+					oNavigationParameters.useContext,
+					oNavigationParameters.bActionCreate
+				);
+			}
+		}
+
+		if (this._getBindingContext() && this._getBindingContext().hasPendingChanges()) {
+			// For now remove the pending changes to avoid the model raises errors and the object page is at least bound
+			// Ideally the user should be asked for
+			this._getBindingContext().getBinding().resetChanges();
+		}
+
+		// remove the context to avoid showing old data
+		this._setBindingContext(null);
+
+		this.onAfterBinding(null);
+		return Promise.resolve();
+	}
+
+	/**
+	 * Sets the binding context of the page from a path.
+	 *
+	 * @param {string} sTargetPath The path to the context
+	 * @param {sap.ui.model.odata.v4.ODataModel} oModel The OData model
+	 * @param {object} oNavigationParameters Navigation parameters
+	 * @returns {Promise}
+	 * @ui5-restricted
+	 */
+	_bindPage(sTargetPath: string, oModel: any, oNavigationParameters: object) {
+		if (sTargetPath === "") {
+			return Promise.resolve(this._bindPageToContext(null, oModel, oNavigationParameters));
+		} else {
+			return this._resolveSemanticPath(sTargetPath, oModel)
+				.then((sTechnicalPath: any) => {
+					this._bindPageToPath(sTechnicalPath, oModel, oNavigationParameters);
+				})
+				.catch((oError: any) => {
+					// Error handling for erroneous metadata request
+					const oResourceBundle = (Core as CoreEx).getLibraryResourceBundle("sap.fe.core");
+
+					this.navigateToMessagePage(oResourceBundle.getText("C_COMMON_SAPFE_DATA_RECEIVED_ERROR"), {
+						title: oResourceBundle.getText("C_COMMON_SAPFE_ERROR"),
+						description: oError.message
+					});
+				});
+		}
+	}
+
+	/**
+	 * Creates the filter to retrieve a context corresponding to a semantic path.
+	 *
+	 * @param {string} sSemanticPath The semantic path
+	 * @param {Array} aSemanticKeys The semantic keys for the path
+	 * @param {object} oMetaModel The instance of the meta model
+	 * @returns {sap.ui.model.Filter} The filter
+	 *
+	 * @ui5-restricted
+	 */
+	_createFilterFromSemanticPath(sSemanticPath: string, aSemanticKeys: any[], oMetaModel: object) {
+		const fnUnquoteAndDecode = function (sValue: any) {
+			if (sValue.indexOf("'") === 0 && sValue.lastIndexOf("'") === sValue.length - 1) {
+				// Remove the quotes from the value and decode special chars
+				sValue = decodeURIComponent(sValue.substring(1, sValue.length - 1));
+			}
+			return sValue;
+		};
+		const aKeyValues = sSemanticPath.substring(sSemanticPath.indexOf("(") + 1, sSemanticPath.length - 1).split(",");
+		let aFilters: Filter[];
+
+		if (aSemanticKeys.length != aKeyValues.length) {
+			return null;
+		}
+
+		const bFilteringCaseSensitive = ModelHelper.isFilteringCaseSensitive(oMetaModel);
+
+		if (aSemanticKeys.length === 1) {
+			// Take the first key value
+			const sKeyValue = fnUnquoteAndDecode(aKeyValues[0]);
+			aFilters = [
+				new Filter({
+					path: aSemanticKeys[0].$PropertyPath,
+					operator: FilterOperator.EQ,
+					value1: sKeyValue,
+					caseSensitive: bFilteringCaseSensitive
+				})
+			];
+		} else {
+			const mKeyValues: any = {};
+			// Create a map of all key values
+			aKeyValues.forEach(function (sKeyAssignment: string) {
+				const aParts = sKeyAssignment.split("="),
+					sKeyValue = fnUnquoteAndDecode(aParts[1]);
+
+				mKeyValues[aParts[0]] = sKeyValue;
+			});
+
+			let bFailed = false;
+			aFilters = aSemanticKeys.map(function (oSemanticKey: any) {
+				const sKey = oSemanticKey.$PropertyPath,
+					sValue = mKeyValues[sKey];
+
+				if (sValue !== undefined) {
+					return new Filter({
+						path: sKey,
+						operator: FilterOperator.EQ,
+						value1: sValue,
+						caseSensitive: bFilteringCaseSensitive
+					});
+				} else {
+					bFailed = true;
+					return new Filter({
+						path: "XX"
+					}); // will be ignore anyway since we return after
+				}
+			});
+
+			if (bFailed) {
+				return null;
+			}
+		}
+
+		// Add a draft filter to make sure we take the draft entity if there is one
+		// Or the active entity otherwise
+		const oDraftFilter = new Filter({
+			filters: [new Filter("IsActiveEntity", "EQ", false), new Filter("SiblingEntity/IsActiveEntity", "EQ", null)],
+			and: false
+		});
+		aFilters.push(oDraftFilter);
+
+		const oCombinedFilter = new Filter(aFilters, true);
+		return oCombinedFilter;
+	}
+
+	/**
+	 * Converts a path with semantic keys to a path with technical keys.
+	 *
+	 * @param {string} sSemanticPath The path with semantic keys
+	 * @param {sap.ui.model.odata.v4.ODataModel} oModel The model for the path
+	 * @param {Array} aSemanticKeys The semantic keys for the path
+	 * @returns {Promise} A Promise containing the path with technical keys if sSemanticPath could be interpreted as a semantic path, null otherwise
+	 *
+	 * @ui5-restricted
+	 */
+	_getTechnicalPathFromSemanticPath(sSemanticPath: string, oModel: any, aSemanticKeys: any[]) {
+		const oMetaModel = oModel.getMetaModel();
+		let sEntitySetPath = oMetaModel.getMetaContext(sSemanticPath).getPath();
+
+		if (!aSemanticKeys || aSemanticKeys.length === 0) {
+			// No semantic keys
+			return Promise.resolve(null);
+		}
+
+		// Create a set of filters corresponding to all keys
+		const oFilter = this._createFilterFromSemanticPath(sSemanticPath, aSemanticKeys, oMetaModel);
+		if (oFilter === null) {
+			// Couldn't interpret the path as a semantic one
+			return Promise.resolve(null);
+		}
+
+		// Load the corresponding object
+		if (!sEntitySetPath?.startsWith("/")) {
+			sEntitySetPath = "/" + sEntitySetPath;
+		}
+		const oListBinding = oModel.bindList(sEntitySetPath, undefined, undefined, oFilter, {
+			"$$groupId": "$auto.Heroes"
+		});
+
+		return oListBinding.requestContexts(0, 2).then(function (oContexts: any) {
+			if (oContexts && oContexts.length) {
+				return oContexts[0].getPath();
+			} else {
+				// No data could be loaded
+				return null;
+			}
+		});
+	}
+
+	/**
+	 * Checks if a path is eligible for semantic bookmarking.
+	 *
+	 * @param {string} sPath The path to test
+	 * @param {sap.ui.model.odata.v4.ODataMetaModel} oMetaModel The associated metadata model
+	 * @returns {boolean} `true` if the path is eligible
+	 *
+	 * @ui5-restricted
+	 */
+	_checkPathForSemanticBookmarking(sPath: string, oMetaModel: any) {
+		// Only path on root objects allow semantic bookmarking, i.e. sPath = xxx(yyy)
+		const aMatches = /^[\/]?(\w+)\([^\/]+\)$/.exec(sPath);
+		if (!aMatches) {
+			return false;
+		}
+		// Get the entitySet name
+		const sEntitySetPath = "/" + aMatches[1];
+		// Check the entity set supports draft (otherwise we don't support semantic bookmarking)
+		const oDraftRoot = oMetaModel.getObject(sEntitySetPath + "@com.sap.vocabularies.Common.v1.DraftRoot");
+		const oDraftNode = oMetaModel.getObject(sEntitySetPath + "@com.sap.vocabularies.Common.v1.DraftNode");
+		return oDraftRoot || oDraftNode ? true : false;
+	}
+
+	/**
+	 * Builds a path with semantic keys from a path with technical keys.
+	 * @param {string} sPathToResolve The path to be transformed
+	 * @param oModel
+	 * @returns {Promise} String promise for the new path. If sPathToResolved couldn't be interpreted as a semantic path, it is returned as is.
+	 * @ui5-restricted
+	 */
+	_resolveSemanticPath(sPathToResolve: string, oModel: any): Promise<string> {
+		const oMetaModel = oModel.getMetaModel();
+		const oLastSemanticMapping = this._oRoutingService.getLastSemanticMapping();
+		let sCurrentHashNoParams = this._oRouter.getHashChanger().getHash().split("?")[0];
+
+		if (sCurrentHashNoParams && sCurrentHashNoParams.lastIndexOf("/") === sCurrentHashNoParams.length - 1) {
+			// Remove trailing '/'
+			sCurrentHashNoParams = sCurrentHashNoParams.substring(0, sCurrentHashNoParams.length - 1);
+		}
+
+		let sRootEntityName = sCurrentHashNoParams && sCurrentHashNoParams.substr(0, sCurrentHashNoParams.indexOf("("));
+		if (sRootEntityName.indexOf("/") === 0) {
+			sRootEntityName = sRootEntityName.substring(1);
+		}
+		const bAllowSemanticBookmark = this._checkPathForSemanticBookmarking(sCurrentHashNoParams, oMetaModel),
+			aSemanticKeys = bAllowSemanticBookmark && SemanticKeyHelper.getSemanticKeys(oMetaModel, sRootEntityName);
+		if (!aSemanticKeys) {
+			// No semantic keys available --> use the path as is
+			return Promise.resolve(sPathToResolve);
+		} else if (oLastSemanticMapping && oLastSemanticMapping.semanticPath === sPathToResolve) {
+			// This semantic path has been resolved previously
+			return Promise.resolve(oLastSemanticMapping.technicalPath);
+		} else {
+			// We need resolve the semantic path to get the technical keys
+			return this._getTechnicalPathFromSemanticPath(sCurrentHashNoParams, oModel, aSemanticKeys).then((sTechnicalPath: any) => {
+				if (sTechnicalPath && sTechnicalPath !== sPathToResolve) {
+					// The semantic path was resolved (otherwise keep the original value for target)
+					this._oRoutingService.setLastSemanticMapping({
+						technicalPath: sTechnicalPath,
+						semanticPath: sPathToResolve
+					});
+					return sTechnicalPath;
+				} else {
+					return sPathToResolve;
+				}
+			});
+		}
+	}
+
+	/**
+	 * Sets the binding context of the page from a path.
+	 *
+	 * @param {string} sTargetPath The path to build the context. Needs to contain technical keys only.
+	 * @param {sap.ui.model.odata.v4.ODataModel} oModel The OData model
+	 * @param {object} oNavigationParameters Navigation parameters
+	 *
+	 * @ui5-restricted
+	 */
+	_bindPageToPath(sTargetPath: string, oModel: any, oNavigationParameters: any) {
+		const oCurrentContext = this._getBindingContext(),
+			sCurrentPath = oCurrentContext && oCurrentContext.getPath(),
+			oUseContext = oNavigationParameters.useContext;
+
+		// We set the binding context only if it's different from the current one
+		// or if we have a context already selected
+		if (sCurrentPath !== sTargetPath || (oUseContext && oUseContext.getPath() === sTargetPath)) {
+			let oTargetContext;
+			if (oUseContext && oUseContext.getPath() === sTargetPath) {
+				// We already have the context to be used
+				oTargetContext = oUseContext;
+			} else {
+				// Otherwise we need to create it from sTargetPath
+				oTargetContext = this._createBindingContext(sTargetPath, oModel, oNavigationParameters.bNavigateToSiblingEntity);
+			}
+			if (oTargetContext !== oCurrentContext) {
+				this._bindPageToContext(oTargetContext, oModel, oNavigationParameters);
+			}
+		} else if (!oNavigationParameters.bReasonIsIappState && EditState.isEditStateDirty()) {
+			this._refreshBindingContext(oCurrentContext);
+		}
+	}
+
+	/**
+	 * Binds the page to a context.
+	 *
+	 * @param {sap.ui.model.odata.v4.Context} oContext Context to be bound
+	 * @param {sap.ui.model.odata.v4.ODataModel} oModel The OData model
+	 * @param {object} oNavigationParameters Navigation parameters
+	 *
+	 * @ui5-restricted
+	 */
+	_bindPageToContext(oContext: any, oModel: any, oNavigationParameters: any) {
+		if (!oContext) {
+			this.onBeforeBinding(null);
+			this.onAfterBinding(null);
+		} else {
+			const oParentListBinding = oContext.getBinding();
+
+			if (!oContext.getBinding() || oContext.getBinding().isA("sap.ui.model.odata.v4.ODataListBinding")) {
+				// We need to recreate the context otherwise we get errors
+				oContext = this._createBindingContext(oContext.getPath(), oModel, oNavigationParameters.bNavigateToSiblingEntity);
+				if (EditState.isEditStateDirty()) {
+					// TODO: as a workaround we invalidate the model cache while the app is dirty
+					// as the manage model sets the parent in an async task and the request side effects
+					// relies on the parent relationship we have to set a timeout 0
+					setTimeout(() => {
+						this._refreshBindingContext(oContext);
+					}, 0);
+				}
+			}
+
+			// Set the binding context with the proper before/after callbacks
+			this.onBeforeBinding(oContext, {
+				editable: oNavigationParameters.bTargetEditable,
+				listBinding: oParentListBinding,
+				bPersistOPScroll: oNavigationParameters.bPersistOPScroll,
+				bDraftNavigation: oNavigationParameters.bDraftNavigation,
+				showPlaceholder: oNavigationParameters.bShowPlaceholder
+			});
+
+			this._setBindingContext(oContext);
+			this.onAfterBinding(oContext);
+		}
+	}
+
+	/**
+	 * Creates a binding context from a path.
+	 *
+	 * @param {string} sPath The path
+	 * @param {sap.ui.model.odata.v4.ODataModel} oModel The OData model
+	 * @returns {sap.ui.model.odata.v4.Context} Created context
+	 *
+	 * @ui5-restricted
+	 */
+	@publicExtension()
+	_createBindingContext(sPath: string, oModel: any, navigateToSiblingEntity: boolean = true) {
+		const oPageComponent = this._oPageComponent,
+			sEntitySet = oPageComponent && oPageComponent.getEntitySet && oPageComponent.getEntitySet(),
+			sContextPath =
+				(oPageComponent && oPageComponent.getContextPath && oPageComponent.getContextPath()) || (sEntitySet && "/" + sEntitySet),
+			oMetaModel = oModel.getMetaModel(),
+			mParameters: any = {
+				$$patchWithoutSideEffects: true,
+				$$groupId: "$auto.Heroes",
+				$$updateGroupId: "$auto"
+			};
+
+		if (sEntitySet) {
+			const sMessagesPath = oMetaModel.getObject(sContextPath + "/@com.sap.vocabularies.Common.v1.Messages/$Path");
+			if (sMessagesPath) {
+				mParameters.$select = sMessagesPath;
+			}
+		}
+
+		// In case of draft: $select the state flags (HasActiveEntity, HasDraftEntity, and IsActiveEntity)
+		const oDraftRoot = oMetaModel.getObject(sContextPath + "@com.sap.vocabularies.Common.v1.DraftRoot");
+		const oDraftNode = oMetaModel.getObject(sContextPath + "@com.sap.vocabularies.Common.v1.DraftNode");
+		if (oDraftRoot || oDraftNode) {
+			if (mParameters.$select === undefined) {
+				mParameters.$select = "HasActiveEntity,HasDraftEntity,IsActiveEntity";
+			} else {
+				mParameters.$select += ",HasActiveEntity,HasDraftEntity,IsActiveEntity";
+			}
+		}
+
+		const oHiddenBinding = oModel.bindContext(sPath, undefined, mParameters);
+
+		oHiddenBinding.attachEventOnce("dataRequested", () => {
+			BusyLocker.lock(this._oView);
+		});
+		oHiddenBinding.attachEventOnce("dataReceived", this._dataReceivedEventHandler.bind(this, navigateToSiblingEntity));
+		return oHiddenBinding.getBoundContext();
+	}
+
+	async _dataReceivedEventHandler(navigateToSiblingEntity: boolean, oEvent: Event) {
+		const context = oEvent?.getSource && (oEvent?.getSource() as any)?.getBoundContext();
+		const ProgrammingModel = FELibrary.ProgrammingModel;
+		const programmingModel = (this._oView?.getController() as PageController)?._editFlow?.getProgrammingModel(context);
+		const sErrorDescription = oEvent && oEvent.getParameter("error");
+		BusyLocker.unlock(this._oView);
+		if (
+			programmingModel === ProgrammingModel.Draft &&
+			ActivitySync.isCollaborationEnabled(this._oView) &&
+			navigateToSiblingEntity &&
+			context.getProperty("IsActiveEntity") &&
+			context.getObject().DraftAdministrativeData
+		) {
+			const siblingInfo = await draft.computeSiblingInformation(context, context);
+			if (siblingInfo) {
+				this.navigateToContext(siblingInfo.targetContext);
+				return;
+			}
+		}
+
+		if (sErrorDescription) {
+			// TODO: in case of 404 the text shall be different
+			try {
+				const oResourceBundle = await (Core as CoreEx).getLibraryResourceBundle("sap.fe.core", true);
+				const messageHandler = this.base.messageHandler;
+				let mParams = {};
+				if (sErrorDescription && sErrorDescription.status === 503) {
+					mParams = {
+						isInitialLoad503Error: true,
+						shellBack: true
+					};
+				} else {
+					mParams = {
+						title: oResourceBundle.getText("SAPFE_ERROR"),
+						description: sErrorDescription,
+						isDataReceivedError: true,
+						shellBack: true
+					};
+				}
+				messageHandler.showMessages(mParams);
+			} catch (oError: any) {
+				Log.error("Error while getting the core resource bundle", oError);
+			}
+		}
+	}
+
+	/**
+	 * Requests side effects on a binding context to "refresh" it.
+	 * TODO: get rid of this once provided by the model
+	 * a refresh on the binding context does not work in case a creation row with a transient context is
+	 * used. also a requestSideEffects with an empty path would fail due to the transient context
+	 * therefore we get all dependent bindings (via private model method) to determine all paths and then
+	 * request them.
+	 *
+	 * @param {sap.ui.model.odata.v4.Context} oBindingContext Context to be refreshed
+	 *
+	 * @ui5-restricted
+	 */
+	_refreshBindingContext(oBindingContext: any) {
+		const oPageComponent = this._oPageComponent;
+		const oSideEffectsService = this._oAppComponent.getSideEffectsService();
+		const sRootContextPath = oBindingContext.getPath();
+		const sEntitySet = oPageComponent && oPageComponent.getEntitySet && oPageComponent.getEntitySet();
+		const sContextPath =
+			(oPageComponent && oPageComponent.getContextPath && oPageComponent.getContextPath()) || (sEntitySet && "/" + sEntitySet);
+		const oMetaModel = this._oView.getModel().getMetaModel();
+		let sMessagesPath;
+		const aNavigationPropertyPaths: any[] = [];
+		const aPropertyPaths: any[] = [];
+		const oSideEffects: any = {
+			TargetProperties: [],
+			TargetEntities: []
+		};
+
+		function getBindingPaths(oBinding: any) {
+			let aDependentBindings;
+			const sRelativePath = ((oBinding.getContext() && oBinding.getContext().getPath()) || "").replace(sRootContextPath, ""); // If no context, this is an absolute binding so no relative path
+			const sPath = (sRelativePath ? sRelativePath.slice(1) + "/" : sRelativePath) + oBinding.getPath();
+
+			if (oBinding.isA("sap.ui.model.odata.v4.ODataContextBinding")) {
+				// if (sPath === "") {
+				// now get the dependent bindings
+				aDependentBindings = oBinding.getDependentBindings();
+				if (aDependentBindings) {
+					// ask the dependent bindings (and only those with the specified groupId
+					//if (aDependentBindings.length > 0) {
+					for (let i = 0; i < aDependentBindings.length; i++) {
+						getBindingPaths(aDependentBindings[i]);
+					}
+				} else if (aNavigationPropertyPaths.indexOf(sPath) === -1) {
+					aNavigationPropertyPaths.push(sPath);
+				}
+			} else if (oBinding.isA("sap.ui.model.odata.v4.ODataListBinding")) {
+				if (aNavigationPropertyPaths.indexOf(sPath) === -1) {
+					aNavigationPropertyPaths.push(sPath);
+				}
+			} else if (oBinding.isA("sap.ui.model.odata.v4.ODataPropertyBinding")) {
+				if (aPropertyPaths.indexOf(sPath) === -1) {
+					aPropertyPaths.push(sPath);
+				}
+			}
+		}
+
+		if (sContextPath) {
+			sMessagesPath = oMetaModel.getObject(sContextPath + "/@com.sap.vocabularies.Common.v1.Messages/$Path");
+		}
+
+		// binding of the context must have $$PatchWithoutSideEffects true, this bound context may be needed to be fetched from the dependent binding
+		getBindingPaths(oBindingContext.getBinding());
+
+		let i;
+		for (i = 0; i < aNavigationPropertyPaths.length; i++) {
+			oSideEffects.TargetEntities.push({
+				$NavigationPropertyPath: aNavigationPropertyPaths[i]
+			});
+		}
+		oSideEffects.TargetProperties = aPropertyPaths;
+		if (sMessagesPath) {
+			oSideEffects.TargetProperties.push({
+				$PropertyPath: sMessagesPath
+			});
+		}
+		oSideEffectsService.requestSideEffects(oSideEffects.TargetEntities.concat(oSideEffects.TargetProperties), oBindingContext);
+	}
+
+	/**
+	 * Gets the binding context of the page or the component.
+	 *
+	 * @returns {sap.ui.model.odata.v4.Context} The binding context
+	 *
+	 * @ui5-restricted
+	 */
+	_getBindingContext(): Context {
+		if (this._oPageComponent) {
+			return this._oPageComponent.getBindingContext() as Context;
+		} else {
+			return this._oView.getBindingContext() as Context;
+		}
+	}
+
+	/**
+	 * Sets the binding context of the page or the component.
+	 *
+	 * @param {sap.ui.model.odata.v4.Context} oContext The binding context
+	 *
+	 * @ui5-restricted
+	 */
+	_setBindingContext(oContext: any) {
+		if (this._oPageComponent) {
+			this._oPageComponent.setBindingContext(oContext);
+		} else {
+			this._oView.setBindingContext(oContext);
+		}
+	}
+
+	/**
+	 * Gets the flexible column layout (FCL) level corresponding to the view (-1 if the app is not FCL).
+	 *
+	 * @returns {number} The level
+	 *
+	 * @ui5-restricted
+	 */
+	_getFCLLevel() {
+		return this._oTargetInformation.FCLLevel;
+	}
+
+	/**
+	 * Switches between column and full-screen mode when FCL is used.
+	 *
+	 * @ui5-restricted
+	 */
+
+	@publicExtension()
+	@finalExtension()
+	switchFullScreen() {
+		const oSource = this.base.getView();
+		const oFCLHelperModel = oSource.getModel("fclhelper"),
+			bIsFullScreen = oFCLHelperModel.getProperty("/actionButtonsInfo/isFullScreen"),
+			sNextLayout = oFCLHelperModel.getProperty(
+				bIsFullScreen ? "/actionButtonsInfo/exitFullScreen" : "/actionButtonsInfo/fullScreen"
+			),
+			oRootViewController = (this._oAppComponent as any).getRootViewController();
+
+		const oContext = oRootViewController.getRightmostContext ? oRootViewController.getRightmostContext() : oSource.getBindingContext();
+
+		this.base._routing.navigateToContext(oContext, { sLayout: sNextLayout }).catch(function () {
+			Log.warning("cannot switch between column and fullscreen");
+		});
+	}
+
+	/**
+	 * Closes the column for the current view in a FCL.
+	 *
+	 * @ui5-restricted
+	 */
+	@publicExtension()
+	@extensible(OverrideExecution.Before)
+	closeColumn() {
+		const oSource = this.base.getView();
+		const oViewData = oSource.getViewData() as any;
+		const oContext = oSource.getBindingContext() as Context;
+		const base = this.base;
+		const oMetaModel = oContext.getModel().getMetaModel();
+
+		if (oViewData && oViewData.viewLevel === 1 && ModelHelper.isDraftSupported(oMetaModel, oContext.getPath())) {
+			CommonUtils.fnProcessDataLossOrDraftDiscardConfirmation(
+				function () {
+					base._routing.navigateBackFromContext(oContext, { noPreservationCache: true });
+				},
+				Function.prototype,
+				oContext,
+				oSource.getController(),
+				false
+			);
+		} else {
+			base._routing.navigateBackFromContext(oContext, { noPreservationCache: true });
+		}
+	}
+}
+
+export default InternalRouting;