@sapui5/sap.fe.core 1.103.0 → 1.106.0

package/src/sap/fe/core/controllerextensions/editFlow/draftDataLossPopup.js

@@ -0,0 +1,309 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/controls/DataLossOrDraftDiscard/DataLossOrDraftDiscardHandler", "sap/fe/core/helpers/EditState", "sap/fe/core/controllerextensions/collaboration/ActivitySync", "sap/base/Log"], function (DataLossOrDraftDiscardHandler, EditState, ActivitySync, Log) {
+  "use strict";
+
+  function _catch(body, recover) {
+    try {
+      var result = body();
+    } catch (e) {
+      return recover(e);
+    }
+
+    if (result && result.then) {
+      return result.then(void 0, recover);
+    }
+
+    return result;
+  }
+
+  /**
+   * The general handler in which the individual steps are called.
+   * 
+   * @param fnProcessFunction
+   * @param fnCancelFunction
+   * @param oContext
+   * @param oController
+   * @param bSkipBindingToView
+   * @param navigationType
+   */
+  var processDataLossOrDraftDiscardConfirmation = function (fnProcessFunction, fnCancelFunction, oContext, oController, bSkipBindingToView, navigationType) {
+    try {
+      if (navigationType === undefined) navigationType = NavigationType.BackNavigation;
+      var oModel = oContext.getModel();
+      var draftDataContext = oModel.bindContext("".concat(oContext.getPath(), "/DraftAdministrativeData")).getBoundContext();
+
+      var _temp17 = function () {
+        if (oContext && oContext.getObject() && (!oContext.getObject().DraftAdministrativeData || oContext.getObject().IsActiveEntity === true)) {
+          fnProcessFunction();
+        } else {
+          var _temp18 = _catch(function () {
+            return Promise.resolve(draftDataContext.requestObject()).then(function (draftAdminData) {
+              return Promise.resolve(processDraftAdminData(draftAdminData, fnProcessFunction, fnCancelFunction, oContext, oController, bSkipBindingToView, navigationType)).then(function () {});
+            });
+          }, function (oError) {
+            Log.error("Cannot retrieve draftDataContext information", oError);
+          });
+
+          if (_temp18 && _temp18.then) return _temp18.then(function () {});
+        }
+      }();
+
+      return Promise.resolve(_temp17 && _temp17.then ? _temp17.then(function () {}) : void 0);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  /**
+   * Logic to process the admin data.
+   * 
+   * @param draftAdminData Admin data
+   * @param fnProcessFunction The functon to process the handler
+   * @param fnCancelFunction The cancel function
+   * @param oContext The context of the current call
+   * @param oController The current controller referenced
+   * @param bSkipBindingToView The optional parameter to skip the binding to the view
+   * @param navigationType The navigation type for which the function should be called
+   */
+  var processDraftAdminData = function (draftAdminData, fnProcessFunction, fnCancelFunction, oContext, oController, bSkipBindingToView, navigationType) {
+    try {
+      if (navigationType === undefined) navigationType = NavigationType.BackNavigation;
+      var collaborationConnected = ActivitySync.isConnected(oController.getView());
+      var processFunctionForDrafts = !collaborationConnected ? fnProcessFunction : function () {
+        ActivitySync.disconnect(oController.getView());
+
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        fnProcessFunction.apply.apply(fnProcessFunction, [null].concat(args));
+      };
+      var bSilentlyKeepDraftOnForwardNavigation = silentlyKeepDraftOnForwardNavigation(oController);
+
+      var _temp13 = function () {
+        if (draftAdminData) {
+          var _temp14 = function () {
+            if (oController.getAppComponent().getRootViewController().isFclEnabled()) {
+              return Promise.resolve(processFclMode(draftAdminData, fnCancelFunction, oController, processFunctionForDrafts, bSkipBindingToView)).then(function () {});
+            } else if (!oContext.getObject().HasActiveEntity) {
+              processNoActiveEntityMode(draftAdminData, fnCancelFunction, oController, processFunctionForDrafts, navigationType, bSilentlyKeepDraftOnForwardNavigation, bSkipBindingToView);
+            } else if (draftAdminData.CreationDateTime === draftAdminData.LastChangeDateTime) {
+              processEditingDraftForExistingEntity(oController, oContext, processFunctionForDrafts, navigationType);
+            } else if (EditState.isEditStateDirty()) {
+              processEditStateDirty(oController, fnCancelFunction, processFunctionForDrafts, navigationType, bSilentlyKeepDraftOnForwardNavigation, bSkipBindingToView);
+            } else {
+              // The user started editing the existing draft but did not make any changes
+              // in the current editing session, so in this case we do not want
+              // to show the dataloss dialog but just keep the draft
+              processFunctionForDrafts();
+            }
+          }();
+
+          if (_temp14 && _temp14.then) return _temp14.then(function () {});
+        } else {
+          fnProcessFunction();
+        }
+      }();
+
+      return Promise.resolve(_temp13 && _temp13.then ? _temp13.then(function () {}) : void 0);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  /**
+   * Logic to process the edit state dirty.
+   * 
+   * @param oController The current controller referenced.
+   * @param fnCancelFunction The cancel function
+   * @param processFunctionForDrafts The functon to process the handler
+   * @param navigationType The navigation type for which the function should be called 
+   * @param bSilentlyKeepDraftOnForwardNavigation The parameter to determine whether to skip the popup appearance in forward case
+   * @param bSkipBindingToView The optional parameter to skip the binding to the view.
+   */
+  var processEditStateDirty = function (oController, fnCancelFunction, processFunctionForDrafts, navigationType, bSilentlyKeepDraftOnForwardNavigation, bSkipBindingToView) {
+    try {
+      if (navigationType === NavigationType.ForwardNavigation && bSilentlyKeepDraftOnForwardNavigation) {
+        // In case we have a "forward navigation" and an additional parameter set in the manifest
+        // we "silently" keep the draft
+        processFunctionForDrafts();
+      } else {
+        // The CreationDateTime and LastChangeDateTime are NOT equal, so we are currently editing
+        // an existing draft and need to distinguish depending on if any changes
+        // have been made in the current editing session or not
+        // Changes have been made in the current editing session so we want
+        // to show the dataloss dialog and let the user decide
+        DataLossOrDraftDiscardHandler.performAfterDiscardorKeepDraft(processFunctionForDrafts, fnCancelFunction, oController, bSkipBindingToView);
+      }
+
+      return Promise.resolve();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  /**
+   * Logic to process the draft editing for existing entity.
+   * 
+   * @param oController The current controller referenced.
+   * @param oContext The context of the current call 
+   * @param processFunctionForDrafts The functon to process the handler
+   * @param navigationType The navigation type for which the function should be called 
+   */
+  var processEditingDraftForExistingEntity = function (oController, oContext, processFunctionForDrafts, navigationType) {
+    try {
+      var _temp9 = function () {
+        if (navigationType === NavigationType.BackNavigation) {
+          var mParameters = {
+            skipDiscardPopover: true
+          };
+
+          var _temp10 = _catch(function () {
+            return Promise.resolve(oController.editFlow.cancelDocument(oContext, mParameters)).then(function () {
+              processFunctionForDrafts();
+            });
+          }, function (error) {
+            Log.error("Error while canceling the document", error);
+          });
+
+          if (_temp10 && _temp10.then) return _temp10.then(function () {});
+        } else {
+          // In case of a forward navigation we silently keep the draft and only
+          // execute the followup function.
+          processFunctionForDrafts();
+        }
+      }();
+
+      // We are editing a draft for an existing active entity
+      // The CreationDateTime and LastChangeDateTime are equal, so this draft was
+      // never saved before, hence we're currently editing a newly created draft for
+      // an existing active entity for the first time.
+      // Also there have so far been no changes made to the draft and in this
+      // case we want to silently navigate and delete the draftin case of a back
+      // navigation but in case of a forward navigation we want to silently keep it!
+      return Promise.resolve(_temp9 && _temp9.then ? _temp9.then(function () {}) : void 0);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  /**
+   * Logic to process the mode with no active entity.
+   * 
+   * @param draftAdminData Admin data
+   * @param fnCancelFunction The cancel function
+   * @param oController The current controller referenced
+   * @param processFunctionForDrafts The functon to process the handler
+   * @param navigationType The navigation type for which the function should be called
+   * @param bSilentlyKeepDraftOnForwardNavigation The parameter to determine whether to skip the popup appearance in forward case
+   * @param bSkipBindingToView The optional parameter to skip the binding to the view
+   */
+  var processNoActiveEntityMode = function (draftAdminData, fnCancelFunction, oController, processFunctionForDrafts, navigationType, bSilentlyKeepDraftOnForwardNavigation, bSkipBindingToView) {
+    try {
+      var _temp4 = function () {
+        if (EditState.isEditStateDirty()) {
+          var _temp5 = function () {
+            if (draftAdminData.CreationDateTime === draftAdminData.LastChangeDateTime && navigationType === NavigationType.BackNavigation) {
+              var _temp6 = _catch(function () {
+                return Promise.resolve(DataLossOrDraftDiscardHandler.discardDraft(oController, bSkipBindingToView)).then(function () {
+                  processFunctionForDrafts();
+                });
+              }, function (error) {
+                Log.error("Error while canceling the document", error);
+              });
+
+              if (_temp6 && _temp6.then) return _temp6.then(function () {});
+            } else if (navigationType === NavigationType.ForwardNavigation && bSilentlyKeepDraftOnForwardNavigation) {
+              // In case we have a "forward navigation" and an additional parameter set in the manifest
+              // we "silently" keep the draft
+              processFunctionForDrafts();
+            } else {
+              // In this case data is being changed or a forward navigation is triggered
+              // and we always want to show the dataloss dialog on navigation
+              DataLossOrDraftDiscardHandler.performAfterDiscardorKeepDraft(processFunctionForDrafts, fnCancelFunction, oController, bSkipBindingToView);
+            }
+          }();
+
+          if (_temp5 && _temp5.then) return _temp5.then(function () {});
+        } else {
+          // We are editing a draft which has been created earlier but never saved to active
+          // version and since the edit state is not dirty, there have been no user changes
+          // so in this case we want to silently navigate and do nothing
+          processFunctionForDrafts();
+        }
+      }();
+
+      // There is no active entity so we are editing either newly created data or
+      // a draft which has never been saved to active version
+      // Since we want to react differently in the two situations, we have to check the
+      // dirty state
+      return Promise.resolve(_temp4 && _temp4.then ? _temp4.then(function () {}) : void 0);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  /**
+   * Logic to process the fcl mode.
+   * 
+   * @param draftAdminData Admin data
+   * @param fnCancelFunction The cancel function
+   * @param oController The current controller referenced
+   * @param processFunctionForDrafts The functon to process the handler
+   * @param bSkipBindingToView The optional parameter to skip the binding to the view
+   */
+  var processFclMode = function (draftAdminData, fnCancelFunction, oController, processFunctionForDrafts, bSkipBindingToView) {
+    try {
+      // The application is running in FCL mode so in this case we fall back to
+      // the old logic since the dirty state handling is not properly working
+      // for FCL.
+      if (draftAdminData.CreationDateTime !== draftAdminData.LastChangeDateTime) {
+        DataLossOrDraftDiscardHandler.performAfterDiscardorKeepDraft(processFunctionForDrafts, fnCancelFunction, oController, bSkipBindingToView);
+      } else {
+        processFunctionForDrafts();
+      }
+
+      return Promise.resolve();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  /* Enum for navigation types */
+  var NavigationType;
+  /**
+   * The method checks whether an optional parameter in the manifest is set to silently keep the draft in case a forward navigation is triggered.
+   *
+   * @param pageController The reference to the current PageController instance
+   * @returns Boolean value with true or false to silently keep the draft
+   */
+
+  (function (NavigationType) {
+    NavigationType["BackNavigation"] = "BackNavigation";
+    NavigationType["ForwardNavigation"] = "ForwardNavigation";
+  })(NavigationType || (NavigationType = {}));
+
+  function silentlyKeepDraftOnForwardNavigation(pageController) {
+    var _oManifest$sapFe, _oManifest$sapFe$app;
+
+    var rbSilentlyKeep = false;
+    var oManifest = pageController.getAppComponent().getManifest();
+    rbSilentlyKeep = (oManifest === null || oManifest === void 0 ? void 0 : (_oManifest$sapFe = oManifest["sap.fe"]) === null || _oManifest$sapFe === void 0 ? void 0 : (_oManifest$sapFe$app = _oManifest$sapFe.app) === null || _oManifest$sapFe$app === void 0 ? void 0 : _oManifest$sapFe$app.silentlyKeepDraftOnForwardNavigation) || false;
+    return rbSilentlyKeep;
+  }
+
+  var draftDataLossPopup = {
+    processDataLossOrDraftDiscardConfirmation: processDataLossOrDraftDiscardConfirmation,
+    silentlyKeepDraftOnForwardNavigation: silentlyKeepDraftOnForwardNavigation,
+    NavigationType: NavigationType,
+    processFclMode: processFclMode,
+    processNoActiveEntityMode: processNoActiveEntityMode,
+    processEditingDraftForExistingEntity: processEditingDraftForExistingEntity,
+    processEditStateDirty: processEditStateDirty
+  };
+  return draftDataLossPopup;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["body","recover","result","e","then","processDataLossOrDraftDiscardConfirmation","fnProcessFunction","fnCancelFunction","oContext","oController","bSkipBindingToView","navigationType","NavigationType","BackNavigation","oModel","getModel","draftDataContext","bindContext","getPath","getBoundContext","getObject","DraftAdministrativeData","IsActiveEntity","requestObject","draftAdminData","processDraftAdminData","oError","Log","error","collaborationConnected","ActivitySync","isConnected","getView","processFunctionForDrafts","disconnect","args","apply","bSilentlyKeepDraftOnForwardNavigation","silentlyKeepDraftOnForwardNavigation","getAppComponent","getRootViewController","isFclEnabled","processFclMode","HasActiveEntity","processNoActiveEntityMode","CreationDateTime","LastChangeDateTime","processEditingDraftForExistingEntity","EditState","isEditStateDirty","processEditStateDirty","ForwardNavigation","DataLossOrDraftDiscardHandler","performAfterDiscardorKeepDraft","mParameters","skipDiscardPopover","editFlow","cancelDocument","discardDraft","pageController","rbSilentlyKeep","oManifest","getManifest","app","draftDataLossPopup"],"sourceRoot":".","sources":["draftDataLossPopup.ts"],"sourcesContent":["import DataLossOrDraftDiscardHandler from \"sap/fe/core/controls/DataLossOrDraftDiscard/DataLossOrDraftDiscardHandler\";\r\nimport EditState from \"sap/fe/core/helpers/EditState\";\r\nimport ActivitySync from \"sap/fe/core/controllerextensions/collaboration/ActivitySync\";\r\nimport Log from \"sap/base/Log\";\r\nimport type PageController from \"../../PageController\";\r\n\r\n/* Enum for navigation types */\r\nenum NavigationType {\r\n    BackNavigation = \"BackNavigation\",\r\n    ForwardNavigation = \"ForwardNavigation\"\r\n}\r\n\r\n/**\r\n * The method checks whether an optional parameter in the manifest is set to silently keep the draft in case a forward navigation is triggered.\r\n *\r\n * @param pageController The reference to the current PageController instance\r\n * @returns Boolean value with true or false to silently keep the draft\r\n */\r\nfunction silentlyKeepDraftOnForwardNavigation(pageController: PageController) {\r\n    let rbSilentlyKeep = false;\r\n    const oManifest = pageController.getAppComponent().getManifest() as any;\r\n    rbSilentlyKeep = oManifest?.[\"sap.fe\"]?.app?.silentlyKeepDraftOnForwardNavigation || false;\r\n    return rbSilentlyKeep;\r\n}\r\n\r\n/**\r\n * Logic to process the fcl mode.\r\n * \r\n * @param draftAdminData Admin data\r\n * @param fnCancelFunction The cancel function\r\n * @param oController The current controller referenced\r\n * @param processFunctionForDrafts The functon to process the handler\r\n * @param bSkipBindingToView The optional parameter to skip the binding to the view\r\n */\r\nasync function processFclMode(\r\n    draftAdminData: any,\r\n    fnCancelFunction: any,\r\n    oController: any,\r\n    processFunctionForDrafts: any,\r\n    bSkipBindingToView?: boolean,\r\n) {\r\n    // The application is running in FCL mode so in this case we fall back to\r\n    // the old logic since the dirty state handling is not properly working\r\n    // for FCL.\r\n    if (draftAdminData.CreationDateTime !== draftAdminData.LastChangeDateTime) {\r\n        DataLossOrDraftDiscardHandler.performAfterDiscardorKeepDraft(\r\n            processFunctionForDrafts,\r\n            fnCancelFunction,\r\n            oController,\r\n            bSkipBindingToView\r\n        );\r\n    } else {\r\n        processFunctionForDrafts();\r\n    }\r\n}\r\n\r\n/**\r\n * Logic to process the mode with no active entity.\r\n * \r\n * @param draftAdminData Admin data\r\n * @param fnCancelFunction The cancel function\r\n * @param oController The current controller referenced\r\n * @param processFunctionForDrafts The functon to process the handler\r\n * @param navigationType The navigation type for which the function should be called\r\n * @param bSilentlyKeepDraftOnForwardNavigation The parameter to determine whether to skip the popup appearance in forward case\r\n * @param bSkipBindingToView The optional parameter to skip the binding to the view\r\n */\r\nasync function processNoActiveEntityMode(\r\n    draftAdminData: any,\r\n    fnCancelFunction: any,\r\n    oController: any,\r\n    processFunctionForDrafts: any,\r\n    navigationType: NavigationType,\r\n    bSilentlyKeepDraftOnForwardNavigation: boolean,\r\n    bSkipBindingToView?: boolean) {\r\n    // There is no active entity so we are editing either newly created data or\r\n    // a draft which has never been saved to active version\r\n    // Since we want to react differently in the two situations, we have to check the\r\n    // dirty state\r\n    if (EditState.isEditStateDirty()) {\r\n        if (\r\n            draftAdminData.CreationDateTime === draftAdminData.LastChangeDateTime &&\r\n            navigationType === NavigationType.BackNavigation\r\n        ) {\r\n            // in case we have untouched changes for the draft and a \"back\"\r\n            // navigation we can silently discard the draft again\r\n            // eslint-disable-next-line promise/no-nesting\r\n            try {\r\n                await DataLossOrDraftDiscardHandler.discardDraft(oController, bSkipBindingToView);\r\n                processFunctionForDrafts();\r\n            } catch (error: any) {\r\n                Log.error(\"Error while canceling the document\", error);\r\n            }\r\n        } else if (navigationType === NavigationType.ForwardNavigation && bSilentlyKeepDraftOnForwardNavigation) {\r\n            // In case we have a \"forward navigation\" and an additional parameter set in the manifest\r\n            // we \"silently\" keep the draft\r\n            processFunctionForDrafts();\r\n        } else {\r\n            // In this case data is being changed or a forward navigation is triggered\r\n            // and we always want to show the dataloss dialog on navigation\r\n            DataLossOrDraftDiscardHandler.performAfterDiscardorKeepDraft(\r\n                processFunctionForDrafts,\r\n                fnCancelFunction,\r\n                oController,\r\n                bSkipBindingToView\r\n            );\r\n        }\r\n    } else {\r\n        // We are editing a draft which has been created earlier but never saved to active\r\n        // version and since the edit state is not dirty, there have been no user changes\r\n        // so in this case we want to silently navigate and do nothing\r\n        processFunctionForDrafts();\r\n    }\r\n}\r\n/**\r\n * Logic to process the draft editing for existing entity.\r\n * \r\n * @param oController The current controller referenced.\r\n * @param oContext The context of the current call \r\n * @param processFunctionForDrafts The functon to process the handler\r\n * @param navigationType The navigation type for which the function should be called \r\n */\r\nasync function processEditingDraftForExistingEntity(\r\n    oController: any,\r\n    oContext: any,\r\n    processFunctionForDrafts: any,\r\n    navigationType: NavigationType,\r\n) {\r\n    // We are editing a draft for an existing active entity\r\n    // The CreationDateTime and LastChangeDateTime are equal, so this draft was\r\n    // never saved before, hence we're currently editing a newly created draft for\r\n    // an existing active entity for the first time.\r\n    // Also there have so far been no changes made to the draft and in this\r\n    // case we want to silently navigate and delete the draftin case of a back\r\n    // navigation but in case of a forward navigation we want to silently keep it!\r\n    if (navigationType === NavigationType.BackNavigation) {\r\n        const mParameters = {\r\n            skipDiscardPopover: true\r\n        };\r\n\r\n        try {\r\n            await oController.editFlow.cancelDocument(oContext, mParameters);\r\n            processFunctionForDrafts();\r\n        } catch (error: any) {\r\n            Log.error(\"Error while canceling the document\", error);\r\n        }\r\n    } else {\r\n        // In case of a forward navigation we silently keep the draft and only\r\n        // execute the followup function.\r\n        processFunctionForDrafts();\r\n    }\r\n}\r\n\r\n/**\r\n * Logic to process the edit state dirty.\r\n * \r\n * @param oController The current controller referenced.\r\n * @param fnCancelFunction The cancel function\r\n * @param processFunctionForDrafts The functon to process the handler\r\n * @param navigationType The navigation type for which the function should be called \r\n * @param bSilentlyKeepDraftOnForwardNavigation The parameter to determine whether to skip the popup appearance in forward case\r\n * @param bSkipBindingToView The optional parameter to skip the binding to the view.\r\n */\r\nasync function processEditStateDirty(\r\n    oController: any,\r\n    fnCancelFunction: any,\r\n    processFunctionForDrafts: any,\r\n    navigationType: NavigationType,\r\n    bSilentlyKeepDraftOnForwardNavigation: boolean,\r\n    bSkipBindingToView?: boolean) {\r\n    if (navigationType === NavigationType.ForwardNavigation && bSilentlyKeepDraftOnForwardNavigation) {\r\n        // In case we have a \"forward navigation\" and an additional parameter set in the manifest\r\n        // we \"silently\" keep the draft\r\n        processFunctionForDrafts();\r\n    } else {\r\n        // The CreationDateTime and LastChangeDateTime are NOT equal, so we are currently editing\r\n        // an existing draft and need to distinguish depending on if any changes\r\n        // have been made in the current editing session or not\r\n        // Changes have been made in the current editing session so we want\r\n        // to show the dataloss dialog and let the user decide\r\n        DataLossOrDraftDiscardHandler.performAfterDiscardorKeepDraft(\r\n            processFunctionForDrafts,\r\n            fnCancelFunction,\r\n            oController,\r\n            bSkipBindingToView\r\n        );\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * Logic to process the admin data.\r\n * \r\n * @param draftAdminData Admin data\r\n * @param fnProcessFunction The functon to process the handler\r\n * @param fnCancelFunction The cancel function\r\n * @param oContext The context of the current call\r\n * @param oController The current controller referenced\r\n * @param bSkipBindingToView The optional parameter to skip the binding to the view\r\n * @param navigationType The navigation type for which the function should be called\r\n */\r\nasync function processDraftAdminData(draftAdminData: any, fnProcessFunction: any,\r\n    fnCancelFunction: any,\r\n    oContext: any,\r\n    oController: any,\r\n    bSkipBindingToView?: boolean,\r\n    navigationType: NavigationType = NavigationType.BackNavigation) {\r\n\r\n    const collaborationConnected = ActivitySync.isConnected(oController.getView());\r\n    const processFunctionForDrafts = !collaborationConnected\r\n        ? fnProcessFunction\r\n        : function (...args: any[]) {\r\n            ActivitySync.disconnect(oController.getView());\r\n            fnProcessFunction.apply(null, ...args);\r\n        };\r\n\r\n    const bSilentlyKeepDraftOnForwardNavigation = silentlyKeepDraftOnForwardNavigation(oController);\r\n\r\n    if (draftAdminData) {\r\n        if (oController.getAppComponent().getRootViewController().isFclEnabled()) {\r\n            await processFclMode(\r\n                draftAdminData,\r\n                fnCancelFunction,\r\n                oController,\r\n                processFunctionForDrafts,\r\n                bSkipBindingToView\r\n            )\r\n        } else if (!oContext.getObject().HasActiveEntity) {\r\n            processNoActiveEntityMode(\r\n                draftAdminData,\r\n                fnCancelFunction,\r\n                oController,\r\n                processFunctionForDrafts,\r\n                navigationType,\r\n                bSilentlyKeepDraftOnForwardNavigation,\r\n                bSkipBindingToView\r\n            );\r\n        } else if (draftAdminData.CreationDateTime === draftAdminData.LastChangeDateTime) {\r\n            processEditingDraftForExistingEntity(\r\n                oController,\r\n                oContext,\r\n                processFunctionForDrafts,\r\n                navigationType,\r\n            )\r\n        } else if (EditState.isEditStateDirty()) {\r\n            processEditStateDirty(\r\n                oController,\r\n                fnCancelFunction,\r\n                processFunctionForDrafts,\r\n                navigationType,\r\n                bSilentlyKeepDraftOnForwardNavigation,\r\n                bSkipBindingToView\r\n            )\r\n        } else {\r\n            // The user started editing the existing draft but did not make any changes\r\n            // in the current editing session, so in this case we do not want\r\n            // to show the dataloss dialog but just keep the draft\r\n            processFunctionForDrafts();\r\n        }\r\n    } else {\r\n        fnProcessFunction();\r\n    }\r\n}\r\n\r\n/**\r\n * The general handler in which the individual steps are called.\r\n * \r\n * @param fnProcessFunction\r\n * @param fnCancelFunction\r\n * @param oContext\r\n * @param oController\r\n * @param bSkipBindingToView\r\n * @param navigationType\r\n */\r\nasync function processDataLossOrDraftDiscardConfirmation(\r\n    fnProcessFunction: any,\r\n    fnCancelFunction: any,\r\n    oContext: any,\r\n    oController: any,\r\n    bSkipBindingToView?: boolean,\r\n    navigationType: NavigationType = NavigationType.BackNavigation\r\n) {\r\n    const oModel = oContext.getModel();\r\n    const draftDataContext = oModel.bindContext(`${oContext.getPath()}/DraftAdministrativeData`).getBoundContext();\r\n\r\n    if (\r\n        oContext &&\r\n        oContext.getObject() &&\r\n        (!oContext.getObject().DraftAdministrativeData || oContext.getObject().IsActiveEntity === true)\r\n    ) {\r\n        fnProcessFunction();\r\n    } else {\r\n        try {\r\n\r\n            const draftAdminData = await draftDataContext.requestObject()\r\n            await processDraftAdminData(draftAdminData,\r\n                fnProcessFunction,\r\n                fnCancelFunction,\r\n                oContext,\r\n                oController,\r\n                bSkipBindingToView,\r\n                navigationType);\r\n\r\n        } catch (oError: any) {\r\n            Log.error(\"Cannot retrieve draftDataContext information\", oError);\r\n        }\r\n    }\r\n}\r\n\r\nconst draftDataLossPopup = {\r\n    processDataLossOrDraftDiscardConfirmation: processDataLossOrDraftDiscardConfirmation,\r\n    silentlyKeepDraftOnForwardNavigation: silentlyKeepDraftOnForwardNavigation,\r\n    NavigationType: NavigationType,\r\n    processFclMode: processFclMode,\r\n    processNoActiveEntityMode: processNoActiveEntityMode,\r\n    processEditingDraftForExistingEntity: processEditingDraftForExistingEntity,\r\n    processEditStateDirty: processEditStateDirty\r\n}\r\n\r\nexport default draftDataLossPopup;"],"mappings":";AAAA;AAAA;AAAA;;;;EAkjBO,gBAAgBA,IAAhB,EAAsBC,OAAtB,EAA+B;IACrC,IAAI;MACH,IAAIC,MAAM,GAAGF,IAAI,EAAjB;IACA,CAFD,CAEE,OAAMG,CAAN,EAAS;MACV,OAAOF,OAAO,CAACE,CAAD,CAAd;IACA;;IACD,IAAID,MAAM,IAAIA,MAAM,CAACE,IAArB,EAA2B;MAC1B,OAAOF,MAAM,CAACE,IAAP,CAAY,KAAK,CAAjB,EAAoBH,OAApB,CAAP;IACA;;IACD,OAAOC,MAAP;EACA;;EApTD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACeG,yC,aACXC,iB,EACAC,gB,EACAC,Q,EACAC,W,EACAC,kB,EACAC,c;QACF;MAAA,IADEA,cACF,gBADEA,cACF,GADmCC,cAAc,CAACC,cAClD;MACE,IAAMC,MAAM,GAAGN,QAAQ,CAACO,QAAT,EAAf;MACA,IAAMC,gBAAgB,GAAGF,MAAM,CAACG,WAAP,WAAsBT,QAAQ,CAACU,OAAT,EAAtB,+BAAoEC,eAApE,EAAzB;;MAFF;QAAA,IAKMX,QAAQ,IACRA,QAAQ,CAACY,SAAT,EADA,KAEC,CAACZ,QAAQ,CAACY,SAAT,GAAqBC,uBAAtB,IAAiDb,QAAQ,CAACY,SAAT,GAAqBE,cAArB,KAAwC,IAF1F,CALN;UASMhB,iBAAiB;QATvB;UAAA,iCAWU;YAAA,uBAE6BU,gBAAgB,CAACO,aAAjB,EAF7B,iBAEMC,cAFN;cAAA,uBAGMC,qBAAqB,CAACD,cAAD,EACvBlB,iBADuB,EAEvBC,gBAFuB,EAGvBC,QAHuB,EAIvBC,WAJuB,EAKvBC,kBALuB,EAMvBC,cANuB,CAH3B;YAAA;UAWH,CAtBP,YAsBee,MAtBf,EAsB4B;YAClBC,GAAG,CAACC,KAAJ,CAAU,8CAAV,EAA0DF,MAA1D;UACH,CAxBP;;UAAA;QAAA;MAAA;;MAAA;IA0BD,C;;;;;EArHD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACeD,qB,aAAsBD,c,EAAqBlB,iB,EACtDC,gB,EACAC,Q,EACAC,W,EACAC,kB,EACAC,c;QAAgE;MAAA,IAAhEA,cAAgE,gBAAhEA,cAAgE,GAA/BC,cAAc,CAACC,cAAgB;MAEhE,IAAMgB,sBAAsB,GAAGC,YAAY,CAACC,WAAb,CAAyBtB,WAAW,CAACuB,OAAZ,EAAzB,CAA/B;MACA,IAAMC,wBAAwB,GAAG,CAACJ,sBAAD,GAC3BvB,iBAD2B,GAE3B,YAA0B;QACxBwB,YAAY,CAACI,UAAb,CAAwBzB,WAAW,CAACuB,OAAZ,EAAxB;;QADwB,kCAAbG,IAAa;UAAbA,IAAa;QAAA;;QAExB7B,iBAAiB,CAAC8B,KAAlB,OAAA9B,iBAAiB,GAAO,IAAP,SAAgB6B,IAAhB,EAAjB;MACH,CALL;MAOA,IAAME,qCAAqC,GAAGC,oCAAoC,CAAC7B,WAAD,CAAlF;;MAVgE;QAAA,IAY5De,cAZ4D;UAAA;YAAA,IAaxDf,WAAW,CAAC8B,eAAZ,GAA8BC,qBAA9B,GAAsDC,YAAtD,EAbwD;cAAA,uBAclDC,cAAc,CAChBlB,cADgB,EAEhBjB,gBAFgB,EAGhBE,WAHgB,EAIhBwB,wBAJgB,EAKhBvB,kBALgB,CAdoC;YAAA,OAqBrD,IAAI,CAACF,QAAQ,CAACY,SAAT,GAAqBuB,eAA1B,EAA2C;cAC9CC,yBAAyB,CACrBpB,cADqB,EAErBjB,gBAFqB,EAGrBE,WAHqB,EAIrBwB,wBAJqB,EAKrBtB,cALqB,EAMrB0B,qCANqB,EAOrB3B,kBAPqB,CAAzB;YASH,CAVM,MAUA,IAAIc,cAAc,CAACqB,gBAAf,KAAoCrB,cAAc,CAACsB,kBAAvD,EAA2E;cAC9EC,oCAAoC,CAChCtC,WADgC,EAEhCD,QAFgC,EAGhCyB,wBAHgC,EAIhCtB,cAJgC,CAApC;YAMH,CAPM,MAOA,IAAIqC,SAAS,CAACC,gBAAV,EAAJ,EAAkC;cACrCC,qBAAqB,CACjBzC,WADiB,EAEjBF,gBAFiB,EAGjB0B,wBAHiB,EAIjBtB,cAJiB,EAKjB0B,qCALiB,EAMjB3B,kBANiB,CAArB;YAQH,CATM,MASA;cACH;cACA;cACA;cACAuB,wBAAwB;YAC3B;UApD2D;;UAAA;QAAA;UAsD5D3B,iBAAiB;QAtD2C;MAAA;;MAAA;IAwDnE,C;;;;;EA7GD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACe4C,qB,aACXzC,W,EACAF,gB,EACA0B,wB,EACAtB,c,EACA0B,qC,EACA3B,kB;QAA8B;MAC9B,IAAIC,cAAc,KAAKC,cAAc,CAACuC,iBAAlC,IAAuDd,qCAA3D,EAAkG;QAC9F;QACA;QACAJ,wBAAwB;MAC3B,CAJD,MAIO;QACH;QACA;QACA;QACA;QACA;QACAmB,6BAA6B,CAACC,8BAA9B,CACIpB,wBADJ,EAEI1B,gBAFJ,EAGIE,WAHJ,EAIIC,kBAJJ;MAMH;;MAjB6B;IAkBjC,C;;;;;EAzED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACeqC,oC,aACXtC,W,EACAD,Q,EACAyB,wB,EACAtB,c;QACF;MAAA;QAAA,IAQMA,cAAc,KAAKC,cAAc,CAACC,cARxC;UASM,IAAMyC,WAAW,GAAG;YAChBC,kBAAkB,EAAE;UADJ,CAApB;;UATN,iCAaU;YAAA,uBACM9C,WAAW,CAAC+C,QAAZ,CAAqBC,cAArB,CAAoCjD,QAApC,EAA8C8C,WAA9C,CADN;cAEArB,wBAAwB;YAFxB;UAGH,CAhBP,YAgBeL,KAhBf,EAgB2B;YACjBD,GAAG,CAACC,KAAJ,CAAU,oCAAV,EAAgDA,KAAhD;UACH,CAlBP;;UAAA;QAAA;UAoBM;UACA;UACAK,wBAAwB;QAtB9B;MAAA;;MACE;MACA;MACA;MACA;MACA;MACA;MACA;MAPF;IAwBD,C;;;;;EA/FD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACeW,yB,aACXpB,c,EACAjB,gB,EACAE,W,EACAwB,wB,EACAtB,c,EACA0B,qC,EACA3B,kB;QAA8B;MAAA;QAAA,IAK1BsC,SAAS,CAACC,gBAAV,EAL0B;UAAA;YAAA,IAOtBzB,cAAc,CAACqB,gBAAf,KAAoCrB,cAAc,CAACsB,kBAAnD,IACAnC,cAAc,KAAKC,cAAc,CAACC,cARZ;cAAA,gCAalB;gBAAA,uBACMuC,6BAA6B,CAACM,YAA9B,CAA2CjD,WAA3C,EAAwDC,kBAAxD,CADN;kBAEAuB,wBAAwB;gBAFxB;cAGH,CAhBqB,YAgBbL,KAhBa,EAgBD;gBACjBD,GAAG,CAACC,KAAJ,CAAU,oCAAV,EAAgDA,KAAhD;cACH,CAlBqB;;cAAA;YAAA,OAmBnB,IAAIjB,cAAc,KAAKC,cAAc,CAACuC,iBAAlC,IAAuDd,qCAA3D,EAAkG;cACrG;cACA;cACAJ,wBAAwB;YAC3B,CAJM,MAIA;cACH;cACA;cACAmB,6BAA6B,CAACC,8BAA9B,CACIpB,wBADJ,EAEI1B,gBAFJ,EAGIE,WAHJ,EAIIC,kBAJJ;YAMH;UAhCyB;;UAAA;QAAA;UAkC1B;UACA;UACA;UACAuB,wBAAwB;QArCE;MAAA;;MAC9B;MACA;MACA;MACA;MAJ8B;IAuCjC,C;;;;;EAxFD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACeS,c,aACXlB,c,EACAjB,gB,EACAE,W,EACAwB,wB,EACAvB,kB;QACF;MACE;MACA;MACA;MACA,IAAIc,cAAc,CAACqB,gBAAf,KAAoCrB,cAAc,CAACsB,kBAAvD,EAA2E;QACvEM,6BAA6B,CAACC,8BAA9B,CACIpB,wBADJ,EAEI1B,gBAFJ,EAGIE,WAHJ,EAIIC,kBAJJ;MAMH,CAPD,MAOO;QACHuB,wBAAwB;MAC3B;;MAbH;IAcD,C;;;;;EAhDD;MACKrB,c;EAKL;AACA;AACA;AACA;AACA;AACA;;aAVKA,c;IAAAA,c;IAAAA,c;KAAAA,c,KAAAA,c;;EAWL,SAAS0B,oCAAT,CAA8CqB,cAA9C,EAA8E;IAAA;;IAC1E,IAAIC,cAAc,GAAG,KAArB;IACA,IAAMC,SAAS,GAAGF,cAAc,CAACpB,eAAf,GAAiCuB,WAAjC,EAAlB;IACAF,cAAc,GAAG,CAAAC,SAAS,SAAT,IAAAA,SAAS,WAAT,gCAAAA,SAAS,CAAG,QAAH,CAAT,8FAAuBE,GAAvB,8EAA4BzB,oCAA5B,KAAoE,KAArF;IACA,OAAOsB,cAAP;EACH;;EA8RD,IAAMI,kBAAkB,GAAG;IACvB3D,yCAAyC,EAAEA,yCADpB;IAEvBiC,oCAAoC,EAAEA,oCAFf;IAGvB1B,cAAc,EAAEA,cAHO;IAIvB8B,cAAc,EAAEA,cAJO;IAKvBE,yBAAyB,EAAEA,yBALJ;IAMvBG,oCAAoC,EAAEA,oCANf;IAOvBG,qBAAqB,EAAEA;EAPA,CAA3B;SAUec,kB"}