@sapui5/sap.fe.core 1.110.0 → 1.111.0

package/src/sap/fe/core/controllerextensions/EditFlow-dbg.js

@@ -0,0 +1,1659 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log", "sap/fe/core/CommonUtils", "sap/fe/core/controllerextensions/BusyLocker", "sap/fe/core/controllerextensions/collaboration/ActivitySync", "sap/fe/core/controllerextensions/collaboration/CollaborationCommon", "sap/fe/core/controllerextensions/editFlow/draft", "sap/fe/core/controllerextensions/Feedback", "sap/fe/core/converters/MetaModelConverter", "sap/fe/core/helpers/ClassSupport", "sap/fe/core/helpers/EditState", "sap/fe/core/helpers/ModelHelper", "sap/fe/core/helpers/SemanticKeyHelper", "sap/fe/core/library", "sap/ui/core/Core", "sap/ui/core/library", "sap/ui/core/message/Message", "sap/ui/core/mvc/ControllerExtension", "sap/ui/core/mvc/OverrideExecution", "sap/ui/model/odata/v4/ODataListBinding", "../ActionRuntime"], function (Log, CommonUtils, BusyLocker, ActivitySync, CollaborationCommon, draft, Feedback, MetaModelConverter, ClassSupport, EditState, ModelHelper, SemanticKeyHelper, FELibrary, Core, coreLibrary, Message, ControllerExtension, OverrideExecution, ODataListBinding, ActionRuntime) {
+  "use strict";
+
+  var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _dec11, _dec12, _dec13, _dec14, _dec15, _dec16, _dec17, _dec18, _dec19, _dec20, _dec21, _dec22, _dec23, _dec24, _dec25, _dec26, _dec27, _dec28, _dec29, _dec30, _dec31, _dec32, _dec33, _dec34, _class, _class2;
+  var publicExtension = ClassSupport.publicExtension;
+  var finalExtension = ClassSupport.finalExtension;
+  var extensible = ClassSupport.extensible;
+  var defineUI5Class = ClassSupport.defineUI5Class;
+  var getInvolvedDataModelObjects = MetaModelConverter.getInvolvedDataModelObjects;
+  var TriggerType = Feedback.TriggerType;
+  var triggerConfiguredSurvey = Feedback.triggerConfiguredSurvey;
+  var StandardActions = Feedback.StandardActions;
+  var shareObject = CollaborationCommon.shareObject;
+  var Activity = CollaborationCommon.Activity;
+  var send = ActivitySync.send;
+  var isConnected = ActivitySync.isConnected;
+  function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+  const CreationMode = FELibrary.CreationMode,
+    ProgrammingModel = FELibrary.ProgrammingModel,
+    Constants = FELibrary.Constants,
+    DraftStatus = FELibrary.DraftStatus,
+    EditMode = FELibrary.EditMode,
+    StartupMode = FELibrary.StartupMode,
+    MessageType = coreLibrary.MessageType;
+
+  /**
+   * A controller extension offering hooks into the edit flow of the application
+   *
+   * @hideconstructor
+   * @public
+   * @since 1.90.0
+   */
+  let EditFlow = (_dec = defineUI5Class("sap.fe.core.controllerextensions.EditFlow"), _dec2 = publicExtension(), _dec3 = finalExtension(), _dec4 = publicExtension(), _dec5 = finalExtension(), _dec6 = publicExtension(), _dec7 = finalExtension(), _dec8 = publicExtension(), _dec9 = finalExtension(), _dec10 = publicExtension(), _dec11 = extensible(OverrideExecution.After), _dec12 = publicExtension(), _dec13 = extensible(OverrideExecution.After), _dec14 = publicExtension(), _dec15 = extensible(OverrideExecution.After), _dec16 = publicExtension(), _dec17 = extensible(OverrideExecution.After), _dec18 = publicExtension(), _dec19 = extensible(OverrideExecution.After), _dec20 = publicExtension(), _dec21 = finalExtension(), _dec22 = publicExtension(), _dec23 = finalExtension(), _dec24 = publicExtension(), _dec25 = finalExtension(), _dec26 = publicExtension(), _dec27 = finalExtension(), _dec28 = publicExtension(), _dec29 = finalExtension(), _dec30 = publicExtension(), _dec31 = finalExtension(), _dec32 = publicExtension(), _dec33 = finalExtension(), _dec34 = publicExtension(), _dec(_class = (_class2 = /*#__PURE__*/function (_ControllerExtension) {
+    _inheritsLoose(EditFlow, _ControllerExtension);
+    function EditFlow() {
+      return _ControllerExtension.apply(this, arguments) || this;
+    }
+    var _proto = EditFlow.prototype;
+    //////////////////////////////////////
+    // Public methods
+    //////////////////////////////////////
+    _proto.getAppComponent = function getAppComponent() {
+      return this.base.getAppComponent();
+    }
+    /**
+     * Gets the InternalEditFlow extension.
+     *
+     * @returns The internalEditFlow controller extension
+     */;
+    _proto.getInternalEditFlow = function getInternalEditFlow() {
+      return this.base.getView().getController()._editFlow;
+    }
+
+    /**
+     * Creates a draft document for an existing active document.
+     *
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @param oContext Context of the active document
+     * @returns Promise resolves once the editable document is available
+     * @alias sap.fe.core.controllerextensions.EditFlow#editDocument
+     * @public
+     * @since 1.90.0
+     */;
+    _proto.editDocument = async function editDocument(oContext) {
+      const bDraftNavigation = true;
+      const transactionHelper = this._getTransactionHelper();
+      const oRootViewController = this._getRootViewController();
+      const model = oContext.getModel();
+      let rightmostContext, siblingInfo;
+      const oViewData = this.getView().getViewData();
+      const sProgrammingModel = this._getProgrammingModel(oContext);
+      let oRootContext = oContext;
+      const oView = this.getView();
+      try {
+        if ((oViewData === null || oViewData === void 0 ? void 0 : oViewData.viewLevel) > 1) {
+          if (sProgrammingModel === ProgrammingModel.Draft) {
+            const draftRootPath = ModelHelper.getDraftRootPath(oContext);
+            oRootContext = oView.getModel().bindContext(draftRootPath).getBoundContext();
+            await oRootContext.requestObject(draftRootPath);
+          } else if (sProgrammingModel === ProgrammingModel.Sticky) {
+            const sStickyRootPath = ModelHelper.getStickyRootPath(oContext);
+            oRootContext = oView.getModel().bindContext(sStickyRootPath).getBoundContext();
+            await oRootContext.requestObject(sStickyRootPath);
+          }
+        }
+        await this.base.editFlow.onBeforeEdit({
+          context: oRootContext
+        });
+        const oNewDocumentContext = await transactionHelper.editDocument(oRootContext, this.getView(), this.getAppComponent(), this._getMessageHandler());
+        this._setStickySessionInternalProperties(sProgrammingModel, model);
+        if (oNewDocumentContext) {
+          this._setEditMode(EditMode.Editable, false);
+          this._setDocumentModified(false);
+          this._getMessageHandler().showMessageDialog();
+          if (oNewDocumentContext !== oRootContext) {
+            let contextToNavigate = oNewDocumentContext;
+            if (this._isFclEnabled()) {
+              rightmostContext = oRootViewController.getRightmostContext();
+              siblingInfo = await this._computeSiblingInformation(oRootContext, rightmostContext, sProgrammingModel, true);
+              siblingInfo = siblingInfo ?? this._createSiblingInfo(oContext, oNewDocumentContext);
+              this._updatePathsInHistory(siblingInfo.pathMapping);
+              if (siblingInfo.targetContext.getPath() != oNewDocumentContext.getPath()) {
+                contextToNavigate = siblingInfo.targetContext;
+              }
+            } else if ((oViewData === null || oViewData === void 0 ? void 0 : oViewData.viewLevel) > 1) {
+              siblingInfo = await this._computeSiblingInformation(oRootContext, oContext, sProgrammingModel, true);
+              contextToNavigate = this._getNavigationTargetForEdit(oContext, oNewDocumentContext, siblingInfo);
+            }
+            await this._handleNewContext(contextToNavigate, true, false, bDraftNavigation, true);
+            if (sProgrammingModel === ProgrammingModel.Sticky) {
+              // The stickyOn handler must be set after the navigation has been done,
+              // as the URL may change in the case of FCL
+              let stickyContext;
+              if (this._isFclEnabled()) {
+                // We need to use the kept-alive context used to bind the page
+                stickyContext = oNewDocumentContext.getModel().getKeepAliveContext(oNewDocumentContext.getPath());
+              } else {
+                stickyContext = oNewDocumentContext;
+              }
+              this._handleStickyOn(stickyContext);
+            } else if (ModelHelper.isCollaborationDraftSupported(model.getMetaModel())) {
+              // according to UX in case of enabled collaboration draft we share the object immediately
+              await shareObject(oNewDocumentContext);
+            }
+          }
+        }
+      } catch (oError) {
+        Log.error("Error while editing the document", oError);
+      }
+    };
+    _proto.deleteMultipleDocuments = function deleteMultipleDocuments(aContexts, mParameters) {
+      if (mParameters) {
+        mParameters.beforeDeleteCallBack = this.base.editFlow.onBeforeDelete;
+      } else {
+        mParameters = {
+          beforeDeleteCallBack: this.base.editFlow.onBeforeDelete
+        };
+      }
+      return this.getInternalEditFlow().deleteMultipleDocuments(aContexts, mParameters);
+    }
+
+    /**
+     * Updates the draft status and displays the error messages if there are errors during an update.
+     *
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @param updatedContext Context of the updated field
+     * @param updatePromise Promise to determine when the update operation is completed. The promise should be resolved when the update operation is completed, so the draft status can be updated.
+     * @returns Promise resolves once draft status has been updated
+     * @alias sap.fe.core.controllerextensions.EditFlow#updateDocument
+     * @public
+     * @since 1.90.0
+     */;
+    _proto.updateDocument = function updateDocument(updatedContext, updatePromise) {
+      const originalBindingContext = this.getView().getBindingContext();
+      const isDraft = this._getProgrammingModel(updatedContext) === ProgrammingModel.Draft;
+      this._getMessageHandler().removeTransitionMessages();
+      return this._syncTask(async () => {
+        if (originalBindingContext) {
+          this._setDocumentModified(true);
+          if (!this._isFclEnabled()) {
+            EditState.setEditStateDirty();
+          }
+          if (isDraft) {
+            this._setDraftStatus(DraftStatus.Saving);
+          }
+        }
+        try {
+          await updatePromise;
+          const currentBindingContext = this.getView().getBindingContext();
+          if (!isDraft || !currentBindingContext || currentBindingContext !== originalBindingContext) {
+            // If a navigation happened while oPromise was being resolved, the binding context of the page changed
+            return;
+          }
+
+          // We're still on the same context
+          const metaModel = currentBindingContext.getModel().getMetaModel();
+          const entitySetName = metaModel.getMetaContext(currentBindingContext.getPath()).getObject("@sapui.name");
+          const semanticKeys = SemanticKeyHelper.getSemanticKeys(metaModel, entitySetName);
+          if (semanticKeys !== null && semanticKeys !== void 0 && semanticKeys.length) {
+            const currentSemanticMapping = this._getSemanticMapping();
+            const currentSemanticPath = currentSemanticMapping === null || currentSemanticMapping === void 0 ? void 0 : currentSemanticMapping.semanticPath,
+              sChangedPath = SemanticKeyHelper.getSemanticPath(currentBindingContext, true);
+            // currentSemanticPath could be null if we have navigated via deep link then there are no semanticMappings to calculate it from
+            if (currentSemanticPath && currentSemanticPath !== sChangedPath) {
+              await this._handleNewContext(currentBindingContext, true, false, true);
+            }
+          }
+          this._setDraftStatus(DraftStatus.Saved);
+        } catch (error) {
+          Log.error("Error while updating the document", error);
+          if (isDraft && originalBindingContext) {
+            this._setDraftStatus(DraftStatus.Clear);
+          }
+        } finally {
+          await this._getMessageHandler().showMessages();
+        }
+      });
+    }
+
+    // Internal only params ---
+    // * @param {string} mParameters.creationMode The creation mode using one of the following:
+    // *                    Sync - the creation is triggered and once the document is created, the navigation is done
+    // *                    Async - the creation and the navigation to the instance are done in parallel
+    // *                    Deferred - the creation is done on the target page
+    // *                    CreationRow - The creation is done inline async so the user is not blocked
+    // mParameters.creationRow Instance of the creation row - (TODO: get rid but use list bindings only)
+
+    /**
+     * Creates a new document.
+     *
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @param vListBinding  ODataListBinding object or the binding path for a temporary list binding
+     * @param mInParameters Contains the following attributes:
+     * @param mInParameters.creationMode The creation mode using one of the following:
+     *                    NewPage - the created document is shown in a new page, depending on whether metadata 'Sync', 'Async' or 'Deferred' is used
+     *                    Inline - The creation is done inline (in a table)
+     *                    External - The creation is done in a different application specified via the parameter 'outbound'
+     * @param mInParameters.outbound The navigation target where the document is created in case of creationMode 'External'
+     * @param mInParameters.createAtEnd Specifies if the new entry should be created at the top or bottom of a table in case of creationMode 'Inline'
+     * @returns Promise resolves once the object has been created
+     * @alias sap.fe.core.controllerextensions.EditFlow#createDocument
+     * @public
+     * @since 1.90.0
+     */;
+    _proto.createDocument = async function createDocument(vListBinding, mInParameters) {
+      const transactionHelper = this._getTransactionHelper(),
+        oLockObject = this._getGlobalUIModel();
+      let oTable; //should be Table but there are missing methods into the def
+      let mParameters = mInParameters;
+      const bShouldBusyLock = !mParameters || mParameters.creationMode !== CreationMode.Inline && mParameters.creationMode !== CreationMode.CreationRow && mParameters.creationMode !== CreationMode.External;
+      let oExecCustomValidation = Promise.resolve([]);
+      const oAppComponent = CommonUtils.getAppComponent(this.getView());
+      oAppComponent.getRouterProxy().removeIAppStateKey();
+      if (mParameters.creationMode === CreationMode.External) {
+        // Create by navigating to an external target
+        // TODO: Call appropriate function (currently using the same as for outbound chevron nav, and without any context - 3rd param)
+        await this._syncTask();
+        const oController = this.getView().getController();
+        const sCreatePath = ModelHelper.getAbsoluteMetaPathForListBinding(this.getView(), vListBinding);
+        oController.handlers.onChevronPressNavigateOutBound(oController, mParameters.outbound, undefined, sCreatePath);
+        return;
+      }
+      if (mParameters.creationMode === CreationMode.CreationRow && mParameters.creationRow) {
+        const oCreationRowObjects = mParameters.creationRow.getBindingContext().getObject();
+        delete oCreationRowObjects["@$ui5.context.isTransient"];
+        oTable = mParameters.creationRow.getParent();
+        oExecCustomValidation = transactionHelper.validateDocument(oTable.getBindingContext(), {
+          data: oCreationRowObjects,
+          customValidationFunction: oTable.getCreationRow().data("customValidationFunction")
+        }, this.base.getView());
+
+        // disableAddRowButtonForEmptyData is set to false in manifest converter (Table.ts) if customValidationFunction exists
+        if (oTable.getCreationRow().data("disableAddRowButtonForEmptyData") === "true") {
+          const oInternalModelContext = oTable.getBindingContext("internal");
+          oInternalModelContext.setProperty("creationRowFieldValidity", {});
+        }
+      }
+      if (mParameters.creationMode === CreationMode.Inline && mParameters.tableId) {
+        oTable = this.getView().byId(mParameters.tableId);
+      }
+      if (oTable && oTable.isA("sap.ui.mdc.Table")) {
+        const fnFocusOrScroll = mParameters.creationMode === CreationMode.Inline ? oTable.focusRow.bind(oTable) : oTable.scrollToIndex.bind(oTable);
+        oTable.getRowBinding().attachEventOnce("change", function () {
+          fnFocusOrScroll(mParameters.createAtEnd ? oTable.getRowBinding().getLength() : 0, true);
+        });
+      }
+      const handleSideEffects = async (oListBinding, oCreationPromise) => {
+        try {
+          const oNewContext = await oCreationPromise;
+          // transient contexts are reliably removed once oNewContext.created() is resolved
+          await oNewContext.created();
+          const oBindingContext = this.getView().getBindingContext();
+          // if there are transient contexts, we must avoid requesting side effects
+          // this is avoid a potential list refresh, there could be a side effect that refreshes the list binding
+          // if list binding is refreshed, transient contexts might be lost
+          if (!CommonUtils.hasTransientContext(oListBinding)) {
+            const appComponent = CommonUtils.getAppComponent(this.getView());
+            appComponent.getSideEffectsService().requestSideEffectsForNavigationProperty(oListBinding.getPath(), oBindingContext);
+          }
+        } catch (oError) {
+          Log.error("Error while creating the document", oError);
+        }
+      };
+
+      /**
+       * @param aValidationMessages Error messages from custom validation function
+       */
+      const createCustomValidationMessages = aValidationMessages => {
+        var _oTable$getBindingCon;
+        const sCustomValidationFunction = oTable && oTable.getCreationRow().data("customValidationFunction");
+        const mCustomValidity = oTable && ((_oTable$getBindingCon = oTable.getBindingContext("internal")) === null || _oTable$getBindingCon === void 0 ? void 0 : _oTable$getBindingCon.getProperty("creationRowCustomValidity"));
+        const oMessageManager = Core.getMessageManager();
+        const aCustomMessages = [];
+        let oFieldControl;
+        let sTarget;
+
+        // Remove existing CustomValidation message
+        oMessageManager.getMessageModel().getData().forEach(function (oMessage) {
+          if (oMessage.code === sCustomValidationFunction) {
+            oMessageManager.removeMessages(oMessage);
+          }
+        });
+        aValidationMessages.forEach(oValidationMessage => {
+          // Handle Bound CustomValidation message
+          if (oValidationMessage.messageTarget) {
+            var _oFieldControl$getBin;
+            oFieldControl = Core.getControl(mCustomValidity[oValidationMessage.messageTarget].fieldId);
+            sTarget = `${(_oFieldControl$getBin = oFieldControl.getBindingContext()) === null || _oFieldControl$getBin === void 0 ? void 0 : _oFieldControl$getBin.getPath()}/${oFieldControl.getBindingPath("value")}`;
+            // Add validation message if still not exists
+            if (oMessageManager.getMessageModel().getData().filter(function (oMessage) {
+              return oMessage.target === sTarget;
+            }).length === 0) {
+              oMessageManager.addMessages(new Message({
+                message: oValidationMessage.messageText,
+                processor: this.getView().getModel(),
+                type: MessageType.Error,
+                code: sCustomValidationFunction,
+                technical: false,
+                persistent: false,
+                target: sTarget
+              }));
+            }
+            // Add controlId in order to get the focus handling of the error popover runable
+            const aExistingValidationMessages = oMessageManager.getMessageModel().getData().filter(function (oMessage) {
+              return oMessage.target === sTarget;
+            });
+            aExistingValidationMessages[0].addControlId(mCustomValidity[oValidationMessage.messageTarget].fieldId);
+
+            // Handle Unbound CustomValidation message
+          } else {
+            aCustomMessages.push({
+              code: sCustomValidationFunction,
+              text: oValidationMessage.messageText,
+              persistent: true,
+              type: MessageType.Error
+            });
+          }
+        });
+        if (aCustomMessages.length > 0) {
+          this._getMessageHandler().showMessageDialog({
+            customMessages: aCustomMessages
+          });
+        }
+      };
+      const resolveCreationMode = (initialCreationMode, programmingModel, oListBinding, oMetaModel) => {
+        if (initialCreationMode && initialCreationMode !== CreationMode.NewPage) {
+          // use the passed creation mode
+          return initialCreationMode;
+        } else {
+          // NewAction is not yet supported for NavigationProperty collection
+          if (!oListBinding.isRelative()) {
+            const sPath = oListBinding.getPath(),
+              // if NewAction with parameters is present, then creation is 'Deferred'
+              // in the absence of NewAction or NewAction with parameters, creation is async
+              sNewAction = programmingModel === ProgrammingModel.Draft ? oMetaModel.getObject(`${sPath}@com.sap.vocabularies.Common.v1.DraftRoot/NewAction`) : oMetaModel.getObject(`${sPath}@com.sap.vocabularies.Session.v1.StickySessionSupported/NewAction`);
+            if (sNewAction) {
+              const aParameters = oMetaModel.getObject(`/${sNewAction}/@$ui5.overload/0/$Parameter`) || [];
+              // binding parameter (eg: _it) is not considered
+              if (aParameters.length > 1) {
+                return CreationMode.Deferred;
+              }
+            }
+          }
+          const sMetaPath = oMetaModel.getMetaPath(oListBinding === null || oListBinding === void 0 ? void 0 : oListBinding.getHeaderContext().getPath());
+          const aNonComputedVisibleKeyFields = CommonUtils.getNonComputedVisibleFields(oMetaModel, sMetaPath, this.getView());
+          if (aNonComputedVisibleKeyFields.length > 0) {
+            return CreationMode.Deferred;
+          }
+          return CreationMode.Async;
+        }
+      };
+      if (bShouldBusyLock) {
+        BusyLocker.lock(oLockObject);
+      }
+      try {
+        const aValidationMessages = await this._syncTask(oExecCustomValidation);
+        if (aValidationMessages.length > 0) {
+          createCustomValidationMessages(aValidationMessages);
+          Log.error("Custom Validation failed");
+          // if custom validation fails, we leave the method immediately
+          return;
+        }
+        let oListBinding;
+        mParameters = mParameters || {};
+        if (vListBinding && typeof vListBinding === "object") {
+          // we already get a list binding use this one
+          oListBinding = vListBinding;
+        } else if (typeof vListBinding === "string") {
+          oListBinding = new ODataListBinding(this.getView().getModel(), vListBinding);
+          mParameters.creationMode = CreationMode.Sync;
+          delete mParameters.createAtEnd;
+        } else {
+          throw new Error("Binding object or path expected");
+        }
+        const oModel = oListBinding.getModel();
+        const sProgrammingModel = this._getProgrammingModel(oListBinding);
+        const resolvedCreationMode = resolveCreationMode(mParameters.creationMode, sProgrammingModel, oListBinding, oModel.getMetaModel());
+        let oCreation;
+        let mArgs;
+        const oCreationRow = mParameters.creationRow;
+        let oCreationRowContext;
+        let oPayload;
+        let sMetaPath;
+        const oMetaModel = oModel.getMetaModel();
+        const oRoutingListener = this._getRoutingListener();
+        if (resolvedCreationMode !== CreationMode.Deferred) {
+          if (resolvedCreationMode === CreationMode.CreationRow) {
+            oCreationRowContext = oCreationRow.getBindingContext();
+            sMetaPath = oMetaModel.getMetaPath(oCreationRowContext.getPath());
+            // prefill data from creation row
+            oPayload = oCreationRowContext.getObject();
+            mParameters.data = {};
+            Object.keys(oPayload).forEach(function (sPropertyPath) {
+              const oProperty = oMetaModel.getObject(`${sMetaPath}/${sPropertyPath}`);
+              // ensure navigation properties are not part of the payload, deep create not supported
+              if (oProperty && oProperty.$kind === "NavigationProperty") {
+                return;
+              }
+              mParameters.data[sPropertyPath] = oPayload[sPropertyPath];
+            });
+            await this._checkForValidationErrors( /*oCreationRowContext*/);
+          }
+          if (resolvedCreationMode === CreationMode.CreationRow || resolvedCreationMode === CreationMode.Inline) {
+            var _oTable, _oTable$getParent, _oTable$getParent$get;
+            mParameters.keepTransientContextOnFailed = false; // currently not fully supported
+            // busy handling shall be done locally only
+            mParameters.busyMode = "Local";
+            mParameters.busyId = (_oTable = oTable) === null || _oTable === void 0 ? void 0 : (_oTable$getParent = _oTable.getParent()) === null || _oTable$getParent === void 0 ? void 0 : (_oTable$getParent$get = _oTable$getParent.getTableDefinition()) === null || _oTable$getParent$get === void 0 ? void 0 : _oTable$getParent$get.annotation.id;
+
+            // take care on message handling, draft indicator (in case of draft)
+            // Attach the create sent and create completed event to the object page binding so that we can react
+            this._handleCreateEvents(oListBinding);
+          }
+          if (!mParameters.parentControl) {
+            mParameters.parentControl = this.getView();
+          }
+          mParameters.beforeCreateCallBack = this.base.editFlow.onBeforeCreate;
+
+          // In case the application was called with preferredMode=autoCreateWith, we want to skip the
+          // action parameter dialog
+          mParameters.skipParameterDialog = oAppComponent.getStartupMode() === StartupMode.AutoCreate;
+          oCreation = transactionHelper.createDocument(oListBinding, mParameters, this.getAppComponent(), this._getMessageHandler(), false, this.getView());
+        }
+        let oNavigation;
+        switch (resolvedCreationMode) {
+          case CreationMode.Deferred:
+            oNavigation = oRoutingListener.navigateForwardToContext(oListBinding, {
+              bDeferredContext: true,
+              editable: true,
+              bForceFocus: true
+            });
+            break;
+          case CreationMode.Async:
+            oNavigation = oRoutingListener.navigateForwardToContext(oListBinding, {
+              asyncContext: oCreation,
+              editable: true,
+              bForceFocus: true
+            });
+            break;
+          case CreationMode.Sync:
+            mArgs = {
+              editable: true,
+              bForceFocus: true
+            };
+            if (sProgrammingModel == ProgrammingModel.Sticky || mParameters.createAction) {
+              mArgs.transient = true;
+            }
+            oNavigation = oCreation.then(function (oNewDocumentContext) {
+              if (!oNewDocumentContext) {
+                const coreResourceBundle = Core.getLibraryResourceBundle("sap.fe.core");
+                return oRoutingListener.navigateToMessagePage(coreResourceBundle.getText("C_COMMON_SAPFE_DATA_RECEIVED_ERROR"), {
+                  title: coreResourceBundle.getText("C_COMMON_SAPFE_ERROR"),
+                  description: coreResourceBundle.getText("C_EDITFLOW_SAPFE_CREATION_FAILED_DESCRIPTION")
+                });
+              } else {
+                // In case the Sync creation was triggered for a deferred creation, we don't navigate forward
+                // as we're already on the corresponding ObjectPage
+                return mParameters.bFromDeferred ? oRoutingListener.navigateToContext(oNewDocumentContext, mArgs) : oRoutingListener.navigateForwardToContext(oNewDocumentContext, mArgs);
+              }
+            });
+            break;
+          case CreationMode.Inline:
+            handleSideEffects(oListBinding, oCreation);
+            this._syncTask(oCreation);
+            break;
+          case CreationMode.CreationRow:
+            // the creation row shall be cleared once the validation check was successful and
+            // therefore the POST can be sent async to the backend
+            try {
+              const oCreationRowListBinding = oCreationRowContext.getBinding();
+              if (!mParameters.bSkipSideEffects) {
+                handleSideEffects(oListBinding, oCreation);
+              }
+              const oNewTransientContext = oCreationRowListBinding.create();
+              oCreationRow.setBindingContext(oNewTransientContext);
+
+              // this is needed to avoid console errors TO be checked with model colleagues
+              oNewTransientContext.created().catch(function () {
+                Log.trace("transient fast creation context deleted");
+              });
+              oNavigation = oCreationRowContext.delete("$direct");
+            } catch (oError) {
+              // Reset busy indicator after a validation error
+              if (BusyLocker.isLocked(this.getView().getModel("ui"))) {
+                BusyLocker.unlock(this.getView().getModel("ui"));
+              }
+              Log.error("CreationRow navigation error: ", oError);
+            }
+            break;
+          default:
+            oNavigation = Promise.reject(`Unhandled creationMode ${resolvedCreationMode}`);
+            break;
+        }
+        if (oCreation) {
+          try {
+            const aParams = await Promise.all([oCreation, oNavigation]);
+            this._setStickySessionInternalProperties(sProgrammingModel, oModel);
+            this._setEditMode(EditMode.Editable); // The createMode flag will be set in InternalEditFlow#computeEditMode
+            if (!oListBinding.isRelative() && sProgrammingModel === ProgrammingModel.Sticky) {
+              var _entitySet$annotation, _entitySet$annotation2;
+              // Workaround to tell the OP that we've created a new object from the LR
+              const metaModel = oListBinding.getModel().getMetaModel();
+              const metaContext = metaModel.bindContext(metaModel.getMetaPath(oListBinding.getPath()));
+              const entitySet = getInvolvedDataModelObjects(metaContext).startingEntitySet;
+              const newAction = entitySet === null || entitySet === void 0 ? void 0 : (_entitySet$annotation = entitySet.annotations.Session) === null || _entitySet$annotation === void 0 ? void 0 : (_entitySet$annotation2 = _entitySet$annotation.StickySessionSupported) === null || _entitySet$annotation2 === void 0 ? void 0 : _entitySet$annotation2.NewAction;
+              this._getInternalModel().setProperty("/lastInvokedAction", newAction);
+            }
+            const oNewDocumentContext = aParams[0];
+            if (oNewDocumentContext) {
+              this._setDocumentModifiedOnCreate(oListBinding);
+              if (!this._isFclEnabled()) {
+                EditState.setEditStateDirty();
+              }
+              this._sendActivity(Activity.Create, oNewDocumentContext);
+              if (ModelHelper.isCollaborationDraftSupported(oModel.getMetaModel())) {
+                // according to UX in case of enabled collaboration draft we share the object immediately
+                await shareObject(oNewDocumentContext);
+              }
+            }
+          } catch (error) {
+            // TODO: currently, the only errors handled here are raised as string - should be changed to Error objects
+            if (error === Constants.CancelActionDialog || error === Constants.ActionExecutionFailed || error === Constants.CreationFailed) {
+              // creation has been cancelled by user or failed in backend => in case we have navigated to transient context before, navigate back
+              // the switch-statement above seems to indicate that this happens in creationModes deferred and async. But in fact, in these cases after the navigation from routeMatched in OP component
+              // createDeferredContext is triggerd, which calls this method (createDocument) again - this time with creationMode sync. Therefore, also in that mode we need to trigger back navigation.
+              // The other cases might still be needed in case the navigation fails.
+              if (resolvedCreationMode === CreationMode.Sync || resolvedCreationMode === CreationMode.Deferred || resolvedCreationMode === CreationMode.Async) {
+                oRoutingListener.navigateBackFromTransientState();
+              }
+            }
+            throw error;
+          }
+        }
+      } finally {
+        if (bShouldBusyLock) {
+          BusyLocker.unlock(oLockObject);
+        }
+      }
+    }
+
+    /**
+     * This function can be used to intercept the 'Save' action. You can execute custom coding in this function.
+     * The framework waits for the returned promise to be resolved before continuing the 'Save' action.
+     * If you reject the promise, the 'Save' action is stopped and the user stays in edit mode.
+     *
+     * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+     * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+     *
+     * @param _mParameters Object containing the parameters passed to onBeforeSave
+     * @param _mParameters.context Page context that is going to be saved.
+     * @returns A promise to be returned by the overridden method. If resolved, the 'Save' action is triggered. If rejected, the 'Save' action is not triggered and the user stays in edit mode.
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeSave
+     * @public
+     * @since 1.90.0
+     */;
+    _proto.onBeforeSave = function onBeforeSave(_mParameters) {
+      // to be overridden
+      return Promise.resolve();
+    }
+    /**
+     * This function can be used to intercept the 'Create' action. You can execute custom coding in this function.
+     * The framework waits for the returned promise to be resolved before continuing the 'Create' action.
+     * If you reject the promise, the 'Create' action is stopped.
+     *
+     * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+     * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+     *
+     * @param _mParameters Object containing the parameters passed to onBeforeCreate
+     * @param _mParameters.contextPath Path pointing to the context on which Create action is triggered
+     * @param _mParameters.createParameters Array of values that are filled in the Action Parameter Dialog
+     * @returns A promise to be returned by the overridden method. If resolved, the 'Create' action is triggered. If rejected, the 'Create' action is not triggered.
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeCreate
+     * @public
+     * @since 1.98.0
+     */;
+    _proto.onBeforeCreate = function onBeforeCreate(_mParameters) {
+      // to be overridden
+      return Promise.resolve();
+    }
+    /**
+     * This function can be used to intercept the 'Edit' action. You can execute custom coding in this function.
+     * The framework waits for the returned promise to be resolved before continuing the 'Edit' action.
+     * If you reject the promise, the 'Edit' action is stopped and the user stays in display mode.
+     *
+     * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+     * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+     *
+     * @param _mParameters Object containing the parameters passed to onBeforeEdit
+     * @param _mParameters.context Page context that is going to be edited.
+     * @returns A promise to be returned by the overridden method. If resolved, the 'Edit' action is triggered. If rejected, the 'Edit' action is not triggered and the user stays in display mode.
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeEdit
+     * @public
+     * @since 1.98.0
+     */;
+    _proto.onBeforeEdit = function onBeforeEdit(_mParameters) {
+      // to be overridden
+      return Promise.resolve();
+    }
+    /**
+     * This function can be used to intercept the 'Discard' action. You can execute custom coding in this function.
+     * The framework waits for the returned promise to be resolved before continuing the 'Discard' action.
+     * If you reject the promise, the 'Discard' action is stopped and the user stays in edit mode.
+     *
+     * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+     * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+     *
+     * @param _mParameters Object containing the parameters passed to onBeforeDiscard
+     * @param _mParameters.context Page context that is going to be discarded.
+     * @returns A promise to be returned by the overridden method. If resolved, the 'Discard' action is triggered. If rejected, the 'Discard' action is not triggered and the user stays in edit mode.
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeDiscard
+     * @public
+     * @since 1.98.0
+     */;
+    _proto.onBeforeDiscard = function onBeforeDiscard(_mParameters) {
+      // to be overridden
+      return Promise.resolve();
+    }
+    /**
+     * This function can be used to intercept the 'Delete' action. You can execute custom coding in this function.
+     * The framework waits for the returned promise to be resolved before continuing the 'Delete' action.
+     * If you reject the promise, the 'Delete' action is stopped.
+     *
+     * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
+     * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.
+     *
+     * @param _mParameters Object containing the parameters passed to onBeforeDelete
+     * @param _mParameters.contexts An array of contexts that are going to be deleted
+     * @returns A promise to be returned by the overridden method. If resolved, the 'Delete' action is triggered. If rejected, the 'Delete' action is not triggered.
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeDelete
+     * @public
+     * @since 1.98.0
+     */;
+    _proto.onBeforeDelete = function onBeforeDelete(_mParameters) {
+      // to be overridden
+      return Promise.resolve();
+    }
+
+    // Internal only params ---
+    // @param {boolean} mParameters.bExecuteSideEffectsOnError Indicates whether SideEffects need to be ignored when user clicks on Save during an Inline creation
+    // @param {object} mParameters.bindings List bindings of the tables in the view.
+    // Both of the above parameters are for the same purpose. User can enter some information in the creation row(s) but does not 'Add row', instead clicks Save.
+    // There can be more than one in the view.
+
+    /**
+     * Saves a new document after checking it.
+     *
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @param oContext  Context of the editable document
+     * @param mParameters PRIVATE
+     * @returns Promise resolves once save is complete
+     * @alias sap.fe.core.controllerextensions.EditFlow#saveDocument
+     * @public
+     * @since 1.90.0
+     */;
+    _proto.saveDocument = async function saveDocument(oContext, mParameters) {
+      mParameters = mParameters || {};
+      const bExecuteSideEffectsOnError = mParameters.bExecuteSideEffectsOnError || undefined;
+      const bDraftNavigation = true;
+      const transactionHelper = this._getTransactionHelper();
+      const oResourceBundle = this._getResourceBundle();
+      const aBindings = mParameters.bindings;
+      try {
+        await this._syncTask();
+        await this._submitOpenChanges(oContext);
+        await this._checkForValidationErrors();
+        await this.base.editFlow.onBeforeSave({
+          context: oContext
+        });
+        const sProgrammingModel = this._getProgrammingModel(oContext);
+        const oRootViewController = this._getRootViewController();
+        let siblingInfo;
+        if ((sProgrammingModel === ProgrammingModel.Sticky || oContext.getProperty("HasActiveEntity")) && oRootViewController.isFclEnabled()) {
+          // No need to try to get rightmost context in case of a new object
+          siblingInfo = await this._computeSiblingInformation(oContext, oRootViewController.getRightmostContext(), sProgrammingModel, true);
+        }
+        const activeDocumentContext = await transactionHelper.saveDocument(oContext, this.getAppComponent(), oResourceBundle, bExecuteSideEffectsOnError, aBindings, this._getMessageHandler(), this._getCreationMode());
+        this._removeStickySessionInternalProperties(sProgrammingModel);
+        this._sendActivity(Activity.Activate, activeDocumentContext);
+        this._triggerConfiguredSurvey(StandardActions.save, TriggerType.standardAction);
+        this._setDocumentModified(false);
+        this._setEditMode(EditMode.Display, false);
+        this._getMessageHandler().showMessageDialog();
+        if (activeDocumentContext !== oContext) {
+          let contextToNavigate = activeDocumentContext;
+          if (oRootViewController.isFclEnabled()) {
+            siblingInfo = siblingInfo ?? this._createSiblingInfo(oContext, activeDocumentContext);
+            this._updatePathsInHistory(siblingInfo.pathMapping);
+            if (siblingInfo.targetContext.getPath() !== activeDocumentContext.getPath()) {
+              contextToNavigate = siblingInfo.targetContext;
+            }
+          }
+          await this._handleNewContext(contextToNavigate, false, false, bDraftNavigation, true);
+        }
+      } catch (oError) {
+        if (!(oError && oError.canceled)) {
+          Log.error("Error while saving the document", oError);
+        }
+        throw oError;
+      }
+    };
+    _proto.toggleDraftActive = async function toggleDraftActive(oContext) {
+      const oContextData = oContext.getObject();
+      let bEditable;
+      const bIsDraft = oContext && this._getProgrammingModel(oContext) === ProgrammingModel.Draft;
+
+      //toggle between draft and active document is only available for edit drafts and active documents with draft)
+      if (!bIsDraft || !(!oContextData.IsActiveEntity && oContextData.HasActiveEntity || oContextData.IsActiveEntity && oContextData.HasDraftEntity)) {
+        return;
+      }
+      if (!oContextData.IsActiveEntity && oContextData.HasActiveEntity) {
+        //start Point: edit draft
+        bEditable = false;
+      } else {
+        // start point active document
+        bEditable = true;
+      }
+      try {
+        const oRootViewController = this._getRootViewController();
+        const oRightmostContext = oRootViewController.isFclEnabled() ? oRootViewController.getRightmostContext() : oContext;
+        const siblingInfo = await this._computeSiblingInformation(oContext, oRightmostContext, ProgrammingModel.Draft, false);
+        if (siblingInfo) {
+          this._setEditMode(bEditable ? EditMode.Editable : EditMode.Display, false); //switch to edit mode only if a draft is available
+
+          if (oRootViewController.isFclEnabled()) {
+            const lastSemanticMapping = this._getSemanticMapping();
+            if ((lastSemanticMapping === null || lastSemanticMapping === void 0 ? void 0 : lastSemanticMapping.technicalPath) === oContext.getPath()) {
+              const targetPath = siblingInfo.pathMapping[siblingInfo.pathMapping.length - 1].newPath;
+              siblingInfo.pathMapping.push({
+                oldPath: lastSemanticMapping.semanticPath,
+                newPath: targetPath
+              });
+            }
+            this._updatePathsInHistory(siblingInfo.pathMapping);
+          }
+          await this._handleNewContext(siblingInfo.targetContext, bEditable, true, true, true);
+        } else {
+          return Promise.reject("Error in EditFlow.toggleDraftActive - Cannot find sibling");
+        }
+      } catch (oError) {
+        return Promise.reject(`Error in EditFlow.toggleDraftActive:${oError}`);
+      }
+    }
+
+    // Internal only params ---
+    // @param {sap.m.Button} mParameters.cancelButton - Currently this is passed as cancelButton internally (replaced by mParameters.control in the JSDoc below). Currently it is also mandatory.
+    // Plan - This should not be mandatory. If not provided, we should have a default that can act as reference control for the discard popover OR we can show a dialog instead of a popover.
+
+    /**
+     * Discard the editable document.
+     *
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @param oContext  Context of the editable document
+     * @param mParameters Can contain the following attributes:
+     * @param mParameters.control This is the control used to open the discard popover
+     * @param mParameters.skipDiscardPopover Optional, supresses the discard popover and allows custom handling
+     * @returns Promise resolves once editable document has been discarded
+     * @alias sap.fe.core.controllerextensions.EditFlow#cancelDocument
+     * @public
+     * @since 1.90.0
+     */;
+    _proto.cancelDocument = async function cancelDocument(oContext, mParameters) {
+      const transactionHelper = this._getTransactionHelper();
+      const oResourceBundle = this._getResourceBundle();
+      const mInParameters = mParameters;
+      let siblingInfo;
+      mInParameters.cancelButton = mParameters.control || mInParameters.cancelButton;
+      mInParameters.beforeCancelCallBack = this.base.editFlow.onBeforeDiscard;
+      try {
+        await this._syncTask();
+        const sProgrammingModel = this._getProgrammingModel(oContext);
+        if ((sProgrammingModel === ProgrammingModel.Sticky || oContext.getProperty("HasActiveEntity")) && this._isFclEnabled()) {
+          const oRootViewController = this._getRootViewController();
+
+          // No need to try to get rightmost context in case of a new object
+          siblingInfo = await this._computeSiblingInformation(oContext, oRootViewController.getRightmostContext(), sProgrammingModel, true);
+        }
+        const cancelResult = await transactionHelper.cancelDocument(oContext, mInParameters, this.getAppComponent(), oResourceBundle, this._getMessageHandler(), this._getCreationMode(), this._isDocumentModified());
+        const bDraftNavigation = true;
+        this._removeStickySessionInternalProperties(sProgrammingModel);
+        this._setEditMode(EditMode.Display, false);
+        this._setDocumentModified(false);
+        this._setDraftStatus(DraftStatus.Clear);
+        // we force the edit state even for FCL because the draft discard might not be implemented
+        // and we may just delete the draft
+        EditState.setEditStateDirty();
+        if (!cancelResult) {
+          this._sendActivity(Activity.Discard, undefined);
+          //in case of a new document, no activeContext is returned --> navigate back.
+          if (!mInParameters.skipBackNavigation) {
+            await this._getRoutingListener().navigateBackFromContext(oContext);
+          }
+        } else {
+          const oActiveDocumentContext = cancelResult;
+          this._sendActivity(Activity.Discard, oActiveDocumentContext);
+          let contextToNavigate = oActiveDocumentContext;
+          if (this._isFclEnabled()) {
+            siblingInfo = siblingInfo ?? this._createSiblingInfo(oContext, oActiveDocumentContext);
+            this._updatePathsInHistory(siblingInfo.pathMapping);
+            if (siblingInfo.targetContext.getPath() !== oActiveDocumentContext.getPath()) {
+              contextToNavigate = siblingInfo.targetContext;
+            }
+          }
+          if (sProgrammingModel === ProgrammingModel.Draft) {
+            // We need to load the semantic keys of the active context, as we need them
+            // for the navigation
+            await this._fetchSemanticKeyValues(oActiveDocumentContext);
+            // We force the recreation of the context, so that it's created and bound in the same microtask,
+            // so that all properties are loaded together by autoExpandSelect, so that when switching back to Edit mode
+            // $$inheritExpandSelect takes all loaded properties into account (BCP 2070462265)
+            if (!mInParameters.skipBindingToView) {
+              await this._handleNewContext(contextToNavigate, false, true, bDraftNavigation, true);
+            } else {
+              return oActiveDocumentContext;
+            }
+          } else {
+            //active context is returned in case of cancel of existing document
+            await this._handleNewContext(contextToNavigate, false, false, bDraftNavigation, true);
+          }
+        }
+      } catch (oError) {
+        Log.error("Error while discarding the document", oError);
+      }
+    }
+
+    /**
+     * Checks if a context corresponds to a draft root.
+     *
+     * @param context The context to check
+     * @returns True if the context points to a draft root
+     * @private
+     */;
+    _proto.isDraftRoot = function isDraftRoot(context) {
+      const metaModel = context.getModel().getMetaModel();
+      const metaContext = metaModel.getMetaContext(context.getPath());
+      return ModelHelper.isDraftRoot(getInvolvedDataModelObjects(metaContext).targetEntitySet);
+    }
+
+    // Internal only params ---
+    // @param {string} mParameters.entitySetName Name of the EntitySet to which the object belongs
+
+    /**
+     * Deletes the document.
+     *
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @param oContext  Context of the document
+     * @param mInParameters Can contain the following attributes:
+     * @param mInParameters.title Title of the object being deleted
+     * @param mInParameters.description Description of the object being deleted
+     * @returns Promise resolves once document has been deleted
+     * @alias sap.fe.core.controllerextensions.EditFlow#deleteDocument
+     * @public
+     * @since 1.90.0
+     */;
+    _proto.deleteDocument = async function deleteDocument(oContext, mInParameters) {
+      const oAppComponent = CommonUtils.getAppComponent(this.getView());
+      let mParameters = mInParameters;
+      if (!mParameters) {
+        mParameters = {
+          bFindActiveContexts: false
+        };
+      } else {
+        mParameters.bFindActiveContexts = false;
+      }
+      mParameters.beforeDeleteCallBack = this.base.editFlow.onBeforeDelete;
+      try {
+        if (this._isFclEnabled() && this.isDraftRoot(oContext) && oContext.getIndex() === undefined && oContext.getProperty("IsActiveEntity") === true && oContext.getProperty("HasDraftEntity") === true) {
+          // Deleting an active entity which has a draft that could potentially be displayed in the ListReport (FCL case)
+          // --> need to remove the draft from the LR and replace it with the active version, so that the ListBinding is properly refreshed
+          // The condition 'oContext.getIndex() === undefined' makes sure the active version isn't already displayed in the LR
+          mParameters.beforeDeleteCallBack = async parameters => {
+            await this.base.editFlow.onBeforeDelete(parameters);
+            try {
+              const model = oContext.getModel();
+              const siblingContext = model.bindContext(`${oContext.getPath()}/SiblingEntity`).getBoundContext();
+              const draftPath = await siblingContext.requestCanonicalPath();
+              const draftContextToRemove = model.getKeepAliveContext(draftPath);
+              draftContextToRemove.replaceWith(oContext);
+            } catch (error) {
+              Log.error("Error while replacing the draft instance in the LR ODLB", error);
+            }
+          };
+        }
+        await this._deleteDocumentTransaction(oContext, mParameters);
+
+        // Single objet deletion is triggered from an OP header button (not from a list)
+        // --> Mark UI dirty and navigate back to dismiss the OP
+        if (!this._isFclEnabled()) {
+          EditState.setEditStateDirty();
+        }
+        this._sendActivity(Activity.Delete, oContext);
+
+        // After delete is successfull, we need to detach the setBackNavigation Methods
+        if (oAppComponent) {
+          oAppComponent.getShellServices().setBackNavigation();
+        }
+        if ((oAppComponent === null || oAppComponent === void 0 ? void 0 : oAppComponent.getStartupMode()) === StartupMode.Deeplink && !this._isFclEnabled()) {
+          // In case the app has been launched with semantic keys, deleting the object we've landed on shall navigate back
+          // to the app we came from (except for FCL, where we navigate to LR as usual)
+          oAppComponent.getRouterProxy().exitFromApp();
+        } else {
+          this._getRoutingListener().navigateBackFromContext(oContext);
+        }
+      } catch (error) {
+        Log.error("Error while deleting the document", error);
+      }
+    }
+
+    /**
+     * Submit the current set of changes and navigate back.
+     *
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @param oContext  Context of the document
+     * @returns Promise resolves once the changes have been saved
+     * @alias sap.fe.core.controllerextensions.EditFlow#applyDocument
+     * @public
+     * @since 1.90.0
+     */;
+    _proto.applyDocument = async function applyDocument(oContext) {
+      const oLockObject = this._getGlobalUIModel();
+      BusyLocker.lock(oLockObject);
+      try {
+        await this._syncTask();
+        await this._submitOpenChanges(oContext);
+        await this._checkForValidationErrors();
+        await this._getMessageHandler().showMessageDialog();
+        await this._getRoutingListener().navigateBackFromContext(oContext);
+      } finally {
+        if (BusyLocker.isLocked(oLockObject)) {
+          BusyLocker.unlock(oLockObject);
+        }
+      }
+    }
+
+    // Internal only params ---
+    // @param {boolean} [mParameters.bStaticAction] Boolean value for static action, undefined for other actions
+    // @param {boolean} [mParameters.isNavigable] Boolean value indicating whether navigation is required after the action has been executed
+    // Currently the parameter isNavigable is used internally and should be changed to requiresNavigation as it is a more apt name for this param
+
+    /**
+     * Invokes an action (bound or unbound) and tracks the changes so that other pages can be refreshed and show the updated data upon navigation.
+     *
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @param sActionName The name of the action to be called
+     * @param mInParameters Contains the following attributes:
+     * @param mInParameters.parameterValues A map of action parameter names and provided values
+     * @param mInParameters.parameterValues.name Name of the parameter
+     * @param mInParameters.parameterValues.value Value of the parameter
+     * @param mInParameters.skipParameterDialog Skips the action parameter dialog if values are provided for all of them in parameterValues
+     * @param mInParameters.contexts For a bound action, a context or an array with contexts for which the action is to be called must be provided
+     * @param mInParameters.model For an unbound action, an instance of an OData V4 model must be provided
+     * @param mInParameters.requiresNavigation Boolean value indicating whether navigation is required after the action has been executed. Navigation takes place to the context returned by the action
+     * @param mInParameters.label A human-readable label for the action. This is needed in case the action has a parameter and a parameter dialog is shown to the user. The label will be used for the title of the dialog and for the confirmation button
+     * @param mInParameters.invocationGrouping Mode how actions are to be called: 'ChangeSet' to put all action calls into one changeset, 'Isolated' to put them into separate changesets
+     * @param mExtraParams PRIVATE
+     * @returns A promise which resolves once the action has been executed, providing the response
+     * @alias sap.fe.core.controllerextensions.EditFlow#invokeAction
+     * @public
+     * @since 1.90.0
+     * @final
+     */;
+    _proto.invokeAction = async function invokeAction(sActionName, mInParameters, mExtraParams) {
+      var _model$getMetaModel;
+      let oControl;
+      const transactionHelper = this._getTransactionHelper();
+      let aParts;
+      let sOverloadEntityType;
+      let oCurrentActionCallBacks;
+      const oView = this.getView();
+      let mParameters = mInParameters || {};
+      // Due to a mistake the invokeAction in the extensionAPI had a different API than this one.
+      // The one from the extensionAPI doesn't exist anymore as we expose the full edit flow now but
+      // due to compatibility reasons we still need to support the old signature
+      if (mParameters.isA && mParameters.isA("sap.ui.model.odata.v4.Context") || Array.isArray(mParameters) || mExtraParams !== undefined) {
+        const contexts = mParameters;
+        mParameters = mExtraParams || {};
+        if (contexts) {
+          mParameters.contexts = contexts;
+        } else {
+          mParameters.model = this.getView().getModel();
+        }
+      }
+      mParameters.isNavigable = mParameters.requiresNavigation || mParameters.isNavigable;
+
+      // Determine if the action is bound or unbound
+      const model = this.getView().getModel();
+      const actionMetaData = model === null || model === void 0 ? void 0 : (_model$getMetaModel = model.getMetaModel()) === null || _model$getMetaModel === void 0 ? void 0 : _model$getMetaModel.getObject("/" + sActionName.split("(")[0]);
+      if (actionMetaData) {
+        if (!Array.isArray(actionMetaData)) {
+          mParameters.isBound = actionMetaData.$IsBound ? actionMetaData.$IsBound : false;
+        } else if (actionMetaData[0].$kind === "Action" && actionMetaData[0].$IsBound === true) {
+          mParameters.isBound = true;
+        }
+      } else {
+        throw new Error("Error in EditFlow.invokeAction: The specified action could not be found");
+      }
+      if (!mParameters.parentControl) {
+        mParameters.parentControl = this.getView();
+      }
+      if (mParameters.controlId) {
+        oControl = this.getView().byId(mParameters.controlId);
+        if (oControl) {
+          // TODO: currently this selected contexts update is done within the operation, should be moved out
+          mParameters.internalModelContext = oControl.getBindingContext("internal");
+        }
+      } else {
+        mParameters.internalModelContext = oView.getBindingContext("internal");
+      }
+      if (sActionName && sActionName.indexOf("(") > -1) {
+        // get entity type of action overload and remove it from the action path
+        // Example sActionName = "<ActionName>(Collection(<OverloadEntityType>))"
+        // sActionName = aParts[0] --> <ActionName>
+        // sOverloadEntityType = aParts[2] --> <OverloadEntityType>
+        aParts = sActionName.split("(");
+        sActionName = aParts[0];
+        sOverloadEntityType = aParts[aParts.length - 1].replaceAll(")", "");
+      }
+      if (mParameters.bStaticAction) {
+        if (oControl.isTableBound()) {
+          mParameters.contexts = oControl.getRowBinding().getHeaderContext();
+        } else {
+          const sBindingPath = oControl.data("rowsBindingInfo").path,
+            oListBinding = new ODataListBinding(this.getView().getModel(), sBindingPath);
+          mParameters.contexts = oListBinding.getHeaderContext();
+        }
+        if (sOverloadEntityType && oControl.getBindingContext()) {
+          mParameters.contexts = this._getActionOverloadContextFromMetadataPath(oControl.getBindingContext(), oControl.getRowBinding(), sOverloadEntityType);
+        }
+        if (mParameters.enableAutoScroll) {
+          oCurrentActionCallBacks = this._createActionPromise(sActionName, oControl.sId);
+        }
+      }
+      mParameters.bGetBoundContext = this._getBoundContext(oView, mParameters);
+      // Need to know that the action is called from ObjectPage for changeSet Isolated workaround
+      mParameters.bObjectPage = oView.getViewData().converterType === "ObjectPage";
+      try {
+        await this._syncTask();
+        const oResponse = await transactionHelper.callAction(sActionName, mParameters, this.getView(), this.getAppComponent(), this._getMessageHandler());
+        if (mParameters.contexts && mParameters.isBound === true) {
+          await this._refreshListIfRequired(this._getActionResponseDataAndKeys(sActionName, oResponse), mParameters.contexts[0]);
+        }
+        this._sendActivity(Activity.Action, mParameters.contexts, sActionName);
+        this._triggerConfiguredSurvey(sActionName, TriggerType.action);
+        if (oCurrentActionCallBacks) {
+          oCurrentActionCallBacks.fResolver(oResponse);
+        }
+        /*
+        		We set the (upper) pages to dirty after an execution of an action
+        		TODO: get rid of this workaround
+        		This workaround is only needed as long as the model does not support the synchronization.
+        		Once this is supported we don't need to set the pages to dirty anymore as the context itself
+        		is already refreshed (it's just not reflected in the object page)
+        		we explicitly don't call this method from the list report but only call it from the object page
+        		as if it is called in the list report it's not needed - as we anyway will remove this logic
+        		we can live with this
+        		we need a context to set the upper pages to dirty - if there are more than one we use the
+        		first one as they are anyway siblings
+        		*/
+        if (mParameters.contexts) {
+          if (!this._isFclEnabled()) {
+            EditState.setEditStateDirty();
+          }
+          this._getInternalModel().setProperty("/lastInvokedAction", sActionName);
+        }
+        if (mParameters.isNavigable) {
+          let vContext = oResponse;
+          if (Array.isArray(vContext) && vContext.length === 1) {
+            vContext = vContext[0].value;
+          }
+          if (vContext && !Array.isArray(vContext)) {
+            const oMetaModel = oView.getModel().getMetaModel();
+            const sContextMetaPath = oMetaModel.getMetaPath(vContext.getPath());
+            const _fnValidContexts = (contexts, applicableContexts) => {
+              return contexts.filter(element => {
+                if (applicableContexts) {
+                  return applicableContexts.indexOf(element) > -1;
+                }
+                return true;
+              });
+            };
+            const oActionContext = Array.isArray(mParameters.contexts) ? _fnValidContexts(mParameters.contexts, mParameters.applicableContext)[0] : mParameters.contexts;
+            const sActionContextMetaPath = oActionContext && oMetaModel.getMetaPath(oActionContext.getPath());
+            if (sContextMetaPath != undefined && sContextMetaPath === sActionContextMetaPath) {
+              if (oActionContext.getPath() !== vContext.getPath()) {
+                this._getRoutingListener().navigateForwardToContext(vContext, {
+                  checkNoHashChange: true,
+                  noHistoryEntry: false
+                });
+              } else {
+                Log.info("Navigation to the same context is not allowed");
+              }
+            }
+          }
+        }
+        return oResponse;
+      } catch (err) {
+        if (oCurrentActionCallBacks) {
+          oCurrentActionCallBacks.fRejector();
+        }
+        // FIXME: in most situations there is no handler for the rejected promises returnedq
+        if (err === Constants.CancelActionDialog) {
+          // This leads to console error. Actually the error is already handled (currently directly in press handler of end button in dialog), so it should not be forwarded
+          // up to here. However, when dialog handling and backend execution are separated, information whether dialog was cancelled, or backend execution has failed needs
+          // to be transported to the place responsible for connecting these two things.
+          // TODO: remove special handling one dialog handling and backend execution are separated
+          throw new Error("Dialog cancelled");
+        } else if (!(err && (err.canceled || err.rejectedItems && err.rejectedItems[0].canceled))) {
+          // TODO: analyze, whether this is of the same category as above
+          throw new Error(`Error in EditFlow.invokeAction:${err}`);
+        }
+        // TODO: Any unexpected errors probably should not be ignored!
+      }
+    }
+
+    /**
+     * Secured execution of the given function. Ensures that the function is only executed when certain conditions are fulfilled.
+     *
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @param fnFunction The function to be executed. Should return a promise that is settled after completion of the execution. If nothing is returned, immediate completion is assumed.
+     * @param mParameters Definitions of the preconditions to be checked before execution
+     * @param mParameters.busy Defines the busy indicator
+     * @param mParameters.busy.set Triggers a busy indicator when the function is executed.
+     * @param mParameters.busy.check Executes function only if application isn't busy.
+     * @param mParameters.updatesDocument This operation updates the current document without using the bound model and context. As a result, the draft status is updated if a draft document exists, and the user has to confirm the cancellation of the editing process.
+     * @returns A promise that is rejected if the execution is prohibited and resolved by the promise returned by the fnFunction.
+     * @alias sap.fe.core.controllerextensions.EditFlow#securedExecution
+     * @public
+     * @experimental As of version 1.90.0
+     * @since 1.90.0
+     */;
+    _proto.securedExecution = function securedExecution(fnFunction, mParameters) {
+      const bBusySet = mParameters && mParameters.busy && mParameters.busy.set !== undefined ? mParameters.busy.set : true,
+        bBusyCheck = mParameters && mParameters.busy && mParameters.busy.check !== undefined ? mParameters.busy.check : true,
+        bUpdatesDocument = mParameters && mParameters.updatesDocument || false,
+        oLockObject = this._getGlobalUIModel(),
+        oContext = this.base.getView().getBindingContext(),
+        bIsDraft = oContext && this._getProgrammingModel(oContext) === ProgrammingModel.Draft;
+      if (bBusyCheck && BusyLocker.isLocked(oLockObject)) {
+        return Promise.reject("Application already busy therefore execution rejected");
+      }
+
+      // we have to set busy and draft indicator immediately also the function might be executed later in queue
+      if (bBusySet) {
+        BusyLocker.lock(oLockObject);
+      }
+      if (bUpdatesDocument && bIsDraft) {
+        this._setDraftStatus(DraftStatus.Saving);
+      }
+      this._getMessageHandler().removeTransitionMessages();
+      return this._syncTask(fnFunction).then(() => {
+        if (bUpdatesDocument) {
+          this._setDocumentModified(true);
+          if (!this._isFclEnabled()) {
+            EditState.setEditStateDirty();
+          }
+          if (bIsDraft) {
+            this._setDraftStatus(DraftStatus.Saved);
+          }
+        }
+      }).catch(oError => {
+        if (bUpdatesDocument && bIsDraft) {
+          this._setDraftStatus(DraftStatus.Clear);
+        }
+        return Promise.reject(oError);
+      }).finally(() => {
+        if (bBusySet) {
+          BusyLocker.unlock(oLockObject);
+        }
+        this._getMessageHandler().showMessageDialog();
+      });
+    }
+
+    /**
+     * Handles the patchSent event: register document modification.
+     *
+     * @param oEvent The event sent by the binding
+     */;
+    _proto.handlePatchSent = function handlePatchSent(oEvent) {
+      var _this$getView, _this$getView$getBind;
+      // In collaborative draft, disable ETag check for PATCH requests
+      const isInCollaborativeDraft = isConnected(this.getView());
+      if (isInCollaborativeDraft) {
+        oEvent.getSource().getModel().setIgnoreETag(true);
+      }
+      if (!((_this$getView = this.getView()) !== null && _this$getView !== void 0 && (_this$getView$getBind = _this$getView.getBindingContext("internal")) !== null && _this$getView$getBind !== void 0 && _this$getView$getBind.getProperty("skipPatchHandlers"))) {
+        // Create a promise that will be resolved or rejected when the path is completed
+        const oPatchPromise = new Promise((resolve, reject) => {
+          oEvent.getSource().attachEventOnce("patchCompleted", patchCompletedEvent => {
+            // Re-enable ETag checks
+            if (isInCollaborativeDraft) {
+              oEvent.getSource().getModel().setIgnoreETag(false);
+            }
+            if (oEvent.getSource().isA("sap.ui.model.odata.v4.ODataListBinding")) {
+              var _this$getView2;
+              ActionRuntime.setActionEnablementAfterPatch(this.getView(), oEvent.getSource(), (_this$getView2 = this.getView()) === null || _this$getView2 === void 0 ? void 0 : _this$getView2.getBindingContext("internal"));
+            }
+            const bSuccess = patchCompletedEvent.getParameter("success");
+            if (bSuccess) {
+              resolve();
+            } else {
+              reject();
+            }
+          });
+        });
+        this.updateDocument(oEvent.getSource(), oPatchPromise);
+      }
+    }
+
+    /**
+     * Handles the CreateActivate event.
+     *
+     * @param oEvent The event sent by the binding
+     */;
+    _proto.handleCreateActivate = async function handleCreateActivate(oEvent) {
+      const oBinding = oEvent.getSource();
+      const transactionHelper = this._getTransactionHelper();
+      const bAtEnd = true;
+      const bInactive = true;
+      const oParams = {
+        creationMode: CreationMode.Inline,
+        createAtEnd: bAtEnd,
+        inactive: bInactive,
+        keepTransientContextOnFailed: false,
+        // currently not fully supported
+        busyMode: "None"
+      };
+      try {
+        var _activatedContext$cre;
+        // Send notification to other users only after the creation has been finalized
+        const activatedContext = oEvent.getParameter("context");
+        (_activatedContext$cre = activatedContext.created()) === null || _activatedContext$cre === void 0 ? void 0 : _activatedContext$cre.then(() => {
+          this._sendActivity(Activity.Create, activatedContext);
+        }).catch(() => {
+          Log.warning(`Failed to activate context ${activatedContext.getPath()}`);
+        });
+
+        // Create a new inactive context (empty row in the table)
+        const newInactiveContext = await transactionHelper.createDocument(oBinding, oParams, this.getAppComponent(), this._getMessageHandler(), false, this.getView());
+        if (newInactiveContext) {
+          if (!this._isFclEnabled()) {
+            EditState.setEditStateDirty();
+          }
+        }
+      } catch (error) {
+        Log.error("Failed to activate new row -", error);
+      }
+    }
+
+    //////////////////////////////////////
+    // Private methods
+    //////////////////////////////////////
+
+    /*
+    		 TO BE CHECKED / DISCUSSED
+    		 _createMultipleDocuments and deleteMultiDocument - couldn't we combine them with create and delete document?
+    		 _createActionPromise and deleteCurrentActionPromise -> next step
+    			 */;
+    _proto._setEditMode = function _setEditMode(sEditMode, bCreationMode) {
+      this.getInternalEditFlow().setEditMode(sEditMode, bCreationMode);
+    };
+    _proto._getCreationMode = function _getCreationMode() {
+      return this.getInternalEditFlow().getCreationMode();
+    };
+    _proto._isDocumentModified = function _isDocumentModified() {
+      return this.getInternalEditFlow().isDocumentModified();
+    };
+    _proto._setDocumentModified = function _setDocumentModified(modified) {
+      this.getInternalEditFlow().setDocumentModified(modified);
+    };
+    _proto._setDocumentModifiedOnCreate = function _setDocumentModifiedOnCreate(listBinding) {
+      this.getInternalEditFlow().setDocumentModifiedOnCreate(listBinding);
+    };
+    _proto._setDraftStatus = function _setDraftStatus(sDraftState) {
+      this.getInternalEditFlow().setDraftStatus(sDraftState);
+    };
+    _proto._getRoutingListener = function _getRoutingListener() {
+      return this.getInternalEditFlow().getRoutingListener();
+    };
+    _proto._getGlobalUIModel = function _getGlobalUIModel() {
+      return this.getInternalEditFlow().getGlobalUIModel();
+    };
+    _proto._syncTask = function _syncTask(vTask) {
+      return this.getInternalEditFlow().syncTask(vTask);
+    };
+    _proto._getProgrammingModel = function _getProgrammingModel(oContext) {
+      return this.getInternalEditFlow().getProgrammingModel(oContext);
+    };
+    _proto._deleteDocumentTransaction = function _deleteDocumentTransaction(oContext, mParameters) {
+      return this.getInternalEditFlow().deleteDocumentTransaction(oContext, mParameters);
+    };
+    _proto._handleCreateEvents = function _handleCreateEvents(oBinding) {
+      this.getInternalEditFlow().handleCreateEvents(oBinding);
+    };
+    _proto._getTransactionHelper = function _getTransactionHelper() {
+      return this.getInternalEditFlow().getTransactionHelper();
+    };
+    _proto._getInternalModel = function _getInternalModel() {
+      return this.getInternalEditFlow().getInternalModel();
+    };
+    _proto._getRootViewController = function _getRootViewController() {
+      return this.getAppComponent().getRootViewController();
+    };
+    _proto._getResourceBundle = function _getResourceBundle() {
+      return this.getView().getController().oResourceBundle;
+    };
+    _proto._getSemanticMapping = function _getSemanticMapping() {
+      return this.getAppComponent().getRoutingService().getLastSemanticMapping();
+    }
+
+    /**
+     * Creates a new promise to wait for an action to be executed
+     *
+     * @function
+     * @name _createActionPromise
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @returns {Function} The resolver function which can be used to externally resolve the promise
+     */;
+    _proto._createActionPromise = function _createActionPromise(sActionName, sControlId) {
+      return this.getInternalEditFlow().createActionPromise(sActionName, sControlId);
+    };
+    _proto._getCurrentActionPromise = function _getCurrentActionPromise() {
+      return this.getInternalEditFlow().getCurrentActionPromise();
+    };
+    _proto._deleteCurrentActionPromise = function _deleteCurrentActionPromise() {
+      return this.getInternalEditFlow().deleteCurrentActionPromise();
+    };
+    _proto._getMessageHandler = function _getMessageHandler() {
+      return this.getInternalEditFlow().getMessageHandler();
+    };
+    _proto._sendActivity = function _sendActivity(action, relatedContexts, actionName) {
+      const content = Array.isArray(relatedContexts) ? relatedContexts.map(context => context.getPath()) : relatedContexts === null || relatedContexts === void 0 ? void 0 : relatedContexts.getPath();
+      send(this.getView(), action, content, actionName);
+    };
+    _proto._triggerConfiguredSurvey = function _triggerConfiguredSurvey(sActionName, triggerType) {
+      triggerConfiguredSurvey(this.getView(), sActionName, triggerType);
+    }
+
+    /**
+     * @function
+     * @name _getActionResponseDataAndKeys
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @param sActionName The name of the action that is executed
+     * @param oResponse The bound action's response data or response context
+     * @returns Object with data and names of the key fields of the response
+     */;
+    _proto._getActionResponseDataAndKeys = function _getActionResponseDataAndKeys(sActionName, oResponse) {
+      return this.getInternalEditFlow().getActionResponseDataAndKeys(sActionName, oResponse);
+    };
+    _proto._submitOpenChanges = async function _submitOpenChanges(oContext) {
+      const oModel = oContext.getModel(),
+        oLockObject = this._getGlobalUIModel();
+      try {
+        // Submit any leftover changes that are not yet submitted
+        // Currently we are using only 1 updateGroupId, hence submitting the batch directly here
+        await oModel.submitBatch("$auto");
+
+        // Wait for all currently running changes
+        // For the time being we agreed with the v4 model team to use an internal method. We'll replace it once
+        // a public or restricted method was provided
+        await oModel.oRequestor.waitForRunningChangeRequests("$auto");
+
+        // Check if all changes were submitted successfully
+        if (oModel.hasPendingChanges("$auto")) {
+          throw new Error("submit of open changes failed");
+        }
+      } finally {
+        if (BusyLocker.isLocked(oLockObject)) {
+          BusyLocker.unlock(oLockObject);
+        }
+      }
+    };
+    _proto._handleStickyOn = function _handleStickyOn(oContext) {
+      return this.getInternalEditFlow().handleStickyOn(oContext);
+    };
+    _proto._handleStickyOff = function _handleStickyOff() {
+      return this.getInternalEditFlow().handleStickyOff();
+    };
+    _proto._onBackNavigationInSession = function _onBackNavigationInSession() {
+      return this.getInternalEditFlow().onBackNavigationInSession();
+    };
+    _proto._setStickySessionInternalProperties = function _setStickySessionInternalProperties(programmingModel, model) {
+      if (programmingModel === ProgrammingModel.Sticky) {
+        const internalModel = this._getInternalModel();
+        internalModel.setProperty("/sessionOn", true);
+        internalModel.setProperty("/stickySessionToken", model.getHttpHeaders(true)["SAP-ContextId"]);
+      }
+    };
+    _proto._removeStickySessionInternalProperties = function _removeStickySessionInternalProperties(programmingModel) {
+      if (programmingModel === ProgrammingModel.Sticky) {
+        const internalModel = this._getInternalModel();
+        internalModel.setProperty("/sessionOn", false);
+        internalModel.setProperty("/stickySessionToken", undefined);
+        this._handleStickyOff( /*oContext*/);
+      }
+    };
+    _proto._handleNewContext = async function _handleNewContext(oContext, bEditable, bRecreateContext, bDraftNavigation) {
+      let bForceFocus = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+      if (!this._isFclEnabled()) {
+        EditState.setEditStateDirty();
+      }
+      await this._getRoutingListener().navigateToContext(oContext, {
+        checkNoHashChange: true,
+        editable: bEditable,
+        bPersistOPScroll: true,
+        bRecreateContext: bRecreateContext,
+        bDraftNavigation: bDraftNavigation,
+        showPlaceholder: false,
+        bForceFocus: bForceFocus,
+        keepCurrentLayout: true
+      });
+    };
+    _proto._getBoundContext = function _getBoundContext(view, params) {
+      const viewLevel = view.getViewData().viewLevel;
+      const bRefreshAfterAction = viewLevel > 1 || viewLevel === 1 && params.controlId;
+      return !params.isNavigable || !!bRefreshAfterAction;
+    }
+
+    /**
+     * Checks if there are validation (parse) errors for controls bound to a given context
+     *
+     * @function
+     * @name _checkForValidationErrors
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @returns {Promise} Promise resolves if there are no validation errors, and rejects if there are validation errors
+     */;
+    _proto._checkForValidationErrors = function _checkForValidationErrors() {
+      return this._syncTask().then(() => {
+        const sViewId = this.base.getView().getId();
+        const aMessages = sap.ui.getCore().getMessageManager().getMessageModel().getData();
+        let oControl;
+        let oMessage;
+        if (!aMessages.length) {
+          return Promise.resolve("No validation errors found");
+        }
+        for (let i = 0; i < aMessages.length; i++) {
+          oMessage = aMessages[i];
+          if (oMessage.validation) {
+            oControl = Core.byId(oMessage.getControlId());
+            while (oControl) {
+              if (oControl.getId() === sViewId) {
+                return Promise.reject("validation errors exist");
+              }
+              oControl = oControl.getParent();
+            }
+          }
+        }
+      });
+    }
+
+    /**
+     * @function
+     * @name _refreshListIfRequired
+     * @memberof sap.fe.core.controllerextensions.EditFlow
+     * @param oResponse The response of the bound action and the names of the key fields
+     * @param oContext The bound context on which the action was executed
+     * @returns Always resolves to param oResponse
+     */;
+    _proto._refreshListIfRequired = function _refreshListIfRequired(oResponse, oContext) {
+      if (!oContext || !oResponse || !oResponse.oData) {
+        return Promise.resolve();
+      }
+      const oBinding = oContext.getBinding();
+      // refresh only lists
+      if (oBinding && oBinding.isA("sap.ui.model.odata.v4.ODataListBinding")) {
+        const oContextData = oResponse.oData;
+        const aKeys = oResponse.keys;
+        const oCurrentData = oContext.getObject();
+        let bReturnedContextIsSame = true;
+        // ensure context is in the response
+        if (Object.keys(oContextData).length) {
+          // check if context in response is different than the bound context
+          bReturnedContextIsSame = aKeys.every(function (sKey) {
+            return oCurrentData[sKey] === oContextData[sKey];
+          });
+          if (!bReturnedContextIsSame) {
+            return new Promise(resolve => {
+              if (oBinding.isRoot()) {
+                oBinding.attachEventOnce("dataReceived", function () {
+                  resolve();
+                });
+                oBinding.refresh();
+              } else {
+                const oAppComponent = CommonUtils.getAppComponent(this.getView());
+                oAppComponent.getSideEffectsService().requestSideEffects([{
+                  $NavigationPropertyPath: oBinding.getPath()
+                }], oBinding.getContext()).then(function () {
+                  resolve();
+                }, function () {
+                  Log.error("Error while refreshing the table");
+                  resolve();
+                }).catch(function (e) {
+                  Log.error("Error while refreshing the table", e);
+                });
+              }
+            });
+          }
+        }
+      }
+      // resolve with oResponse to not disturb the promise chain afterwards
+      return Promise.resolve();
+    };
+    _proto._fetchSemanticKeyValues = function _fetchSemanticKeyValues(oContext) {
+      const oMetaModel = oContext.getModel().getMetaModel(),
+        sEntitySetName = oMetaModel.getMetaContext(oContext.getPath()).getObject("@sapui.name"),
+        aSemanticKeys = SemanticKeyHelper.getSemanticKeys(oMetaModel, sEntitySetName);
+      if (aSemanticKeys && aSemanticKeys.length) {
+        const aRequestPromises = aSemanticKeys.map(function (oKey) {
+          return oContext.requestObject(oKey.$PropertyPath);
+        });
+        return Promise.all(aRequestPromises);
+      } else {
+        return Promise.resolve();
+      }
+    }
+
+    /**
+     * Provides the latest context in the metadata hierarchy from rootBinding to given context pointing to given entityType
+     * if any such context exists. Otherwise, it returns the original context.
+     * Note: It is only needed as work-around for incorrect modelling. Correct modelling would imply a DataFieldForAction in a LineItem
+     * to point to an overload defined either on the corresponding EntityType or a collection of the same.
+     *
+     * @param rootContext The context to start searching from
+     * @param listBinding The listBinding of the table
+     * @param overloadEntityType The ActionOverload entity type to search for
+     * @returns Returns the context of the ActionOverload entity
+     */;
+    _proto._getActionOverloadContextFromMetadataPath = function _getActionOverloadContextFromMetadataPath(rootContext, listBinding, overloadEntityType) {
+      const model = rootContext.getModel();
+      const metaModel = model.getMetaModel();
+      let contextSegments = listBinding.getPath().split("/");
+      let currentContext = rootContext;
+
+      // We expect that the last segment of the listBinding is the ListBinding of the table. Remove this from contextSegments
+      // because it is incorrect to execute bindContext on a list. We do not anyway need to search this context for the overload.
+      contextSegments.pop();
+      if (contextSegments.length === 0) {
+        contextSegments = [""]; // Don't leave contextSegments undefined
+      }
+
+      if (contextSegments[0] !== "") {
+        contextSegments.unshift(""); // to also get the root context, i.e. the bindingContext of the table
+      }
+      // load all the parent contexts into an array
+      const parentContexts = contextSegments.map(pathSegment => {
+        if (pathSegment !== "") {
+          currentContext = model.bindContext(pathSegment, currentContext).getBoundContext();
+        } else {
+          // Creating a new context using bindContext(...).getBoundContext() does not work if the etag is needed. According to model colleagues,
+          // we should always use an existing context if possible.
+          // Currently, the only example we know about is using the rootContext - and in this case, we can obviously reuse that existing context.
+          // If other examples should come up, the best possible work around would be to request some data to get an existing context. To keep the
+          // request as small and fast as possible, we should request only the first key property. As this would introduce asynchronism, and anyway
+          // the whole logic is only part of work-around for incorrect modelling, we wait until we have an example needing it before implementing this.
+          currentContext = rootContext;
+        }
+        return currentContext;
+      }).reverse();
+      // search for context backwards
+      const overloadContext = parentContexts.find(parentContext => metaModel.getMetaContext(parentContext.getPath()).getObject("$Type") === overloadEntityType);
+      return overloadContext || listBinding.getHeaderContext();
+    };
+    _proto._createSiblingInfo = function _createSiblingInfo(currentContext, newContext) {
+      return {
+        targetContext: newContext,
+        pathMapping: [{
+          oldPath: currentContext.getPath(),
+          newPath: newContext.getPath()
+        }]
+      };
+    };
+    _proto._updatePathsInHistory = function _updatePathsInHistory(mappings) {
+      const oAppComponent = this.getAppComponent();
+      oAppComponent.getRouterProxy().setPathMapping(mappings);
+
+      // Also update the semantic mapping in the routing service
+      const lastSemanticMapping = this._getSemanticMapping();
+      if (mappings.length && (lastSemanticMapping === null || lastSemanticMapping === void 0 ? void 0 : lastSemanticMapping.technicalPath) === mappings[mappings.length - 1].oldPath) {
+        lastSemanticMapping.technicalPath = mappings[mappings.length - 1].newPath;
+      }
+    };
+    _proto._getNavigationTargetForEdit = function _getNavigationTargetForEdit(context, newDocumentContext, siblingInfo) {
+      let contextToNavigate;
+      siblingInfo = siblingInfo ?? this._createSiblingInfo(context, newDocumentContext);
+      this._updatePathsInHistory(siblingInfo.pathMapping);
+      if (siblingInfo.targetContext.getPath() != newDocumentContext.getPath()) {
+        contextToNavigate = siblingInfo.targetContext;
+      }
+      return contextToNavigate;
+    }
+    /**
+     * This method creates a sibling context for a subobject page, and calculates a sibling path
+     * for all intermediate paths between the object page and the subobject page.
+     *
+     * @param rootCurrentContext The context for the root of the draft
+     * @param rightmostCurrentContext The context of the subobject
+     * @param sProgrammingModel The programming model
+     * @param doNotComputeIfRoot If true, we don't compute siblingInfo if the root and the rightmost contexts are the same
+     * @returns Returns the siblingInformation object
+     */;
+    _proto._computeSiblingInformation = async function _computeSiblingInformation(rootCurrentContext, rightmostCurrentContext, sProgrammingModel, doNotComputeIfRoot) {
+      rightmostCurrentContext = rightmostCurrentContext ?? rootCurrentContext;
+      if (!rightmostCurrentContext.getPath().startsWith(rootCurrentContext.getPath())) {
+        // Wrong usage !!
+        Log.error("Cannot compute rightmost sibling context");
+        throw new Error("Cannot compute rightmost sibling context");
+      }
+      if (doNotComputeIfRoot && rightmostCurrentContext.getPath() === rootCurrentContext.getPath()) {
+        return Promise.resolve(undefined);
+      }
+      const model = rootCurrentContext.getModel();
+      if (sProgrammingModel === ProgrammingModel.Draft) {
+        return draft.computeSiblingInformation(rootCurrentContext, rightmostCurrentContext);
+      } else {
+        // If not in draft mode, we just recreate a context from the path of the rightmost context
+        // No path mapping is needed
+        return {
+          targetContext: model.bindContext(rightmostCurrentContext.getPath()).getBoundContext(),
+          pathMapping: []
+        };
+      }
+    };
+    _proto._isFclEnabled = function _isFclEnabled() {
+      return CommonUtils.getAppComponent(this.getView())._isFclEnabled();
+    };
+    return EditFlow;
+  }(ControllerExtension), (_applyDecoratedDescriptor(_class2.prototype, "editDocument", [_dec2, _dec3], Object.getOwnPropertyDescriptor(_class2.prototype, "editDocument"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "deleteMultipleDocuments", [_dec4, _dec5], Object.getOwnPropertyDescriptor(_class2.prototype, "deleteMultipleDocuments"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "updateDocument", [_dec6, _dec7], Object.getOwnPropertyDescriptor(_class2.prototype, "updateDocument"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "createDocument", [_dec8, _dec9], Object.getOwnPropertyDescriptor(_class2.prototype, "createDocument"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onBeforeSave", [_dec10, _dec11], Object.getOwnPropertyDescriptor(_class2.prototype, "onBeforeSave"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onBeforeCreate", [_dec12, _dec13], Object.getOwnPropertyDescriptor(_class2.prototype, "onBeforeCreate"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onBeforeEdit", [_dec14, _dec15], Object.getOwnPropertyDescriptor(_class2.prototype, "onBeforeEdit"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onBeforeDiscard", [_dec16, _dec17], Object.getOwnPropertyDescriptor(_class2.prototype, "onBeforeDiscard"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onBeforeDelete", [_dec18, _dec19], Object.getOwnPropertyDescriptor(_class2.prototype, "onBeforeDelete"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "saveDocument", [_dec20, _dec21], Object.getOwnPropertyDescriptor(_class2.prototype, "saveDocument"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "toggleDraftActive", [_dec22, _dec23], Object.getOwnPropertyDescriptor(_class2.prototype, "toggleDraftActive"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "cancelDocument", [_dec24, _dec25], Object.getOwnPropertyDescriptor(_class2.prototype, "cancelDocument"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "deleteDocument", [_dec26, _dec27], Object.getOwnPropertyDescriptor(_class2.prototype, "deleteDocument"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "applyDocument", [_dec28, _dec29], Object.getOwnPropertyDescriptor(_class2.prototype, "applyDocument"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "invokeAction", [_dec30, _dec31], Object.getOwnPropertyDescriptor(_class2.prototype, "invokeAction"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "securedExecution", [_dec32, _dec33], Object.getOwnPropertyDescriptor(_class2.prototype, "securedExecution"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "handlePatchSent", [_dec34], Object.getOwnPropertyDescriptor(_class2.prototype, "handlePatchSent"), _class2.prototype)), _class2)) || _class);
+  return EditFlow;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["CreationMode","FELibrary","ProgrammingModel","Constants","DraftStatus","EditMode","StartupMode","MessageType","coreLibrary","EditFlow","defineUI5Class","publicExtension","finalExtension","extensible","OverrideExecution","After","getAppComponent","base","getInternalEditFlow","getView","getController","_editFlow","editDocument","oContext","bDraftNavigation","transactionHelper","_getTransactionHelper","oRootViewController","_getRootViewController","model","getModel","rightmostContext","siblingInfo","oViewData","getViewData","sProgrammingModel","_getProgrammingModel","oRootContext","oView","viewLevel","Draft","draftRootPath","ModelHelper","getDraftRootPath","bindContext","getBoundContext","requestObject","Sticky","sStickyRootPath","getStickyRootPath","editFlow","onBeforeEdit","context","oNewDocumentContext","_getMessageHandler","_setStickySessionInternalProperties","_setEditMode","Editable","_setDocumentModified","showMessageDialog","contextToNavigate","_isFclEnabled","getRightmostContext","_computeSiblingInformation","_createSiblingInfo","_updatePathsInHistory","pathMapping","targetContext","getPath","_getNavigationTargetForEdit","_handleNewContext","stickyContext","getKeepAliveContext","_handleStickyOn","isCollaborationDraftSupported","getMetaModel","shareObject","oError","Log","error","deleteMultipleDocuments","aContexts","mParameters","beforeDeleteCallBack","onBeforeDelete","updateDocument","updatedContext","updatePromise","originalBindingContext","getBindingContext","isDraft","removeTransitionMessages","_syncTask","EditState","setEditStateDirty","_setDraftStatus","Saving","currentBindingContext","metaModel","entitySetName","getMetaContext","getObject","semanticKeys","SemanticKeyHelper","getSemanticKeys","length","currentSemanticMapping","_getSemanticMapping","currentSemanticPath","semanticPath","sChangedPath","getSemanticPath","Saved","Clear","showMessages","createDocument","vListBinding","mInParameters","oLockObject","_getGlobalUIModel","oTable","bShouldBusyLock","creationMode","Inline","CreationRow","External","oExecCustomValidation","Promise","resolve","oAppComponent","CommonUtils","getRouterProxy","removeIAppStateKey","oController","sCreatePath","getAbsoluteMetaPathForListBinding","handlers","onChevronPressNavigateOutBound","outbound","undefined","creationRow","oCreationRowObjects","getParent","validateDocument","data","customValidationFunction","getCreationRow","oInternalModelContext","setProperty","tableId","byId","isA","fnFocusOrScroll","focusRow","bind","scrollToIndex","getRowBinding","attachEventOnce","createAtEnd","getLength","handleSideEffects","oListBinding","oCreationPromise","oNewContext","created","oBindingContext","hasTransientContext","appComponent","getSideEffectsService","requestSideEffectsForNavigationProperty","createCustomValidationMessages","aValidationMessages","sCustomValidationFunction","mCustomValidity","getProperty","oMessageManager","Core","getMessageManager","aCustomMessages","oFieldControl","sTarget","getMessageModel","getData","forEach","oMessage","code","removeMessages","oValidationMessage","messageTarget","getControl","fieldId","getBindingPath","filter","target","addMessages","Message","message","messageText","processor","type","Error","technical","persistent","aExistingValidationMessages","addControlId","push","text","customMessages","resolveCreationMode","initialCreationMode","programmingModel","oMetaModel","NewPage","isRelative","sPath","sNewAction","aParameters","Deferred","sMetaPath","getMetaPath","getHeaderContext","aNonComputedVisibleKeyFields","getNonComputedVisibleFields","Async","BusyLocker","lock","ODataListBinding","Sync","oModel","resolvedCreationMode","oCreation","mArgs","oCreationRow","oCreationRowContext","oPayload","oRoutingListener","_getRoutingListener","Object","keys","sPropertyPath","oProperty","$kind","_checkForValidationErrors","keepTransientContextOnFailed","busyMode","busyId","getTableDefinition","annotation","id","_handleCreateEvents","parentControl","beforeCreateCallBack","onBeforeCreate","skipParameterDialog","getStartupMode","AutoCreate","oNavigation","navigateForwardToContext","bDeferredContext","editable","bForceFocus","asyncContext","createAction","transient","then","coreResourceBundle","getLibraryResourceBundle","navigateToMessagePage","getText","title","description","bFromDeferred","navigateToContext","oCreationRowListBinding","getBinding","bSkipSideEffects","oNewTransientContext","create","setBindingContext","catch","trace","delete","isLocked","unlock","reject","aParams","all","metaContext","entitySet","getInvolvedDataModelObjects","startingEntitySet","newAction","annotations","Session","StickySessionSupported","NewAction","_getInternalModel","_setDocumentModifiedOnCreate","_sendActivity","Activity","Create","CancelActionDialog","ActionExecutionFailed","CreationFailed","navigateBackFromTransientState","onBeforeSave","_mParameters","onBeforeDiscard","saveDocument","bExecuteSideEffectsOnError","oResourceBundle","_getResourceBundle","aBindings","bindings","_submitOpenChanges","isFclEnabled","activeDocumentContext","_getCreationMode","_removeStickySessionInternalProperties","Activate","_triggerConfiguredSurvey","StandardActions","save","TriggerType","standardAction","Display","canceled","toggleDraftActive","oContextData","bEditable","bIsDraft","IsActiveEntity","HasActiveEntity","HasDraftEntity","oRightmostContext","lastSemanticMapping","technicalPath","targetPath","newPath","oldPath","cancelDocument","cancelButton","control","beforeCancelCallBack","cancelResult","_isDocumentModified","Discard","skipBackNavigation","navigateBackFromContext","oActiveDocumentContext","_fetchSemanticKeyValues","skipBindingToView","isDraftRoot","targetEntitySet","deleteDocument","bFindActiveContexts","getIndex","parameters","siblingContext","draftPath","requestCanonicalPath","draftContextToRemove","replaceWith","_deleteDocumentTransaction","Delete","getShellServices","setBackNavigation","Deeplink","exitFromApp","applyDocument","invokeAction","sActionName","mExtraParams","oControl","aParts","sOverloadEntityType","oCurrentActionCallBacks","Array","isArray","contexts","isNavigable","requiresNavigation","actionMetaData","split","isBound","$IsBound","controlId","internalModelContext","indexOf","replaceAll","bStaticAction","isTableBound","sBindingPath","path","_getActionOverloadContextFromMetadataPath","enableAutoScroll","_createActionPromise","sId","bGetBoundContext","_getBoundContext","bObjectPage","converterType","oResponse","callAction","_refreshListIfRequired","_getActionResponseDataAndKeys","Action","action","fResolver","vContext","value","sContextMetaPath","_fnValidContexts","applicableContexts","element","oActionContext","applicableContext","sActionContextMetaPath","checkNoHashChange","noHistoryEntry","info","err","fRejector","rejectedItems","securedExecution","fnFunction","bBusySet","busy","set","bBusyCheck","check","bUpdatesDocument","updatesDocument","finally","handlePatchSent","oEvent","isInCollaborativeDraft","isConnected","getSource","setIgnoreETag","oPatchPromise","patchCompletedEvent","ActionRuntime","setActionEnablementAfterPatch","bSuccess","getParameter","handleCreateActivate","oBinding","bAtEnd","bInactive","oParams","inactive","activatedContext","warning","newInactiveContext","sEditMode","bCreationMode","setEditMode","getCreationMode","isDocumentModified","modified","setDocumentModified","listBinding","setDocumentModifiedOnCreate","sDraftState","setDraftStatus","getRoutingListener","getGlobalUIModel","vTask","syncTask","getProgrammingModel","deleteDocumentTransaction","handleCreateEvents","getTransactionHelper","getInternalModel","getRootViewController","getRoutingService","getLastSemanticMapping","sControlId","createActionPromise","_getCurrentActionPromise","getCurrentActionPromise","_deleteCurrentActionPromise","deleteCurrentActionPromise","getMessageHandler","relatedContexts","actionName","content","map","send","triggerType","triggerConfiguredSurvey","getActionResponseDataAndKeys","submitBatch","oRequestor","waitForRunningChangeRequests","hasPendingChanges","handleStickyOn","_handleStickyOff","handleStickyOff","_onBackNavigationInSession","onBackNavigationInSession","internalModel","getHttpHeaders","bRecreateContext","bPersistOPScroll","showPlaceholder","keepCurrentLayout","view","params","bRefreshAfterAction","sViewId","getId","aMessages","sap","ui","getCore","i","validation","getControlId","oData","aKeys","oCurrentData","bReturnedContextIsSame","every","sKey","isRoot","refresh","requestSideEffects","$NavigationPropertyPath","getContext","e","sEntitySetName","aSemanticKeys","aRequestPromises","oKey","$PropertyPath","rootContext","overloadEntityType","contextSegments","currentContext","pop","unshift","parentContexts","pathSegment","reverse","overloadContext","find","parentContext","newContext","mappings","setPathMapping","newDocumentContext","rootCurrentContext","rightmostCurrentContext","doNotComputeIfRoot","startsWith","draft","computeSiblingInformation","ControllerExtension"],"sourceRoot":".","sources":["EditFlow.ts"],"sourcesContent":["import type { EntitySet } from \"@sap-ux/vocabularies-types\";\nimport type ResourceBundle from \"sap/base/i18n/ResourceBundle\";\nimport Log from \"sap/base/Log\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport BusyLocker from \"sap/fe/core/controllerextensions/BusyLocker\";\nimport { isConnected, send } from \"sap/fe/core/controllerextensions/collaboration/ActivitySync\";\nimport { Activity, shareObject } from \"sap/fe/core/controllerextensions/collaboration/CollaborationCommon\";\nimport type { SiblingInformation } from \"sap/fe/core/controllerextensions/editFlow/draft\";\nimport draft from \"sap/fe/core/controllerextensions/editFlow/draft\";\nimport { StandardActions, triggerConfiguredSurvey, TriggerType } from \"sap/fe/core/controllerextensions/Feedback\";\nimport { getInvolvedDataModelObjects } from \"sap/fe/core/converters/MetaModelConverter\";\nimport { defineUI5Class, extensible, finalExtension, publicExtension } from \"sap/fe/core/helpers/ClassSupport\";\nimport EditState from \"sap/fe/core/helpers/EditState\";\nimport type { InternalModelContext } from \"sap/fe/core/helpers/ModelHelper\";\nimport ModelHelper from \"sap/fe/core/helpers/ModelHelper\";\nimport SemanticKeyHelper from \"sap/fe/core/helpers/SemanticKeyHelper\";\nimport FELibrary from \"sap/fe/core/library\";\nimport type PageController from \"sap/fe/core/PageController\";\nimport type { SemanticMapping } from \"sap/fe/core/services/RoutingServiceFactory\";\nimport type Event from \"sap/ui/base/Event\";\nimport type Control from \"sap/ui/core/Control\";\nimport Core from \"sap/ui/core/Core\";\nimport coreLibrary from \"sap/ui/core/library\";\nimport Message from \"sap/ui/core/message/Message\";\nimport ControllerExtension from \"sap/ui/core/mvc/ControllerExtension\";\nimport OverrideExecution from \"sap/ui/core/mvc/OverrideExecution\";\nimport type Table from \"sap/ui/mdc/Table\";\nimport type Binding from \"sap/ui/model/Binding\";\nimport type Context from \"sap/ui/model/odata/v4/Context\";\nimport ODataListBinding from \"sap/ui/model/odata/v4/ODataListBinding\";\nimport type ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport type ODataModel from \"sap/ui/model/odata/v4/ODataModel\";\nimport type { ODataListBinding as V4ListBinding } from \"types/extension_types\";\nimport ActionRuntime from \"../ActionRuntime\";\nimport type { BaseManifestSettings } from \"../converters/ManifestSettings\";\nimport type InternalEditFlow from \"./InternalEditFlow\";\n\nconst CreationMode = FELibrary.CreationMode,\n\tProgrammingModel = FELibrary.ProgrammingModel,\n\tConstants = FELibrary.Constants,\n\tDraftStatus = FELibrary.DraftStatus,\n\tEditMode = FELibrary.EditMode,\n\tStartupMode = FELibrary.StartupMode,\n\tMessageType = coreLibrary.MessageType;\n\n/**\n * A controller extension offering hooks into the edit flow of the application\n *\n * @hideconstructor\n * @public\n * @since 1.90.0\n */\n@defineUI5Class(\"sap.fe.core.controllerextensions.EditFlow\")\nclass EditFlow extends ControllerExtension {\n\tprotected base!: PageController;\n\n\t//////////////////////////////////////\n\t// Public methods\n\t//////////////////////////////////////\n\n\tprivate fnDirtyStateProvider?: Function;\n\tprivate fnHandleSessionTimeout?: Function;\n\tprivate mPatchPromises?: any;\n\tprivate _fnStickyDiscardAfterNavigation?: Function;\n\n\tgetAppComponent(): AppComponent {\n\t\treturn this.base.getAppComponent();\n\t}\n\t/**\n\t * Gets the InternalEditFlow extension.\n\t *\n\t * @returns The internalEditFlow controller extension\n\t */\n\tprivate getInternalEditFlow(): InternalEditFlow {\n\t\treturn (this.base.getView().getController() as PageController)._editFlow;\n\t}\n\n\t/**\n\t * Creates a draft document for an existing active document.\n\t *\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @param oContext Context of the active document\n\t * @returns Promise resolves once the editable document is available\n\t * @alias sap.fe.core.controllerextensions.EditFlow#editDocument\n\t * @public\n\t * @since 1.90.0\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tasync editDocument(oContext: Context): Promise<void> {\n\t\tconst bDraftNavigation = true;\n\t\tconst transactionHelper = this._getTransactionHelper();\n\t\tconst oRootViewController = this._getRootViewController() as any;\n\t\tconst model = oContext.getModel();\n\t\tlet rightmostContext, siblingInfo;\n\t\tconst oViewData = this.getView().getViewData() as BaseManifestSettings;\n\t\tconst sProgrammingModel = this._getProgrammingModel(oContext);\n\t\tlet oRootContext: Context = oContext;\n\t\tconst oView = this.getView();\n\t\ttry {\n\t\t\tif ((oViewData?.viewLevel as number) > 1) {\n\t\t\t\tif (sProgrammingModel === ProgrammingModel.Draft) {\n\t\t\t\t\tconst draftRootPath: string | undefined = ModelHelper.getDraftRootPath(oContext);\n\t\t\t\t\toRootContext = oView\n\t\t\t\t\t\t.getModel()\n\t\t\t\t\t\t.bindContext(draftRootPath as string)\n\t\t\t\t\t\t.getBoundContext() as Context;\n\t\t\t\t\tawait oRootContext.requestObject(draftRootPath);\n\t\t\t\t} else if (sProgrammingModel === ProgrammingModel.Sticky) {\n\t\t\t\t\tconst sStickyRootPath = ModelHelper.getStickyRootPath(oContext);\n\t\t\t\t\toRootContext = oView\n\t\t\t\t\t\t.getModel()\n\t\t\t\t\t\t.bindContext(sStickyRootPath as string)\n\t\t\t\t\t\t.getBoundContext() as Context;\n\t\t\t\t\tawait oRootContext.requestObject(sStickyRootPath);\n\t\t\t\t}\n\t\t\t}\n\t\t\tawait this.base.editFlow.onBeforeEdit({ context: oRootContext });\n\t\t\tconst oNewDocumentContext = await transactionHelper.editDocument(\n\t\t\t\toRootContext,\n\t\t\t\tthis.getView(),\n\t\t\t\tthis.getAppComponent(),\n\t\t\t\tthis._getMessageHandler()\n\t\t\t);\n\n\t\t\tthis._setStickySessionInternalProperties(sProgrammingModel, model);\n\n\t\t\tif (oNewDocumentContext) {\n\t\t\t\tthis._setEditMode(EditMode.Editable, false);\n\t\t\t\tthis._setDocumentModified(false);\n\t\t\t\tthis._getMessageHandler().showMessageDialog();\n\n\t\t\t\tif (oNewDocumentContext !== oRootContext) {\n\t\t\t\t\tlet contextToNavigate: Context | undefined = oNewDocumentContext;\n\t\t\t\t\tif (this._isFclEnabled()) {\n\t\t\t\t\t\trightmostContext = oRootViewController.getRightmostContext();\n\t\t\t\t\t\tsiblingInfo = await this._computeSiblingInformation(oRootContext, rightmostContext, sProgrammingModel, true);\n\t\t\t\t\t\tsiblingInfo = siblingInfo ?? this._createSiblingInfo(oContext, oNewDocumentContext);\n\t\t\t\t\t\tthis._updatePathsInHistory(siblingInfo.pathMapping);\n\t\t\t\t\t\tif (siblingInfo.targetContext.getPath() != oNewDocumentContext.getPath()) {\n\t\t\t\t\t\t\tcontextToNavigate = siblingInfo.targetContext;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if ((oViewData?.viewLevel as number) > 1) {\n\t\t\t\t\t\tsiblingInfo = await this._computeSiblingInformation(oRootContext, oContext, sProgrammingModel, true);\n\t\t\t\t\t\tcontextToNavigate = this._getNavigationTargetForEdit(oContext, oNewDocumentContext, siblingInfo) as Context;\n\t\t\t\t\t}\n\t\t\t\t\tawait this._handleNewContext(contextToNavigate, true, false, bDraftNavigation, true);\n\t\t\t\t\tif (sProgrammingModel === ProgrammingModel.Sticky) {\n\t\t\t\t\t\t// The stickyOn handler must be set after the navigation has been done,\n\t\t\t\t\t\t// as the URL may change in the case of FCL\n\t\t\t\t\t\tlet stickyContext: Context;\n\t\t\t\t\t\tif (this._isFclEnabled()) {\n\t\t\t\t\t\t\t// We need to use the kept-alive context used to bind the page\n\t\t\t\t\t\t\tstickyContext = oNewDocumentContext.getModel().getKeepAliveContext(oNewDocumentContext.getPath());\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tstickyContext = oNewDocumentContext;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tthis._handleStickyOn(stickyContext);\n\t\t\t\t\t} else if (ModelHelper.isCollaborationDraftSupported(model.getMetaModel())) {\n\t\t\t\t\t\t// according to UX in case of enabled collaboration draft we share the object immediately\n\t\t\t\t\t\tawait shareObject(oNewDocumentContext);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (oError) {\n\t\t\tLog.error(\"Error while editing the document\", oError as any);\n\t\t}\n\t}\n\t@publicExtension()\n\t@finalExtension()\n\tdeleteMultipleDocuments(aContexts: any, mParameters: any) {\n\t\tif (mParameters) {\n\t\t\tmParameters.beforeDeleteCallBack = this.base.editFlow.onBeforeDelete;\n\t\t} else {\n\t\t\tmParameters = {\n\t\t\t\tbeforeDeleteCallBack: this.base.editFlow.onBeforeDelete\n\t\t\t};\n\t\t}\n\t\treturn this.getInternalEditFlow().deleteMultipleDocuments(aContexts, mParameters);\n\t}\n\n\t/**\n\t * Updates the draft status and displays the error messages if there are errors during an update.\n\t *\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @param updatedContext Context of the updated field\n\t * @param updatePromise Promise to determine when the update operation is completed. The promise should be resolved when the update operation is completed, so the draft status can be updated.\n\t * @returns Promise resolves once draft status has been updated\n\t * @alias sap.fe.core.controllerextensions.EditFlow#updateDocument\n\t * @public\n\t * @since 1.90.0\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tupdateDocument(updatedContext: object, updatePromise: Promise<any>): Promise<void> {\n\t\tconst originalBindingContext = this.getView().getBindingContext();\n\t\tconst isDraft = this._getProgrammingModel(updatedContext) === ProgrammingModel.Draft;\n\n\t\tthis._getMessageHandler().removeTransitionMessages();\n\t\treturn this._syncTask(async () => {\n\t\t\tif (originalBindingContext) {\n\t\t\t\tthis._setDocumentModified(true);\n\t\t\t\tif (!this._isFclEnabled()) {\n\t\t\t\t\tEditState.setEditStateDirty();\n\t\t\t\t}\n\n\t\t\t\tif (isDraft) {\n\t\t\t\t\tthis._setDraftStatus(DraftStatus.Saving);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tawait updatePromise;\n\t\t\t\tconst currentBindingContext = this.getView().getBindingContext();\n\t\t\t\tif (!isDraft || !currentBindingContext || currentBindingContext !== originalBindingContext) {\n\t\t\t\t\t// If a navigation happened while oPromise was being resolved, the binding context of the page changed\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// We're still on the same context\n\t\t\t\tconst metaModel = currentBindingContext.getModel().getMetaModel() as ODataMetaModel;\n\t\t\t\tconst entitySetName = metaModel.getMetaContext(currentBindingContext.getPath()).getObject(\"@sapui.name\");\n\t\t\t\tconst semanticKeys = SemanticKeyHelper.getSemanticKeys(metaModel, entitySetName);\n\t\t\t\tif (semanticKeys?.length) {\n\t\t\t\t\tconst currentSemanticMapping = this._getSemanticMapping();\n\t\t\t\t\tconst currentSemanticPath = currentSemanticMapping?.semanticPath,\n\t\t\t\t\t\tsChangedPath = SemanticKeyHelper.getSemanticPath(currentBindingContext, true);\n\t\t\t\t\t// currentSemanticPath could be null if we have navigated via deep link then there are no semanticMappings to calculate it from\n\t\t\t\t\tif (currentSemanticPath && currentSemanticPath !== sChangedPath) {\n\t\t\t\t\t\tawait this._handleNewContext(currentBindingContext as Context, true, false, true);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tthis._setDraftStatus(DraftStatus.Saved);\n\t\t\t} catch (error: any) {\n\t\t\t\tLog.error(\"Error while updating the document\", error);\n\t\t\t\tif (isDraft && originalBindingContext) {\n\t\t\t\t\tthis._setDraftStatus(DraftStatus.Clear);\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tawait this._getMessageHandler().showMessages();\n\t\t\t}\n\t\t});\n\t}\n\n\t// Internal only params ---\n\t// * @param {string} mParameters.creationMode The creation mode using one of the following:\n\t// *                    Sync - the creation is triggered and once the document is created, the navigation is done\n\t// *                    Async - the creation and the navigation to the instance are done in parallel\n\t// *                    Deferred - the creation is done on the target page\n\t// *                    CreationRow - The creation is done inline async so the user is not blocked\n\t// mParameters.creationRow Instance of the creation row - (TODO: get rid but use list bindings only)\n\n\t/**\n\t * Creates a new document.\n\t *\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @param vListBinding  ODataListBinding object or the binding path for a temporary list binding\n\t * @param mInParameters Contains the following attributes:\n\t * @param mInParameters.creationMode The creation mode using one of the following:\n\t *                    NewPage - the created document is shown in a new page, depending on whether metadata 'Sync', 'Async' or 'Deferred' is used\n\t *                    Inline - The creation is done inline (in a table)\n\t *                    External - The creation is done in a different application specified via the parameter 'outbound'\n\t * @param mInParameters.outbound The navigation target where the document is created in case of creationMode 'External'\n\t * @param mInParameters.createAtEnd Specifies if the new entry should be created at the top or bottom of a table in case of creationMode 'Inline'\n\t * @returns Promise resolves once the object has been created\n\t * @alias sap.fe.core.controllerextensions.EditFlow#createDocument\n\t * @public\n\t * @since 1.90.0\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tasync createDocument(\n\t\tvListBinding: ODataListBinding | string,\n\t\tmInParameters: {\n\t\t\tcreationMode: string;\n\t\t\toutbound?: string;\n\t\t\tcreateAtEnd?: boolean;\n\t\t}\n\t): Promise<void> {\n\t\tconst transactionHelper = this._getTransactionHelper(),\n\t\t\toLockObject = this._getGlobalUIModel();\n\t\tlet oTable: any; //should be Table but there are missing methods into the def\n\t\tlet mParameters: any = mInParameters;\n\t\tconst bShouldBusyLock =\n\t\t\t!mParameters ||\n\t\t\t(mParameters.creationMode !== CreationMode.Inline &&\n\t\t\t\tmParameters.creationMode !== CreationMode.CreationRow &&\n\t\t\t\tmParameters.creationMode !== CreationMode.External);\n\t\tlet oExecCustomValidation = Promise.resolve([]);\n\t\tconst oAppComponent = CommonUtils.getAppComponent(this.getView());\n\t\toAppComponent.getRouterProxy().removeIAppStateKey();\n\n\t\tif (mParameters.creationMode === CreationMode.External) {\n\t\t\t// Create by navigating to an external target\n\t\t\t// TODO: Call appropriate function (currently using the same as for outbound chevron nav, and without any context - 3rd param)\n\t\t\tawait this._syncTask();\n\t\t\tconst oController = this.getView().getController();\n\t\t\tconst sCreatePath = ModelHelper.getAbsoluteMetaPathForListBinding(this.getView(), vListBinding);\n\n\t\t\t(oController as any).handlers.onChevronPressNavigateOutBound(oController, mParameters.outbound, undefined, sCreatePath);\n\n\t\t\treturn;\n\t\t}\n\n\t\tif (mParameters.creationMode === CreationMode.CreationRow && mParameters.creationRow) {\n\t\t\tconst oCreationRowObjects = mParameters.creationRow.getBindingContext().getObject();\n\t\t\tdelete oCreationRowObjects[\"@$ui5.context.isTransient\"];\n\t\t\toTable = mParameters.creationRow.getParent();\n\t\t\toExecCustomValidation = transactionHelper.validateDocument(\n\t\t\t\toTable.getBindingContext(),\n\t\t\t\t{\n\t\t\t\t\tdata: oCreationRowObjects,\n\t\t\t\t\tcustomValidationFunction: oTable.getCreationRow().data(\"customValidationFunction\")\n\t\t\t\t},\n\t\t\t\tthis.base.getView()\n\t\t\t);\n\n\t\t\t// disableAddRowButtonForEmptyData is set to false in manifest converter (Table.ts) if customValidationFunction exists\n\t\t\tif (oTable.getCreationRow().data(\"disableAddRowButtonForEmptyData\") === \"true\") {\n\t\t\t\tconst oInternalModelContext = oTable.getBindingContext(\"internal\") as InternalModelContext;\n\t\t\t\toInternalModelContext.setProperty(\"creationRowFieldValidity\", {});\n\t\t\t}\n\t\t}\n\n\t\tif (mParameters.creationMode === CreationMode.Inline && mParameters.tableId) {\n\t\t\toTable = this.getView().byId(mParameters.tableId) as Table;\n\t\t}\n\n\t\tif (oTable && oTable.isA(\"sap.ui.mdc.Table\")) {\n\t\t\tconst fnFocusOrScroll =\n\t\t\t\tmParameters.creationMode === CreationMode.Inline ? oTable.focusRow.bind(oTable) : oTable.scrollToIndex.bind(oTable);\n\t\t\toTable.getRowBinding().attachEventOnce(\"change\", function () {\n\t\t\t\tfnFocusOrScroll(mParameters.createAtEnd ? oTable.getRowBinding().getLength() : 0, true);\n\t\t\t});\n\t\t}\n\n\t\tconst handleSideEffects = async (oListBinding: any, oCreationPromise: Promise<Context>) => {\n\t\t\ttry {\n\t\t\t\tconst oNewContext = await oCreationPromise;\n\t\t\t\t// transient contexts are reliably removed once oNewContext.created() is resolved\n\t\t\t\tawait oNewContext.created();\n\t\t\t\tconst oBindingContext = this.getView().getBindingContext() as Context;\n\t\t\t\t// if there are transient contexts, we must avoid requesting side effects\n\t\t\t\t// this is avoid a potential list refresh, there could be a side effect that refreshes the list binding\n\t\t\t\t// if list binding is refreshed, transient contexts might be lost\n\t\t\t\tif (!CommonUtils.hasTransientContext(oListBinding)) {\n\t\t\t\t\tconst appComponent = CommonUtils.getAppComponent(this.getView());\n\t\t\t\t\tappComponent.getSideEffectsService().requestSideEffectsForNavigationProperty(oListBinding.getPath(), oBindingContext);\n\t\t\t\t}\n\t\t\t} catch (oError: any) {\n\t\t\t\tLog.error(\"Error while creating the document\", oError);\n\t\t\t}\n\t\t};\n\n\t\t/**\n\t\t * @param aValidationMessages Error messages from custom validation function\n\t\t */\n\t\tconst createCustomValidationMessages = (aValidationMessages: any[]) => {\n\t\t\tconst sCustomValidationFunction = oTable && oTable.getCreationRow().data(\"customValidationFunction\");\n\t\t\tconst mCustomValidity = oTable && oTable.getBindingContext(\"internal\")?.getProperty(\"creationRowCustomValidity\");\n\t\t\tconst oMessageManager = Core.getMessageManager();\n\t\t\tconst aCustomMessages: any[] = [];\n\t\t\tlet oFieldControl;\n\t\t\tlet sTarget: string;\n\n\t\t\t// Remove existing CustomValidation message\n\t\t\toMessageManager\n\t\t\t\t.getMessageModel()\n\t\t\t\t.getData()\n\t\t\t\t.forEach(function (oMessage: any) {\n\t\t\t\t\tif (oMessage.code === sCustomValidationFunction) {\n\t\t\t\t\t\toMessageManager.removeMessages(oMessage);\n\t\t\t\t\t}\n\t\t\t\t});\n\n\t\t\taValidationMessages.forEach((oValidationMessage: any) => {\n\t\t\t\t// Handle Bound CustomValidation message\n\t\t\t\tif (oValidationMessage.messageTarget) {\n\t\t\t\t\toFieldControl = Core.getControl(mCustomValidity[oValidationMessage.messageTarget].fieldId) as Control;\n\t\t\t\t\tsTarget = `${oFieldControl.getBindingContext()?.getPath()}/${oFieldControl.getBindingPath(\"value\")}`;\n\t\t\t\t\t// Add validation message if still not exists\n\t\t\t\t\tif (\n\t\t\t\t\t\toMessageManager\n\t\t\t\t\t\t\t.getMessageModel()\n\t\t\t\t\t\t\t.getData()\n\t\t\t\t\t\t\t.filter(function (oMessage: any) {\n\t\t\t\t\t\t\t\treturn oMessage.target === sTarget;\n\t\t\t\t\t\t\t}).length === 0\n\t\t\t\t\t) {\n\t\t\t\t\t\toMessageManager.addMessages(\n\t\t\t\t\t\t\tnew Message({\n\t\t\t\t\t\t\t\tmessage: oValidationMessage.messageText,\n\t\t\t\t\t\t\t\tprocessor: this.getView().getModel(),\n\t\t\t\t\t\t\t\ttype: MessageType.Error,\n\t\t\t\t\t\t\t\tcode: sCustomValidationFunction,\n\t\t\t\t\t\t\t\ttechnical: false,\n\t\t\t\t\t\t\t\tpersistent: false,\n\t\t\t\t\t\t\t\ttarget: sTarget\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t\t// Add controlId in order to get the focus handling of the error popover runable\n\t\t\t\t\tconst aExistingValidationMessages = oMessageManager\n\t\t\t\t\t\t.getMessageModel()\n\t\t\t\t\t\t.getData()\n\t\t\t\t\t\t.filter(function (oMessage: any) {\n\t\t\t\t\t\t\treturn oMessage.target === sTarget;\n\t\t\t\t\t\t});\n\t\t\t\t\taExistingValidationMessages[0].addControlId(mCustomValidity[oValidationMessage.messageTarget].fieldId);\n\n\t\t\t\t\t// Handle Unbound CustomValidation message\n\t\t\t\t} else {\n\t\t\t\t\taCustomMessages.push({\n\t\t\t\t\t\tcode: sCustomValidationFunction,\n\t\t\t\t\t\ttext: oValidationMessage.messageText,\n\t\t\t\t\t\tpersistent: true,\n\t\t\t\t\t\ttype: MessageType.Error\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tif (aCustomMessages.length > 0) {\n\t\t\t\tthis._getMessageHandler().showMessageDialog({\n\t\t\t\t\tcustomMessages: aCustomMessages\n\t\t\t\t});\n\t\t\t}\n\t\t};\n\n\t\tconst resolveCreationMode = (\n\t\t\tinitialCreationMode: string,\n\t\t\tprogrammingModel: string,\n\t\t\toListBinding: ODataListBinding,\n\t\t\toMetaModel: ODataMetaModel\n\t\t): string => {\n\t\t\tif (initialCreationMode && initialCreationMode !== CreationMode.NewPage) {\n\t\t\t\t// use the passed creation mode\n\t\t\t\treturn initialCreationMode;\n\t\t\t} else {\n\t\t\t\t// NewAction is not yet supported for NavigationProperty collection\n\t\t\t\tif (!oListBinding.isRelative()) {\n\t\t\t\t\tconst sPath = oListBinding.getPath(),\n\t\t\t\t\t\t// if NewAction with parameters is present, then creation is 'Deferred'\n\t\t\t\t\t\t// in the absence of NewAction or NewAction with parameters, creation is async\n\t\t\t\t\t\tsNewAction =\n\t\t\t\t\t\t\tprogrammingModel === ProgrammingModel.Draft\n\t\t\t\t\t\t\t\t? oMetaModel.getObject(`${sPath}@com.sap.vocabularies.Common.v1.DraftRoot/NewAction`)\n\t\t\t\t\t\t\t\t: oMetaModel.getObject(`${sPath}@com.sap.vocabularies.Session.v1.StickySessionSupported/NewAction`);\n\t\t\t\t\tif (sNewAction) {\n\t\t\t\t\t\tconst aParameters = oMetaModel.getObject(`/${sNewAction}/@$ui5.overload/0/$Parameter`) || [];\n\t\t\t\t\t\t// binding parameter (eg: _it) is not considered\n\t\t\t\t\t\tif (aParameters.length > 1) {\n\t\t\t\t\t\t\treturn CreationMode.Deferred;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tconst sMetaPath = oMetaModel.getMetaPath(oListBinding?.getHeaderContext()!.getPath());\n\t\t\t\tconst aNonComputedVisibleKeyFields = CommonUtils.getNonComputedVisibleFields(oMetaModel, sMetaPath, this.getView());\n\t\t\t\tif (aNonComputedVisibleKeyFields.length > 0) {\n\t\t\t\t\treturn CreationMode.Deferred;\n\t\t\t\t}\n\t\t\t\treturn CreationMode.Async;\n\t\t\t}\n\t\t};\n\n\t\tif (bShouldBusyLock) {\n\t\t\tBusyLocker.lock(oLockObject);\n\t\t}\n\t\ttry {\n\t\t\tconst aValidationMessages = await this._syncTask(oExecCustomValidation);\n\t\t\tif (aValidationMessages.length > 0) {\n\t\t\t\tcreateCustomValidationMessages(aValidationMessages);\n\t\t\t\tLog.error(\"Custom Validation failed\");\n\t\t\t\t// if custom validation fails, we leave the method immediately\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tlet oListBinding: any;\n\t\t\tmParameters = mParameters || {};\n\n\t\t\tif (vListBinding && typeof vListBinding === \"object\") {\n\t\t\t\t// we already get a list binding use this one\n\t\t\t\toListBinding = vListBinding;\n\t\t\t} else if (typeof vListBinding === \"string\") {\n\t\t\t\toListBinding = new (ODataListBinding as any)(this.getView().getModel(), vListBinding);\n\t\t\t\tmParameters.creationMode = CreationMode.Sync;\n\t\t\t\tdelete mParameters.createAtEnd;\n\t\t\t} else {\n\t\t\t\tthrow new Error(\"Binding object or path expected\");\n\t\t\t}\n\n\t\t\tconst oModel = oListBinding.getModel();\n\t\t\tconst sProgrammingModel: string = this._getProgrammingModel(oListBinding);\n\t\t\tconst resolvedCreationMode = resolveCreationMode(\n\t\t\t\tmParameters.creationMode,\n\t\t\t\tsProgrammingModel,\n\t\t\t\toListBinding,\n\t\t\t\toModel.getMetaModel()\n\t\t\t);\n\n\t\t\tlet oCreation: any;\n\t\t\tlet mArgs: any;\n\t\t\tconst oCreationRow = mParameters.creationRow;\n\t\t\tlet oCreationRowContext: any;\n\t\t\tlet oPayload: any;\n\t\t\tlet sMetaPath: string;\n\t\t\tconst oMetaModel = oModel.getMetaModel();\n\t\t\tconst oRoutingListener = this._getRoutingListener();\n\n\t\t\tif (resolvedCreationMode !== CreationMode.Deferred) {\n\t\t\t\tif (resolvedCreationMode === CreationMode.CreationRow) {\n\t\t\t\t\toCreationRowContext = oCreationRow.getBindingContext();\n\t\t\t\t\tsMetaPath = oMetaModel.getMetaPath(oCreationRowContext.getPath());\n\t\t\t\t\t// prefill data from creation row\n\t\t\t\t\toPayload = oCreationRowContext.getObject();\n\t\t\t\t\tmParameters.data = {};\n\t\t\t\t\tObject.keys(oPayload).forEach(function (sPropertyPath: string) {\n\t\t\t\t\t\tconst oProperty = oMetaModel.getObject(`${sMetaPath}/${sPropertyPath}`);\n\t\t\t\t\t\t// ensure navigation properties are not part of the payload, deep create not supported\n\t\t\t\t\t\tif (oProperty && oProperty.$kind === \"NavigationProperty\") {\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmParameters.data[sPropertyPath] = oPayload[sPropertyPath];\n\t\t\t\t\t});\n\t\t\t\t\tawait this._checkForValidationErrors(/*oCreationRowContext*/);\n\t\t\t\t}\n\t\t\t\tif (resolvedCreationMode === CreationMode.CreationRow || resolvedCreationMode === CreationMode.Inline) {\n\t\t\t\t\tmParameters.keepTransientContextOnFailed = false; // currently not fully supported\n\t\t\t\t\t// busy handling shall be done locally only\n\t\t\t\t\tmParameters.busyMode = \"Local\";\n\t\t\t\t\tmParameters.busyId = oTable?.getParent()?.getTableDefinition()?.annotation.id;\n\n\t\t\t\t\t// take care on message handling, draft indicator (in case of draft)\n\t\t\t\t\t// Attach the create sent and create completed event to the object page binding so that we can react\n\t\t\t\t\tthis._handleCreateEvents(oListBinding);\n\t\t\t\t}\n\n\t\t\t\tif (!mParameters.parentControl) {\n\t\t\t\t\tmParameters.parentControl = this.getView();\n\t\t\t\t}\n\t\t\t\tmParameters.beforeCreateCallBack = this.base.editFlow.onBeforeCreate;\n\n\t\t\t\t// In case the application was called with preferredMode=autoCreateWith, we want to skip the\n\t\t\t\t// action parameter dialog\n\t\t\t\tmParameters.skipParameterDialog = oAppComponent.getStartupMode() === StartupMode.AutoCreate;\n\n\t\t\t\toCreation = transactionHelper.createDocument(\n\t\t\t\t\toListBinding,\n\t\t\t\t\tmParameters,\n\t\t\t\t\tthis.getAppComponent(),\n\t\t\t\t\tthis._getMessageHandler(),\n\t\t\t\t\tfalse,\n\t\t\t\t\tthis.getView()\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tlet oNavigation;\n\t\t\tswitch (resolvedCreationMode) {\n\t\t\t\tcase CreationMode.Deferred:\n\t\t\t\t\toNavigation = oRoutingListener.navigateForwardToContext(oListBinding, {\n\t\t\t\t\t\tbDeferredContext: true,\n\t\t\t\t\t\teditable: true,\n\t\t\t\t\t\tbForceFocus: true\n\t\t\t\t\t});\n\t\t\t\t\tbreak;\n\t\t\t\tcase CreationMode.Async:\n\t\t\t\t\toNavigation = oRoutingListener.navigateForwardToContext(oListBinding, {\n\t\t\t\t\t\tasyncContext: oCreation,\n\t\t\t\t\t\teditable: true,\n\t\t\t\t\t\tbForceFocus: true\n\t\t\t\t\t});\n\t\t\t\t\tbreak;\n\t\t\t\tcase CreationMode.Sync:\n\t\t\t\t\tmArgs = {\n\t\t\t\t\t\teditable: true,\n\t\t\t\t\t\tbForceFocus: true\n\t\t\t\t\t};\n\t\t\t\t\tif (sProgrammingModel == ProgrammingModel.Sticky || mParameters.createAction) {\n\t\t\t\t\t\tmArgs.transient = true;\n\t\t\t\t\t}\n\t\t\t\t\toNavigation = oCreation.then(function (oNewDocumentContext: any) {\n\t\t\t\t\t\tif (!oNewDocumentContext) {\n\t\t\t\t\t\t\tconst coreResourceBundle = Core.getLibraryResourceBundle(\"sap.fe.core\");\n\t\t\t\t\t\t\treturn oRoutingListener.navigateToMessagePage(\n\t\t\t\t\t\t\t\tcoreResourceBundle.getText(\"C_COMMON_SAPFE_DATA_RECEIVED_ERROR\"),\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\ttitle: coreResourceBundle.getText(\"C_COMMON_SAPFE_ERROR\"),\n\t\t\t\t\t\t\t\t\tdescription: coreResourceBundle.getText(\"C_EDITFLOW_SAPFE_CREATION_FAILED_DESCRIPTION\")\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// In case the Sync creation was triggered for a deferred creation, we don't navigate forward\n\t\t\t\t\t\t\t// as we're already on the corresponding ObjectPage\n\t\t\t\t\t\t\treturn mParameters.bFromDeferred\n\t\t\t\t\t\t\t\t? oRoutingListener.navigateToContext(oNewDocumentContext, mArgs)\n\t\t\t\t\t\t\t\t: oRoutingListener.navigateForwardToContext(oNewDocumentContext, mArgs);\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t\tbreak;\n\t\t\t\tcase CreationMode.Inline:\n\t\t\t\t\thandleSideEffects(oListBinding, oCreation);\n\t\t\t\t\tthis._syncTask(oCreation);\n\t\t\t\t\tbreak;\n\t\t\t\tcase CreationMode.CreationRow:\n\t\t\t\t\t// the creation row shall be cleared once the validation check was successful and\n\t\t\t\t\t// therefore the POST can be sent async to the backend\n\t\t\t\t\ttry {\n\t\t\t\t\t\tconst oCreationRowListBinding = oCreationRowContext.getBinding();\n\n\t\t\t\t\t\tif (!mParameters.bSkipSideEffects) {\n\t\t\t\t\t\t\thandleSideEffects(oListBinding, oCreation);\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tconst oNewTransientContext = oCreationRowListBinding.create();\n\t\t\t\t\t\toCreationRow.setBindingContext(oNewTransientContext);\n\n\t\t\t\t\t\t// this is needed to avoid console errors TO be checked with model colleagues\n\t\t\t\t\t\toNewTransientContext.created().catch(function () {\n\t\t\t\t\t\t\tLog.trace(\"transient fast creation context deleted\");\n\t\t\t\t\t\t});\n\t\t\t\t\t\toNavigation = oCreationRowContext.delete(\"$direct\");\n\t\t\t\t\t} catch (oError: any) {\n\t\t\t\t\t\t// Reset busy indicator after a validation error\n\t\t\t\t\t\tif (BusyLocker.isLocked(this.getView().getModel(\"ui\"))) {\n\t\t\t\t\t\t\tBusyLocker.unlock(this.getView().getModel(\"ui\"));\n\t\t\t\t\t\t}\n\t\t\t\t\t\tLog.error(\"CreationRow navigation error: \", oError);\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\toNavigation = Promise.reject(`Unhandled creationMode ${resolvedCreationMode}`);\n\t\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tif (oCreation) {\n\t\t\t\ttry {\n\t\t\t\t\tconst aParams = await Promise.all([oCreation, oNavigation]);\n\t\t\t\t\tthis._setStickySessionInternalProperties(sProgrammingModel, oModel);\n\n\t\t\t\t\tthis._setEditMode(EditMode.Editable); // The createMode flag will be set in InternalEditFlow#computeEditMode\n\t\t\t\t\tif (!oListBinding.isRelative() && sProgrammingModel === ProgrammingModel.Sticky) {\n\t\t\t\t\t\t// Workaround to tell the OP that we've created a new object from the LR\n\t\t\t\t\t\tconst metaModel = oListBinding.getModel().getMetaModel();\n\t\t\t\t\t\tconst metaContext = metaModel.bindContext(metaModel.getMetaPath(oListBinding.getPath()));\n\t\t\t\t\t\tconst entitySet = getInvolvedDataModelObjects(metaContext).startingEntitySet as EntitySet;\n\t\t\t\t\t\tconst newAction = entitySet?.annotations.Session?.StickySessionSupported?.NewAction;\n\t\t\t\t\t\tthis._getInternalModel().setProperty(\"/lastInvokedAction\", newAction);\n\t\t\t\t\t}\n\t\t\t\t\tconst oNewDocumentContext = aParams[0];\n\t\t\t\t\tif (oNewDocumentContext) {\n\t\t\t\t\t\tthis._setDocumentModifiedOnCreate(oListBinding);\n\t\t\t\t\t\tif (!this._isFclEnabled()) {\n\t\t\t\t\t\t\tEditState.setEditStateDirty();\n\t\t\t\t\t\t}\n\t\t\t\t\t\tthis._sendActivity(Activity.Create, oNewDocumentContext);\n\t\t\t\t\t\tif (ModelHelper.isCollaborationDraftSupported(oModel.getMetaModel())) {\n\t\t\t\t\t\t\t// according to UX in case of enabled collaboration draft we share the object immediately\n\t\t\t\t\t\t\tawait shareObject(oNewDocumentContext);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} catch (error: unknown) {\n\t\t\t\t\t// TODO: currently, the only errors handled here are raised as string - should be changed to Error objects\n\t\t\t\t\tif (\n\t\t\t\t\t\terror === Constants.CancelActionDialog ||\n\t\t\t\t\t\terror === Constants.ActionExecutionFailed ||\n\t\t\t\t\t\terror === Constants.CreationFailed\n\t\t\t\t\t) {\n\t\t\t\t\t\t// creation has been cancelled by user or failed in backend => in case we have navigated to transient context before, navigate back\n\t\t\t\t\t\t// the switch-statement above seems to indicate that this happens in creationModes deferred and async. But in fact, in these cases after the navigation from routeMatched in OP component\n\t\t\t\t\t\t// createDeferredContext is triggerd, which calls this method (createDocument) again - this time with creationMode sync. Therefore, also in that mode we need to trigger back navigation.\n\t\t\t\t\t\t// The other cases might still be needed in case the navigation fails.\n\t\t\t\t\t\tif (\n\t\t\t\t\t\t\tresolvedCreationMode === CreationMode.Sync ||\n\t\t\t\t\t\t\tresolvedCreationMode === CreationMode.Deferred ||\n\t\t\t\t\t\t\tresolvedCreationMode === CreationMode.Async\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\toRoutingListener.navigateBackFromTransientState();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tthrow error;\n\t\t\t\t}\n\t\t\t}\n\t\t} finally {\n\t\t\tif (bShouldBusyLock) {\n\t\t\t\tBusyLocker.unlock(oLockObject);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * This function can be used to intercept the 'Save' action. You can execute custom coding in this function.\n\t * The framework waits for the returned promise to be resolved before continuing the 'Save' action.\n\t * If you reject the promise, the 'Save' action is stopped and the user stays in edit mode.\n\t *\n\t * This function is meant to be individually overridden by consuming controllers, but not to be called directly.\n\t * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.\n\t *\n\t * @param _mParameters Object containing the parameters passed to onBeforeSave\n\t * @param _mParameters.context Page context that is going to be saved.\n\t * @returns A promise to be returned by the overridden method. If resolved, the 'Save' action is triggered. If rejected, the 'Save' action is not triggered and the user stays in edit mode.\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeSave\n\t * @public\n\t * @since 1.90.0\n\t */\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\tonBeforeSave(_mParameters?: { context?: Context }): Promise<void> {\n\t\t// to be overridden\n\t\treturn Promise.resolve();\n\t}\n\t/**\n\t * This function can be used to intercept the 'Create' action. You can execute custom coding in this function.\n\t * The framework waits for the returned promise to be resolved before continuing the 'Create' action.\n\t * If you reject the promise, the 'Create' action is stopped.\n\t *\n\t * This function is meant to be individually overridden by consuming controllers, but not to be called directly.\n\t * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.\n\t *\n\t * @param _mParameters Object containing the parameters passed to onBeforeCreate\n\t * @param _mParameters.contextPath Path pointing to the context on which Create action is triggered\n\t * @param _mParameters.createParameters Array of values that are filled in the Action Parameter Dialog\n\t * @returns A promise to be returned by the overridden method. If resolved, the 'Create' action is triggered. If rejected, the 'Create' action is not triggered.\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeCreate\n\t * @public\n\t * @since 1.98.0\n\t */\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\tonBeforeCreate(_mParameters?: { contextPath?: string; createParameters?: any[] }): Promise<void> {\n\t\t// to be overridden\n\t\treturn Promise.resolve();\n\t}\n\t/**\n\t * This function can be used to intercept the 'Edit' action. You can execute custom coding in this function.\n\t * The framework waits for the returned promise to be resolved before continuing the 'Edit' action.\n\t * If you reject the promise, the 'Edit' action is stopped and the user stays in display mode.\n\t *\n\t * This function is meant to be individually overridden by consuming controllers, but not to be called directly.\n\t * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.\n\t *\n\t * @param _mParameters Object containing the parameters passed to onBeforeEdit\n\t * @param _mParameters.context Page context that is going to be edited.\n\t * @returns A promise to be returned by the overridden method. If resolved, the 'Edit' action is triggered. If rejected, the 'Edit' action is not triggered and the user stays in display mode.\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeEdit\n\t * @public\n\t * @since 1.98.0\n\t */\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\tonBeforeEdit(_mParameters?: { context?: Context }): Promise<void> {\n\t\t// to be overridden\n\t\treturn Promise.resolve();\n\t}\n\t/**\n\t * This function can be used to intercept the 'Discard' action. You can execute custom coding in this function.\n\t * The framework waits for the returned promise to be resolved before continuing the 'Discard' action.\n\t * If you reject the promise, the 'Discard' action is stopped and the user stays in edit mode.\n\t *\n\t * This function is meant to be individually overridden by consuming controllers, but not to be called directly.\n\t * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.\n\t *\n\t * @param _mParameters Object containing the parameters passed to onBeforeDiscard\n\t * @param _mParameters.context Page context that is going to be discarded.\n\t * @returns A promise to be returned by the overridden method. If resolved, the 'Discard' action is triggered. If rejected, the 'Discard' action is not triggered and the user stays in edit mode.\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeDiscard\n\t * @public\n\t * @since 1.98.0\n\t */\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\tonBeforeDiscard(_mParameters?: { context?: Context }): Promise<void> {\n\t\t// to be overridden\n\t\treturn Promise.resolve();\n\t}\n\t/**\n\t * This function can be used to intercept the 'Delete' action. You can execute custom coding in this function.\n\t * The framework waits for the returned promise to be resolved before continuing the 'Delete' action.\n\t * If you reject the promise, the 'Delete' action is stopped.\n\t *\n\t * This function is meant to be individually overridden by consuming controllers, but not to be called directly.\n\t * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After}.\n\t *\n\t * @param _mParameters Object containing the parameters passed to onBeforeDelete\n\t * @param _mParameters.contexts An array of contexts that are going to be deleted\n\t * @returns A promise to be returned by the overridden method. If resolved, the 'Delete' action is triggered. If rejected, the 'Delete' action is not triggered.\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @alias sap.fe.core.controllerextensions.EditFlow#onBeforeDelete\n\t * @public\n\t * @since 1.98.0\n\t */\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\tonBeforeDelete(_mParameters?: { contexts?: Context[] }): Promise<void> {\n\t\t// to be overridden\n\t\treturn Promise.resolve();\n\t}\n\n\t// Internal only params ---\n\t// @param {boolean} mParameters.bExecuteSideEffectsOnError Indicates whether SideEffects need to be ignored when user clicks on Save during an Inline creation\n\t// @param {object} mParameters.bindings List bindings of the tables in the view.\n\t// Both of the above parameters are for the same purpose. User can enter some information in the creation row(s) but does not 'Add row', instead clicks Save.\n\t// There can be more than one in the view.\n\n\t/**\n\t * Saves a new document after checking it.\n\t *\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @param oContext  Context of the editable document\n\t * @param mParameters PRIVATE\n\t * @returns Promise resolves once save is complete\n\t * @alias sap.fe.core.controllerextensions.EditFlow#saveDocument\n\t * @public\n\t * @since 1.90.0\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tasync saveDocument(oContext: Context, mParameters: any): Promise<void> {\n\t\tmParameters = mParameters || {};\n\t\tconst bExecuteSideEffectsOnError = mParameters.bExecuteSideEffectsOnError || undefined;\n\t\tconst bDraftNavigation = true;\n\t\tconst transactionHelper = this._getTransactionHelper();\n\t\tconst oResourceBundle = this._getResourceBundle();\n\t\tconst aBindings = mParameters.bindings;\n\n\t\ttry {\n\t\t\tawait this._syncTask();\n\t\t\tawait this._submitOpenChanges(oContext);\n\t\t\tawait this._checkForValidationErrors();\n\t\t\tawait this.base.editFlow.onBeforeSave({ context: oContext });\n\n\t\t\tconst sProgrammingModel = this._getProgrammingModel(oContext);\n\t\t\tconst oRootViewController = this._getRootViewController() as any;\n\t\t\tlet siblingInfo: SiblingInformation | undefined;\n\t\t\tif (\n\t\t\t\t(sProgrammingModel === ProgrammingModel.Sticky || oContext.getProperty(\"HasActiveEntity\")) &&\n\t\t\t\toRootViewController.isFclEnabled()\n\t\t\t) {\n\t\t\t\t// No need to try to get rightmost context in case of a new object\n\t\t\t\tsiblingInfo = await this._computeSiblingInformation(\n\t\t\t\t\toContext,\n\t\t\t\t\toRootViewController.getRightmostContext(),\n\t\t\t\t\tsProgrammingModel,\n\t\t\t\t\ttrue\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tconst activeDocumentContext = await transactionHelper.saveDocument(\n\t\t\t\toContext,\n\t\t\t\tthis.getAppComponent(),\n\t\t\t\toResourceBundle,\n\t\t\t\tbExecuteSideEffectsOnError,\n\t\t\t\taBindings,\n\t\t\t\tthis._getMessageHandler(),\n\t\t\t\tthis._getCreationMode()\n\t\t\t);\n\t\t\tthis._removeStickySessionInternalProperties(sProgrammingModel);\n\n\t\t\tthis._sendActivity(Activity.Activate, activeDocumentContext);\n\t\t\tthis._triggerConfiguredSurvey(StandardActions.save, TriggerType.standardAction);\n\n\t\t\tthis._setDocumentModified(false);\n\t\t\tthis._setEditMode(EditMode.Display, false);\n\t\t\tthis._getMessageHandler().showMessageDialog();\n\n\t\t\tif (activeDocumentContext !== oContext) {\n\t\t\t\tlet contextToNavigate = activeDocumentContext;\n\t\t\t\tif (oRootViewController.isFclEnabled()) {\n\t\t\t\t\tsiblingInfo = siblingInfo ?? this._createSiblingInfo(oContext, activeDocumentContext);\n\t\t\t\t\tthis._updatePathsInHistory(siblingInfo.pathMapping);\n\t\t\t\t\tif (siblingInfo.targetContext.getPath() !== activeDocumentContext.getPath()) {\n\t\t\t\t\t\tcontextToNavigate = siblingInfo.targetContext;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tawait this._handleNewContext(contextToNavigate, false, false, bDraftNavigation, true);\n\t\t\t}\n\t\t} catch (oError: any) {\n\t\t\tif (!(oError && oError.canceled)) {\n\t\t\t\tLog.error(\"Error while saving the document\", oError);\n\t\t\t}\n\t\t\tthrow oError;\n\t\t}\n\t}\n\t@publicExtension()\n\t@finalExtension()\n\tasync toggleDraftActive(oContext: Context): Promise<void> {\n\t\tconst oContextData = oContext.getObject();\n\t\tlet bEditable: boolean;\n\t\tconst bIsDraft = oContext && this._getProgrammingModel(oContext) === ProgrammingModel.Draft;\n\n\t\t//toggle between draft and active document is only available for edit drafts and active documents with draft)\n\t\tif (\n\t\t\t!bIsDraft ||\n\t\t\t!(\n\t\t\t\t(!oContextData.IsActiveEntity && oContextData.HasActiveEntity) ||\n\t\t\t\t(oContextData.IsActiveEntity && oContextData.HasDraftEntity)\n\t\t\t)\n\t\t) {\n\t\t\treturn;\n\t\t}\n\n\t\tif (!oContextData.IsActiveEntity && oContextData.HasActiveEntity) {\n\t\t\t//start Point: edit draft\n\t\t\tbEditable = false;\n\t\t} else {\n\t\t\t// start point active document\n\t\t\tbEditable = true;\n\t\t}\n\n\t\ttry {\n\t\t\tconst oRootViewController = this._getRootViewController() as any;\n\t\t\tconst oRightmostContext = oRootViewController.isFclEnabled() ? oRootViewController.getRightmostContext() : oContext;\n\t\t\tconst siblingInfo = await this._computeSiblingInformation(oContext, oRightmostContext, ProgrammingModel.Draft, false);\n\t\t\tif (siblingInfo) {\n\t\t\t\tthis._setEditMode(bEditable ? EditMode.Editable : EditMode.Display, false); //switch to edit mode only if a draft is available\n\n\t\t\t\tif (oRootViewController.isFclEnabled()) {\n\t\t\t\t\tconst lastSemanticMapping = this._getSemanticMapping();\n\t\t\t\t\tif (lastSemanticMapping?.technicalPath === oContext.getPath()) {\n\t\t\t\t\t\tconst targetPath = siblingInfo.pathMapping[siblingInfo.pathMapping.length - 1].newPath;\n\t\t\t\t\t\tsiblingInfo.pathMapping.push({ oldPath: lastSemanticMapping.semanticPath, newPath: targetPath });\n\t\t\t\t\t}\n\t\t\t\t\tthis._updatePathsInHistory(siblingInfo.pathMapping);\n\t\t\t\t}\n\n\t\t\t\tawait this._handleNewContext(siblingInfo.targetContext, bEditable, true, true, true);\n\t\t\t} else {\n\t\t\t\treturn Promise.reject(\"Error in EditFlow.toggleDraftActive - Cannot find sibling\");\n\t\t\t}\n\t\t} catch (oError) {\n\t\t\treturn Promise.reject(`Error in EditFlow.toggleDraftActive:${oError}` as any);\n\t\t}\n\t}\n\n\t// Internal only params ---\n\t// @param {sap.m.Button} mParameters.cancelButton - Currently this is passed as cancelButton internally (replaced by mParameters.control in the JSDoc below). Currently it is also mandatory.\n\t// Plan - This should not be mandatory. If not provided, we should have a default that can act as reference control for the discard popover OR we can show a dialog instead of a popover.\n\n\t/**\n\t * Discard the editable document.\n\t *\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @param oContext  Context of the editable document\n\t * @param mParameters Can contain the following attributes:\n\t * @param mParameters.control This is the control used to open the discard popover\n\t * @param mParameters.skipDiscardPopover Optional, supresses the discard popover and allows custom handling\n\t * @returns Promise resolves once editable document has been discarded\n\t * @alias sap.fe.core.controllerextensions.EditFlow#cancelDocument\n\t * @public\n\t * @since 1.90.0\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tasync cancelDocument(oContext: Context, mParameters: { control: object; skipDiscardPopover?: boolean }): Promise<any> {\n\t\tconst transactionHelper = this._getTransactionHelper();\n\t\tconst oResourceBundle = this._getResourceBundle();\n\t\tconst mInParameters: any = mParameters;\n\t\tlet siblingInfo: SiblingInformation | undefined;\n\n\t\tmInParameters.cancelButton = mParameters.control || mInParameters.cancelButton;\n\t\tmInParameters.beforeCancelCallBack = this.base.editFlow.onBeforeDiscard;\n\n\t\ttry {\n\t\t\tawait this._syncTask();\n\t\t\tconst sProgrammingModel = this._getProgrammingModel(oContext);\n\t\t\tif ((sProgrammingModel === ProgrammingModel.Sticky || oContext.getProperty(\"HasActiveEntity\")) && this._isFclEnabled()) {\n\t\t\t\tconst oRootViewController = this._getRootViewController() as any;\n\n\t\t\t\t// No need to try to get rightmost context in case of a new object\n\t\t\t\tsiblingInfo = await this._computeSiblingInformation(\n\t\t\t\t\toContext,\n\t\t\t\t\toRootViewController.getRightmostContext(),\n\t\t\t\t\tsProgrammingModel,\n\t\t\t\t\ttrue\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tconst cancelResult = await transactionHelper.cancelDocument(\n\t\t\t\toContext,\n\t\t\t\tmInParameters,\n\t\t\t\tthis.getAppComponent(),\n\t\t\t\toResourceBundle,\n\t\t\t\tthis._getMessageHandler(),\n\t\t\t\tthis._getCreationMode(),\n\t\t\t\tthis._isDocumentModified()\n\t\t\t);\n\t\t\tconst bDraftNavigation = true;\n\t\t\tthis._removeStickySessionInternalProperties(sProgrammingModel);\n\n\t\t\tthis._setEditMode(EditMode.Display, false);\n\t\t\tthis._setDocumentModified(false);\n\t\t\tthis._setDraftStatus(DraftStatus.Clear);\n\t\t\t// we force the edit state even for FCL because the draft discard might not be implemented\n\t\t\t// and we may just delete the draft\n\t\t\tEditState.setEditStateDirty();\n\n\t\t\tif (!cancelResult) {\n\t\t\t\tthis._sendActivity(Activity.Discard, undefined);\n\t\t\t\t//in case of a new document, no activeContext is returned --> navigate back.\n\t\t\t\tif (!mInParameters.skipBackNavigation) {\n\t\t\t\t\tawait this._getRoutingListener().navigateBackFromContext(oContext);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tconst oActiveDocumentContext = cancelResult as Context;\n\t\t\t\tthis._sendActivity(Activity.Discard, oActiveDocumentContext);\n\t\t\t\tlet contextToNavigate = oActiveDocumentContext;\n\t\t\t\tif (this._isFclEnabled()) {\n\t\t\t\t\tsiblingInfo = siblingInfo ?? this._createSiblingInfo(oContext, oActiveDocumentContext);\n\t\t\t\t\tthis._updatePathsInHistory(siblingInfo.pathMapping);\n\t\t\t\t\tif (siblingInfo.targetContext.getPath() !== oActiveDocumentContext.getPath()) {\n\t\t\t\t\t\tcontextToNavigate = siblingInfo.targetContext;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (sProgrammingModel === ProgrammingModel.Draft) {\n\t\t\t\t\t// We need to load the semantic keys of the active context, as we need them\n\t\t\t\t\t// for the navigation\n\t\t\t\t\tawait this._fetchSemanticKeyValues(oActiveDocumentContext);\n\t\t\t\t\t// We force the recreation of the context, so that it's created and bound in the same microtask,\n\t\t\t\t\t// so that all properties are loaded together by autoExpandSelect, so that when switching back to Edit mode\n\t\t\t\t\t// $$inheritExpandSelect takes all loaded properties into account (BCP 2070462265)\n\t\t\t\t\tif (!mInParameters.skipBindingToView) {\n\t\t\t\t\t\tawait this._handleNewContext(contextToNavigate, false, true, bDraftNavigation, true);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn oActiveDocumentContext;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t//active context is returned in case of cancel of existing document\n\t\t\t\t\tawait this._handleNewContext(contextToNavigate, false, false, bDraftNavigation, true);\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (oError) {\n\t\t\tLog.error(\"Error while discarding the document\", oError as any);\n\t\t}\n\t}\n\n\t/**\n\t * Checks if a context corresponds to a draft root.\n\t *\n\t * @param context The context to check\n\t * @returns True if the context points to a draft root\n\t * @private\n\t */\n\tprotected isDraftRoot(context: Context): boolean {\n\t\tconst metaModel = context.getModel().getMetaModel();\n\t\tconst metaContext = metaModel.getMetaContext(context.getPath());\n\t\treturn ModelHelper.isDraftRoot(getInvolvedDataModelObjects(metaContext).targetEntitySet);\n\t}\n\n\t// Internal only params ---\n\t// @param {string} mParameters.entitySetName Name of the EntitySet to which the object belongs\n\n\t/**\n\t * Deletes the document.\n\t *\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @param oContext  Context of the document\n\t * @param mInParameters Can contain the following attributes:\n\t * @param mInParameters.title Title of the object being deleted\n\t * @param mInParameters.description Description of the object being deleted\n\t * @returns Promise resolves once document has been deleted\n\t * @alias sap.fe.core.controllerextensions.EditFlow#deleteDocument\n\t * @public\n\t * @since 1.90.0\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tasync deleteDocument(oContext: Context, mInParameters: { title: string; description: string }): Promise<void> {\n\t\tconst oAppComponent = CommonUtils.getAppComponent(this.getView());\n\t\tlet mParameters: any = mInParameters;\n\t\tif (!mParameters) {\n\t\t\tmParameters = {\n\t\t\t\tbFindActiveContexts: false\n\t\t\t};\n\t\t} else {\n\t\t\tmParameters.bFindActiveContexts = false;\n\t\t}\n\t\tmParameters.beforeDeleteCallBack = this.base.editFlow.onBeforeDelete;\n\t\ttry {\n\t\t\tif (\n\t\t\t\tthis._isFclEnabled() &&\n\t\t\t\tthis.isDraftRoot(oContext) &&\n\t\t\t\toContext.getIndex() === undefined &&\n\t\t\t\toContext.getProperty(\"IsActiveEntity\") === true &&\n\t\t\t\toContext.getProperty(\"HasDraftEntity\") === true\n\t\t\t) {\n\t\t\t\t// Deleting an active entity which has a draft that could potentially be displayed in the ListReport (FCL case)\n\t\t\t\t// --> need to remove the draft from the LR and replace it with the active version, so that the ListBinding is properly refreshed\n\t\t\t\t// The condition 'oContext.getIndex() === undefined' makes sure the active version isn't already displayed in the LR\n\t\t\t\tmParameters.beforeDeleteCallBack = async (parameters?: { contexts?: Context[] }) => {\n\t\t\t\t\tawait this.base.editFlow.onBeforeDelete(parameters);\n\n\t\t\t\t\ttry {\n\t\t\t\t\t\tconst model = oContext.getModel();\n\t\t\t\t\t\tconst siblingContext = model.bindContext(`${oContext.getPath()}/SiblingEntity`).getBoundContext();\n\t\t\t\t\t\tconst draftPath = await siblingContext.requestCanonicalPath();\n\t\t\t\t\t\tconst draftContextToRemove = model.getKeepAliveContext(draftPath);\n\t\t\t\t\t\tdraftContextToRemove.replaceWith(oContext);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tLog.error(\"Error while replacing the draft instance in the LR ODLB\", error as any);\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tawait this._deleteDocumentTransaction(oContext, mParameters);\n\n\t\t\t// Single objet deletion is triggered from an OP header button (not from a list)\n\t\t\t// --> Mark UI dirty and navigate back to dismiss the OP\n\t\t\tif (!this._isFclEnabled()) {\n\t\t\t\tEditState.setEditStateDirty();\n\t\t\t}\n\t\t\tthis._sendActivity(Activity.Delete, oContext);\n\n\t\t\t// After delete is successfull, we need to detach the setBackNavigation Methods\n\t\t\tif (oAppComponent) {\n\t\t\t\toAppComponent.getShellServices().setBackNavigation();\n\t\t\t}\n\n\t\t\tif (oAppComponent?.getStartupMode() === StartupMode.Deeplink && !this._isFclEnabled()) {\n\t\t\t\t// In case the app has been launched with semantic keys, deleting the object we've landed on shall navigate back\n\t\t\t\t// to the app we came from (except for FCL, where we navigate to LR as usual)\n\t\t\t\toAppComponent.getRouterProxy().exitFromApp();\n\t\t\t} else {\n\t\t\t\tthis._getRoutingListener().navigateBackFromContext(oContext);\n\t\t\t}\n\t\t} catch (error) {\n\t\t\tLog.error(\"Error while deleting the document\", error as any);\n\t\t}\n\t}\n\n\t/**\n\t * Submit the current set of changes and navigate back.\n\t *\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @param oContext  Context of the document\n\t * @returns Promise resolves once the changes have been saved\n\t * @alias sap.fe.core.controllerextensions.EditFlow#applyDocument\n\t * @public\n\t * @since 1.90.0\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tasync applyDocument(oContext: object): Promise<void> {\n\t\tconst oLockObject = this._getGlobalUIModel();\n\t\tBusyLocker.lock(oLockObject);\n\n\t\ttry {\n\t\t\tawait this._syncTask();\n\t\t\tawait this._submitOpenChanges(oContext);\n\t\t\tawait this._checkForValidationErrors();\n\t\t\tawait this._getMessageHandler().showMessageDialog();\n\t\t\tawait this._getRoutingListener().navigateBackFromContext(oContext);\n\t\t} finally {\n\t\t\tif (BusyLocker.isLocked(oLockObject)) {\n\t\t\t\tBusyLocker.unlock(oLockObject);\n\t\t\t}\n\t\t}\n\t}\n\n\t// Internal only params ---\n\t// @param {boolean} [mParameters.bStaticAction] Boolean value for static action, undefined for other actions\n\t// @param {boolean} [mParameters.isNavigable] Boolean value indicating whether navigation is required after the action has been executed\n\t// Currently the parameter isNavigable is used internally and should be changed to requiresNavigation as it is a more apt name for this param\n\n\t/**\n\t * Invokes an action (bound or unbound) and tracks the changes so that other pages can be refreshed and show the updated data upon navigation.\n\t *\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @param sActionName The name of the action to be called\n\t * @param mInParameters Contains the following attributes:\n\t * @param mInParameters.parameterValues A map of action parameter names and provided values\n\t * @param mInParameters.parameterValues.name Name of the parameter\n\t * @param mInParameters.parameterValues.value Value of the parameter\n\t * @param mInParameters.skipParameterDialog Skips the action parameter dialog if values are provided for all of them in parameterValues\n\t * @param mInParameters.contexts For a bound action, a context or an array with contexts for which the action is to be called must be provided\n\t * @param mInParameters.model For an unbound action, an instance of an OData V4 model must be provided\n\t * @param mInParameters.requiresNavigation Boolean value indicating whether navigation is required after the action has been executed. Navigation takes place to the context returned by the action\n\t * @param mInParameters.label A human-readable label for the action. This is needed in case the action has a parameter and a parameter dialog is shown to the user. The label will be used for the title of the dialog and for the confirmation button\n\t * @param mInParameters.invocationGrouping Mode how actions are to be called: 'ChangeSet' to put all action calls into one changeset, 'Isolated' to put them into separate changesets\n\t * @param mExtraParams PRIVATE\n\t * @returns A promise which resolves once the action has been executed, providing the response\n\t * @alias sap.fe.core.controllerextensions.EditFlow#invokeAction\n\t * @public\n\t * @since 1.90.0\n\t * @final\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tasync invokeAction(\n\t\tsActionName: string,\n\t\tmInParameters?: {\n\t\t\tparameterValues?: { name: string; value: any };\n\t\t\tskipParameterDialog?: boolean;\n\t\t\tcontexts?: Context | Context[];\n\t\t\tmodel?: ODataModel;\n\t\t\trequiresNavigation?: boolean;\n\t\t\tlabel?: string;\n\t\t\tinvocationGrouping?: string;\n\t\t},\n\t\tmExtraParams?: any\n\t): Promise<void> {\n\t\tlet oControl: any;\n\t\tconst transactionHelper = this._getTransactionHelper();\n\t\tlet aParts;\n\t\tlet sOverloadEntityType;\n\t\tlet oCurrentActionCallBacks: any;\n\t\tconst oView = this.getView();\n\n\t\tlet mParameters: any = mInParameters || {};\n\t\t// Due to a mistake the invokeAction in the extensionAPI had a different API than this one.\n\t\t// The one from the extensionAPI doesn't exist anymore as we expose the full edit flow now but\n\t\t// due to compatibility reasons we still need to support the old signature\n\t\tif (\n\t\t\t(mParameters.isA && mParameters.isA(\"sap.ui.model.odata.v4.Context\")) ||\n\t\t\tArray.isArray(mParameters) ||\n\t\t\tmExtraParams !== undefined\n\t\t) {\n\t\t\tconst contexts = mParameters;\n\t\t\tmParameters = mExtraParams || {};\n\t\t\tif (contexts) {\n\t\t\t\tmParameters.contexts = contexts;\n\t\t\t} else {\n\t\t\t\tmParameters.model = this.getView().getModel();\n\t\t\t}\n\t\t}\n\n\t\tmParameters.isNavigable = mParameters.requiresNavigation || mParameters.isNavigable;\n\n\t\t// Determine if the action is bound or unbound\n\t\tconst model = this.getView().getModel();\n\t\tconst actionMetaData = model?.getMetaModel()?.getObject(\"/\" + sActionName.split(\"(\")[0]);\n\t\tif (actionMetaData) {\n\t\t\tif (!Array.isArray(actionMetaData)) {\n\t\t\t\tmParameters.isBound = actionMetaData.$IsBound ? actionMetaData.$IsBound : false;\n\t\t\t} else if (actionMetaData[0].$kind === \"Action\" && actionMetaData[0].$IsBound === true) {\n\t\t\t\tmParameters.isBound = true;\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new Error(\"Error in EditFlow.invokeAction: The specified action could not be found\");\n\t\t}\n\n\t\tif (!mParameters.parentControl) {\n\t\t\tmParameters.parentControl = this.getView();\n\t\t}\n\n\t\tif (mParameters.controlId) {\n\t\t\toControl = this.getView().byId(mParameters.controlId);\n\t\t\tif (oControl) {\n\t\t\t\t// TODO: currently this selected contexts update is done within the operation, should be moved out\n\t\t\t\tmParameters.internalModelContext = oControl.getBindingContext(\"internal\");\n\t\t\t}\n\t\t} else {\n\t\t\tmParameters.internalModelContext = oView.getBindingContext(\"internal\");\n\t\t}\n\n\t\tif (sActionName && sActionName.indexOf(\"(\") > -1) {\n\t\t\t// get entity type of action overload and remove it from the action path\n\t\t\t// Example sActionName = \"<ActionName>(Collection(<OverloadEntityType>))\"\n\t\t\t// sActionName = aParts[0] --> <ActionName>\n\t\t\t// sOverloadEntityType = aParts[2] --> <OverloadEntityType>\n\t\t\taParts = sActionName.split(\"(\");\n\t\t\tsActionName = aParts[0];\n\t\t\tsOverloadEntityType = (aParts[aParts.length - 1] as any).replaceAll(\")\", \"\");\n\t\t}\n\n\t\tif (mParameters.bStaticAction) {\n\t\t\tif (oControl.isTableBound()) {\n\t\t\t\tmParameters.contexts = oControl.getRowBinding().getHeaderContext();\n\t\t\t} else {\n\t\t\t\tconst sBindingPath = oControl.data(\"rowsBindingInfo\").path,\n\t\t\t\t\toListBinding = new (ODataListBinding as any)(this.getView().getModel(), sBindingPath);\n\t\t\t\tmParameters.contexts = oListBinding.getHeaderContext();\n\t\t\t}\n\n\t\t\tif (sOverloadEntityType && oControl.getBindingContext()) {\n\t\t\t\tmParameters.contexts = this._getActionOverloadContextFromMetadataPath(\n\t\t\t\t\toControl.getBindingContext(),\n\t\t\t\t\toControl.getRowBinding(),\n\t\t\t\t\tsOverloadEntityType\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tif (mParameters.enableAutoScroll) {\n\t\t\t\toCurrentActionCallBacks = this._createActionPromise(sActionName, oControl.sId);\n\t\t\t}\n\t\t}\n\t\tmParameters.bGetBoundContext = this._getBoundContext(oView, mParameters);\n\t\t// Need to know that the action is called from ObjectPage for changeSet Isolated workaround\n\t\tmParameters.bObjectPage = (oView.getViewData() as any).converterType === \"ObjectPage\";\n\n\t\ttry {\n\t\t\tawait this._syncTask();\n\t\t\tconst oResponse = await transactionHelper.callAction(\n\t\t\t\tsActionName,\n\t\t\t\tmParameters,\n\t\t\t\tthis.getView(),\n\t\t\t\tthis.getAppComponent(),\n\t\t\t\tthis._getMessageHandler()\n\t\t\t);\n\t\t\tif (mParameters.contexts && mParameters.isBound === true) {\n\t\t\t\tawait this._refreshListIfRequired(this._getActionResponseDataAndKeys(sActionName, oResponse), mParameters.contexts[0]);\n\t\t\t}\n\t\t\tthis._sendActivity(Activity.Action, mParameters.contexts, sActionName);\n\t\t\tthis._triggerConfiguredSurvey(sActionName, TriggerType.action);\n\n\t\t\tif (oCurrentActionCallBacks) {\n\t\t\t\toCurrentActionCallBacks.fResolver(oResponse);\n\t\t\t}\n\t\t\t/*\n\t\t\t\t\tWe set the (upper) pages to dirty after an execution of an action\n\t\t\t\t\tTODO: get rid of this workaround\n\t\t\t\t\tThis workaround is only needed as long as the model does not support the synchronization.\n\t\t\t\t\tOnce this is supported we don't need to set the pages to dirty anymore as the context itself\n\t\t\t\t\tis already refreshed (it's just not reflected in the object page)\n\t\t\t\t\twe explicitly don't call this method from the list report but only call it from the object page\n\t\t\t\t\tas if it is called in the list report it's not needed - as we anyway will remove this logic\n\t\t\t\t\twe can live with this\n\t\t\t\t\twe need a context to set the upper pages to dirty - if there are more than one we use the\n\t\t\t\t\tfirst one as they are anyway siblings\n\t\t\t\t\t*/\n\t\t\tif (mParameters.contexts) {\n\t\t\t\tif (!this._isFclEnabled()) {\n\t\t\t\t\tEditState.setEditStateDirty();\n\t\t\t\t}\n\t\t\t\tthis._getInternalModel().setProperty(\"/lastInvokedAction\", sActionName);\n\t\t\t}\n\t\t\tif (mParameters.isNavigable) {\n\t\t\t\tlet vContext = oResponse;\n\t\t\t\tif (Array.isArray(vContext) && vContext.length === 1) {\n\t\t\t\t\tvContext = vContext[0].value;\n\t\t\t\t}\n\t\t\t\tif (vContext && !Array.isArray(vContext)) {\n\t\t\t\t\tconst oMetaModel = oView.getModel().getMetaModel() as ODataMetaModel;\n\t\t\t\t\tconst sContextMetaPath = oMetaModel.getMetaPath(vContext.getPath());\n\t\t\t\t\tconst _fnValidContexts = (contexts: any, applicableContexts: any) => {\n\t\t\t\t\t\treturn contexts.filter((element: any) => {\n\t\t\t\t\t\t\tif (applicableContexts) {\n\t\t\t\t\t\t\t\treturn applicableContexts.indexOf(element) > -1;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t});\n\t\t\t\t\t};\n\t\t\t\t\tconst oActionContext = Array.isArray(mParameters.contexts)\n\t\t\t\t\t\t? _fnValidContexts(mParameters.contexts, mParameters.applicableContext)[0]\n\t\t\t\t\t\t: mParameters.contexts;\n\t\t\t\t\tconst sActionContextMetaPath = oActionContext && oMetaModel.getMetaPath(oActionContext.getPath());\n\t\t\t\t\tif (sContextMetaPath != undefined && sContextMetaPath === sActionContextMetaPath) {\n\t\t\t\t\t\tif (oActionContext.getPath() !== vContext.getPath()) {\n\t\t\t\t\t\t\tthis._getRoutingListener().navigateForwardToContext(vContext, {\n\t\t\t\t\t\t\t\tcheckNoHashChange: true,\n\t\t\t\t\t\t\t\tnoHistoryEntry: false\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tLog.info(\"Navigation to the same context is not allowed\");\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn oResponse;\n\t\t} catch (err: any) {\n\t\t\tif (oCurrentActionCallBacks) {\n\t\t\t\toCurrentActionCallBacks.fRejector();\n\t\t\t}\n\t\t\t// FIXME: in most situations there is no handler for the rejected promises returnedq\n\t\t\tif (err === Constants.CancelActionDialog) {\n\t\t\t\t// This leads to console error. Actually the error is already handled (currently directly in press handler of end button in dialog), so it should not be forwarded\n\t\t\t\t// up to here. However, when dialog handling and backend execution are separated, information whether dialog was cancelled, or backend execution has failed needs\n\t\t\t\t// to be transported to the place responsible for connecting these two things.\n\t\t\t\t// TODO: remove special handling one dialog handling and backend execution are separated\n\t\t\t\tthrow new Error(\"Dialog cancelled\");\n\t\t\t} else if (!(err && (err.canceled || (err.rejectedItems && err.rejectedItems[0].canceled)))) {\n\t\t\t\t// TODO: analyze, whether this is of the same category as above\n\t\t\t\tthrow new Error(`Error in EditFlow.invokeAction:${err}`);\n\t\t\t}\n\t\t\t// TODO: Any unexpected errors probably should not be ignored!\n\t\t}\n\t}\n\n\t/**\n\t * Secured execution of the given function. Ensures that the function is only executed when certain conditions are fulfilled.\n\t *\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @param fnFunction The function to be executed. Should return a promise that is settled after completion of the execution. If nothing is returned, immediate completion is assumed.\n\t * @param mParameters Definitions of the preconditions to be checked before execution\n\t * @param mParameters.busy Defines the busy indicator\n\t * @param mParameters.busy.set Triggers a busy indicator when the function is executed.\n\t * @param mParameters.busy.check Executes function only if application isn't busy.\n\t * @param mParameters.updatesDocument This operation updates the current document without using the bound model and context. As a result, the draft status is updated if a draft document exists, and the user has to confirm the cancellation of the editing process.\n\t * @returns A promise that is rejected if the execution is prohibited and resolved by the promise returned by the fnFunction.\n\t * @alias sap.fe.core.controllerextensions.EditFlow#securedExecution\n\t * @public\n\t * @experimental As of version 1.90.0\n\t * @since 1.90.0\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tsecuredExecution(\n\t\tfnFunction: Function,\n\t\tmParameters?: {\n\t\t\tbusy?: {\n\t\t\t\tset?: boolean;\n\t\t\t\tcheck?: boolean;\n\t\t\t};\n\t\t\tupdatesDocument?: boolean;\n\t\t}\n\t): Promise<void> {\n\t\tconst bBusySet = mParameters && mParameters.busy && mParameters.busy.set !== undefined ? mParameters.busy.set : true,\n\t\t\tbBusyCheck = mParameters && mParameters.busy && mParameters.busy.check !== undefined ? mParameters.busy.check : true,\n\t\t\tbUpdatesDocument = (mParameters && (mParameters as any).updatesDocument) || false,\n\t\t\toLockObject = this._getGlobalUIModel(),\n\t\t\toContext = this.base.getView().getBindingContext(),\n\t\t\tbIsDraft = oContext && this._getProgrammingModel(oContext) === ProgrammingModel.Draft;\n\n\t\tif (bBusyCheck && BusyLocker.isLocked(oLockObject)) {\n\t\t\treturn Promise.reject(\"Application already busy therefore execution rejected\");\n\t\t}\n\n\t\t// we have to set busy and draft indicator immediately also the function might be executed later in queue\n\t\tif (bBusySet) {\n\t\t\tBusyLocker.lock(oLockObject);\n\t\t}\n\t\tif (bUpdatesDocument && bIsDraft) {\n\t\t\tthis._setDraftStatus(DraftStatus.Saving);\n\t\t}\n\n\t\tthis._getMessageHandler().removeTransitionMessages();\n\n\t\treturn this._syncTask(fnFunction)\n\t\t\t.then(() => {\n\t\t\t\tif (bUpdatesDocument) {\n\t\t\t\t\tthis._setDocumentModified(true);\n\t\t\t\t\tif (!this._isFclEnabled()) {\n\t\t\t\t\t\tEditState.setEditStateDirty();\n\t\t\t\t\t}\n\t\t\t\t\tif (bIsDraft) {\n\t\t\t\t\t\tthis._setDraftStatus(DraftStatus.Saved);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t})\n\t\t\t.catch((oError: any) => {\n\t\t\t\tif (bUpdatesDocument && bIsDraft) {\n\t\t\t\t\tthis._setDraftStatus(DraftStatus.Clear);\n\t\t\t\t}\n\t\t\t\treturn Promise.reject(oError);\n\t\t\t})\n\t\t\t.finally(() => {\n\t\t\t\tif (bBusySet) {\n\t\t\t\t\tBusyLocker.unlock(oLockObject);\n\t\t\t\t}\n\t\t\t\tthis._getMessageHandler().showMessageDialog();\n\t\t\t});\n\t}\n\n\t/**\n\t * Handles the patchSent event: register document modification.\n\t *\n\t * @param oEvent The event sent by the binding\n\t */\n\t@publicExtension()\n\thandlePatchSent(oEvent: Event) {\n\t\t// In collaborative draft, disable ETag check for PATCH requests\n\t\tconst isInCollaborativeDraft = isConnected(this.getView());\n\t\tif (isInCollaborativeDraft) {\n\t\t\t((oEvent.getSource() as Binding).getModel() as any).setIgnoreETag(true);\n\t\t}\n\t\tif (!(this.getView()?.getBindingContext(\"internal\") as InternalModelContext)?.getProperty(\"skipPatchHandlers\")) {\n\t\t\t// Create a promise that will be resolved or rejected when the path is completed\n\t\t\tconst oPatchPromise = new Promise<void>((resolve, reject) => {\n\t\t\t\toEvent.getSource().attachEventOnce(\"patchCompleted\", (patchCompletedEvent: any) => {\n\t\t\t\t\t// Re-enable ETag checks\n\t\t\t\t\tif (isInCollaborativeDraft) {\n\t\t\t\t\t\t((oEvent.getSource() as Binding).getModel() as any).setIgnoreETag(false);\n\t\t\t\t\t}\n\n\t\t\t\t\tif (oEvent.getSource().isA(\"sap.ui.model.odata.v4.ODataListBinding\")) {\n\t\t\t\t\t\tActionRuntime.setActionEnablementAfterPatch(\n\t\t\t\t\t\t\tthis.getView(),\n\t\t\t\t\t\t\toEvent.getSource() as V4ListBinding,\n\t\t\t\t\t\t\tthis.getView()?.getBindingContext(\"internal\") as InternalModelContext\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t\tconst bSuccess = patchCompletedEvent.getParameter(\"success\");\n\t\t\t\t\tif (bSuccess) {\n\t\t\t\t\t\tresolve();\n\t\t\t\t\t} else {\n\t\t\t\t\t\treject();\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t});\n\t\t\tthis.updateDocument(oEvent.getSource(), oPatchPromise);\n\t\t}\n\t}\n\n\t/**\n\t * Handles the CreateActivate event.\n\t *\n\t * @param oEvent The event sent by the binding\n\t */\n\tasync handleCreateActivate(oEvent: Event) {\n\t\tconst oBinding = oEvent.getSource();\n\t\tconst transactionHelper = this._getTransactionHelper();\n\t\tconst bAtEnd = true;\n\t\tconst bInactive = true;\n\t\tconst oParams: any = {\n\t\t\tcreationMode: CreationMode.Inline,\n\t\t\tcreateAtEnd: bAtEnd,\n\t\t\tinactive: bInactive,\n\t\t\tkeepTransientContextOnFailed: false, // currently not fully supported\n\t\t\tbusyMode: \"None\"\n\t\t};\n\t\ttry {\n\t\t\t// Send notification to other users only after the creation has been finalized\n\t\t\tconst activatedContext = oEvent.getParameter(\"context\") as Context;\n\t\t\tactivatedContext\n\t\t\t\t.created()\n\t\t\t\t?.then(() => {\n\t\t\t\t\tthis._sendActivity(Activity.Create, activatedContext);\n\t\t\t\t})\n\t\t\t\t.catch(() => {\n\t\t\t\t\tLog.warning(`Failed to activate context ${activatedContext.getPath()}`);\n\t\t\t\t});\n\n\t\t\t// Create a new inactive context (empty row in the table)\n\t\t\tconst newInactiveContext = await transactionHelper.createDocument(\n\t\t\t\toBinding as V4ListBinding,\n\t\t\t\toParams,\n\t\t\t\tthis.getAppComponent(),\n\t\t\t\tthis._getMessageHandler(),\n\t\t\t\tfalse,\n\t\t\t\tthis.getView()\n\t\t\t);\n\t\t\tif (newInactiveContext) {\n\t\t\t\tif (!this._isFclEnabled()) {\n\t\t\t\t\tEditState.setEditStateDirty();\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (error) {\n\t\t\tLog.error(\"Failed to activate new row -\", error as any);\n\t\t}\n\t}\n\n\t//////////////////////////////////////\n\t// Private methods\n\t//////////////////////////////////////\n\n\t/*\n\t\t\t TO BE CHECKED / DISCUSSED\n\t\t\t _createMultipleDocuments and deleteMultiDocument - couldn't we combine them with create and delete document?\n\t\t\t _createActionPromise and deleteCurrentActionPromise -> next step\n\n\t\t\t */\n\n\t_setEditMode(sEditMode: any, bCreationMode?: boolean) {\n\t\tthis.getInternalEditFlow().setEditMode(sEditMode, bCreationMode);\n\t}\n\n\t_getCreationMode(): boolean {\n\t\treturn this.getInternalEditFlow().getCreationMode();\n\t}\n\n\t_isDocumentModified(): boolean {\n\t\treturn this.getInternalEditFlow().isDocumentModified();\n\t}\n\n\t_setDocumentModified(modified: boolean) {\n\t\tthis.getInternalEditFlow().setDocumentModified(modified);\n\t}\n\n\t_setDocumentModifiedOnCreate(listBinding: ODataListBinding) {\n\t\tthis.getInternalEditFlow().setDocumentModifiedOnCreate(listBinding);\n\t}\n\n\t_setDraftStatus(sDraftState: any) {\n\t\tthis.getInternalEditFlow().setDraftStatus(sDraftState);\n\t}\n\n\t_getRoutingListener() {\n\t\treturn this.getInternalEditFlow().getRoutingListener();\n\t}\n\n\t_getGlobalUIModel() {\n\t\treturn this.getInternalEditFlow().getGlobalUIModel();\n\t}\n\t_syncTask(vTask?: any) {\n\t\treturn this.getInternalEditFlow().syncTask(vTask);\n\t}\n\n\t_getProgrammingModel(oContext: any) {\n\t\treturn this.getInternalEditFlow().getProgrammingModel(oContext);\n\t}\n\n\t_deleteDocumentTransaction(oContext: any, mParameters: any) {\n\t\treturn this.getInternalEditFlow().deleteDocumentTransaction(oContext, mParameters);\n\t}\n\n\t_handleCreateEvents(oBinding: any) {\n\t\tthis.getInternalEditFlow().handleCreateEvents(oBinding);\n\t}\n\n\t_getTransactionHelper() {\n\t\treturn this.getInternalEditFlow().getTransactionHelper();\n\t}\n\n\t_getInternalModel() {\n\t\treturn this.getInternalEditFlow().getInternalModel();\n\t}\n\n\t_getRootViewController() {\n\t\treturn this.getAppComponent().getRootViewController();\n\t}\n\n\t_getResourceBundle(): ResourceBundle {\n\t\treturn (this.getView().getController() as any).oResourceBundle as ResourceBundle;\n\t}\n\n\t_getSemanticMapping(): SemanticMapping | undefined {\n\t\treturn this.getAppComponent().getRoutingService().getLastSemanticMapping();\n\t}\n\n\t/**\n\t * Creates a new promise to wait for an action to be executed\n\t *\n\t * @function\n\t * @name _createActionPromise\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @returns {Function} The resolver function which can be used to externally resolve the promise\n\t */\n\n\t_createActionPromise(sActionName: any, sControlId: any) {\n\t\treturn this.getInternalEditFlow().createActionPromise(sActionName, sControlId);\n\t}\n\n\t_getCurrentActionPromise() {\n\t\treturn this.getInternalEditFlow().getCurrentActionPromise();\n\t}\n\n\t_deleteCurrentActionPromise() {\n\t\treturn this.getInternalEditFlow().deleteCurrentActionPromise();\n\t}\n\n\t_getMessageHandler() {\n\t\treturn this.getInternalEditFlow().getMessageHandler();\n\t}\n\n\t_sendActivity(action: Activity, relatedContexts: Context | Context[] | undefined, actionName?: string) {\n\t\tconst content = Array.isArray(relatedContexts) ? relatedContexts.map((context) => context.getPath()) : relatedContexts?.getPath();\n\t\tsend(this.getView(), action, content, actionName);\n\t}\n\n\t_triggerConfiguredSurvey(sActionName: string, triggerType: TriggerType) {\n\t\ttriggerConfiguredSurvey(this.getView(), sActionName, triggerType);\n\t}\n\n\t/**\n\t * @function\n\t * @name _getActionResponseDataAndKeys\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @param sActionName The name of the action that is executed\n\t * @param oResponse The bound action's response data or response context\n\t * @returns Object with data and names of the key fields of the response\n\t */\n\t_getActionResponseDataAndKeys(sActionName: string, oResponse: object) {\n\t\treturn this.getInternalEditFlow().getActionResponseDataAndKeys(sActionName, oResponse);\n\t}\n\n\tasync _submitOpenChanges(oContext: any): Promise<any> {\n\t\tconst oModel = oContext.getModel(),\n\t\t\toLockObject = this._getGlobalUIModel();\n\n\t\ttry {\n\t\t\t// Submit any leftover changes that are not yet submitted\n\t\t\t// Currently we are using only 1 updateGroupId, hence submitting the batch directly here\n\t\t\tawait oModel.submitBatch(\"$auto\");\n\n\t\t\t// Wait for all currently running changes\n\t\t\t// For the time being we agreed with the v4 model team to use an internal method. We'll replace it once\n\t\t\t// a public or restricted method was provided\n\t\t\tawait oModel.oRequestor.waitForRunningChangeRequests(\"$auto\");\n\n\t\t\t// Check if all changes were submitted successfully\n\t\t\tif (oModel.hasPendingChanges(\"$auto\")) {\n\t\t\t\tthrow new Error(\"submit of open changes failed\");\n\t\t\t}\n\t\t} finally {\n\t\t\tif (BusyLocker.isLocked(oLockObject)) {\n\t\t\t\tBusyLocker.unlock(oLockObject);\n\t\t\t}\n\t\t}\n\t}\n\n\t_handleStickyOn(oContext: Context) {\n\t\treturn this.getInternalEditFlow().handleStickyOn(oContext);\n\t}\n\n\t_handleStickyOff() {\n\t\treturn this.getInternalEditFlow().handleStickyOff();\n\t}\n\n\t_onBackNavigationInSession() {\n\t\treturn this.getInternalEditFlow().onBackNavigationInSession();\n\t}\n\n\t_setStickySessionInternalProperties(programmingModel: any, model: ODataModel) {\n\t\tif (programmingModel === ProgrammingModel.Sticky) {\n\t\t\tconst internalModel = this._getInternalModel();\n\t\t\tinternalModel.setProperty(\"/sessionOn\", true);\n\t\t\tinternalModel.setProperty(\"/stickySessionToken\", (model.getHttpHeaders(true) as any)[\"SAP-ContextId\"]);\n\t\t}\n\t}\n\n\t_removeStickySessionInternalProperties(programmingModel: any) {\n\t\tif (programmingModel === ProgrammingModel.Sticky) {\n\t\t\tconst internalModel = this._getInternalModel();\n\t\t\tinternalModel.setProperty(\"/sessionOn\", false);\n\t\t\tinternalModel.setProperty(\"/stickySessionToken\", undefined);\n\t\t\tthis._handleStickyOff(/*oContext*/);\n\t\t}\n\t}\n\n\tasync _handleNewContext(\n\t\toContext: Context,\n\t\tbEditable: boolean,\n\t\tbRecreateContext: boolean,\n\t\tbDraftNavigation: boolean,\n\t\tbForceFocus = false\n\t) {\n\t\tif (!this._isFclEnabled()) {\n\t\t\tEditState.setEditStateDirty();\n\t\t}\n\n\t\tawait this._getRoutingListener().navigateToContext(oContext, {\n\t\t\tcheckNoHashChange: true,\n\t\t\teditable: bEditable,\n\t\t\tbPersistOPScroll: true,\n\t\t\tbRecreateContext: bRecreateContext,\n\t\t\tbDraftNavigation: bDraftNavigation,\n\t\t\tshowPlaceholder: false,\n\t\t\tbForceFocus: bForceFocus,\n\t\t\tkeepCurrentLayout: true\n\t\t});\n\t}\n\n\t_getBoundContext(view: any, params: any) {\n\t\tconst viewLevel = view.getViewData().viewLevel;\n\t\tconst bRefreshAfterAction = viewLevel > 1 || (viewLevel === 1 && params.controlId);\n\t\treturn !params.isNavigable || !!bRefreshAfterAction;\n\t}\n\n\t/**\n\t * Checks if there are validation (parse) errors for controls bound to a given context\n\t *\n\t * @function\n\t * @name _checkForValidationErrors\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @returns {Promise} Promise resolves if there are no validation errors, and rejects if there are validation errors\n\t */\n\n\t_checkForValidationErrors() {\n\t\treturn this._syncTask().then(() => {\n\t\t\tconst sViewId = this.base.getView().getId();\n\t\t\tconst aMessages = sap.ui.getCore().getMessageManager().getMessageModel().getData();\n\t\t\tlet oControl;\n\t\t\tlet oMessage;\n\n\t\t\tif (!aMessages.length) {\n\t\t\t\treturn Promise.resolve(\"No validation errors found\");\n\t\t\t}\n\n\t\t\tfor (let i = 0; i < aMessages.length; i++) {\n\t\t\t\toMessage = aMessages[i];\n\t\t\t\tif (oMessage.validation) {\n\t\t\t\t\toControl = Core.byId(oMessage.getControlId());\n\t\t\t\t\twhile (oControl) {\n\t\t\t\t\t\tif (oControl.getId() === sViewId) {\n\t\t\t\t\t\t\treturn Promise.reject(\"validation errors exist\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\toControl = oControl.getParent();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * @function\n\t * @name _refreshListIfRequired\n\t * @memberof sap.fe.core.controllerextensions.EditFlow\n\t * @param oResponse The response of the bound action and the names of the key fields\n\t * @param oContext The bound context on which the action was executed\n\t * @returns Always resolves to param oResponse\n\t */\n\t_refreshListIfRequired(oResponse: any, oContext: Context) {\n\t\tif (!oContext || !oResponse || !oResponse.oData) {\n\t\t\treturn Promise.resolve();\n\t\t}\n\t\tconst oBinding = oContext.getBinding();\n\t\t// refresh only lists\n\t\tif (oBinding && oBinding.isA(\"sap.ui.model.odata.v4.ODataListBinding\")) {\n\t\t\tconst oContextData = oResponse.oData;\n\t\t\tconst aKeys = oResponse.keys;\n\t\t\tconst oCurrentData = oContext.getObject();\n\t\t\tlet bReturnedContextIsSame = true;\n\t\t\t// ensure context is in the response\n\t\t\tif (Object.keys(oContextData).length) {\n\t\t\t\t// check if context in response is different than the bound context\n\t\t\t\tbReturnedContextIsSame = aKeys.every(function (sKey: any) {\n\t\t\t\t\treturn oCurrentData[sKey] === oContextData[sKey];\n\t\t\t\t});\n\t\t\t\tif (!bReturnedContextIsSame) {\n\t\t\t\t\treturn new Promise<void>((resolve) => {\n\t\t\t\t\t\tif ((oBinding as any).isRoot()) {\n\t\t\t\t\t\t\toBinding.attachEventOnce(\"dataReceived\", function () {\n\t\t\t\t\t\t\t\tresolve();\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\toBinding.refresh();\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tconst oAppComponent = CommonUtils.getAppComponent(this.getView());\n\t\t\t\t\t\t\toAppComponent\n\t\t\t\t\t\t\t\t.getSideEffectsService()\n\t\t\t\t\t\t\t\t.requestSideEffects([{ $NavigationPropertyPath: oBinding.getPath() }], oBinding.getContext() as Context)\n\t\t\t\t\t\t\t\t.then(\n\t\t\t\t\t\t\t\t\tfunction () {\n\t\t\t\t\t\t\t\t\t\tresolve();\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\tfunction () {\n\t\t\t\t\t\t\t\t\t\tLog.error(\"Error while refreshing the table\");\n\t\t\t\t\t\t\t\t\t\tresolve();\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t\t.catch(function (e: any) {\n\t\t\t\t\t\t\t\t\tLog.error(\"Error while refreshing the table\", e);\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t// resolve with oResponse to not disturb the promise chain afterwards\n\t\treturn Promise.resolve();\n\t}\n\n\t_fetchSemanticKeyValues(oContext: Context): Promise<any> {\n\t\tconst oMetaModel = oContext.getModel().getMetaModel() as any,\n\t\t\tsEntitySetName = oMetaModel.getMetaContext(oContext.getPath()).getObject(\"@sapui.name\"),\n\t\t\taSemanticKeys = SemanticKeyHelper.getSemanticKeys(oMetaModel, sEntitySetName);\n\n\t\tif (aSemanticKeys && aSemanticKeys.length) {\n\t\t\tconst aRequestPromises = aSemanticKeys.map(function (oKey: any) {\n\t\t\t\treturn oContext.requestObject(oKey.$PropertyPath);\n\t\t\t});\n\n\t\t\treturn Promise.all(aRequestPromises);\n\t\t} else {\n\t\t\treturn Promise.resolve();\n\t\t}\n\t}\n\n\t/**\n\t * Provides the latest context in the metadata hierarchy from rootBinding to given context pointing to given entityType\n\t * if any such context exists. Otherwise, it returns the original context.\n\t * Note: It is only needed as work-around for incorrect modelling. Correct modelling would imply a DataFieldForAction in a LineItem\n\t * to point to an overload defined either on the corresponding EntityType or a collection of the same.\n\t *\n\t * @param rootContext The context to start searching from\n\t * @param listBinding The listBinding of the table\n\t * @param overloadEntityType The ActionOverload entity type to search for\n\t * @returns Returns the context of the ActionOverload entity\n\t */\n\t_getActionOverloadContextFromMetadataPath(rootContext: Context, listBinding: ODataListBinding, overloadEntityType: string): Context {\n\t\tconst model: ODataModel = rootContext.getModel();\n\t\tconst metaModel: ODataMetaModel = model.getMetaModel();\n\t\tlet contextSegments: string[] = listBinding.getPath().split(\"/\");\n\t\tlet currentContext: Context = rootContext;\n\n\t\t// We expect that the last segment of the listBinding is the ListBinding of the table. Remove this from contextSegments\n\t\t// because it is incorrect to execute bindContext on a list. We do not anyway need to search this context for the overload.\n\t\tcontextSegments.pop();\n\t\tif (contextSegments.length === 0) {\n\t\t\tcontextSegments = [\"\"]; // Don't leave contextSegments undefined\n\t\t}\n\n\t\tif (contextSegments[0] !== \"\") {\n\t\t\tcontextSegments.unshift(\"\"); // to also get the root context, i.e. the bindingContext of the table\n\t\t}\n\t\t// load all the parent contexts into an array\n\t\tconst parentContexts: Context[] = contextSegments\n\t\t\t.map((pathSegment: string) => {\n\t\t\t\tif (pathSegment !== \"\") {\n\t\t\t\t\tcurrentContext = model.bindContext(pathSegment, currentContext).getBoundContext();\n\t\t\t\t} else {\n\t\t\t\t\t// Creating a new context using bindContext(...).getBoundContext() does not work if the etag is needed. According to model colleagues,\n\t\t\t\t\t// we should always use an existing context if possible.\n\t\t\t\t\t// Currently, the only example we know about is using the rootContext - and in this case, we can obviously reuse that existing context.\n\t\t\t\t\t// If other examples should come up, the best possible work around would be to request some data to get an existing context. To keep the\n\t\t\t\t\t// request as small and fast as possible, we should request only the first key property. As this would introduce asynchronism, and anyway\n\t\t\t\t\t// the whole logic is only part of work-around for incorrect modelling, we wait until we have an example needing it before implementing this.\n\t\t\t\t\tcurrentContext = rootContext;\n\t\t\t\t}\n\t\t\t\treturn currentContext;\n\t\t\t})\n\t\t\t.reverse();\n\t\t// search for context backwards\n\t\tconst overloadContext: Context | undefined = parentContexts.find(\n\t\t\t(parentContext: Context) =>\n\t\t\t\t(metaModel.getMetaContext(parentContext.getPath()).getObject(\"$Type\") as unknown as string) === overloadEntityType\n\t\t);\n\t\treturn overloadContext || listBinding.getHeaderContext()!;\n\t}\n\n\t_createSiblingInfo(currentContext: Context, newContext: Context): SiblingInformation {\n\t\treturn {\n\t\t\ttargetContext: newContext,\n\t\t\tpathMapping: [\n\t\t\t\t{\n\t\t\t\t\toldPath: currentContext.getPath(),\n\t\t\t\t\tnewPath: newContext.getPath()\n\t\t\t\t}\n\t\t\t]\n\t\t};\n\t}\n\n\t_updatePathsInHistory(mappings: { oldPath: string; newPath: string }[]) {\n\t\tconst oAppComponent = this.getAppComponent();\n\t\toAppComponent.getRouterProxy().setPathMapping(mappings);\n\n\t\t// Also update the semantic mapping in the routing service\n\t\tconst lastSemanticMapping = this._getSemanticMapping();\n\t\tif (mappings.length && lastSemanticMapping?.technicalPath === mappings[mappings.length - 1].oldPath) {\n\t\t\tlastSemanticMapping.technicalPath = mappings[mappings.length - 1].newPath;\n\t\t}\n\t}\n\n\t_getNavigationTargetForEdit(context: Context, newDocumentContext: Context, siblingInfo: SiblingInformation | undefined) {\n\t\tlet contextToNavigate: Context | undefined;\n\t\tsiblingInfo = siblingInfo ?? this._createSiblingInfo(context, newDocumentContext);\n\t\tthis._updatePathsInHistory(siblingInfo.pathMapping);\n\t\tif (siblingInfo.targetContext.getPath() != newDocumentContext.getPath()) {\n\t\t\tcontextToNavigate = siblingInfo.targetContext;\n\t\t}\n\t\treturn contextToNavigate;\n\t}\n\t/**\n\t * This method creates a sibling context for a subobject page, and calculates a sibling path\n\t * for all intermediate paths between the object page and the subobject page.\n\t *\n\t * @param rootCurrentContext The context for the root of the draft\n\t * @param rightmostCurrentContext The context of the subobject\n\t * @param sProgrammingModel The programming model\n\t * @param doNotComputeIfRoot If true, we don't compute siblingInfo if the root and the rightmost contexts are the same\n\t * @returns Returns the siblingInformation object\n\t */\n\tasync _computeSiblingInformation(\n\t\trootCurrentContext: Context,\n\t\trightmostCurrentContext: Context | null | undefined,\n\t\tsProgrammingModel: string,\n\t\tdoNotComputeIfRoot: boolean\n\t): Promise<SiblingInformation | undefined> {\n\t\trightmostCurrentContext = rightmostCurrentContext ?? rootCurrentContext;\n\t\tif (!rightmostCurrentContext.getPath().startsWith(rootCurrentContext.getPath())) {\n\t\t\t// Wrong usage !!\n\t\t\tLog.error(\"Cannot compute rightmost sibling context\");\n\t\t\tthrow new Error(\"Cannot compute rightmost sibling context\");\n\t\t}\n\t\tif (doNotComputeIfRoot && rightmostCurrentContext.getPath() === rootCurrentContext.getPath()) {\n\t\t\treturn Promise.resolve(undefined);\n\t\t}\n\n\t\tconst model = rootCurrentContext.getModel();\n\t\tif (sProgrammingModel === ProgrammingModel.Draft) {\n\t\t\treturn draft.computeSiblingInformation(rootCurrentContext, rightmostCurrentContext);\n\t\t} else {\n\t\t\t// If not in draft mode, we just recreate a context from the path of the rightmost context\n\t\t\t// No path mapping is needed\n\t\t\treturn {\n\t\t\t\ttargetContext: model.bindContext(rightmostCurrentContext.getPath()).getBoundContext(),\n\t\t\t\tpathMapping: []\n\t\t\t};\n\t\t}\n\t}\n\t_isFclEnabled(): boolean {\n\t\treturn CommonUtils.getAppComponent(this.getView())._isFclEnabled();\n\t}\n}\n\nexport default EditFlow;\n"],"mappings":"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oBAAoB,KAAKrO,YAAY,CAACmO,IAAI,IAC1CE,oBAAoB,KAAKrO,YAAY,CAACyN,QAAQ,IAC9CY,oBAAoB,KAAKrO,YAAY,CAAC+N,KAAK,EAC1C;gBACDY,gBAAgB,CAACqE,8BAA8B,EAAE;cAClD;YACD;YACA,MAAMjO,KAAK;UACZ;QACD;MACD,CAAC,SAAS;QACT,IAAI0C,eAAe,EAAE;UACpBuG,UAAU,CAAC2D,MAAM,CAACrK,WAAW,CAAC;QAC/B;MACD;IACD;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAfC;IAAA,OAkBA2L,YAAY,GAFZ,sBAEaC,YAAoC,EAAiB;MACjE;MACA,OAAOnL,OAAO,CAACC,OAAO,EAAE;IACzB;IACA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAhBC;IAAA,OAmBA4H,cAAc,GAFd,wBAEesD,YAAiE,EAAiB;MAChG;MACA,OAAOnL,OAAO,CAACC,OAAO,EAAE;IACzB;IACA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAfC;IAAA,OAkBA7E,YAAY,GAFZ,sBAEa+P,YAAoC,EAAiB;MACjE;MACA,OAAOnL,OAAO,CAACC,OAAO,EAAE;IACzB;IACA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAfC;IAAA,OAkBAmL,eAAe,GAFf,yBAEgBD,YAAoC,EAAiB;MACpE;MACA,OAAOnL,OAAO,CAACC,OAAO,EAAE;IACzB;IACA;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAfC;IAAA,OAkBA5C,cAAc,GAFd,wBAEe8N,YAAuC,EAAiB;MACtE;MACA,OAAOnL,OAAO,CAACC,OAAO,EAAE;IACzB;;IAEA;IACA;IACA;IACA;IACA;;IAEA;AACD;AACA;AACA;AAC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"}