@sapui5/sap.fe.core 1.121.2 → 1.123.0

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

@@ -8,13 +8,13 @@ import BusyLocker from "sap/fe/core/controllerextensions/BusyLocker";
 import { type NavigationToErrorPageResult } from "sap/fe/core/controllerextensions/MessageHandler";
 import type { BindContextParameters } from "sap/fe/core/controllerextensions/editFlow/draft";
 import draft from "sap/fe/core/controllerextensions/editFlow/draft";
+import { getDraftOrActiveContext, isPathOnDraftRoot, resolvePath } from "sap/fe/core/controllerextensions/routing/ContextPathHelper";
 import NavigationReason from "sap/fe/core/controllerextensions/routing/NavigationReason";
 import type RouterProxy from "sap/fe/core/controllerextensions/routing/RouterProxy";
 import type { EnhanceWithUI5 } from "sap/fe/core/helpers/ClassSupport";
 import { defineUI5Class, 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 type FclController from "sap/fe/core/rootView/Fcl.controller";
 import type { RoutingNavigationInfo, RoutingNavigationParameters, RoutingService } from "sap/fe/core/services/RoutingServiceFactory";
 import type Event from "sap/ui/base/Event";
@@ -25,13 +25,10 @@ import ControllerExtension from "sap/ui/core/mvc/ControllerExtension";
 import OverrideExecution from "sap/ui/core/mvc/OverrideExecution";
 import type Router from "sap/ui/core/routing/Router";
 import type Binding from "sap/ui/model/Binding";
-import Filter from "sap/ui/model/Filter";
-import FilterOperator from "sap/ui/model/FilterOperator";
 import type JSONModel from "sap/ui/model/json/JSONModel";
 import type Context from "sap/ui/model/odata/v4/Context";
 import type ODataContextBinding from "sap/ui/model/odata/v4/ODataContextBinding";
 import type ODataListBinding from "sap/ui/model/odata/v4/ODataListBinding";
-import type ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
 import type ODataModel from "sap/ui/model/odata/v4/ODataModel";
 import type ODataPropertyBinding from "sap/ui/model/odata/v4/ODataPropertyBinding";
 import { getInvolvedDataModelObjects } from "../converters/MetaModelConverter";
@@ -124,20 +121,27 @@ class InternalRouting extends ControllerExtension {
 
 	@publicExtension()
 	@extensible(OverrideExecution.After)
-	onBeforeBinding(oBindingContext: Context | null, _mParameters?: unknown): void {
+	onBeforeBinding(_bindingContext: Context | null, _mParameters?: unknown): void {}
+
+	beforeSetBindingContext(bindingContext: Context | null, _mParameters?: unknown): void {
+		this.onBeforeBinding(bindingContext, _mParameters);
 		const oRouting = this.base.getView().getController().routing;
 		if (oRouting && oRouting.onBeforeBinding) {
-			oRouting.onBeforeBinding(oBindingContext);
+			oRouting.onBeforeBinding(bindingContext);
 		}
 	}
 
 	@publicExtension()
 	@extensible(OverrideExecution.After)
-	onAfterBinding(oBindingContext: Context | null, _mParameters?: unknown): void {
-		this._oAppComponent.getRootViewController().onContextBoundToView(oBindingContext);
+	onAfterBinding(bindingContext: Context | null, _mParameters?: unknown): void {
+		this._oAppComponent.getRootViewController().onContextBoundToView(bindingContext);
+	}
+
+	afterSetBindingContext(bindingContext: Context | null, _mParameters?: unknown): void {
+		this.onAfterBinding(bindingContext, _mParameters);
 		const oRouting = this.base.getView().getController().routing;
 		if (oRouting && oRouting.onAfterBinding) {
-			oRouting.onAfterBinding(oBindingContext);
+			oRouting.onAfterBinding(bindingContext);
 		}
 	}
 
@@ -241,9 +245,103 @@ class InternalRouting extends ControllerExtension {
 
 		parameters.FCLLevel = this._getFCLLevel();
 
+		// In case we're navigating from a table in a ListReport with draft, there's special handling for collaboration and tree table.
+		// We may not navigate to the context the user clicked on.
+		if (parameters.reason === NavigationReason.RowPress && context.isA<Context>("sap.ui.model.odata.v4.Context")) {
+			const model = context.getModel();
+			const metaModel = model.getMetaModel();
+
+			if (isPathOnDraftRoot(context.getPath(), metaModel)) {
+				const contextForNavigation =
+					(await this.getContextForNavigationWithCollaboration(context, parameters)) ??
+					(await this.getContextForNavigationFromTreeTable(context));
+
+				// Use another instance for navigation
+				if (contextForNavigation) {
+					context = contextForNavigation;
+				}
+			}
+		}
+
 		return this._oRoutingService.navigateToContext(context, parameters, this._oView.getViewData(), this._oTargetInformation);
 	}
 
+	/**
+	 * Retrieves the context to use for navigation in case we're navigating to a draft instance from the LR and we're in a collaboration application.
+	 *
+	 * @param originalContext
+	 * @param parameters
+	 * @returns The context to use for navigation if it's different from the original context, null otherwise
+	 */
+	private async getContextForNavigationWithCollaboration(
+		originalContext: Context,
+		parameters: RoutingNavigationParameters
+	): Promise<Context | null> {
+		const model = originalContext.getModel();
+		const metaModel = model.getMetaModel();
+		if (ModelHelper.isCollaborationDraftSupported(metaModel) && originalContext.getProperty("IsActiveEntity") === false) {
+			// If we're in a collaboration application, and we're navigating to a draft instance from the LR,
+			// We want to check if the draft instance exists first. Otherwise we navigate to the original (draft) version.
+			const draftOrActiveContext = await getDraftOrActiveContext(originalContext);
+
+			if (draftOrActiveContext !== null && originalContext.getPath() !== draftOrActiveContext.getPath()) {
+				// Notify the user that we have navigated to the saved instance
+				const objectPath = getInvolvedDataModelObjects(metaModel.getMetaContext(originalContext.getPath()));
+				parameters.redirectedToNonDraft =
+					(objectPath.targetEntityType.annotations.UI?.HeaderInfo?.TypeName as unknown as string) ??
+					objectPath.targetEntityType.name;
+
+				if (this._oAppComponent.getRootViewController().isFclEnabled()) {
+					// FCL: replace the context in the list binding
+					const contextToReplaceWith = model.getKeepAliveContext(draftOrActiveContext.getPath());
+					originalContext.replaceWith(contextToReplaceWith);
+				} else {
+					// Fullscreen: trigger a refresh of the list binding
+					EditState.setEditStateDirty();
+				}
+
+				// Use the saved instance for navigation
+				return draftOrActiveContext;
+			}
+		}
+
+		// Use the original context
+		return null;
+	}
+
+	/**
+	 * Retrieves the context to use for navigation in case we're navigating to an active instance from the LR and we're in a Tree table.
+	 *
+	 * @param originalContext
+	 * @returns The context to use for navigation if it's different from the original context, null otherwise
+	 */
+	private async getContextForNavigationFromTreeTable(originalContext: Context): Promise<Context | null> {
+		const parentBinding = originalContext.getBinding();
+		if (!parentBinding.isA<ODataListBinding>("sap.ui.model.odata.v4.ODataListBinding")) {
+			// The context doesn't belong to a list binding
+			return null;
+		}
+		const aggregation = parentBinding.getAggregation() as { hierarchyQualifier?: string } | undefined;
+		if (!aggregation?.hierarchyQualifier) {
+			// The context doesn't belong to a hierarchical list binding
+			return null;
+		}
+
+		if (originalContext.getProperty("IsActiveEntity") === true && originalContext.getProperty("HasDraftEntity") === true) {
+			// If we're in a TreeTable, and we're navigating to an active instance instance that has a draft,
+			// --> We try to navigate to the draft instance (if it still exists)
+			const draftOrActiveContext = await getDraftOrActiveContext(originalContext);
+
+			if (draftOrActiveContext !== null && originalContext.getPath() !== draftOrActiveContext.getPath()) {
+				// Use the draft instance for navigation
+				return draftOrActiveContext;
+			}
+		}
+
+		// Use the original context
+		return null;
+	}
+
 	/**
 	 * Navigates backwards from a context.
 	 *
@@ -449,7 +547,7 @@ class InternalRouting extends ControllerExtension {
 	 * @returns A promise
 	 */
 	async _bindDeferred(targetPath: string, navigationParameters: RoutingNavigationInfo): Promise<void> {
-		this.onBeforeBinding(null, { editable: navigationParameters.bTargetEditable });
+		this.beforeSetBindingContext(null, { editable: navigationParameters.bTargetEditable });
 
 		if (!navigationParameters.createOnNavigateParameters || navigationParameters.createOnNavigateParameters.mode === "Deferred") {
 			// either the context shall be created in the target page (deferred Context) or it shall
@@ -477,7 +575,7 @@ class InternalRouting extends ControllerExtension {
 		// remove the context to avoid showing old data
 		this._setBindingContext(null);
 
-		this.onAfterBinding(null);
+		this.afterSetBindingContext(null);
 
 		return Promise.resolve();
 	}
@@ -494,7 +592,7 @@ class InternalRouting extends ControllerExtension {
 	 */
 	async _bindPageForEdit(targetPath: string, model: ODataModel, navigationParameters: RoutingNavigationInfo): Promise<void | Context> {
 		try {
-			const technicalPath: string = await this.resolvePath(targetPath, model, navigationParameters);
+			const technicalPath: string = await resolvePath(targetPath, model, this._oRoutingService, this._oRouter);
 			if (technicalPath.includes("IsActiveEntity=true")) {
 				// create context
 				const activeContext = this._createContext(technicalPath, model);
@@ -529,7 +627,7 @@ class InternalRouting extends ControllerExtension {
 			return Promise.resolve(this._bindPageToContext(null, model, navigationParameters));
 		}
 
-		return this.resolvePath(targetPath, model, navigationParameters)
+		return resolvePath(targetPath, model, this._oRoutingService, this._oRouter)
 			.then((technicalPath: string): void => {
 				return this._bindPageToPath(technicalPath, model, navigationParameters);
 			})
@@ -544,296 +642,6 @@ class InternalRouting extends ControllerExtension {
 			});
 	}
 
-	/**
-	 * Creates the filter to retrieve a context corresponding to a semantic path.
-	 *
-	 * @param semanticPath The semantic or technical path
-	 * @param semanticKeys The semantic or technical keys for the path
-	 * @param metaModel The instance of the metamodel
-	 * @returns The filter
-	 */
-	createFilterFromPath(semanticPath: string, semanticKeys: string[], metaModel: ODataMetaModel): Filter | null {
-		const unquoteAndDecode = function (value: string): string {
-			if (value.indexOf("'") === 0 && value.lastIndexOf("'") === value.length - 1) {
-				// Remove the quotes from the value and decode special chars
-				value = decodeURIComponent(value.substring(1, value.length - 1));
-			}
-			return value;
-		};
-		const keyValues = semanticPath.substring(semanticPath.indexOf("(") + 1, semanticPath.length - 1).split(",");
-
-		let finalKeys = semanticKeys;
-		let finalKeyValues = keyValues;
-		// If we have technical keys, IsActiveEntity will be present. We need to remove it as we're already adding them at the end.
-		if (semanticKeys.includes("IsActiveEntity")) {
-			finalKeys = semanticKeys.filter((singleKey) => !singleKey.includes("IsActiveEntity"));
-			finalKeyValues = keyValues.filter((element) => !element.startsWith("IsActiveEntity"));
-		}
-
-		if (finalKeys.length != finalKeyValues.length) {
-			return null;
-		}
-
-		const filteringCaseSensitive = ModelHelper.isFilteringCaseSensitive(metaModel);
-		let filters: Filter[];
-		if (finalKeys.length === 1) {
-			// If this is a technical key, the equal is present because there's at least 2 parameters, a technical key and IsActiveEntity
-			if (finalKeyValues[0].indexOf("=") > 0) {
-				const keyPart = finalKeyValues[0].split("=");
-				finalKeyValues[0] = keyPart[1];
-			}
-			// Take the first key value
-			const keyValue = unquoteAndDecode(finalKeyValues[0]);
-			filters = [
-				new Filter({
-					path: finalKeys[0],
-					operator: FilterOperator.EQ,
-					value1: keyValue,
-					caseSensitive: filteringCaseSensitive
-				})
-			];
-		} else {
-			const mKeyValues: Record<string, unknown> = {};
-			// Create a map of all key values
-			finalKeyValues.forEach(function (sKeyAssignment: string) {
-				const aParts = sKeyAssignment.split("="),
-					keyValue = unquoteAndDecode(aParts[1]);
-
-				mKeyValues[aParts[0]] = keyValue;
-			});
-
-			let failed = false;
-			filters = finalKeys.map(function (semanticKey) {
-				const key = semanticKey,
-					value = mKeyValues[key];
-
-				if (value !== undefined) {
-					return new Filter({
-						path: key,
-						operator: FilterOperator.EQ,
-						value1: value,
-						caseSensitive: filteringCaseSensitive
-					});
-				} else {
-					failed = true;
-					return new Filter({
-						path: "XX"
-					}); // will be ignored anyway since we return after
-				}
-			});
-
-			if (failed) {
-				return null;
-			}
-		}
-
-		// Add a draft filter to make sure we take the draft entity if there is one
-		// Or the active entity otherwise
-		const draftFilter = new Filter({
-			filters: [new Filter("IsActiveEntity", "EQ", false), new Filter("SiblingEntity/IsActiveEntity", "EQ", null)],
-			and: false
-		});
-		filters.push(draftFilter);
-
-		return new Filter(filters, true);
-	}
-
-	/**
-	 * Converts a path with semantic keys to a path with technical keys.
-	 *
-	 * @param pathWithParameters The path with semantic keys
-	 * @param model The model for the path
-	 * @param keys The semantic or technical keys for the path
-	 * @returns A Promise containing the path with technical keys if pathWithParameters could be interpreted as a technical path, null otherwise
-	 */
-	async getTechnicalPathFromPath(pathWithParameters: string, model: ODataModel, keys: string[]): Promise<string | null> {
-		const metaModel = model.getMetaModel();
-		if (!keys || keys.length === 0) {
-			// No semantic/technical keys
-			return null;
-		}
-
-		// Create a set of filters corresponding to all keys
-
-		const filter = this.createFilterFromPath(pathWithParameters, keys, metaModel);
-		if (filter === null) {
-			// Couldn't interpret the path as a semantic one
-			return null;
-		}
-
-		// Retrieve the entity keys to add them in the $select query parameter
-		const absolutePath = pathWithParameters.startsWith("/") ? pathWithParameters : `/${pathWithParameters}`;
-		const metaContext = metaModel.getMetaContext(absolutePath);
-		const objectPath = getInvolvedDataModelObjects(metaContext);
-		const technicalKeys = objectPath.targetEntityType.keys.map((property) => property.name);
-
-		// Load the corresponding object
-		const listBinding = model.bindList(metaContext.getPath(), undefined, undefined, filter, {
-			$select: technicalKeys.join(","),
-			$$groupId: "$auto.Heroes"
-		});
-
-		const contexts = await listBinding.requestContexts(0, 2);
-		if (contexts.length) {
-			return contexts[0].getPath();
-		} else {
-			// No data could be loaded
-			return null;
-		}
-	}
-
-	/**
-	 * Refreshes a context.
-	 *
-	 * @param model The OData model
-	 * @param pathToReplaceWith The path to the new context
-	 * @param contextToRemove The initial context that is going to be replaced
-	 */
-	refreshContext(model: ODataModel, pathToReplaceWith: string, contextToRemove: Context): void {
-		const rootViewController = this._oAppComponent.getRootViewController();
-		if (rootViewController.isFclEnabled()) {
-			const contextToReplaceWith = model.getKeepAliveContext(pathToReplaceWith);
-			contextToRemove.replaceWith(contextToReplaceWith);
-		} else {
-			EditState.setEditStateDirty();
-		}
-	}
-
-	/**
-	 * Checks if a path is a root draft.
-	 *
-	 * @param path The path to test
-	 * @param metaModel The associated metadata model
-	 * @returns `true` if the path is a root path
-	 */
-	checkDraftAvailability(path: string, metaModel: ODataMetaModel): boolean {
-		const matches = /^[/]?(\w+)\([^/]+\)$/.exec(path);
-		if (!matches) {
-			return false;
-		}
-		// Get the entitySet name
-		const entitySetPath = `/${matches[1]}`;
-		// Check the entity set supports draft
-		const draftRoot = metaModel.getObject(`${entitySetPath}@com.sap.vocabularies.Common.v1.DraftRoot`);
-		return draftRoot ? true : false;
-	}
-
-	/**
-	 * Builds a path to navigate to from a path with SemanticKeys or technical keys.
-	 *
-	 * @param pathToResolve The path to be transformed
-	 * @param model The OData model
-	 * @param navigationParameter The parameter of the navigation
-	 * @returns String promise for the new path. If pathToResolve couldn't be interpreted as a semantic path, it is returned as is.
-	 */
-	async resolvePath(pathToResolve: string, model: ODataModel, navigationParameter: RoutingNavigationInfo): Promise<string> {
-		const metaModel = model.getMetaModel();
-		const lastSemanticMapping = this._oRoutingService.getLastSemanticMapping();
-		let currentHashNoParams = this._oRouter.getHashChanger().getHash().split("?")[0];
-
-		if (currentHashNoParams?.lastIndexOf("/") === currentHashNoParams?.length - 1) {
-			// Remove trailing '/'
-			currentHashNoParams = currentHashNoParams.substring(0, currentHashNoParams.length - 1);
-		}
-
-		let rootEntityName = currentHashNoParams?.substring(0, currentHashNoParams.indexOf("("));
-		if (rootEntityName.indexOf("/") === 0) {
-			rootEntityName = rootEntityName.substring(1);
-		}
-		const isRootDraft = this.checkDraftAvailability(currentHashNoParams, metaModel),
-			semanticKeys = isRootDraft
-				? (SemanticKeyHelper.getSemanticKeys(metaModel, rootEntityName) as { $PropertyPath: string }[])
-				: undefined,
-			isCollaborationEnabled = ModelHelper.isCollaborationDraftSupported(metaModel);
-
-		/**
-		 * If the entity is draft enabled, we're in a collaboration application, and we're navigating to a draft from a list, we're treating it as a new path.
-		 * We want to check if the draft exists first, then we navigate on it if it does exist, otherwise we navigate to the saved version.
-		 */
-		if (isRootDraft && isCollaborationEnabled && navigationParameter.reason === NavigationReason.RowPress) {
-			const isActiveEntity = navigationParameter.useContext?.getProperty("IsActiveEntity") ?? true;
-			if (!isActiveEntity) {
-				return this.resolveCollaborationPath(pathToResolve, model, navigationParameter, semanticKeys, rootEntityName);
-			}
-		}
-		/**
-		 * This is the 'normal' process.
-		 * If we don't have semantic keys, the path we have is technical and can be used as is.
-		 * If the path to resolve is the same as the semantic path, then we know is has been resolved previously and we can return the technical path
-		 * Otherwise, we need to evaluate the technical path, to set up the semantic mapping (if it's been resolved).
-		 */
-		if (semanticKeys === undefined) {
-			return pathToResolve;
-		}
-		if (lastSemanticMapping?.semanticPath === pathToResolve) {
-			// This semantic path has been resolved previously
-			return lastSemanticMapping.technicalPath;
-		}
-		const formattedSemanticKeys = semanticKeys.map((singleKey) => singleKey.$PropertyPath);
-
-		// We need resolve the semantic path to get the technical keys
-		const technicalPath = await this.getTechnicalPathFromPath(currentHashNoParams, model, formattedSemanticKeys);
-
-		if (technicalPath && technicalPath !== pathToResolve) {
-			// The semantic path was resolved (otherwise keep the original value for target)
-			this._oRoutingService.setLastSemanticMapping({
-				technicalPath: technicalPath,
-				semanticPath: pathToResolve
-			});
-			return technicalPath;
-		}
-		return pathToResolve;
-	}
-
-	/**
-	 * Evaluate the path to navigate when we're in a collaboration application and navigating to a draft.
-	 * If the draft has been discarded, we change the path to the sibling element associated, otherwise we keep the same path.
-	 * We're not doing it outside of collaboration as it's adding a request during navigation!
-	 *
-	 * @param pathToResolve The path we're checking. If the draft exists, we return it as is, otherwise we return the sibling element associated
-	 * @param model The oData model
-	 * @param navigationParameter The parameter of the navigation
-	 * @param semanticKeys The semantic keys if we have semantic navigation, otherwise false
-	 * @param rootEntityName Name of the root entity
-	 * @returns The path to navigate to
-	 */
-	async resolveCollaborationPath(
-		pathToResolve: string,
-		model: ODataModel,
-		navigationParameter: RoutingNavigationInfo,
-		semanticKeys: { $PropertyPath: string }[] | undefined,
-		rootEntityName: string
-	): Promise<string> {
-		const lastSemanticMapping = this._oRoutingService.getLastSemanticMapping();
-		const metaModel = model.getMetaModel();
-		const currentHashNoParams = this._oRouter.getHashChanger().getHash().split("?")[0];
-		let formattedKeys: string[];
-		const comparativePath = lastSemanticMapping?.technicalPath ?? pathToResolve;
-		if (semanticKeys) {
-			formattedKeys = semanticKeys.map((singleKey) => singleKey.$PropertyPath);
-		} else {
-			formattedKeys = metaModel.getObject(`/${rootEntityName}/$Type/$Key`);
-		}
-
-		const technicalPath = await this.getTechnicalPathFromPath(currentHashNoParams, model, formattedKeys);
-		if (technicalPath === null) {
-			return pathToResolve;
-		}
-		// Comparing path that was returned from the server with the one we have. If they are different, it means the draft doesn't exist.
-		if (technicalPath !== comparativePath && navigationParameter.useContext) {
-			if (lastSemanticMapping) {
-				this._oRoutingService.setLastSemanticMapping({
-					technicalPath: technicalPath,
-					semanticPath: pathToResolve
-				});
-			}
-			navigationParameter.redirectedToNonDraft =
-				metaModel.getObject(`/${rootEntityName}/@com.sap.vocabularies.UI.v1.HeaderInfo`)?.TypeName ?? rootEntityName;
-			this.refreshContext(model, technicalPath, navigationParameter.useContext);
-		}
-		return technicalPath;
-	}
-
 	/**
 	 * Sets the binding context for the page from a path.
 	 *
@@ -886,14 +694,14 @@ class InternalRouting extends ControllerExtension {
 			} else if (oNavigationParameters.reason === NavigationReason.EditFlowAction) {
 				// We have the same context but an editflow action happened (e.g. CancelDocument in sticky mode)
 				// --> We need to call onBefore/AfterBinding to refresh the object page properly
-				this.onBeforeBinding(oUseContext, {
+				this.beforeSetBindingContext(oUseContext, {
 					editable: oNavigationParameters.bTargetEditable,
 					listBinding: oUseContext.getBinding(),
 					bPersistOPScroll: oNavigationParameters.bPersistOPScroll,
 					reason: oNavigationParameters.reason,
 					showPlaceholder: oNavigationParameters.bShowPlaceholder
 				});
-				this.onAfterBinding(oUseContext, { redirectedToNonDraft: oNavigationParameters?.redirectedToNonDraft });
+				this.afterSetBindingContext(oUseContext, { redirectedToNonDraft: oNavigationParameters?.redirectedToNonDraft });
 			}
 		} else if (sCurrentPath !== sTargetPath || oNavigationParameters.reason === NavigationReason.EditFlowAction) {
 			// We need to create a new context for its path
@@ -918,8 +726,8 @@ class InternalRouting extends ControllerExtension {
 	 */
 	_bindPageToContext(oContext: Context | null, oModel: ODataModel, oNavigationParameters: RoutingNavigationInfo): void {
 		if (!oContext) {
-			this.onBeforeBinding(null);
-			this.onAfterBinding(null);
+			this.beforeSetBindingContext(null);
+			this.afterSetBindingContext(null);
 			return;
 		}
 
@@ -955,7 +763,7 @@ class InternalRouting extends ControllerExtension {
 		}
 
 		// Set the binding context with the proper before/after callbacks
-		this.onBeforeBinding(oContext, {
+		this.beforeSetBindingContext(oContext, {
 			editable: oNavigationParameters.bTargetEditable,
 			listBinding: oParentListBinding,
 			bPersistOPScroll: oNavigationParameters.bPersistOPScroll,
@@ -964,7 +772,7 @@ class InternalRouting extends ControllerExtension {
 		});
 
 		this._setBindingContext(oContext);
-		this.onAfterBinding(oContext, { redirectedToNonDraft: oNavigationParameters?.redirectedToNonDraft });
+		this.afterSetBindingContext(oContext, { redirectedToNonDraft: oNavigationParameters?.redirectedToNonDraft });
 	}
 
 	/**