@sapui5/sap.fe.templates 1.110.1 → 1.111.0

package/src/sap/fe/templates/ListReport/overrides/ViewState-dbg.js

@@ -0,0 +1,481 @@
+/*!
+ * 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/helpers/KeepAliveHelper", "sap/fe/core/helpers/ModelHelper", "sap/fe/core/library", "sap/fe/core/templating/PropertyFormatters", "sap/fe/macros/DelegateUtil", "sap/fe/macros/filter/FilterUtils", "sap/fe/navigation/library", "sap/ui/Device", "sap/ui/fl/apply/api/ControlVariantApplyAPI", "sap/ui/mdc/enum/ConditionValidated", "sap/ui/mdc/p13n/StateUtil"], function (Log, CommonUtils, KeepAliveHelper, ModelHelper, CoreLibrary, PropertyFormatters, DelegateUtil, FilterUtils, NavLibrary, Device, ControlVariantApplyAPI, ConditionValidated, StateUtil) {
+  "use strict";
+
+  var system = Device.system;
+  const NavType = NavLibrary.NavType,
+    VariantManagementType = CoreLibrary.VariantManagement,
+    TemplateContentView = CoreLibrary.TemplateContentView,
+    InitialLoadMode = CoreLibrary.InitialLoadMode,
+    CONDITION_PATH_TO_PROPERTY_PATH_REGEX = /\+|\*/g;
+  const ViewStateOverride = {
+    _bSearchTriggered: false,
+    applyInitialStateOnly: function () {
+      return true;
+    },
+    onBeforeStateApplied: function (aPromises) {
+      const oView = this.getView(),
+        oController = oView.getController(),
+        oFilterBar = oController._getFilterBarControl(),
+        aTables = oController._getControls("table");
+      if (oFilterBar) {
+        oFilterBar.setSuspendSelection(true);
+        aPromises.push(oFilterBar.waitForInitialization());
+      }
+      aTables.forEach(function (oTable) {
+        aPromises.push(oTable.initialized());
+      });
+      delete this._bSearchTriggered;
+    },
+    onAfterStateApplied: function () {
+      const oController = this.getView().getController();
+      const oFilterBar = oController._getFilterBarControl();
+      if (oFilterBar) {
+        oFilterBar.setSuspendSelection(false);
+      } else if (oController._isFilterBarHidden()) {
+        const oInternalModelContext = oController.getView().getBindingContext("internal");
+        oInternalModelContext.setProperty("hasPendingFilters", false);
+        if (oController._isMultiMode()) {
+          oController._getMultiModeControl().setCountsOutDated(true);
+        }
+      }
+    },
+    adaptBindingRefreshControls: function (aControls) {
+      const oView = this.getView(),
+        oController = oView.getController(),
+        aViewControls = oController._getControls(),
+        aControlsToRefresh = KeepAliveHelper.getControlsForRefresh(oView, aViewControls);
+      Array.prototype.push.apply(aControls, aControlsToRefresh);
+    },
+    adaptStateControls: function (aStateControls) {
+      const oView = this.getView(),
+        oController = oView.getController(),
+        oViewData = oView.getViewData(),
+        bControlVM = oViewData.variantManagement === VariantManagementType.Control;
+      const oFilterBarVM = this._getFilterBarVM(oView);
+      if (oFilterBarVM) {
+        aStateControls.push(oFilterBarVM);
+      }
+      if (oController._isMultiMode()) {
+        aStateControls.push(oController._getMultiModeControl());
+      }
+      oController._getControls("table").forEach(function (oTable) {
+        const oQuickFilter = oTable.getQuickFilter();
+        if (oQuickFilter) {
+          aStateControls.push(oQuickFilter);
+        }
+        if (bControlVM) {
+          aStateControls.push(oTable.getVariant());
+        }
+        aStateControls.push(oTable);
+      });
+      if (oController._getControls("Chart")) {
+        oController._getControls("Chart").forEach(function (oChart) {
+          if (bControlVM) {
+            aStateControls.push(oChart.getVariant());
+          }
+          aStateControls.push(oChart);
+        });
+      }
+      if (oController._hasMultiVisualizations()) {
+        aStateControls.push(oController._getSegmentedButton(TemplateContentView.Chart));
+        aStateControls.push(oController._getSegmentedButton(TemplateContentView.Table));
+      }
+      const oFilterBar = oController._getFilterBarControl();
+      if (oFilterBar) {
+        aStateControls.push(oFilterBar);
+      }
+      aStateControls.push(oView.byId("fe::ListReport"));
+    },
+    retrieveAdditionalStates: function (mAdditionalStates) {
+      const oView = this.getView(),
+        oController = oView.getController(),
+        bPendingFilter = oView.getBindingContext("internal").getProperty("hasPendingFilters");
+      mAdditionalStates.dataLoaded = !bPendingFilter || !!this._bSearchTriggered;
+      if (oController._hasMultiVisualizations()) {
+        const sAlpContentView = oView.getBindingContext("internal").getProperty("alpContentView");
+        mAdditionalStates.alpContentView = sAlpContentView;
+      }
+      delete this._bSearchTriggered;
+    },
+    applyAdditionalStates: function (oAdditionalStates) {
+      const oView = this.getView(),
+        oController = oView.getController(),
+        oFilterBar = oController._getFilterBarControl();
+      if (oAdditionalStates) {
+        // explicit check for boolean values - 'undefined' should not alter the triggered search property
+        if (oAdditionalStates.dataLoaded === false && oFilterBar) {
+          // without this, the data is loaded on navigating back
+          oFilterBar._bSearchTriggered = false;
+        } else if (oAdditionalStates.dataLoaded === true) {
+          if (oFilterBar) {
+            oFilterBar.triggerSearch();
+          }
+          this._bSearchTriggered = true;
+        }
+        if (oController._hasMultiVisualizations()) {
+          const oInternalModelContext = oView.getBindingContext("internal");
+          if (!system.desktop && oAdditionalStates.alpContentView == TemplateContentView.Hybrid) {
+            oAdditionalStates.alpContentView = TemplateContentView.Chart;
+          }
+          oInternalModelContext.getModel().setProperty(`${oInternalModelContext.getPath()}/alpContentView`, oAdditionalStates.alpContentView);
+        }
+      }
+    },
+    _applyNavigationParametersToFilterbar: function (oNavigationParameter, aResults) {
+      const oView = this.getView();
+      const oController = oView.getController();
+      const oAppComponent = oController.getAppComponent();
+      const oComponentData = oAppComponent.getComponentData();
+      const oStartupParameters = oComponentData && oComponentData.startupParameters || {};
+      const oVariantPromise = this.handleVariantIdPassedViaURLParams(oStartupParameters);
+      let bFilterVariantApplied;
+      aResults.push(oVariantPromise.then(aVariants => {
+        if (aVariants && aVariants.length > 0) {
+          if (aVariants[0] === true || aVariants[1] === true) {
+            bFilterVariantApplied = true;
+          }
+        }
+        return this._applySelectionVariant(oView, oNavigationParameter, bFilterVariantApplied);
+      }).then(() => {
+        const oDynamicPage = oController._getDynamicListReportControl();
+        let bPreventInitialSearch = false;
+        const oFilterBarVM = this._getFilterBarVM(oView);
+        const oFilterBarControl = oController._getFilterBarControl();
+        if (oFilterBarControl) {
+          if (oNavigationParameter.navigationType !== NavType.initial && oNavigationParameter.requiresStandardVariant || !oFilterBarVM && oView.getViewData().initialLoad === InitialLoadMode.Enabled || oController._shouldAutoTriggerSearch(oFilterBarVM)) {
+            oFilterBarControl.triggerSearch();
+          } else {
+            bPreventInitialSearch = this._preventInitialSearch(oFilterBarVM);
+          }
+          // reset the suspend selection on filter bar to allow loading of data when needed (was set on LR Init)
+          oFilterBarControl.setSuspendSelection(false);
+          this._bSearchTriggered = !bPreventInitialSearch;
+          oDynamicPage.setHeaderExpanded(system.desktop || bPreventInitialSearch);
+        }
+      }).catch(function () {
+        Log.error("Variant ID cannot be applied");
+      }));
+    },
+    handleVariantIdPassedViaURLParams: function (oUrlParams) {
+      const aPageVariantId = oUrlParams["sap-ui-fe-variant-id"],
+        aFilterBarVariantId = oUrlParams["sap-ui-fe-filterbar-variant-id"],
+        aTableVariantId = oUrlParams["sap-ui-fe-table-variant-id"],
+        aChartVariantId = oUrlParams["sap-ui-fe-chart-variant-id"];
+      let oVariantIDs;
+      if (aPageVariantId || aFilterBarVariantId || aTableVariantId || aChartVariantId) {
+        oVariantIDs = {
+          sPageVariantId: aPageVariantId && aPageVariantId[0],
+          sFilterBarVariantId: aFilterBarVariantId && aFilterBarVariantId[0],
+          sTableVariantId: aTableVariantId && aTableVariantId[0],
+          sChartVariantId: aChartVariantId && aChartVariantId[0]
+        };
+      }
+      return this._handleControlVariantId(oVariantIDs);
+    },
+    _handleControlVariantId: function (oVariantIDs) {
+      let oVM;
+      const oView = this.getView(),
+        aPromises = [];
+      const sVariantManagement = oView.getViewData().variantManagement;
+      if (oVariantIDs && oVariantIDs.sPageVariantId && sVariantManagement === "Page") {
+        oVM = oView.byId("fe::PageVariantManagement");
+        this._handlePageVariantId(oVariantIDs, oVM, aPromises);
+      } else if (oVariantIDs && sVariantManagement === "Control") {
+        if (oVariantIDs.sFilterBarVariantId) {
+          oVM = oView.getController()._getFilterBarVariantControl();
+          this._handleFilterBarVariantControlId(oVariantIDs, oVM, aPromises);
+        }
+        if (oVariantIDs.sTableVariantId) {
+          const oController = oView.getController();
+          this._handleTableControlVariantId(oVariantIDs, oController, aPromises);
+        }
+        if (oVariantIDs.sChartVariantId) {
+          const oController = oView.getController();
+          this._handleChartControlVariantId(oVariantIDs, oController, aPromises);
+        }
+      }
+      return Promise.all(aPromises);
+    },
+    /*
+     * Handles page level variant and passes the variant to the function that pushes the promise to the promise array
+     *
+     * @param oVarinatIDs contains an object of all variant IDs
+     * @param oVM contains the vairant management object for the page variant
+     * @param aPromises is an array of all promises
+     * @private
+     */
+    _handlePageVariantId: function (oVariantIDs, oVM, aPromises) {
+      oVM.getVariants().forEach(oVariant => {
+        this._findAndPushVariantToPromise(oVariant, oVariantIDs.sPageVariantId, oVM, aPromises, true);
+      });
+    },
+    /*
+     * Handles control level variant for filter bar and passes the variant to the function that pushes the promise to the promise array
+     *
+     * @param oVarinatIDs contains an object of all variant IDs
+     * @param oVM contains the vairant management object for the filter bar
+     * @param aPromises is an array of all promises
+     * @private
+     */
+
+    _handleFilterBarVariantControlId: function (oVariantIDs, oVM, aPromises) {
+      if (oVM) {
+        oVM.getVariants().forEach(oVariant => {
+          this._findAndPushVariantToPromise(oVariant, oVariantIDs.sFilterBarVariantId, oVM, aPromises, true);
+        });
+      }
+    },
+    /*
+     * Handles control level variant for table and passes the variant to the function that pushes the promise to the promise array
+     *
+     * @param oVarinatIDs contains an object of all variant IDs
+     * @param oController has the list report controller object
+     * @param aPromises is an array of all promises
+     * @private
+     */
+    _handleTableControlVariantId: function (oVariantIDs, oController, aPromises) {
+      const aTables = oController._getControls("table");
+      aTables.forEach(oTable => {
+        const oTableVariant = oTable.getVariant();
+        if (oTable && oTableVariant) {
+          oTableVariant.getVariants().forEach(oVariant => {
+            this._findAndPushVariantToPromise(oVariant, oVariantIDs.sTableVariantId, oTableVariant, aPromises);
+          });
+        }
+      });
+    },
+    /*
+     * Handles control level variant for chart and passes the variant to the function that pushes the promise to the promise array
+     *
+     * @param oVarinatIDs contains an object of all variant IDs
+     * @param oController has the list report controller object
+     * @param aPromises is an array of all promises
+     * @private
+     */
+    _handleChartControlVariantId: function (oVariantIDs, oController, aPromises) {
+      const aCharts = oController._getControls("Chart");
+      aCharts.forEach(oChart => {
+        const oChartVariant = oChart.getVariant();
+        const aVariants = oChartVariant.getVariants();
+        if (aVariants) {
+          aVariants.forEach(oVariant => {
+            this._findAndPushVariantToPromise(oVariant, oVariantIDs.sChartVariantId, oChartVariant, aPromises);
+          });
+        }
+      });
+    },
+    /*
+     * Matches the variant ID provided in the url to the available vairant IDs and pushes the appropriate promise to the promise array
+     *
+     * @param oVariant is an object for a specific variant
+     * @param sVariantId is the variant ID provided in the url
+     * @param oVM is the variant management object for the specfic variant
+     * @param aPromises is an array of promises
+     * @param bFilterVariantApplied is an optional parameter which is set to ture in case the filter variant is applied
+     * @private
+     */
+    _findAndPushVariantToPromise: function (oVariant, sVariantId, oVM, aPromises, bFilterVariantApplied) {
+      if (oVariant.key === sVariantId) {
+        aPromises.push(this._applyControlVariant(oVM, sVariantId, bFilterVariantApplied));
+      }
+    },
+    _applyControlVariant: function (oVariant, sVariantID, bFilterVariantApplied) {
+      const sVariantReference = this._checkIfVariantIdIsAvailable(oVariant, sVariantID) ? sVariantID : oVariant.getStandardVariantKey();
+      const oVM = ControlVariantApplyAPI.activateVariant({
+        element: oVariant,
+        variantReference: sVariantReference
+      });
+      return oVM.then(function () {
+        return bFilterVariantApplied;
+      });
+    },
+    /************************************* private helper *****************************************/
+
+    _getFilterBarVM: function (oView) {
+      const oViewData = oView.getViewData();
+      switch (oViewData.variantManagement) {
+        case VariantManagementType.Page:
+          return oView.byId("fe::PageVariantManagement");
+        case VariantManagementType.Control:
+          return oView.getController()._getFilterBarVariantControl();
+        case VariantManagementType.None:
+          return null;
+        default:
+          throw new Error(`unhandled variant setting: ${oViewData.variantManagement}`);
+      }
+    },
+    _preventInitialSearch: function (oVariantManagement) {
+      if (!oVariantManagement) {
+        return true;
+      }
+      const aVariants = oVariantManagement.getVariants();
+      const oCurrentVariant = aVariants.find(function (oItem) {
+        return oItem.key === oVariantManagement.getCurrentVariantKey();
+      });
+      return !oCurrentVariant.executeOnSelect;
+    },
+    _applySelectionVariant: function (oView, oNavigationParameter, bFilterVariantApplied) {
+      const oFilterBar = oView.getController()._getFilterBarControl(),
+        oSelectionVariant = oNavigationParameter.selectionVariant,
+        oSelectionVariantDefaults = oNavigationParameter.selectionVariantDefaults;
+      if (!oFilterBar || !oSelectionVariant) {
+        return Promise.resolve();
+      }
+      let oConditions = {};
+      const oMetaModel = oView.getModel().getMetaModel();
+      const oViewData = oView.getViewData();
+      const sContextPath = oViewData.contextPath || `/${oViewData.entitySet}`;
+      const aMandatoryFilterFields = CommonUtils.getMandatoryFilterFields(oMetaModel, sContextPath);
+      const bUseSemanticDateRange = oFilterBar.data("useSemanticDateRange");
+      let oVariant;
+      switch (oViewData.variantManagement) {
+        case VariantManagementType.Page:
+          oVariant = oView.byId("fe::PageVariantManagement");
+          break;
+        case VariantManagementType.Control:
+          oVariant = oView.getController()._getFilterBarVariantControl();
+          break;
+        case VariantManagementType.None:
+        default:
+          break;
+      }
+      const bRequiresStandardVariant = oNavigationParameter.requiresStandardVariant;
+      // check if FLP default values are there and is it standard variant
+      const bIsFLPValuePresent = oSelectionVariantDefaults && oSelectionVariantDefaults.getSelectOptionsPropertyNames().length > 0 && oVariant.getDefaultVariantKey() === oVariant.getStandardVariantKey() && oNavigationParameter.bNavSelVarHasDefaultsOnly;
+
+      // get conditions when FLP value is present
+      if (bFilterVariantApplied || bIsFLPValuePresent) {
+        oConditions = oFilterBar.getConditions();
+      }
+      CommonUtils.addDefaultDisplayCurrency(aMandatoryFilterFields, oSelectionVariant, oSelectionVariantDefaults);
+      CommonUtils.addSelectionVariantToConditions(oSelectionVariant, oConditions, oMetaModel, sContextPath, bIsFLPValuePresent, bUseSemanticDateRange, oViewData);
+      return this._activateSelectionVariant(oFilterBar, oConditions, oVariant, bRequiresStandardVariant, bFilterVariantApplied, bIsFLPValuePresent);
+    },
+    _activateSelectionVariant: function (oFilterBar, oConditions, oVariant, bRequiresStandardVariant, bFilterVariantApplied, bIsFLPValuePresent) {
+      let oPromise;
+      if (oVariant && !bFilterVariantApplied) {
+        let oVariantKey = bRequiresStandardVariant ? oVariant.getStandardVariantKey() : oVariant.getDefaultVariantKey();
+        if (oVariantKey === null) {
+          oVariantKey = oVariant.getId();
+        }
+        oPromise = ControlVariantApplyAPI.activateVariant({
+          element: oVariant,
+          variantReference: oVariantKey
+        }).then(function () {
+          return bRequiresStandardVariant || oVariant.getDefaultVariantKey() === oVariant.getStandardVariantKey();
+        });
+      } else {
+        oPromise = Promise.resolve(true);
+      }
+      return oPromise.then(bClearFilterAndReplaceWithAppState => {
+        if (bClearFilterAndReplaceWithAppState) {
+          return this._fnApplyConditions(oFilterBar, oConditions, bIsFLPValuePresent);
+        }
+      });
+    },
+    /*
+     * Sets filtered: false flag to every field so that it can be cleared out
+     *
+     * @param oFilterBar filterbar control is used to display filter properties in a user-friendly manner to populate values for a query
+     * @returns promise which will be resolved to object
+     * @private
+     */
+    _fnClearStateBeforexAppNav: async function (oFilterBar) {
+      return await StateUtil.retrieveExternalState(oFilterBar).then(oExternalState => {
+        const oCondition = oExternalState.filter;
+        for (const field in oCondition) {
+          if (field !== "$editState" && field !== "$search") {
+            oCondition[field][0]["filtered"] = false;
+          }
+        }
+        return Promise.resolve(oCondition);
+      }).catch(function (oError) {
+        Log.error("Error while retrieving the external state", oError);
+      });
+    },
+    _fnApplyConditions: async function (oFilterBar, oConditions, bIsFLPValuePresent) {
+      const mFilter = {},
+        aItems = [],
+        fnAdjustValueHelpCondition = function (oCondition) {
+          // in case the condition is meant for a field having a VH, the format required by MDC differs
+          oCondition.validated = ConditionValidated.Validated;
+          if (oCondition.operator === "Empty") {
+            oCondition.operator = "EQ";
+            oCondition.values = [""];
+          } else if (oCondition.operator === "NotEmpty") {
+            oCondition.operator = "NE";
+            oCondition.values = [""];
+          }
+          delete oCondition.isEmpty;
+        };
+      const fnGetPropertyInfo = function (oFilterControl, sEntityTypePath) {
+        const sEntitySetPath = ModelHelper.getEntitySetPath(sEntityTypePath),
+          oMetaModel = oFilterControl.getModel().getMetaModel(),
+          oFR = CommonUtils.getFilterRestrictionsByPath(sEntitySetPath, oMetaModel),
+          aNonFilterableProps = oFR.NonFilterableProperties,
+          mFilterFields = FilterUtils.getConvertedFilterFields(oFilterControl, sEntityTypePath),
+          aPropertyInfo = [];
+        Object.keys(mFilterFields).forEach(function (sFilterFieldKey) {
+          const oConvertedProperty = mFilterFields[sFilterFieldKey];
+          const sPropertyPath = oConvertedProperty.conditionPath.replace(CONDITION_PATH_TO_PROPERTY_PATH_REGEX, "");
+          if (aNonFilterableProps.indexOf(sPropertyPath) === -1) {
+            const sAnnotationPath = oConvertedProperty.annotationPath;
+            const oPropertyContext = oMetaModel.createBindingContext(sAnnotationPath);
+            aPropertyInfo.push({
+              path: oConvertedProperty.conditionPath,
+              hiddenFilter: oConvertedProperty.availability === "Hidden",
+              hasValueHelp: !sAnnotationPath ? false : PropertyFormatters.hasValueHelp(oPropertyContext.getObject(), {
+                context: oPropertyContext
+              })
+            });
+          }
+        });
+        return aPropertyInfo;
+      };
+      return oFilterBar.waitForInitialization().then(async () => {
+        const sEntityTypePath = DelegateUtil.getCustomData(oFilterBar, "entityType");
+        // During external app navigation, we have to clear the existing conditions to avoid merging of values coming from annotation and context
+        // Condition !bIsFLPValuePresent indicates it's external app navigation
+        if (!bIsFLPValuePresent) {
+          const oClearConditions = await this._fnClearStateBeforexAppNav(oFilterBar);
+          await StateUtil.applyExternalState(oFilterBar, {
+            filter: oClearConditions,
+            items: aItems
+          });
+        }
+        const aPropertyInfo = fnGetPropertyInfo(oFilterBar, sEntityTypePath);
+        aPropertyInfo.filter(function (oPropertyInfo) {
+          return oPropertyInfo.path !== "$editState" && oPropertyInfo.path !== "$search";
+        }).forEach(function (oPropertyInfo) {
+          if (oPropertyInfo.path in oConditions) {
+            mFilter[oPropertyInfo.path] = oConditions[oPropertyInfo.path];
+            if (!oPropertyInfo.hiddenFilter) {
+              aItems.push({
+                name: oPropertyInfo.path
+              });
+            }
+            if (oPropertyInfo.hasValueHelp) {
+              mFilter[oPropertyInfo.path].forEach(fnAdjustValueHelpCondition);
+            } else {
+              mFilter[oPropertyInfo.path].forEach(function (oCondition) {
+                oCondition.validated = oCondition.filtered ? ConditionValidated.NotValidated : oCondition.validated;
+              });
+            }
+          } else {
+            mFilter[oPropertyInfo.path] = [];
+          }
+        });
+        return StateUtil.applyExternalState(oFilterBar, {
+          filter: mFilter,
+          items: aItems
+        });
+      });
+    }
+  };
+  return ViewStateOverride;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["NavType","NavLibrary","VariantManagementType","CoreLibrary","VariantManagement","TemplateContentView","InitialLoadMode","CONDITION_PATH_TO_PROPERTY_PATH_REGEX","ViewStateOverride","_bSearchTriggered","applyInitialStateOnly","onBeforeStateApplied","aPromises","oView","getView","oController","getController","oFilterBar","_getFilterBarControl","aTables","_getControls","setSuspendSelection","push","waitForInitialization","forEach","oTable","initialized","onAfterStateApplied","_isFilterBarHidden","oInternalModelContext","getBindingContext","setProperty","_isMultiMode","_getMultiModeControl","setCountsOutDated","adaptBindingRefreshControls","aControls","aViewControls","aControlsToRefresh","KeepAliveHelper","getControlsForRefresh","Array","prototype","apply","adaptStateControls","aStateControls","oViewData","getViewData","bControlVM","variantManagement","Control","oFilterBarVM","_getFilterBarVM","oQuickFilter","getQuickFilter","getVariant","oChart","_hasMultiVisualizations","_getSegmentedButton","Chart","Table","byId","retrieveAdditionalStates","mAdditionalStates","bPendingFilter","getProperty","dataLoaded","sAlpContentView","alpContentView","applyAdditionalStates","oAdditionalStates","triggerSearch","system","desktop","Hybrid","getModel","getPath","_applyNavigationParametersToFilterbar","oNavigationParameter","aResults","oAppComponent","getAppComponent","oComponentData","getComponentData","oStartupParameters","startupParameters","oVariantPromise","handleVariantIdPassedViaURLParams","bFilterVariantApplied","then","aVariants","length","_applySelectionVariant","oDynamicPage","_getDynamicListReportControl","bPreventInitialSearch","oFilterBarControl","navigationType","initial","requiresStandardVariant","initialLoad","Enabled","_shouldAutoTriggerSearch","_preventInitialSearch","setHeaderExpanded","catch","Log","error","oUrlParams","aPageVariantId","aFilterBarVariantId","aTableVariantId","aChartVariantId","oVariantIDs","sPageVariantId","sFilterBarVariantId","sTableVariantId","sChartVariantId","_handleControlVariantId","oVM","sVariantManagement","_handlePageVariantId","_getFilterBarVariantControl","_handleFilterBarVariantControlId","_handleTableControlVariantId","_handleChartControlVariantId","Promise","all","getVariants","oVariant","_findAndPushVariantToPromise","oTableVariant","aCharts","oChartVariant","sVariantId","key","_applyControlVariant","sVariantID","sVariantReference","_checkIfVariantIdIsAvailable","getStandardVariantKey","ControlVariantApplyAPI","activateVariant","element","variantReference","Page","None","Error","oVariantManagement","oCurrentVariant","find","oItem","getCurrentVariantKey","executeOnSelect","oSelectionVariant","selectionVariant","oSelectionVariantDefaults","selectionVariantDefaults","resolve","oConditions","oMetaModel","getMetaModel","sContextPath","contextPath","entitySet","aMandatoryFilterFields","CommonUtils","getMandatoryFilterFields","bUseSemanticDateRange","data","bRequiresStandardVariant","bIsFLPValuePresent","getSelectOptionsPropertyNames","getDefaultVariantKey","bNavSelVarHasDefaultsOnly","getConditions","addDefaultDisplayCurrency","addSelectionVariantToConditions","_activateSelectionVariant","oPromise","oVariantKey","getId","bClearFilterAndReplaceWithAppState","_fnApplyConditions","_fnClearStateBeforexAppNav","StateUtil","retrieveExternalState","oExternalState","oCondition","filter","field","oError","mFilter","aItems","fnAdjustValueHelpCondition","validated","ConditionValidated","Validated","operator","values","isEmpty","fnGetPropertyInfo","oFilterControl","sEntityTypePath","sEntitySetPath","ModelHelper","getEntitySetPath","oFR","getFilterRestrictionsByPath","aNonFilterableProps","NonFilterableProperties","mFilterFields","FilterUtils","getConvertedFilterFields","aPropertyInfo","Object","keys","sFilterFieldKey","oConvertedProperty","sPropertyPath","conditionPath","replace","indexOf","sAnnotationPath","annotationPath","oPropertyContext","createBindingContext","path","hiddenFilter","availability","hasValueHelp","PropertyFormatters","getObject","context","DelegateUtil","getCustomData","oClearConditions","applyExternalState","items","oPropertyInfo","name","filtered","NotValidated"],"sourceRoot":".","sources":["ViewState.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport type ViewState from \"sap/fe/core/controllerextensions/ViewState\";\nimport KeepAliveHelper from \"sap/fe/core/helpers/KeepAliveHelper\";\nimport type { InternalModelContext } from \"sap/fe/core/helpers/ModelHelper\";\nimport ModelHelper from \"sap/fe/core/helpers/ModelHelper\";\nimport CoreLibrary from \"sap/fe/core/library\";\nimport * as PropertyFormatters from \"sap/fe/core/templating/PropertyFormatters\";\nimport DelegateUtil from \"sap/fe/macros/DelegateUtil\";\nimport FilterUtils from \"sap/fe/macros/filter/FilterUtils\";\nimport NavLibrary from \"sap/fe/navigation/library\";\nimport type ListReportController from \"sap/fe/templates/ListReport/ListReportController.controller\";\nimport { system } from \"sap/ui/Device\";\nimport ControlVariantApplyAPI from \"sap/ui/fl/apply/api/ControlVariantApplyAPI\";\nimport type VariantManagement from \"sap/ui/fl/variants/VariantManagement\";\nimport Chart from \"sap/ui/mdc/Chart\";\nimport ConditionValidated from \"sap/ui/mdc/enum/ConditionValidated\";\nimport FilterBar from \"sap/ui/mdc/FilterBar\";\nimport StateUtil from \"sap/ui/mdc/p13n/StateUtil\";\nimport Table from \"sap/ui/mdc/Table\";\n\ntype VariantObject = {\n\tauthor: String;\n\tchange: boolean;\n\tcontexts: object;\n\texecuteOnSelect: boolean;\n\tfavorite: boolean;\n\tkey: String;\n\toriginalContexts: object;\n\toriginalExecuteOnSelect: boolean;\n\toriginalFavorite: boolean;\n\toriginalTitle: String;\n\toriginalVisible: boolean;\n\tremove: boolean;\n\trename: boolean;\n\tsharing: String;\n\ttitle: String;\n\tvisible: boolean;\n};\n\ntype VariantIDs = {\n\tsPageVariantId: String;\n\tsFilterBarVariantId: String;\n\tsTableVariantId: String;\n\tsChartVariantId: String;\n};\n\nconst NavType = NavLibrary.NavType,\n\tVariantManagementType = CoreLibrary.VariantManagement,\n\tTemplateContentView = CoreLibrary.TemplateContentView,\n\tInitialLoadMode = CoreLibrary.InitialLoadMode,\n\tCONDITION_PATH_TO_PROPERTY_PATH_REGEX = /\\+|\\*/g;\n\nconst ViewStateOverride: any = {\n\t_bSearchTriggered: false,\n\tapplyInitialStateOnly: function () {\n\t\treturn true;\n\t},\n\tonBeforeStateApplied: function (this: ViewState & typeof ViewStateOverride, aPromises: any) {\n\t\tconst oView = this.getView(),\n\t\t\toController = oView.getController() as ListReportController,\n\t\t\toFilterBar = oController._getFilterBarControl(),\n\t\t\taTables = oController._getControls(\"table\");\n\t\tif (oFilterBar) {\n\t\t\toFilterBar.setSuspendSelection(true);\n\t\t\taPromises.push((oFilterBar as any).waitForInitialization());\n\t\t}\n\t\taTables.forEach(function (oTable: any) {\n\t\t\taPromises.push(oTable.initialized());\n\t\t});\n\n\t\tdelete this._bSearchTriggered;\n\t},\n\tonAfterStateApplied: function (this: ViewState) {\n\t\tconst oController = this.getView().getController() as ListReportController;\n\t\tconst oFilterBar = oController._getFilterBarControl();\n\t\tif (oFilterBar) {\n\t\t\toFilterBar.setSuspendSelection(false);\n\t\t} else if (oController._isFilterBarHidden()) {\n\t\t\tconst oInternalModelContext = oController.getView().getBindingContext(\"internal\") as InternalModelContext;\n\t\t\toInternalModelContext.setProperty(\"hasPendingFilters\", false);\n\t\t\tif (oController._isMultiMode()) {\n\t\t\t\toController._getMultiModeControl().setCountsOutDated(true);\n\t\t\t}\n\t\t}\n\t},\n\tadaptBindingRefreshControls: function (this: ViewState, aControls: any) {\n\t\tconst oView = this.getView(),\n\t\t\toController = oView.getController() as ListReportController,\n\t\t\taViewControls = oController._getControls(),\n\t\t\taControlsToRefresh = KeepAliveHelper.getControlsForRefresh(oView, aViewControls);\n\n\t\tArray.prototype.push.apply(aControls, aControlsToRefresh);\n\t},\n\tadaptStateControls: function (this: ViewState & typeof ViewStateOverride, aStateControls: any) {\n\t\tconst oView = this.getView(),\n\t\t\toController = oView.getController() as ListReportController,\n\t\t\toViewData = oView.getViewData(),\n\t\t\tbControlVM = oViewData.variantManagement === VariantManagementType.Control;\n\n\t\tconst oFilterBarVM = this._getFilterBarVM(oView);\n\t\tif (oFilterBarVM) {\n\t\t\taStateControls.push(oFilterBarVM);\n\t\t}\n\t\tif (oController._isMultiMode()) {\n\t\t\taStateControls.push(oController._getMultiModeControl());\n\t\t}\n\t\toController._getControls(\"table\").forEach(function (oTable: any) {\n\t\t\tconst oQuickFilter = oTable.getQuickFilter();\n\t\t\tif (oQuickFilter) {\n\t\t\t\taStateControls.push(oQuickFilter);\n\t\t\t}\n\t\t\tif (bControlVM) {\n\t\t\t\taStateControls.push(oTable.getVariant());\n\t\t\t}\n\t\t\taStateControls.push(oTable);\n\t\t});\n\t\tif (oController._getControls(\"Chart\")) {\n\t\t\toController._getControls(\"Chart\").forEach(function (oChart: any) {\n\t\t\t\tif (bControlVM) {\n\t\t\t\t\taStateControls.push(oChart.getVariant());\n\t\t\t\t}\n\t\t\t\taStateControls.push(oChart);\n\t\t\t});\n\t\t}\n\t\tif (oController._hasMultiVisualizations()) {\n\t\t\taStateControls.push(oController._getSegmentedButton(TemplateContentView.Chart));\n\t\t\taStateControls.push(oController._getSegmentedButton(TemplateContentView.Table));\n\t\t}\n\t\tconst oFilterBar = oController._getFilterBarControl();\n\t\tif (oFilterBar) {\n\t\t\taStateControls.push(oFilterBar);\n\t\t}\n\t\taStateControls.push(oView.byId(\"fe::ListReport\"));\n\t},\n\tretrieveAdditionalStates: function (this: ViewState & typeof ViewStateOverride, mAdditionalStates: any) {\n\t\tconst oView = this.getView(),\n\t\t\toController = oView.getController() as ListReportController,\n\t\t\tbPendingFilter = (oView.getBindingContext(\"internal\") as InternalModelContext).getProperty(\"hasPendingFilters\");\n\n\t\tmAdditionalStates.dataLoaded = !bPendingFilter || !!this._bSearchTriggered;\n\t\tif (oController._hasMultiVisualizations()) {\n\t\t\tconst sAlpContentView = oView.getBindingContext(\"internal\").getProperty(\"alpContentView\");\n\t\t\tmAdditionalStates.alpContentView = sAlpContentView;\n\t\t}\n\n\t\tdelete this._bSearchTriggered;\n\t},\n\tapplyAdditionalStates: function (this: ViewState & typeof ViewStateOverride, oAdditionalStates: any) {\n\t\tconst oView = this.getView(),\n\t\t\toController = oView.getController() as ListReportController,\n\t\t\toFilterBar = oController._getFilterBarControl();\n\n\t\tif (oAdditionalStates) {\n\t\t\t// explicit check for boolean values - 'undefined' should not alter the triggered search property\n\t\t\tif (oAdditionalStates.dataLoaded === false && oFilterBar) {\n\t\t\t\t// without this, the data is loaded on navigating back\n\t\t\t\t(oFilterBar as any)._bSearchTriggered = false;\n\t\t\t} else if (oAdditionalStates.dataLoaded === true) {\n\t\t\t\tif (oFilterBar) {\n\t\t\t\t\toFilterBar.triggerSearch();\n\t\t\t\t}\n\t\t\t\tthis._bSearchTriggered = true;\n\t\t\t}\n\t\t\tif (oController._hasMultiVisualizations()) {\n\t\t\t\tconst oInternalModelContext = oView.getBindingContext(\"internal\") as InternalModelContext;\n\t\t\t\tif (!system.desktop && oAdditionalStates.alpContentView == TemplateContentView.Hybrid) {\n\t\t\t\t\toAdditionalStates.alpContentView = TemplateContentView.Chart;\n\t\t\t\t}\n\t\t\t\toInternalModelContext\n\t\t\t\t\t.getModel()\n\t\t\t\t\t.setProperty(`${oInternalModelContext.getPath()}/alpContentView`, oAdditionalStates.alpContentView);\n\t\t\t}\n\t\t}\n\t},\n\t_applyNavigationParametersToFilterbar: function (this: ViewState & typeof ViewStateOverride, oNavigationParameter: any, aResults: any) {\n\t\tconst oView = this.getView();\n\t\tconst oController = oView.getController() as ListReportController;\n\t\tconst oAppComponent = oController.getAppComponent();\n\t\tconst oComponentData = oAppComponent.getComponentData();\n\t\tconst oStartupParameters = (oComponentData && oComponentData.startupParameters) || {};\n\t\tconst oVariantPromise = this.handleVariantIdPassedViaURLParams(oStartupParameters);\n\t\tlet bFilterVariantApplied: boolean;\n\t\taResults.push(\n\t\t\toVariantPromise\n\t\t\t\t.then((aVariants: any[]) => {\n\t\t\t\t\tif (aVariants && aVariants.length > 0) {\n\t\t\t\t\t\tif (aVariants[0] === true || aVariants[1] === true) {\n\t\t\t\t\t\t\tbFilterVariantApplied = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this._applySelectionVariant(oView, oNavigationParameter, bFilterVariantApplied);\n\t\t\t\t})\n\t\t\t\t.then(() => {\n\t\t\t\t\tconst oDynamicPage = oController._getDynamicListReportControl();\n\t\t\t\t\tlet bPreventInitialSearch = false;\n\t\t\t\t\tconst oFilterBarVM = this._getFilterBarVM(oView);\n\t\t\t\t\tconst oFilterBarControl = oController._getFilterBarControl();\n\t\t\t\t\tif (oFilterBarControl) {\n\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t(oNavigationParameter.navigationType !== NavType.initial && oNavigationParameter.requiresStandardVariant) ||\n\t\t\t\t\t\t\t(!oFilterBarVM && oView.getViewData().initialLoad === InitialLoadMode.Enabled) ||\n\t\t\t\t\t\t\toController._shouldAutoTriggerSearch(oFilterBarVM)\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\toFilterBarControl.triggerSearch();\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tbPreventInitialSearch = this._preventInitialSearch(oFilterBarVM);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// reset the suspend selection on filter bar to allow loading of data when needed (was set on LR Init)\n\t\t\t\t\t\toFilterBarControl.setSuspendSelection(false);\n\t\t\t\t\t\tthis._bSearchTriggered = !bPreventInitialSearch;\n\t\t\t\t\t\toDynamicPage.setHeaderExpanded(system.desktop || bPreventInitialSearch);\n\t\t\t\t\t}\n\t\t\t\t})\n\t\t\t\t.catch(function () {\n\t\t\t\t\tLog.error(\"Variant ID cannot be applied\");\n\t\t\t\t})\n\t\t);\n\t},\n\n\thandleVariantIdPassedViaURLParams: function (this: ViewState & typeof ViewStateOverride, oUrlParams: any) {\n\t\tconst aPageVariantId = oUrlParams[\"sap-ui-fe-variant-id\"],\n\t\t\taFilterBarVariantId = oUrlParams[\"sap-ui-fe-filterbar-variant-id\"],\n\t\t\taTableVariantId = oUrlParams[\"sap-ui-fe-table-variant-id\"],\n\t\t\taChartVariantId = oUrlParams[\"sap-ui-fe-chart-variant-id\"];\n\t\tlet oVariantIDs;\n\t\tif (aPageVariantId || aFilterBarVariantId || aTableVariantId || aChartVariantId) {\n\t\t\toVariantIDs = {\n\t\t\t\tsPageVariantId: aPageVariantId && aPageVariantId[0],\n\t\t\t\tsFilterBarVariantId: aFilterBarVariantId && aFilterBarVariantId[0],\n\t\t\t\tsTableVariantId: aTableVariantId && aTableVariantId[0],\n\t\t\t\tsChartVariantId: aChartVariantId && aChartVariantId[0]\n\t\t\t};\n\t\t}\n\t\treturn this._handleControlVariantId(oVariantIDs);\n\t},\n\n\t_handleControlVariantId: function (this: ViewState & typeof ViewStateOverride, oVariantIDs: VariantIDs) {\n\t\tlet oVM: VariantManagement;\n\t\tconst oView = this.getView(),\n\t\t\taPromises: VariantManagement[] = [];\n\t\tconst sVariantManagement = oView.getViewData().variantManagement;\n\t\tif (oVariantIDs && oVariantIDs.sPageVariantId && sVariantManagement === \"Page\") {\n\t\t\toVM = oView.byId(\"fe::PageVariantManagement\");\n\t\t\tthis._handlePageVariantId(oVariantIDs, oVM, aPromises);\n\t\t} else if (oVariantIDs && sVariantManagement === \"Control\") {\n\t\t\tif (oVariantIDs.sFilterBarVariantId) {\n\t\t\t\toVM = oView.getController()._getFilterBarVariantControl();\n\t\t\t\tthis._handleFilterBarVariantControlId(oVariantIDs, oVM, aPromises);\n\t\t\t}\n\t\t\tif (oVariantIDs.sTableVariantId) {\n\t\t\t\tconst oController = oView.getController() as ListReportController;\n\t\t\t\tthis._handleTableControlVariantId(oVariantIDs, oController, aPromises);\n\t\t\t}\n\n\t\t\tif (oVariantIDs.sChartVariantId) {\n\t\t\t\tconst oController = oView.getController() as ListReportController;\n\t\t\t\tthis._handleChartControlVariantId(oVariantIDs, oController, aPromises);\n\t\t\t}\n\t\t}\n\t\treturn Promise.all(aPromises);\n\t},\n\t/*\n\t * Handles page level variant and passes the variant to the function that pushes the promise to the promise array\n\t *\n\t * @param oVarinatIDs contains an object of all variant IDs\n\t * @param oVM contains the vairant management object for the page variant\n\t * @param aPromises is an array of all promises\n\t * @private\n\t */\n\t_handlePageVariantId: function (\n\t\tthis: ViewState & typeof ViewStateOverride,\n\t\toVariantIDs: VariantIDs,\n\t\toVM: VariantManagement,\n\t\taPromises: VariantManagement[]\n\t) {\n\t\toVM.getVariants().forEach((oVariant: VariantObject) => {\n\t\t\tthis._findAndPushVariantToPromise(oVariant, oVariantIDs.sPageVariantId, oVM, aPromises, true);\n\t\t});\n\t},\n\n\t/*\n\t * Handles control level variant for filter bar and passes the variant to the function that pushes the promise to the promise array\n\t *\n\t * @param oVarinatIDs contains an object of all variant IDs\n\t * @param oVM contains the vairant management object for the filter bar\n\t * @param aPromises is an array of all promises\n\t * @private\n\t */\n\n\t_handleFilterBarVariantControlId: function (\n\t\tthis: ViewState & typeof ViewStateOverride,\n\t\toVariantIDs: VariantIDs,\n\t\toVM: VariantManagement,\n\t\taPromises: VariantManagement[]\n\t) {\n\t\tif (oVM) {\n\t\t\toVM.getVariants().forEach((oVariant: VariantObject) => {\n\t\t\t\tthis._findAndPushVariantToPromise(oVariant, oVariantIDs.sFilterBarVariantId, oVM, aPromises, true);\n\t\t\t});\n\t\t}\n\t},\n\n\t/*\n\t * Handles control level variant for table and passes the variant to the function that pushes the promise to the promise array\n\t *\n\t * @param oVarinatIDs contains an object of all variant IDs\n\t * @param oController has the list report controller object\n\t * @param aPromises is an array of all promises\n\t * @private\n\t */\n\t_handleTableControlVariantId: function (\n\t\tthis: ViewState & typeof ViewStateOverride,\n\t\toVariantIDs: VariantIDs,\n\t\toController: ListReportController,\n\t\taPromises: VariantManagement[]\n\t) {\n\t\tconst aTables = oController._getControls(\"table\");\n\t\taTables.forEach((oTable: Table) => {\n\t\t\tconst oTableVariant = oTable.getVariant();\n\t\t\tif (oTable && oTableVariant) {\n\t\t\t\toTableVariant.getVariants().forEach((oVariant: VariantObject) => {\n\t\t\t\t\tthis._findAndPushVariantToPromise(oVariant, oVariantIDs.sTableVariantId, oTableVariant, aPromises);\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t},\n\n\t/*\n\t * Handles control level variant for chart and passes the variant to the function that pushes the promise to the promise array\n\t *\n\t * @param oVarinatIDs contains an object of all variant IDs\n\t * @param oController has the list report controller object\n\t * @param aPromises is an array of all promises\n\t * @private\n\t */\n\t_handleChartControlVariantId: function (\n\t\tthis: ViewState & typeof ViewStateOverride,\n\t\toVariantIDs: VariantIDs,\n\t\toController: ListReportController,\n\t\taPromises: VariantManagement[]\n\t) {\n\t\tconst aCharts = oController._getControls(\"Chart\");\n\t\taCharts.forEach((oChart: Chart) => {\n\t\t\tconst oChartVariant = oChart.getVariant();\n\t\t\tconst aVariants = oChartVariant.getVariants();\n\t\t\tif (aVariants) {\n\t\t\t\taVariants.forEach((oVariant: VariantObject) => {\n\t\t\t\t\tthis._findAndPushVariantToPromise(oVariant, oVariantIDs.sChartVariantId, oChartVariant, aPromises);\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t},\n\t/*\n\t * Matches the variant ID provided in the url to the available vairant IDs and pushes the appropriate promise to the promise array\n\t *\n\t * @param oVariant is an object for a specific variant\n\t * @param sVariantId is the variant ID provided in the url\n\t * @param oVM is the variant management object for the specfic variant\n\t * @param aPromises is an array of promises\n\t * @param bFilterVariantApplied is an optional parameter which is set to ture in case the filter variant is applied\n\t * @private\n\t */\n\t_findAndPushVariantToPromise: function (\n\t\t//This function finds the suitable variant for the variantID provided in the url and pushes them to the promise array\n\t\tthis: ViewState & typeof ViewStateOverride,\n\t\toVariant: VariantObject,\n\t\tsVariantId: String,\n\t\toVM: VariantManagement,\n\t\taPromises: VariantManagement[],\n\t\tbFilterVariantApplied?: boolean\n\t) {\n\t\tif (oVariant.key === sVariantId) {\n\t\t\taPromises.push(this._applyControlVariant(oVM, sVariantId, bFilterVariantApplied));\n\t\t}\n\t},\n\n\t_applyControlVariant: function (oVariant: any, sVariantID: any, bFilterVariantApplied: any) {\n\t\tconst sVariantReference = this._checkIfVariantIdIsAvailable(oVariant, sVariantID) ? sVariantID : oVariant.getStandardVariantKey();\n\t\tconst oVM = ControlVariantApplyAPI.activateVariant({\n\t\t\telement: oVariant,\n\t\t\tvariantReference: sVariantReference\n\t\t});\n\t\treturn oVM.then(function () {\n\t\t\treturn bFilterVariantApplied;\n\t\t});\n\t},\n\t/************************************* private helper *****************************************/\n\n\t_getFilterBarVM: function (oView: any) {\n\t\tconst oViewData = oView.getViewData();\n\t\tswitch (oViewData.variantManagement) {\n\t\t\tcase VariantManagementType.Page:\n\t\t\t\treturn oView.byId(\"fe::PageVariantManagement\");\n\t\t\tcase VariantManagementType.Control:\n\t\t\t\treturn oView.getController()._getFilterBarVariantControl();\n\t\t\tcase VariantManagementType.None:\n\t\t\t\treturn null;\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`unhandled variant setting: ${oViewData.variantManagement}`);\n\t\t}\n\t},\n\n\t_preventInitialSearch: function (oVariantManagement: any) {\n\t\tif (!oVariantManagement) {\n\t\t\treturn true;\n\t\t}\n\t\tconst aVariants = oVariantManagement.getVariants();\n\t\tconst oCurrentVariant = aVariants.find(function (oItem: any) {\n\t\t\treturn oItem.key === oVariantManagement.getCurrentVariantKey();\n\t\t});\n\t\treturn !oCurrentVariant.executeOnSelect;\n\t},\n\n\t_applySelectionVariant: function (oView: any, oNavigationParameter: any, bFilterVariantApplied: any) {\n\t\tconst oFilterBar = oView.getController()._getFilterBarControl(),\n\t\t\toSelectionVariant = oNavigationParameter.selectionVariant,\n\t\t\toSelectionVariantDefaults = oNavigationParameter.selectionVariantDefaults;\n\t\tif (!oFilterBar || !oSelectionVariant) {\n\t\t\treturn Promise.resolve();\n\t\t}\n\t\tlet oConditions = {};\n\t\tconst oMetaModel = oView.getModel().getMetaModel();\n\t\tconst oViewData = oView.getViewData();\n\t\tconst sContextPath = oViewData.contextPath || `/${oViewData.entitySet}`;\n\t\tconst aMandatoryFilterFields = CommonUtils.getMandatoryFilterFields(oMetaModel, sContextPath);\n\t\tconst bUseSemanticDateRange = oFilterBar.data(\"useSemanticDateRange\");\n\t\tlet oVariant;\n\t\tswitch (oViewData.variantManagement) {\n\t\t\tcase VariantManagementType.Page:\n\t\t\t\toVariant = oView.byId(\"fe::PageVariantManagement\");\n\t\t\t\tbreak;\n\t\t\tcase VariantManagementType.Control:\n\t\t\t\toVariant = oView.getController()._getFilterBarVariantControl();\n\t\t\t\tbreak;\n\t\t\tcase VariantManagementType.None:\n\t\t\tdefault:\n\t\t\t\tbreak;\n\t\t}\n\t\tconst bRequiresStandardVariant = oNavigationParameter.requiresStandardVariant;\n\t\t// check if FLP default values are there and is it standard variant\n\t\tconst bIsFLPValuePresent: boolean =\n\t\t\toSelectionVariantDefaults &&\n\t\t\toSelectionVariantDefaults.getSelectOptionsPropertyNames().length > 0 &&\n\t\t\toVariant.getDefaultVariantKey() === oVariant.getStandardVariantKey() &&\n\t\t\toNavigationParameter.bNavSelVarHasDefaultsOnly;\n\n\t\t// get conditions when FLP value is present\n\t\tif (bFilterVariantApplied || bIsFLPValuePresent) {\n\t\t\toConditions = oFilterBar.getConditions();\n\t\t}\n\t\tCommonUtils.addDefaultDisplayCurrency(aMandatoryFilterFields, oSelectionVariant, oSelectionVariantDefaults);\n\t\tCommonUtils.addSelectionVariantToConditions(\n\t\t\toSelectionVariant,\n\t\t\toConditions,\n\t\t\toMetaModel,\n\t\t\tsContextPath,\n\t\t\tbIsFLPValuePresent,\n\t\t\tbUseSemanticDateRange,\n\t\t\toViewData\n\t\t);\n\n\t\treturn this._activateSelectionVariant(\n\t\t\toFilterBar,\n\t\t\toConditions,\n\t\t\toVariant,\n\t\t\tbRequiresStandardVariant,\n\t\t\tbFilterVariantApplied,\n\t\t\tbIsFLPValuePresent\n\t\t);\n\t},\n\t_activateSelectionVariant: function (\n\t\toFilterBar: any,\n\t\toConditions: any,\n\t\toVariant: any,\n\t\tbRequiresStandardVariant: any,\n\t\tbFilterVariantApplied: any,\n\t\tbIsFLPValuePresent?: boolean\n\t) {\n\t\tlet oPromise;\n\n\t\tif (oVariant && !bFilterVariantApplied) {\n\t\t\tlet oVariantKey = bRequiresStandardVariant ? oVariant.getStandardVariantKey() : oVariant.getDefaultVariantKey();\n\t\t\tif (oVariantKey === null) {\n\t\t\t\toVariantKey = oVariant.getId();\n\t\t\t}\n\t\t\toPromise = ControlVariantApplyAPI.activateVariant({\n\t\t\t\telement: oVariant,\n\t\t\t\tvariantReference: oVariantKey\n\t\t\t}).then(function () {\n\t\t\t\treturn bRequiresStandardVariant || oVariant.getDefaultVariantKey() === oVariant.getStandardVariantKey();\n\t\t\t});\n\t\t} else {\n\t\t\toPromise = Promise.resolve(true);\n\t\t}\n\t\treturn oPromise.then((bClearFilterAndReplaceWithAppState: any) => {\n\t\t\tif (bClearFilterAndReplaceWithAppState) {\n\t\t\t\treturn this._fnApplyConditions(oFilterBar, oConditions, bIsFLPValuePresent);\n\t\t\t}\n\t\t});\n\t},\n\n\t/*\n\t * Sets filtered: false flag to every field so that it can be cleared out\n\t *\n\t * @param oFilterBar filterbar control is used to display filter properties in a user-friendly manner to populate values for a query\n\t * @returns promise which will be resolved to object\n\t * @private\n\t */\n\t_fnClearStateBeforexAppNav: async function (oFilterBar: FilterBar) {\n\t\treturn await StateUtil.retrieveExternalState(oFilterBar)\n\t\t\t.then((oExternalState: any) => {\n\t\t\t\tconst oCondition = oExternalState.filter;\n\t\t\t\tfor (const field in oCondition) {\n\t\t\t\t\tif (field !== \"$editState\" && field !== \"$search\") {\n\t\t\t\t\t\toCondition[field][0][\"filtered\"] = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn Promise.resolve(oCondition);\n\t\t\t})\n\t\t\t.catch(function (oError: any) {\n\t\t\t\tLog.error(\"Error while retrieving the external state\", oError);\n\t\t\t});\n\t},\n\n\t_fnApplyConditions: async function (oFilterBar: any, oConditions: any, bIsFLPValuePresent?: boolean) {\n\t\tconst mFilter: any = {},\n\t\t\taItems: any[] = [],\n\t\t\tfnAdjustValueHelpCondition = function (oCondition: any) {\n\t\t\t\t// in case the condition is meant for a field having a VH, the format required by MDC differs\n\t\t\t\toCondition.validated = ConditionValidated.Validated;\n\t\t\t\tif (oCondition.operator === \"Empty\") {\n\t\t\t\t\toCondition.operator = \"EQ\";\n\t\t\t\t\toCondition.values = [\"\"];\n\t\t\t\t} else if (oCondition.operator === \"NotEmpty\") {\n\t\t\t\t\toCondition.operator = \"NE\";\n\t\t\t\t\toCondition.values = [\"\"];\n\t\t\t\t}\n\t\t\t\tdelete oCondition.isEmpty;\n\t\t\t};\n\t\tconst fnGetPropertyInfo = function (oFilterControl: any, sEntityTypePath: any) {\n\t\t\tconst sEntitySetPath = ModelHelper.getEntitySetPath(sEntityTypePath),\n\t\t\t\toMetaModel = oFilterControl.getModel().getMetaModel(),\n\t\t\t\toFR = CommonUtils.getFilterRestrictionsByPath(sEntitySetPath, oMetaModel),\n\t\t\t\taNonFilterableProps = oFR.NonFilterableProperties,\n\t\t\t\tmFilterFields = FilterUtils.getConvertedFilterFields(oFilterControl, sEntityTypePath),\n\t\t\t\taPropertyInfo: any[] = [];\n\t\t\tObject.keys(mFilterFields).forEach(function (sFilterFieldKey: string) {\n\t\t\t\tconst oConvertedProperty = mFilterFields[sFilterFieldKey];\n\t\t\t\tconst sPropertyPath = oConvertedProperty.conditionPath.replace(CONDITION_PATH_TO_PROPERTY_PATH_REGEX, \"\");\n\t\t\t\tif (aNonFilterableProps.indexOf(sPropertyPath) === -1) {\n\t\t\t\t\tconst sAnnotationPath = oConvertedProperty.annotationPath;\n\t\t\t\t\tconst oPropertyContext = oMetaModel.createBindingContext(sAnnotationPath);\n\t\t\t\t\taPropertyInfo.push({\n\t\t\t\t\t\tpath: oConvertedProperty.conditionPath,\n\t\t\t\t\t\thiddenFilter: oConvertedProperty.availability === \"Hidden\",\n\t\t\t\t\t\thasValueHelp: !sAnnotationPath\n\t\t\t\t\t\t\t? false\n\t\t\t\t\t\t\t: PropertyFormatters.hasValueHelp(oPropertyContext.getObject(), { context: oPropertyContext })\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t});\n\t\t\treturn aPropertyInfo;\n\t\t};\n\n\t\treturn oFilterBar.waitForInitialization().then(async () => {\n\t\t\tconst sEntityTypePath = DelegateUtil.getCustomData(oFilterBar, \"entityType\");\n\t\t\t// During external app navigation, we have to clear the existing conditions to avoid merging of values coming from annotation and context\n\t\t\t// Condition !bIsFLPValuePresent indicates it's external app navigation\n\t\t\tif (!bIsFLPValuePresent) {\n\t\t\t\tconst oClearConditions = await this._fnClearStateBeforexAppNav(oFilterBar);\n\t\t\t\tawait StateUtil.applyExternalState(oFilterBar, {\n\t\t\t\t\tfilter: oClearConditions,\n\t\t\t\t\titems: aItems\n\t\t\t\t});\n\t\t\t}\n\t\t\tconst aPropertyInfo = fnGetPropertyInfo(oFilterBar, sEntityTypePath);\n\t\t\taPropertyInfo\n\t\t\t\t.filter(function (oPropertyInfo: any) {\n\t\t\t\t\treturn oPropertyInfo.path !== \"$editState\" && oPropertyInfo.path !== \"$search\";\n\t\t\t\t})\n\t\t\t\t.forEach(function (oPropertyInfo: any) {\n\t\t\t\t\tif (oPropertyInfo.path in oConditions) {\n\t\t\t\t\t\tmFilter[oPropertyInfo.path] = oConditions[oPropertyInfo.path];\n\t\t\t\t\t\tif (!oPropertyInfo.hiddenFilter) {\n\t\t\t\t\t\t\taItems.push({ name: oPropertyInfo.path });\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (oPropertyInfo.hasValueHelp) {\n\t\t\t\t\t\t\tmFilter[oPropertyInfo.path].forEach(fnAdjustValueHelpCondition);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tmFilter[oPropertyInfo.path].forEach(function (oCondition: any) {\n\t\t\t\t\t\t\t\toCondition.validated = oCondition.filtered ? ConditionValidated.NotValidated : oCondition.validated;\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tmFilter[oPropertyInfo.path] = [];\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\treturn StateUtil.applyExternalState(oFilterBar, { filter: mFilter, items: aItems });\n\t\t});\n\t}\n};\n\nexport default ViewStateOverride;\n"],"mappings":"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"}