@sapui5/sap.fe.templates 1.100.0 → 1.101.0

package/src/sap/fe/templates/ObjectPage/ObjectPageController.controller.ts

@@ -0,0 +1,1442 @@
+import ResourceBundle from "sap/base/i18n/ResourceBundle";
+import Log from "sap/base/Log";
+import merge from "sap/base/util/merge";
+import { connect } from "sap/fe/core/actions/collaboration/ActivitySync";
+import { openManageDialog, showUserDetails } from "sap/fe/core/actions/collaboration/Manage";
+import BusyLocker from "sap/fe/core/BusyLocker";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import EditFlow from "sap/fe/core/controllerextensions/EditFlow";
+import IntentBasedNavigation from "sap/fe/core/controllerextensions/IntentBasedNavigation";
+import InternalEditFlow from "sap/fe/core/controllerextensions/InternalEditFlow";
+import InternalIntentBasedNavigation from "sap/fe/core/controllerextensions/InternalIntentBasedNavigation";
+import InternalRouting from "sap/fe/core/controllerextensions/InternalRouting";
+import MassEdit from "sap/fe/core/controllerextensions/MassEdit";
+import MessageHandler from "sap/fe/core/controllerextensions/MessageHandler";
+import PageReady from "sap/fe/core/controllerextensions/PageReady";
+import Paginator from "sap/fe/core/controllerextensions/Paginator";
+import Placeholder from "sap/fe/core/controllerextensions/Placeholder";
+import Share from "sap/fe/core/controllerextensions/Share";
+import ViewState from "sap/fe/core/controllerextensions/ViewState";
+import { defineUI5Class, extensible, finalExtension, publicExtension, usingExtension } from "sap/fe/core/helpers/ClassSupport";
+import ModelHelper, { InternalModelContext } from "sap/fe/core/helpers/ModelHelper";
+import PageController from "sap/fe/core/PageController";
+import ChartRuntime from "sap/fe/macros/chart/ChartRuntime";
+import CommonHelper from "sap/fe/macros/CommonHelper";
+import DelegateUtil from "sap/fe/macros/DelegateUtil";
+import TableUtils from "sap/fe/macros/table/Utils";
+import SelectionVariant from "sap/fe/navigation/SelectionVariant";
+import { default as ExtensionAPI, default as ObjectPageExtensionAPI } from "sap/fe/templates/ObjectPage/ExtensionAPI";
+import RootContainerBaseController from "sap/fe/templates/RootContainer/controller/RootContainerBaseController";
+import EditFlowOverrides from "sap/fe/templates/RootContainer/overrides/EditFlow";
+import TableScroller from "sap/fe/templates/TableScroller";
+import InstanceManager from "sap/m/InstanceManager";
+import Link from "sap/m/Link";
+import MessageBox from "sap/m/MessageBox";
+import Popover from "sap/m/Popover";
+import SelectList from "sap/m/SelectList";
+import Event from "sap/ui/base/Event";
+import Control from "sap/ui/core/Control";
+import Fragment from "sap/ui/core/Fragment";
+import Item from "sap/ui/core/Item";
+import OverrideExecution from "sap/ui/core/mvc/OverrideExecution";
+import XMLPreprocessor from "sap/ui/core/util/XMLPreprocessor";
+import XMLTemplateProcessor from "sap/ui/core/XMLTemplateProcessor";
+import JSONModel from "sap/ui/model/json/JSONModel";
+import Context from "sap/ui/model/odata/v4/Context";
+import ODataListBinding from "sap/ui/model/odata/v4/ODataListBinding";
+import ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
+import ODataModel from "sap/ui/model/odata/v4/ODataModel";
+import ResourceModel from "sap/ui/model/resource/ResourceModel";
+import ObjectPageDynamicHeaderTitle from "sap/uxap/ObjectPageDynamicHeaderTitle";
+import ObjectPageLayout from "sap/uxap/ObjectPageLayout";
+import ObjectPageSection from "sap/uxap/ObjectPageSection";
+import ObjectPageSubSection from "sap/uxap/ObjectPageSubSection";
+import IntentBasedNavigationOverride from "./overrides/IntentBasedNavigation";
+import InternalRoutingOverride from "./overrides/InternalRouting";
+import MessageHandlerOverride from "./overrides/MessageHandler";
+import PaginatorOverride from "./overrides/Paginator";
+import ShareOverrides from "./overrides/Share";
+import ViewStateOverrides from "./overrides/ViewState";
+
+@defineUI5Class("sap.fe.templates.ObjectPage.ObjectPageController")
+class ObjectPageController extends PageController {
+	@usingExtension(Placeholder)
+	placeholder!: Placeholder;
+	@usingExtension(EditFlow)
+	editFlow!: EditFlow;
+	@usingExtension(Share.override(ShareOverrides))
+	share!: Share;
+	@usingExtension(InternalEditFlow.override(EditFlowOverrides))
+	_editFlow!: InternalEditFlow;
+	@usingExtension(InternalRouting.override(InternalRoutingOverride))
+	_routing!: InternalRouting;
+	@usingExtension(Paginator.override(PaginatorOverride))
+	paginator!: Paginator;
+	@usingExtension(MessageHandler.override(MessageHandlerOverride))
+	messageHandler!: MessageHandler;
+	@usingExtension(IntentBasedNavigation.override(IntentBasedNavigationOverride))
+	intentBasedNavigation!: IntentBasedNavigation;
+	@usingExtension(
+		InternalIntentBasedNavigation.override({
+			getNavigationMode: function (this: InternalIntentBasedNavigation) {
+				const bIsStickyEditMode =
+					(this.getView().getController() as ObjectPageController).getStickyEditMode &&
+					(this.getView().getController() as ObjectPageController).getStickyEditMode();
+				return bIsStickyEditMode ? "explace" : undefined;
+			}
+		})
+	)
+	_intentBasedNavigation!: InternalIntentBasedNavigation;
+	@usingExtension(ViewState.override(ViewStateOverrides))
+	viewState!: ViewState;
+	@usingExtension(
+		PageReady.override({
+			isContextExpected: function () {
+				return true;
+			}
+		})
+	)
+	pageReady!: PageReady;
+	@usingExtension(MassEdit)
+	massEdit!: MassEdit;
+	private mCustomSectionExtensionAPIs?: Record<string, ObjectPageExtensionAPI>;
+	private extensionAPI?: ObjectPageExtensionAPI;
+	private oResourceBundle?: ResourceBundle;
+	private bSectionNavigated?: boolean;
+	private switchDraftAndActivePopOver?: Popover;
+
+	@publicExtension()
+	@finalExtension()
+	getExtensionAPI(sId?: string): ExtensionAPI {
+		if (sId) {
+			// to allow local ID usage for custom pages we'll create/return own instances for custom sections
+			this.mCustomSectionExtensionAPIs = this.mCustomSectionExtensionAPIs || {};
+
+			if (!this.mCustomSectionExtensionAPIs[sId]) {
+				this.mCustomSectionExtensionAPIs[sId] = new ExtensionAPI(this, sId);
+			}
+			return this.mCustomSectionExtensionAPIs[sId];
+		} else {
+			if (!this.extensionAPI) {
+				this.extensionAPI = new ExtensionAPI(this);
+			}
+			return this.extensionAPI;
+		}
+	}
+
+	onInit() {
+		super.onInit();
+		const oObjectPage = this._getObjectPageLayoutControl();
+
+		// Setting defaults of internal model context
+		const oInternalModelContext = this.getView().getBindingContext("internal") as InternalModelContext;
+		oInternalModelContext.setProperty("externalNavigationContext", { "page": true });
+		oInternalModelContext.setProperty("relatedApps", {
+			visibility: false,
+			items: null
+		});
+		oInternalModelContext.setProperty("batchGroups", this._getBatchGroupsForView());
+		oInternalModelContext.setProperty("errorNavigationSectionFlag", false);
+		if (!(this.getView().getViewData() as any).useNewLazyLoading && (oObjectPage as any).getEnableLazyLoading()) {
+			//Attaching the event to make the subsection context binding active when it is visible.
+			oObjectPage.attachEvent("subSectionEnteredViewPort", this._handleSubSectionEnteredViewPort.bind(this));
+		}
+	}
+
+	onExit() {
+		if (this.mCustomSectionExtensionAPIs) {
+			for (const sId of Object.keys(this.mCustomSectionExtensionAPIs)) {
+				this.mCustomSectionExtensionAPIs[sId] && this.mCustomSectionExtensionAPIs[sId].destroy();
+			}
+			delete this.mCustomSectionExtensionAPIs;
+		}
+		this.extensionAPI && this.extensionAPI.destroy();
+		delete this.extensionAPI;
+
+		const oMessageButton = this.getView().byId("fe::FooterBar::MessageButton"),
+			oMessagePopover = oMessageButton ? (oMessageButton as any).oMessagePopover : null;
+		if (oMessagePopover && oMessagePopover.isOpen()) {
+			oMessagePopover.close();
+		}
+	}
+
+	_getTableBinding(oTable: any) {
+		return oTable && oTable.getRowBinding();
+	}
+
+	onBeforeRendering() {
+		PageController.prototype.onBeforeRendering.apply(this);
+	}
+
+	onAfterRendering() {
+		((this.getView().getModel("sap.fe.i18n") as ResourceModel).getResourceBundle() as Promise<ResourceBundle>)
+			.then((response: any) => {
+				this.oResourceBundle = response;
+			})
+			.catch(function (oError: any) {
+				Log.error("Error while retrieving the resource bundle", oError);
+			});
+	}
+
+	_onBeforeBinding(oContext: any, mParameters: any) {
+		// TODO: we should check how this comes together with the transaction helper, same to the change in the afterBinding
+		const aTables = this._findTables(),
+			oObjectPage = this._getObjectPageLayoutControl() as ObjectPageLayout,
+			oInternalModelContext = this.getView().getBindingContext("internal") as InternalModelContext,
+			oInternalModel = this.getView().getModel("internal") as JSONModel,
+			aBatchGroups = oInternalModelContext.getProperty("batchGroups"),
+			iViewLevel = (this.getView().getViewData() as any).viewLevel;
+		let oFastCreationRow;
+		aBatchGroups.push("$auto");
+		if (mParameters.bDraftNavigation !== true) {
+			this._closeSideContent();
+		}
+		const opContext = oObjectPage.getBindingContext() as Context;
+		if (
+			opContext &&
+			opContext.hasPendingChanges() &&
+			!aBatchGroups.some((opContext.getModel() as ODataModel).hasPendingChanges.bind(opContext.getModel()))
+		) {
+			/* 	In case there are pending changes for the creation row and no others we need to reset the changes
+    						TODO: this is just a quick solution, this needs to be reworked
+    				 	*/
+
+			opContext.getBinding().resetChanges();
+		}
+
+		// For now we have to set the binding context to null for every fast creation row
+		// TODO: Get rid of this coding or move it to another layer - to be discussed with MDC and model
+		for (let i = 0; i < aTables.length; i++) {
+			oFastCreationRow = aTables[i].getCreationRow();
+			if (oFastCreationRow) {
+				oFastCreationRow.setBindingContext(null);
+			}
+		}
+
+		// Scroll to present Section so that bindings are enabled during navigation through paginator buttons, as there is no view rerendering/rebind
+		const fnScrollToPresentSection = function () {
+			if (!(oObjectPage as any).isFirstRendering() && !mParameters.bPersistOPScroll) {
+				oObjectPage.setSelectedSection(null as any);
+			}
+		};
+		oObjectPage.attachEventOnce("modelContextChange", fnScrollToPresentSection);
+
+		// if the structure of the ObjectPageLayout is changed then scroll to present Section
+		// FIXME Is this really working as intended ? Initially this was onBeforeRendering, but never triggered onBeforeRendering because it was registered after it
+		const oDelegateOnBefore = {
+			onAfterRendering: fnScrollToPresentSection
+		};
+		oObjectPage.addEventDelegate(oDelegateOnBefore, this);
+		this.pageReady.attachEventOnce("pageReady", function () {
+			oObjectPage.removeEventDelegate(oDelegateOnBefore);
+		});
+
+		//Set the Binding for Paginators using ListBinding ID
+		if (iViewLevel > 1) {
+			let oBinding = mParameters && mParameters.listBinding;
+			const oPaginatorCurrentContext = oInternalModel.getProperty("/paginatorCurrentContext");
+			if (oPaginatorCurrentContext) {
+				const oBindingToUse = oPaginatorCurrentContext.getBinding();
+				this.paginator.initialize(oBindingToUse, oPaginatorCurrentContext);
+				oInternalModel.setProperty("/paginatorCurrentContext", null);
+			} else if (oBinding) {
+				if (oBinding.isA("sap.ui.model.odata.v4.ODataListBinding")) {
+					this.paginator.initialize(oBinding, oContext);
+				} else {
+					//if the binding type is not ODataListBinding because of a deeplink navigation or a refresh of the page
+					// we need to create it
+					const sContextPath = oBinding.getPath().replace(/\([^\)]*\)*$/, ""); //removing the last tuple
+					oBinding = new (ODataListBinding as any)(oBinding.oModel, "", oBinding.oModel.createBindingContext(sContextPath));
+					const _setListBindingAsync = () => {
+						if (oBinding.getContexts().length > 0) {
+							this.paginator.initialize(oBinding, oContext);
+							oBinding.detachEvent("change", _setListBindingAsync);
+						}
+					};
+					oBinding.getContexts(0);
+					oBinding.attachEvent("change", _setListBindingAsync);
+				}
+			}
+		}
+		if (!(this.getView().getViewData() as any).useNewLazyLoading && oObjectPage.getEnableLazyLoading()) {
+			const aSections = oObjectPage.getSections();
+			const bUseIconTabBar = oObjectPage.getUseIconTabBar();
+			let iSkip = 2;
+			const bIsInEditMode = oObjectPage.getModel("ui").getProperty("/isEditable");
+			const bEditableHeader = (this.getView().getViewData() as any).editableHeaderContent;
+			for (let iSection = 0; iSection < aSections.length; iSection++) {
+				const oSection = aSections[iSection];
+				const aSubSections = oSection.getSubSections();
+				for (let iSubSection = 0; iSubSection < aSubSections.length; iSubSection++, iSkip--) {
+					// In IconTabBar mode keep the second section bound if there is an editable header and we are switching to display mode
+					if (iSkip < 1 || (bUseIconTabBar && (iSection > 1 || (iSection === 1 && !bEditableHeader && !bIsInEditMode)))) {
+						const oSubSection = aSubSections[iSubSection];
+						if (oSubSection.data().isVisibilityDynamic !== "true") {
+							oSubSection.setBindingContext(null as any);
+						}
+					}
+				}
+			}
+		}
+
+		if (this.placeholder.isPlaceholderEnabled() && mParameters.showPlaceholder) {
+			const oView = this.getView();
+			const oNavContainer = (oView.getParent() as any).oContainer.getParent();
+			if (oNavContainer) {
+				oNavContainer.showPlaceholder({});
+			}
+		}
+	}
+
+	_getFirstClickableElement(oObjectPage: any) {
+		let oFirstClickableElement;
+		const aActions = oObjectPage.getHeaderTitle() && oObjectPage.getHeaderTitle().getActions();
+		if (aActions && aActions.length) {
+			oFirstClickableElement = aActions.find(function (oAction: any) {
+				// Due to the left alignment of the Draft switch and the collaborative draft avatar controls
+				// there is a ToolbarSpacer in the actions aggregation which we need to exclude here!
+				return !oAction.isA("sap.m.ToolbarSpacer") && oAction.getVisible() && oAction.getEnabled();
+			});
+		}
+		return oFirstClickableElement;
+	}
+
+	_getFirstEmptyMandatoryFieldFromSubSection(aSubSections: any) {
+		if (aSubSections) {
+			for (let subSection = 0; subSection < aSubSections.length; subSection++) {
+				const aBlocks = aSubSections[subSection].getBlocks();
+
+				if (aBlocks) {
+					for (let block = 0; block < aBlocks.length; block++) {
+						let aFormContainers;
+
+						if (aBlocks[block].isA("sap.ui.layout.form.Form")) {
+							aFormContainers = aBlocks[block].getFormContainers();
+						} else if (
+							aBlocks[block].getContent &&
+							aBlocks[block].getContent() &&
+							aBlocks[block].getContent().isA("sap.ui.layout.form.Form")
+						) {
+							aFormContainers = aBlocks[block].getContent().getFormContainers();
+						}
+
+						if (aFormContainers) {
+							for (let formContainer = 0; formContainer < aFormContainers.length; formContainer++) {
+								const aFormElements = aFormContainers[formContainer].getFormElements();
+								if (aFormElements) {
+									for (let formElement = 0; formElement < aFormElements.length; formElement++) {
+										const aFields = aFormElements[formElement].getFields();
+
+										// The first field is not necessarily an InputBase (e.g. could be a Text)
+										// So we need to check whether it has a getRequired method
+										try {
+											if (aFields[0].getRequired && aFields[0].getRequired() && !aFields[0].getValue()) {
+												return aFields[0];
+											}
+										} catch (error) {
+											Log.debug("Error when searching for mandaotry empty field: " + error);
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		return undefined;
+	}
+
+	_updateFocusInEditMode(aSubSections: any) {
+		const oObjectPage = this._getObjectPageLayoutControl() as ObjectPageLayout;
+
+		const oMandatoryField = this._getFirstEmptyMandatoryFieldFromSubSection(aSubSections);
+		let oFieldToFocus: any;
+		if (oMandatoryField) {
+			oFieldToFocus = oMandatoryField.content.getContentEdit()[0];
+		} else {
+			oFieldToFocus = (oObjectPage as any)._getFirstEditableInput() || this._getFirstClickableElement(oObjectPage);
+		}
+
+		if (oFieldToFocus) {
+			setTimeout(function () {
+				// We set the focus in a timeeout, otherwise the focus sometimes goes to the TabBar
+				oFieldToFocus.focus();
+			}, 0);
+		}
+	}
+
+	_handleSubSectionEnteredViewPort(oEvent: any) {
+		const oSubSection = oEvent.getParameter("subSection");
+		oSubSection.setBindingContext(undefined);
+	}
+
+	_onBackNavigationInDraft(oContext: any) {
+		if (this.getAppComponent().getRouterProxy().checkIfBackHasSameContext()) {
+			// Back nav will keep the same context --> no need to display the dialog
+			history.back();
+		} else {
+			CommonUtils.fnProcessDataLossOrDraftDiscardConfirmation(
+				function () {
+					history.back();
+				},
+				Function.prototype,
+				oContext,
+				this,
+				false
+			);
+		}
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	_onAfterBinding(oBindingContext: any, mParameters: any) {
+		const oObjectPage = this._getObjectPageLayoutControl() as ObjectPageLayout;
+		const aTables = this._findTables();
+
+		this._sideEffects.clearPropertiesStatus();
+
+		// TODO: this is only a temp solution as long as the model fix the cache issue and we use this additional
+		// binding with ownRequest
+		oBindingContext = oObjectPage.getBindingContext();
+
+		let aIBNActions: any[] = [];
+		oObjectPage.getSections().forEach(function (oSection: any) {
+			oSection.getSubSections().forEach(function (oSubSection: any) {
+				aIBNActions = CommonUtils.getIBNActions(oSubSection, aIBNActions);
+			});
+		});
+
+		// Assign internal binding contexts to oFormContainer:
+		// 1. It is not possible to assign the internal binding context to the XML fragment
+		// (FormContainer.fragment.xml) yet - it is used already for the data-structure.
+		// 2. Another problem is, that FormContainers assigned to a 'MoreBlock' does not have an
+		// internal model context at all.
+
+		aTables.forEach(function (oTable: any) {
+			const oInternalModelContext = oTable.getBindingContext("internal");
+			oInternalModelContext.setProperty("creationRowFieldValidity", {});
+			oInternalModelContext.setProperty("creationRowCustomValidity", {});
+
+			aIBNActions = CommonUtils.getIBNActions(oTable, aIBNActions);
+			// temporary workaround for BCP: 2080218004
+			// Need to fix with BLI: FIORITECHP1-15274
+			// only for edit mode, we clear the table cache
+			// Workaround starts here!!
+			const oTableRowBinding = oTable.getRowBinding();
+			if (oTableRowBinding) {
+				if (ModelHelper.isStickySessionSupported(oTableRowBinding.getModel().getMetaModel())) {
+					// apply for both edit and display mode in sticky
+					oTableRowBinding.removeCachesAndMessages("");
+				}
+			}
+			// Workaround ends here!!
+
+			// Update 'enabled' property of DataFieldForAction buttons on table toolbar
+			// The same is also performed on Table selectionChange event
+			const oActionOperationAvailableMap = JSON.parse(
+					CommonHelper.parseCustomData(DelegateUtil.getCustomData(oTable, "operationAvailableMap")) as any
+				),
+				aSelectedContexts = oTable.getSelectedContexts();
+
+			CommonUtils.setActionEnablement(oInternalModelContext, oActionOperationAvailableMap, aSelectedContexts);
+		});
+		CommonUtils.getSemanticTargetsFromPageModel(this, "_pageModel");
+		//Retrieve Object Page header actions from Object Page title control
+		const oObjectPageTitle = oObjectPage.getHeaderTitle();
+		let aIBNHeaderActions: any[] = [];
+		aIBNHeaderActions = CommonUtils.getIBNActions(oObjectPageTitle, aIBNHeaderActions);
+		aIBNActions = aIBNActions.concat(aIBNHeaderActions);
+		CommonUtils.updateDataFieldForIBNButtonsVisibility(aIBNActions, this.getView());
+
+		let oModel: any, oFinalUIState: any;
+
+		// TODO: this should be moved into an init event of the MDC tables (not yet existing) and should be part
+		// of any controller extension
+		/**
+		 * @param oTable
+		 * @param oListBinding
+		 */
+		function enableFastCreationRow(oTable: any, oListBinding: any) {
+			const oFastCreationRow = oTable.getCreationRow();
+			let oFastCreationListBinding, oFastCreationContext;
+
+			if (oFastCreationRow) {
+				oFinalUIState
+					.then(function () {
+						if (oFastCreationRow.getModel("ui").getProperty("/isEditable")) {
+							oFastCreationListBinding = oModel.bindList(oListBinding.getPath(), oListBinding.getContext(), [], [], {
+								$$updateGroupId: "doNotSubmit",
+								$$groupId: "doNotSubmit"
+							});
+							// Workaround suggested by OData model v4 colleagues
+							oFastCreationListBinding.refreshInternal = function () {
+								/* do nothing */
+							};
+							/*
+    															oFastCreationListBinding.hasPendingChanges = function() {
+    								return false;
+    							};
+    															*/
+
+							oFastCreationContext = oFastCreationListBinding.create();
+							oFastCreationRow.setBindingContext(oFastCreationContext);
+
+							// this is needed to avoid console error
+							oFastCreationContext.created().catch(function () {
+								Log.trace("transient fast creation context deleted");
+							});
+						}
+					})
+					.catch(function (oError: any) {
+						Log.error("Error while computing the final UI state", oError);
+					});
+			}
+		}
+
+		// this should not be needed at the all
+		/**
+		 * @param oTable
+		 */
+		const handleTableModifications = (oTable: any) => {
+			const oBinding = this._getTableBinding(oTable),
+				fnHandleTablePatchEvents = function () {
+					enableFastCreationRow(oTable, oBinding);
+				};
+
+			if (!oBinding) {
+				Log.error("Expected binding missing for table: " + oTable.getId());
+				return;
+			}
+
+			if (oBinding.oContext) {
+				fnHandleTablePatchEvents();
+			} else {
+				const fnHandleChange = function () {
+					if (oBinding.oContext) {
+						fnHandleTablePatchEvents();
+						oBinding.detachChange(fnHandleChange);
+					}
+				};
+				oBinding.attachChange(fnHandleChange);
+			}
+		};
+
+		if (oBindingContext) {
+			oModel = oBindingContext.getModel();
+
+			// Compute Edit Mode
+			oFinalUIState = this._editFlow.computeEditMode(oBindingContext);
+
+			if (ModelHelper.isCollaborationDraftSupported(oModel.getMetaModel())) {
+				oFinalUIState
+					.then(() => {
+						if (this.getView().getModel("ui").getProperty("/isEditable")) {
+							connect(this.getView());
+						}
+					})
+					.catch(function (oError: any) {
+						Log.error("Error while waiting for the final UI State", oError);
+					});
+			}
+
+			// update related apps once Data is received in case of binding cache is not available
+			// TODO: this is only a temp solution since we need to call _updateRelatedApps method only after data for Object Page is received (if there is no binding)
+			if (oBindingContext.getBinding().oCache) {
+				this._updateRelatedApps();
+			} else {
+				const fnUpdateRelatedApps = () => {
+					this._updateRelatedApps();
+					oBindingContext.getBinding().detachDataReceived(fnUpdateRelatedApps);
+				};
+				oBindingContext.getBinding().attachDataReceived(fnUpdateRelatedApps);
+			}
+
+			//Attach the patch sent and patch completed event to the object page binding so that we can react
+			const oBinding = (oBindingContext.getBinding && oBindingContext.getBinding()) || oBindingContext;
+			oBinding.attachEvent("patchSent", this.editFlow.handlePatchSent, this);
+
+			aTables.forEach(function (oTable: any) {
+				// access binding only after table is bound
+				TableUtils.whenBound(oTable)
+					.then(handleTableModifications)
+					.catch(function (oError: any) {
+						Log.error("Error while waiting for the table to be bound", oError);
+					});
+			});
+
+			if (!(this.getView().getViewData() as any).useNewLazyLoading) {
+				// should be called only after binding is ready hence calling it in onAfterBinding
+				(oObjectPage as any)._triggerVisibleSubSectionsEvents();
+			}
+		}
+	}
+
+	@publicExtension()
+	@extensible(OverrideExecution.After)
+	onPageReady(mParameters: any) {
+		// Apply app state only after the page is ready with the first section selected
+		const oView = this.getView();
+		const oInternalModelContext = oView.getBindingContext("internal") as InternalModelContext;
+		const oBindingContext = oView.getBindingContext();
+		//Show popup while navigating back from object page in case of draft
+		if (oBindingContext) {
+			const bIsStickyMode = ModelHelper.isStickySessionSupported((oBindingContext.getModel() as ODataModel).getMetaModel());
+			if (!bIsStickyMode) {
+				const oAppComponent = CommonUtils.getAppComponent(oView);
+				oAppComponent.getShellServices().setBackNavigation(() => this._onBackNavigationInDraft(oBindingContext));
+			}
+		}
+		this.getAppComponent().getAppStateHandler().applyAppState();
+
+		if (mParameters.forceFocus) {
+			const oObjectPage = this._getObjectPageLayoutControl() as ObjectPageLayout;
+			// set the focus to the first action button, or to the first editable input if in editable mode
+			const isInDisplayMode = !oObjectPage.getModel("ui").getProperty("/isEditable");
+			const aVisibleSections = oObjectPage.getSections().filter(function (oSection) {
+				return oSection.getVisible() === true;
+			});
+			// Select the first visible section
+			oObjectPage.setSelectedSection(aVisibleSections[0].getId());
+
+			if (isInDisplayMode) {
+				const oFirstClickableElement = this._getFirstClickableElement(oObjectPage);
+				if (oFirstClickableElement) {
+					oFirstClickableElement.focus();
+				}
+			} else {
+				let aVisibleSubSections;
+				if ((oView.getViewData() as any).sectionLayout === "Tabs") {
+					// In a tabbed layout, only the subsections of the selected section are visible on the screen
+					aVisibleSubSections = aVisibleSections[0].getSubSections();
+				} else {
+					// In a paged layout, all subsections of the visible sections are visible on the screen
+					aVisibleSubSections = (
+						aVisibleSections.map(function (oSection: any) {
+							return oSection.getSubSections();
+						}) as any
+					).flat();
+				}
+				this._updateFocusInEditMode(aVisibleSubSections);
+			}
+		}
+
+		oInternalModelContext.setProperty("errorNavigationSectionFlag", false);
+		this._checkDataPointTitleForExternalNavigation();
+	}
+
+	/**
+	 * Get the status of edit mode for sticky session.
+	 *
+	 * @returns {boolean} The status of edit mode for sticky session
+	 *
+	 *
+	 */
+	getStickyEditMode() {
+		const oBindingContext = this.getView().getBindingContext && (this.getView().getBindingContext() as Context);
+		let bIsStickyEditMode = false;
+		if (oBindingContext) {
+			const bIsStickyMode = ModelHelper.isStickySessionSupported(oBindingContext.getModel().getMetaModel() as ODataMetaModel);
+			if (bIsStickyMode) {
+				bIsStickyEditMode = this.getView().getModel("ui").getProperty("/isEditable");
+			}
+		}
+		return bIsStickyEditMode;
+	}
+
+	_getObjectPageLayoutControl() {
+		return this.byId("fe::ObjectPage") as ObjectPageLayout;
+	}
+
+	_getPageTitleInformation() {
+		const oObjectPage = this._getObjectPageLayoutControl();
+		const oObjectPageSubtitle = oObjectPage.getCustomData().find(function (oCustomData: any) {
+			return oCustomData.getKey() === "ObjectPageSubtitle";
+		});
+		const oTitleInfo = {
+			title: oObjectPage.data("ObjectPageTitle") || "",
+			subtitle: oObjectPageSubtitle && oObjectPageSubtitle.getValue(),
+			intent: "",
+			icon: ""
+		};
+
+		return oTitleInfo;
+	}
+
+	_executeHeaderShortcut(sId: any) {
+		const sButtonId = this.getView().getId() + "--" + sId,
+			oButton = (this._getObjectPageLayoutControl().getHeaderTitle() as ObjectPageDynamicHeaderTitle)
+				.getActions()
+				.find(function (oElement: any) {
+					return oElement.getId() === sButtonId;
+				});
+		CommonUtils.fireButtonPress(oButton);
+	}
+
+	_executeFooterShortcut(sId: any) {
+		const sButtonId = this.getView().getId() + "--" + sId,
+			oButton = (this._getObjectPageLayoutControl().getFooter() as any).getContent().find(function (oElement: any) {
+				return oElement.getMetadata().getName() === "sap.m.Button" && oElement.getId() === sButtonId;
+			});
+		CommonUtils.fireButtonPress(oButton);
+	}
+
+	_executeTabShortCut(oExecution: any) {
+		const oObjectPage = this._getObjectPageLayoutControl(),
+			aSections = oObjectPage.getSections(),
+			iSectionIndexMax = aSections.length - 1,
+			sCommand = oExecution.oSource.getCommand();
+		let newSection,
+			iSelectedSectionIndex = oObjectPage.indexOfSection(this.byId(oObjectPage.getSelectedSection()) as ObjectPageSection);
+		if (iSelectedSectionIndex !== -1 && iSectionIndexMax > 0) {
+			if (sCommand === "NextTab") {
+				if (iSelectedSectionIndex <= iSectionIndexMax - 1) {
+					newSection = aSections[++iSelectedSectionIndex];
+				}
+			} else {
+				// PreviousTab
+				if (iSelectedSectionIndex !== 0) {
+					newSection = aSections[--iSelectedSectionIndex];
+				}
+			}
+			if (newSection) {
+				oObjectPage.setSelectedSection(newSection);
+				newSection.focus();
+			}
+		}
+	}
+
+	_getFooterVisibility() {
+		const oInternalModelContext = this.getView().getBindingContext("internal") as InternalModelContext;
+		const sViewId = this.getView().getId();
+		oInternalModelContext.setProperty("messageFooterContainsErrors", false);
+		sap.ui
+			.getCore()
+			.getMessageManager()
+			.getMessageModel()
+			.getData()
+			.forEach(function (oMessage: any) {
+				if (oMessage.validation && oMessage.type === "Error" && oMessage.target.indexOf(sViewId) > -1) {
+					oInternalModelContext.setProperty("messageFooterContainsErrors", true);
+				}
+			});
+	}
+
+	_showMessagePopover(err?: any, oRet?: any) {
+		if (err) {
+			Log.error(err);
+		}
+		if (!(this.getAppComponent().getRootContainer() as any).getCurrentPage().isA("sap.m.MessagePage")) {
+			const oMessageButton = this.getView().byId("fe::FooterBar::MessageButton") as any,
+				oMessagePopover = oMessageButton.oMessagePopover,
+				oItemBinding = oMessagePopover.getBinding("items");
+
+			if (oItemBinding.getLength() > 0 && !oMessagePopover.isOpen()) {
+				oMessageButton.setVisible(true);
+				// workaround to ensure that oMessageButton is rendered when openBy is called
+				setTimeout(function () {
+					oMessagePopover.openBy(oMessageButton);
+				}, 0);
+			}
+		}
+		return oRet;
+	}
+
+	_editDocument(oContext: any) {
+		const oModel = this.getView().getModel("ui");
+		BusyLocker.lock(oModel);
+		return this.editFlow.editDocument.apply(this.editFlow, [oContext]).finally(function () {
+			BusyLocker.unlock(oModel);
+		});
+	}
+
+	_saveDocument(oContext: any) {
+		const oModel = this.getView().getModel("ui"),
+			aWaitCreateDocuments: any[] = [];
+		// indicates if we are creating a new row in the OP
+		let bExecuteSideEffectsOnError = false;
+		BusyLocker.lock(oModel);
+		this._findTables().forEach((oTable: any) => {
+			const oBinding = this._getTableBinding(oTable);
+			const mParameters: any = {
+				creationMode: oTable.data("creationMode"),
+				creationRow: oTable.getCreationRow(),
+				createAtEnd: oTable.data("createAtEnd") === "true"
+			};
+			const bCreateDocument =
+				mParameters.creationRow &&
+				mParameters.creationRow.getBindingContext() &&
+				Object.keys(mParameters.creationRow.getBindingContext().getObject()).length > 1;
+			if (bCreateDocument) {
+				// the bSkipSideEffects is a parameter created when we click the save key. If we press this key
+				// we don't execute the handleSideEffects funciton to avoid batch redundancy
+				mParameters.bSkipSideEffects = true;
+				bExecuteSideEffectsOnError = true;
+				aWaitCreateDocuments.push(
+					this.editFlow.createDocument(oBinding, mParameters).then(function () {
+						return oBinding;
+					})
+				);
+			}
+		});
+		return Promise.all(aWaitCreateDocuments)
+			.then((aBindings: any[]) => {
+				const mParameters = {
+					bExecuteSideEffectsOnError: bExecuteSideEffectsOnError,
+					bindings: aBindings
+				};
+				return this.editFlow.saveDocument(oContext, mParameters).catch(() => this._showMessagePopover);
+			})
+			.finally(function () {
+				if (BusyLocker.isLocked(oModel)) {
+					BusyLocker.unlock(oModel);
+				}
+			});
+	}
+
+	_manageCollaboration() {
+		openManageDialog(this.getView());
+	}
+
+	_showCollaborationUserDetails(event: any) {
+		showUserDetails(event, this.getView());
+	}
+
+	_cancelDocument(oContext: any, mParameters: any) {
+		mParameters.cancelButton = this.getView().byId(mParameters.cancelButton); //to get the reference of the cancel button from command execution
+		return this.editFlow.cancelDocument(oContext, mParameters);
+	}
+
+	_applyDocument(oContext: any) {
+		return this.editFlow.applyDocument(oContext).catch(() => this._showMessagePopover());
+	}
+
+	_showSwitchDraftAndActivePopover(event: Event) {
+		const view = this.getView(),
+			source = event.getSource(),
+			fragmentName = "sap.fe.templates.ObjectPage.view.fragments.SwitchDraftAndActiveObjectPopOver";
+
+		if (this.switchDraftAndActivePopOver) {
+			this.switchDraftAndActivePopOver.openBy(source, false);
+		} else {
+			const localThisModel = new JSONModel({}),
+				preprocessorSettings = {
+					bindingContexts: {
+						"this": localThisModel.createBindingContext("/")
+					},
+					models: {
+						"this": localThisModel
+					}
+				};
+			const popoverFragment = XMLTemplateProcessor.loadTemplate(fragmentName, "fragment");
+			Promise.resolve(XMLPreprocessor.process(popoverFragment, { name: fragmentName }, preprocessorSettings))
+				.then((fragment) => {
+					return Fragment.load({ definition: fragment, controller: this });
+				})
+				.then((popover: any) => {
+					view.addDependent(popover);
+					popover.setModel(view.getModel("sap.fe.i18n"), "i18n");
+					popover.setPlacement("Bottom"); // TODO
+					this.switchDraftAndActivePopOver = popover;
+					popover.attachAfterOpen(() => {
+						// While the list entry corresponding to the currently displayed document version is emphasized with a blue
+						// background, we need to pre-focus the other entry
+						const context: any = this.getView().getBindingContext(),
+							isActiveEntity = context.getObject().IsActiveEntity;
+						const switchDraftAndActiveOptionsList: SelectList = (popover.getContent() as unknown as Control[]).find(
+							(element) => element.data("listIdentifier") === "switchDraftAndActivePopoverList"
+						) as SelectList;
+						const listItemToFocus: Item = isActiveEntity
+							? (switchDraftAndActiveOptionsList.getItems().find((element) => element.getKey() === "switchToDraft") as Item)
+							: (switchDraftAndActiveOptionsList.getItems().find((element) => element.getKey() === "switchToActive") as Item);
+						listItemToFocus.focus();
+					});
+					popover.openBy(source);
+					// ensure to remove the reference to the draft popover as it would be destroyed on exit
+					view.attachEventOnce("beforeExit", () => {
+						delete this.switchDraftAndActivePopOver;
+					});
+				})
+				.catch(function (Error) {
+					Log.error("Error while opening the draft switch popup", Error);
+				});
+		}
+	}
+
+	_switchDraftAndActivePopoverListSelect(event: Event) {
+		const context: any = this.getView().getBindingContext(),
+			selectedItemKey = event.getParameter("item").getProperty("key"),
+			isActiveEntity = context.getObject().IsActiveEntity;
+		// It was decided that we should NOT set the entry in the list corresponding to the currently displayed document version to
+		// disabled, hence the user can click entries which to not cause an action (clicking "Draft" when you already display the
+		// draft version of the document)
+		// Hence we check here which entry in the list was clicked and which document version we currently display and only do
+		// the switch between draft / active version if it makes sense.
+		if ((isActiveEntity && selectedItemKey === "switchToDraft") || (!isActiveEntity && selectedItemKey === "switchToActive")) {
+			this.editFlow.toggleDraftActive(context);
+		}
+		((event.getSource() as Control).getParent() as Popover).close();
+	}
+
+	_updateRelatedApps() {
+		const oObjectPage = this._getObjectPageLayoutControl();
+		if (CommonUtils.resolveStringtoBoolean(oObjectPage.data("showRelatedApps"))) {
+			CommonUtils.updateRelatedAppsDetails(oObjectPage);
+		}
+	}
+
+	_findTableInSubSection(aParentElement: any, aSubsection: any, aTables: any) {
+		const aSubSectionTables = [];
+		for (let element = 0; element < aParentElement.length; element++) {
+			let oElement = aParentElement[element].getContent instanceof Function && aParentElement[element].getContent();
+			if (oElement && oElement.isA && oElement.isA("sap.ui.layout.DynamicSideContent")) {
+				oElement = oElement.getMainContent instanceof Function && oElement.getMainContent();
+				if (oElement && oElement.length > 0) {
+					oElement = oElement[0];
+				}
+			}
+			if (oElement && oElement.isA && oElement.isA("sap.fe.macros.TableAPI")) {
+				oElement = oElement.getContent instanceof Function && oElement.getContent();
+				if (oElement && oElement.length > 0) {
+					oElement = oElement[0];
+				}
+			}
+			if (oElement && oElement.isA && oElement.isA("sap.ui.mdc.Table")) {
+				aTables.push(oElement);
+				aSubSectionTables.push({
+					"table": oElement,
+					"gridTable": oElement.getType().isA("sap.ui.mdc.table.GridTableType")
+				});
+			}
+		}
+		if (
+			aSubSectionTables.length === 1 &&
+			aParentElement.length === 1 &&
+			aSubSectionTables[0].gridTable &&
+			!aSubsection.hasStyleClass("sapUxAPObjectPageSubSectionFitContainer")
+		) {
+			//In case there is only a single table in a section we fit that to the whole page so that the scrollbar comes only on table and not on page
+			aSubsection.addStyleClass("sapUxAPObjectPageSubSectionFitContainer");
+		} else {
+			if (aSubSectionTables && !aSubsection.hasStyleClass("sapUxAPObjectPageSubSectionFitContainer")) {
+				aSubSectionTables.forEach(function (oTable: { table: any; gridTable: any }) {
+					if (oTable.gridTable) {
+						//Resetting the row count to default value in case we have a combination of forms and tables or multiple tables in a subsection
+						oTable.table.getType().setRowCount(null);
+					}
+				});
+			}
+		}
+	}
+
+	_getAllSubSections() {
+		const oObjectPage = this._getObjectPageLayoutControl();
+		let aSubSections: any[] = [];
+		oObjectPage.getSections().forEach(function (oSection: any) {
+			aSubSections = aSubSections.concat(oSection.getSubSections());
+		});
+		return aSubSections;
+	}
+
+	_getAllBlocks() {
+		let aBlocks: any[] = [];
+		this._getAllSubSections().forEach(function (oSubSection: any) {
+			aBlocks = aBlocks.concat(oSubSection.getBlocks());
+		});
+		return aBlocks;
+	}
+
+	//TODO: This is needed for two workarounds - to be removed again
+	_findTables() {
+		const aSubSections = this._getAllSubSections();
+		const aTables: any[] = [];
+		for (let subSection = 0; subSection < aSubSections.length; subSection++) {
+			this._findTableInSubSection(aSubSections[subSection].getBlocks(), aSubSections[subSection], aTables);
+			this._findTableInSubSection(aSubSections[subSection].getMoreBlocks(), aSubSections[subSection], aTables);
+		}
+		return aTables;
+	}
+
+	_closeSideContent() {
+		this._getAllBlocks().forEach(function (oBlock: any) {
+			const oContent = oBlock.getContent instanceof Function && oBlock.getContent();
+			if (oContent && oContent.isA && oContent.isA("sap.ui.layout.DynamicSideContent")) {
+				if (oContent.setShowSideContent instanceof Function) {
+					oContent.setShowSideContent(false);
+				}
+			}
+		});
+	}
+
+	/**
+	 * Chart Context is resolved for 1:n microcharts.
+	 *
+	 * @param {sap.ui.model.Context} oChartContext The Context of the MicroChart
+	 * @param {string} sChartPath The collectionPath of the the chart
+	 * @returns {Array} Array of Attributes of the chart Context
+	 */
+	_getChartContextData(oChartContext: any, sChartPath: string) {
+		const oContextData = oChartContext.getObject();
+		let oChartContextData = [oContextData];
+		if (oChartContext && sChartPath) {
+			if (oContextData[sChartPath]) {
+				oChartContextData = oContextData[sChartPath];
+				delete oContextData[sChartPath];
+				oChartContextData.push(oContextData);
+			}
+		}
+		return oChartContextData;
+	}
+
+	/**
+	 * Scroll the tables to the row with the sPath
+	 *
+	 * @function
+	 * @name sap.fe.templates.ObjectPage.ObjectPageController.controller#_scrollTablesToRow
+	 * @param {string} sRowPath 'sPath of the table row'
+	 *
+	 */
+
+	_scrollTablesToRow(sRowPath: string) {
+		if (this._findTables && this._findTables().length > 0) {
+			const aTables = this._findTables();
+			for (let i = 0; i < aTables.length; i++) {
+				TableScroller.scrollTableToRow(aTables[i], sRowPath);
+			}
+		}
+	}
+
+	/**
+	 * Method to merge selected contexts and filters.
+	 *
+	 * @function
+	 * @name _mergeMultipleContexts
+	 * @param {object} oPageContext Page context
+	 * @param {object|Array} aLineContext Selected Contexts
+	 * @param {string} sChartPath Collection name of the chart
+	 * @returns {object} Selection Variant Object
+	 */
+	_mergeMultipleContexts(oPageContext: Context, aLineContext: any[], sChartPath: string) {
+		let aAttributes: any[] = [],
+			aPageAttributes = [],
+			oContext,
+			sMetaPathLine: string,
+			sPathLine;
+
+		const sPagePath = oPageContext.getPath();
+		const oMetaModel = oPageContext && oPageContext.getModel() && (oPageContext.getModel().getMetaModel() as ODataMetaModel);
+		const sMetaPathPage = oMetaModel && oMetaModel.getMetaPath(sPagePath).replace(/^\/*/, "");
+
+		// Get single line context if necessary
+		if (aLineContext && aLineContext.length) {
+			oContext = aLineContext[0];
+			sPathLine = oContext.getPath();
+			sMetaPathLine = oMetaModel && oMetaModel.getMetaPath(sPathLine).replace(/^\/*/, "");
+
+			aLineContext.map((oSingleContext: any) => {
+				if (sChartPath) {
+					const oChartContextData = this._getChartContextData(oSingleContext, sChartPath);
+					if (oChartContextData) {
+						aAttributes = oChartContextData.map(function (oChartContextData: any) {
+							return {
+								contextData: oChartContextData,
+								entitySet: sMetaPathPage + "/" + sChartPath
+							};
+						});
+					}
+				} else {
+					aAttributes.push({
+						contextData: oSingleContext.getObject(),
+						entitySet: sMetaPathLine
+					});
+				}
+			});
+		}
+		aPageAttributes.push({
+			contextData: oPageContext.getObject(),
+			entitySet: sMetaPathPage
+		});
+		// Adding Page Context to selection variant
+		aPageAttributes = CommonUtils.removeSensitiveData(aPageAttributes, oMetaModel);
+		const oPageLevelSV = CommonUtils.addPageContextToSelectionVariant(new SelectionVariant(), aPageAttributes, this.getView());
+		aAttributes = CommonUtils.removeSensitiveData(aAttributes, oMetaModel);
+		return {
+			selectionVariant: oPageLevelSV,
+			attributes: aAttributes
+		};
+	}
+
+	_getBatchGroupsForView() {
+		const oViewData = this.getView().getViewData() as any,
+			oConfigurations = oViewData.controlConfiguration,
+			aConfigurations = oConfigurations && Object.keys(oConfigurations),
+			aBatchGroups = ["$auto.Heroes", "$auto.Decoration", "$auto.Workers"];
+
+		if (aConfigurations && aConfigurations.length > 0) {
+			aConfigurations.forEach(function (sKey: any) {
+				const oConfiguration = oConfigurations[sKey];
+				if (oConfiguration.requestGroupId === "LongRunners") {
+					aBatchGroups.push("$auto.LongRunners");
+				}
+			});
+		}
+		return aBatchGroups;
+	}
+
+	/*
+	 * Reset Breadcrumb links
+	 *
+	 * @function
+	 * @param {sap.m.Breadcrumbs} [oSource] parent control
+	 * @description Used when context of the objectpage changes.
+	 *              This event callback is attached to modelContextChange
+	 *              event of the Breadcrumb control to catch context change.
+	 *              Then element binding and hrefs are updated for each Link.
+	 *
+	 * @ui5-restricted
+	 * @experimental
+	 */
+	_setBreadcrumbLinks(oSource: any) {
+		const oContext = oSource.getBindingContext();
+		const oAppComponent = this.getAppComponent();
+		if (oContext) {
+			const sNewPath = oContext.getPath(),
+				aPathParts = sNewPath.split("/"),
+				oMetaModel = oAppComponent.getMetaModel();
+			let sPath = "",
+				iSkipParameterized = 0;
+
+			aPathParts.shift();
+			aPathParts.splice(-1, 1);
+			aPathParts.forEach(function (sPathPart: any, i: any) {
+				sPath += "/" + sPathPart;
+				const oRootViewController = oAppComponent.getRootViewController() as RootContainerBaseController;
+				const sParameterPath = oMetaModel.getMetaPath(sPath);
+				const bResultContext = oMetaModel.getObject(sParameterPath + "/@com.sap.vocabularies.Common.v1.ResultContext");
+				if (bResultContext) {
+					// We dont need to create a breadcrumb for Parameter path
+					iSkipParameterized = 1;
+					return;
+				}
+
+				const pWaitForTitleHiearchyInfo = oRootViewController.getTitleInfoFromPath(sPath);
+
+				pWaitForTitleHiearchyInfo
+					.then(function (oTitleHiearchyInfo: any) {
+						const idx = i - iSkipParameterized,
+							oLink = oSource.getLinks()[idx] ? oSource.getLinks()[idx] : new Link();
+						// sCurrentEntity is a fallback value in case of empty title
+						oLink.setText(oTitleHiearchyInfo.subtitle || oTitleHiearchyInfo.title);
+						oLink.setHref(oTitleHiearchyInfo.intent);
+						if (!oSource.getLinks()[idx]) {
+							oSource.addLink(oLink);
+						}
+					})
+					.catch(function (oError: any) {
+						Log.error("Error while computing the title hierarchy", oError);
+					});
+			});
+		}
+	}
+
+	_checkDataPointTitleForExternalNavigation() {
+		const oView = this.getView();
+		const oInternalModelContext = oView.getBindingContext("internal") as InternalModelContext;
+		const oDataPoints = CommonUtils.getHeaderFacetItemConfigForExternalNavigation(
+			oView.getViewData(),
+			this.getAppComponent().getRoutingService().getOutbounds()
+		);
+		const oShellServices = this.getAppComponent().getShellServices();
+		const oPageContext = oView && (oView.getBindingContext() as Context);
+		oInternalModelContext.setProperty("isHeaderDPLinkVisible", {});
+		if (oPageContext) {
+			oPageContext
+				.requestObject()
+				.then(function (oData: any) {
+					fnGetLinks(oDataPoints, oData);
+				})
+				.catch(function (oError: any) {
+					Log.error("Cannot retrieve the links from the shell service", oError);
+				});
+		}
+
+		/**
+		 * @param oError
+		 */
+		function fnOnError(oError: any) {
+			Log.error(oError);
+		}
+
+		function fnSetLinkEnablement(id: string, aSupportedLinks: any) {
+			const sLinkId = id;
+			// process viable links from getLinks for all datapoints having outbound
+			if (aSupportedLinks && aSupportedLinks.length === 1 && aSupportedLinks[0].supported) {
+				oInternalModelContext.setProperty("isHeaderDPLinkVisible/" + sLinkId, true);
+			}
+		}
+
+		/**
+		 * @param oDataPoints
+		 * @param oPageData
+		 */
+		function fnGetLinks(oDataPoints: any, oPageData: any) {
+			for (const sId in oDataPoints) {
+				const oDataPoint = oDataPoints[sId];
+				const oParams: any = {};
+				const oLink = oView.byId(sId);
+				if (!oLink) {
+					// for data points configured in app descriptor but not annotated in the header
+					continue;
+				}
+				const oLinkContext = oLink.getBindingContext();
+				const oLinkData: any = oLinkContext && oLinkContext.getObject();
+				let oMixedContext: any = merge({}, oPageData, oLinkData);
+				// process semantic object mappings
+				if (oDataPoint.semanticObjectMapping) {
+					const aSemanticObjectMapping = oDataPoint.semanticObjectMapping;
+					for (const item in aSemanticObjectMapping) {
+						const oMapping = aSemanticObjectMapping[item];
+						const sMainProperty = oMapping["LocalProperty"]["$PropertyPath"];
+						const sMappedProperty = oMapping["SemanticObjectProperty"];
+						if (sMainProperty !== sMappedProperty) {
+							if (oMixedContext.hasOwnProperty(sMainProperty)) {
+								const oNewMapping: any = {};
+								oNewMapping[sMappedProperty] = oMixedContext[sMainProperty];
+								oMixedContext = merge({}, oMixedContext, oNewMapping);
+								delete oMixedContext[sMainProperty];
+							}
+						}
+					}
+				}
+
+				if (oMixedContext) {
+					for (const sKey in oMixedContext) {
+						if (sKey.indexOf("_") !== 0 && sKey.indexOf("odata.context") === -1) {
+							oParams[sKey] = oMixedContext[sKey];
+						}
+					}
+				}
+				// validate if a link must be rendered
+				oShellServices
+					.isNavigationSupported([
+						{
+							target: {
+								semanticObject: oDataPoint.semanticObject,
+								action: oDataPoint.action
+							},
+							params: oParams
+						}
+					])
+					.then((aLinks) => {
+						return fnSetLinkEnablement(sId, aLinks);
+					})
+					.catch(fnOnError);
+			}
+		}
+	}
+
+	handlers = {
+		onTableContextChange(this: ObjectPageController, oEvent: any) {
+			const oSource = oEvent.getSource();
+			let oTable: any;
+			this._findTables().some(function (_oTable: any) {
+				if (_oTable.getRowBinding() === oSource) {
+					oTable = _oTable;
+					return true;
+				}
+				return false;
+			});
+
+			const oCurrentActionPromise = this._editFlow.getCurrentActionPromise();
+			if (oCurrentActionPromise) {
+				let aTableContexts: any;
+				if (oTable.getType().getMetadata().isA("sap.ui.mdc.table.GridTableType")) {
+					aTableContexts = oSource.getContexts(0);
+				} else {
+					aTableContexts = oSource.getCurrentContexts();
+				}
+				//if contexts are not fully loaded the getcontexts function above will trigger a new change event call
+				if (!aTableContexts[0]) {
+					return;
+				}
+				oCurrentActionPromise
+					.then((oActionResponse: any) => {
+						if (!oActionResponse || oActionResponse.controlId !== oTable.sId) {
+							return;
+						}
+						const oActionData = oActionResponse.oData;
+						const aKeys = oActionResponse.keys;
+						let iNewItemp = -1;
+						aTableContexts.find(function (oTableContext: any, i: any) {
+							const oTableData = oTableContext.getObject();
+							const bCompare = aKeys.every(function (sKey: any) {
+								return oTableData[sKey] === oActionData[sKey];
+							});
+							if (bCompare) {
+								iNewItemp = i;
+							}
+							return bCompare;
+						});
+						if (iNewItemp !== -1) {
+							const aDialogs = InstanceManager.getOpenDialogs();
+							const oDialog =
+								aDialogs.length > 0 ? aDialogs.find((dialog) => dialog.data("FullScreenDialog") !== true) : null;
+							if (oDialog) {
+								// by design, a sap.m.dialog set the focus to the previous focused element when closing.
+								// we should wait for the dialog to be close before to focus another element
+								oDialog.attachEventOnce("afterClose", function () {
+									oTable.focusRow(iNewItemp, true);
+								});
+							} else {
+								oTable.focusRow(iNewItemp, true);
+							}
+							this._editFlow.deleteCurrentActionPromise();
+						}
+					})
+					.catch(function (err: any) {
+						Log.error("An error occurs while scrolling to the newly created Item: " + err);
+					});
+			}
+			// fire ModelContextChange on the message button whenever the table context changes
+			const oMessageButton = this.getView().byId("fe::FooterBar::MessageButton");
+			oMessageButton.fireModelContextChange();
+		},
+
+		/**
+		 * Invokes an action - bound/unbound and sets the page dirty.
+		 *
+		 * @param oView
+		 * @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 shall be called
+		 * @param {sap.ui.model.odata.v4.ODataModel} [mParameters.model] Mandatory for an unbound action; an instance of an OData V4 model
+		 * @returns {Promise}
+		 * @ui5-restricted
+		 * @final
+		 */
+		onCallAction(oView: any, sActionName: string, mParameters: any) {
+			const oController = oView.getController();
+			const that = oController;
+			return oController.editFlow
+				.invokeAction(sActionName, mParameters)
+				.then(that._showMessagePopover.bind(that, undefined))
+				.catch(that._showMessagePopover.bind(that));
+		},
+		onDataPointTitlePressed(oController: any, oSource: any, oManifestOutbound: any, sControlConfig: any, sCollectionPath: any) {
+			oManifestOutbound = typeof oManifestOutbound === "string" ? JSON.parse(oManifestOutbound) : oManifestOutbound;
+			const oTargetInfo = oManifestOutbound[sControlConfig],
+				aSemanticObjectMapping = CommonUtils.getSemanticObjectMapping(oTargetInfo),
+				oDataPointOrChartBindingContext = oSource.getBindingContext(),
+				sMetaPath = oDataPointOrChartBindingContext
+					.getModel()
+					.getMetaModel()
+					.getMetaPath(oDataPointOrChartBindingContext.getPath());
+			let aNavigationData = oController._getChartContextData(oDataPointOrChartBindingContext, sCollectionPath);
+			let additionalNavigationParameters;
+
+			aNavigationData = aNavigationData.map(function (oNavigationData: any) {
+				return {
+					data: oNavigationData,
+					metaPath: sMetaPath + (sCollectionPath ? "/" + sCollectionPath : "")
+				};
+			});
+			if (oTargetInfo && oTargetInfo.parameters) {
+				const oParams = oTargetInfo.parameters && oController._intentBasedNavigation.getOutboundParams(oTargetInfo.parameters);
+				if (Object.keys(oParams).length > 0) {
+					additionalNavigationParameters = oParams;
+				}
+			}
+			if (oTargetInfo && oTargetInfo.semanticObject && oTargetInfo.action) {
+				oController._intentBasedNavigation.navigate(oTargetInfo.semanticObject, oTargetInfo.action, {
+					navigationContexts: aNavigationData,
+					semanticObjectMapping: aSemanticObjectMapping,
+					additionalNavigationParameters: additionalNavigationParameters
+				});
+			}
+		},
+		/**
+		 * Triggers an outbound navigation when a user chooses the chevron.
+		 *
+		 * @param {object} oController
+		 * @param {string} sOutboundTarget Name of the outbound target (needs to be defined in the manifest)
+		 * @param {sap.ui.model.odata.v4.Context} oContext The context that contains the data for the target app
+		 * @param {string} sCreatePath Create path when the chevron is created.
+		 * @returns {Promise} Promise which is resolved once the navigation is triggered (??? maybe only once finished?)
+		 * @ui5-restricted
+		 * @final
+		 */
+		onChevronPressNavigateOutBound(oController: ObjectPageController, sOutboundTarget: string, oContext: any, sCreatePath: string) {
+			return oController._intentBasedNavigation.onChevronPressNavigateOutBound(oController, sOutboundTarget, oContext, sCreatePath);
+		},
+
+		onNavigateChange(this: ObjectPageController, oEvent: any) {
+			//will be called always when we click on a section tab
+			this.getExtensionAPI().updateAppState();
+			this.bSectionNavigated = true;
+
+			const oInternalModelContext = this.getView().getBindingContext("internal") as InternalModelContext;
+			const oObjectPage = this._getObjectPageLayoutControl();
+			if (
+				oObjectPage.getModel("ui").getProperty("/isEditable") &&
+				(this.getView().getViewData() as any).sectionLayout === "Tabs" &&
+				oInternalModelContext.getProperty("errorNavigationSectionFlag") === false
+			) {
+				const oSubSection = oEvent.getParameter("subSection");
+				this._updateFocusInEditMode([oSubSection]);
+			}
+		},
+		onVariantSelected: function (this: ObjectPageController) {
+			this.getExtensionAPI().updateAppState();
+		},
+		onVariantSaved: function (this: ObjectPageController) {
+			//TODO: Should remove this setTimeOut once Variant Management provides an api to fetch the current variant key on save
+			setTimeout(() => {
+				this.getExtensionAPI().updateAppState();
+			}, 500);
+		},
+		navigateToSubSection: function (oController: ObjectPageController, vDetailConfig: any) {
+			const oDetailConfig = typeof vDetailConfig === "string" ? JSON.parse(vDetailConfig) : vDetailConfig;
+			const oObjectPage = oController.getView().byId("fe::ObjectPage") as ObjectPageLayout;
+			let oSection;
+			let oSubSection;
+			if (oDetailConfig.sectionId) {
+				oSection = oController.getView().byId(oDetailConfig.sectionId) as ObjectPageSection;
+				oSubSection = (
+					oDetailConfig.subSectionId
+						? oController.getView().byId(oDetailConfig.subSectionId)
+						: oSection && oSection.getSubSections() && oSection.getSubSections()[0]
+				) as ObjectPageSubSection;
+			} else if (oDetailConfig.subSectionId) {
+				oSubSection = oController.getView().byId(oDetailConfig.subSectionId) as ObjectPageSubSection;
+				oSection = oSubSection && (oSubSection.getParent() as ObjectPageSection);
+			}
+			if (!oSection || !oSubSection || !oSection.getVisible() || !oSubSection.getVisible()) {
+				((oController.getView().getModel("sap.fe.i18n") as ResourceModel).getResourceBundle() as Promise<ResourceBundle>)
+					.then(function (oResourceBundle) {
+						const sTitle = CommonUtils.getTranslatedText(
+							"C_ROUTING_NAVIGATION_DISABLED_TITLE",
+							oResourceBundle,
+							null,
+							(oController.getView().getViewData() as any).entitySet
+						);
+						Log.error(sTitle);
+						MessageBox.error(sTitle);
+					})
+					.catch(function (error) {
+						Log.error(error);
+					});
+			} else {
+				oObjectPage.scrollToSection(oSubSection.getId());
+				// trigger iapp state change
+				oObjectPage.fireNavigate({
+					section: oSection,
+					subSection: oSubSection
+				});
+			}
+		},
+		onChartSelectionChanged: function (oEvent: any) {
+			ChartRuntime.fnUpdateChart(oEvent);
+		}
+	};
+}
+
+export default ObjectPageController;