@sapui5/sap.fe.templates 1.110.0 → 1.111.0

package/src/sap/fe/templates/ListReport/ListReportController-dbg.controller.js

@@ -0,0 +1,799 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log", "sap/base/util/ObjectPath", "sap/fe/core/ActionRuntime", "sap/fe/core/CommonUtils", "sap/fe/core/controllerextensions/IntentBasedNavigation", "sap/fe/core/controllerextensions/InternalIntentBasedNavigation", "sap/fe/core/controllerextensions/InternalRouting", "sap/fe/core/controllerextensions/KPIManagement", "sap/fe/core/controllerextensions/MassEdit", "sap/fe/core/controllerextensions/Placeholder", "sap/fe/core/controllerextensions/Share", "sap/fe/core/controllerextensions/SideEffects", "sap/fe/core/controllerextensions/ViewState", "sap/fe/core/helpers/ClassSupport", "sap/fe/core/helpers/DeleteHelper", "sap/fe/core/helpers/EditState", "sap/fe/core/helpers/MessageStrip", "sap/fe/core/helpers/StableIdHelper", "sap/fe/core/library", "sap/fe/core/PageController", "sap/fe/macros/chart/ChartUtils", "sap/fe/macros/CommonHelper", "sap/fe/macros/DelegateUtil", "sap/fe/macros/filter/FilterUtils", "sap/fe/templates/ListReport/ExtensionAPI", "sap/fe/templates/TableScroller", "sap/ui/core/mvc/OverrideExecution", "sap/ui/Device", "sap/ui/mdc/p13n/StateUtil", "sap/ui/thirdparty/hasher", "./ListReportTemplating", "./overrides/IntentBasedNavigation", "./overrides/Share", "./overrides/ViewState"], function (Log, ObjectPath, ActionRuntime, CommonUtils, IntentBasedNavigation, InternalIntentBasedNavigation, InternalRouting, KPIManagement, MassEdit, Placeholder, Share, SideEffects, ViewState, ClassSupport, DeleteHelper, EditState, MessageStrip, StableIdHelper, CoreLibrary, PageController, ChartUtils, CommonHelper, DelegateUtil, FilterUtils, ExtensionAPI, TableScroller, OverrideExecution, Device, StateUtil, hasher, ListReportTemplating, IntentBasedNavigationOverride, ShareOverrides, ViewStateOverrides) {
+  "use strict";
+
+  var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _dec11, _dec12, _dec13, _dec14, _dec15, _dec16, _dec17, _dec18, _dec19, _dec20, _class, _class2, _descriptor, _descriptor2, _descriptor3, _descriptor4, _descriptor5, _descriptor6, _descriptor7, _descriptor8, _descriptor9;
+  var system = Device.system;
+  var usingExtension = ClassSupport.usingExtension;
+  var publicExtension = ClassSupport.publicExtension;
+  var privateExtension = ClassSupport.privateExtension;
+  var finalExtension = ClassSupport.finalExtension;
+  var extensible = ClassSupport.extensible;
+  var defineUI5Class = ClassSupport.defineUI5Class;
+  function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+  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; }
+  function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); }
+  const TemplateContentView = CoreLibrary.TemplateContentView,
+    InitialLoadMode = CoreLibrary.InitialLoadMode;
+
+  /**
+   * Controller class for the list report page, used inside an SAP Fiori elements application.
+   *
+   * @hideconstructor
+   * @public
+   */
+  let ListReportController = (_dec = defineUI5Class("sap.fe.templates.ListReport.ListReportController"), _dec2 = usingExtension(InternalRouting.override({
+    onAfterBinding: function () {
+      this.getView().getController()._onAfterBinding();
+    }
+  })), _dec3 = usingExtension(InternalIntentBasedNavigation.override({
+    getEntitySet: function () {
+      return this.base.getCurrentEntitySet();
+    }
+  })), _dec4 = usingExtension(SideEffects), _dec5 = usingExtension(IntentBasedNavigation.override(IntentBasedNavigationOverride)), _dec6 = usingExtension(Share.override(ShareOverrides)), _dec7 = usingExtension(ViewState.override(ViewStateOverrides)), _dec8 = usingExtension(KPIManagement), _dec9 = usingExtension(Placeholder), _dec10 = usingExtension(MassEdit), _dec11 = publicExtension(), _dec12 = finalExtension(), _dec13 = privateExtension(), _dec14 = extensible(OverrideExecution.After), _dec15 = publicExtension(), _dec16 = extensible(OverrideExecution.After), _dec17 = publicExtension(), _dec18 = extensible(OverrideExecution.After), _dec19 = publicExtension(), _dec20 = extensible(OverrideExecution.After), _dec(_class = (_class2 = /*#__PURE__*/function (_PageController) {
+    _inheritsLoose(ListReportController, _PageController);
+    function ListReportController() {
+      var _this;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _PageController.call(this, ...args) || this;
+      _initializerDefineProperty(_this, "_routing", _descriptor, _assertThisInitialized(_this));
+      _initializerDefineProperty(_this, "_intentBasedNavigation", _descriptor2, _assertThisInitialized(_this));
+      _initializerDefineProperty(_this, "sideEffects", _descriptor3, _assertThisInitialized(_this));
+      _initializerDefineProperty(_this, "intentBasedNavigation", _descriptor4, _assertThisInitialized(_this));
+      _initializerDefineProperty(_this, "share", _descriptor5, _assertThisInitialized(_this));
+      _initializerDefineProperty(_this, "viewState", _descriptor6, _assertThisInitialized(_this));
+      _initializerDefineProperty(_this, "kpiManagement", _descriptor7, _assertThisInitialized(_this));
+      _initializerDefineProperty(_this, "placeholder", _descriptor8, _assertThisInitialized(_this));
+      _initializerDefineProperty(_this, "massEdit", _descriptor9, _assertThisInitialized(_this));
+      _this.handlers = {
+        onFilterSearch() {
+          this._getFilterBarControl().triggerSearch();
+        },
+        onFiltersChanged(oEvent) {
+          const oFilterBar = this._getFilterBarControl();
+          if (oFilterBar) {
+            const oInternalModelContext = this.getView().getBindingContext("internal");
+            // Pending filters into FilterBar to be used for custom views
+            this.onPendingFilters();
+            oInternalModelContext.setProperty("appliedFilters", oFilterBar.getAssignedFiltersText().filtersText);
+            if (oEvent.getParameter("conditionsBased")) {
+              oInternalModelContext.setProperty("hasPendingFilters", true);
+            }
+          }
+        },
+        onVariantSelected(oEvent) {
+          const oVM = oEvent.getSource();
+          const currentVariantKey = oEvent.getParameter("key");
+          const oMultiModeControl = this._getMultiModeControl();
+          oMultiModeControl === null || oMultiModeControl === void 0 ? void 0 : oMultiModeControl.invalidateContent();
+          oMultiModeControl === null || oMultiModeControl === void 0 ? void 0 : oMultiModeControl.setFreezeContent(true);
+
+          // setTimeout cause the variant needs to be applied before judging the auto search or updating the app state
+          setTimeout(() => {
+            if (this._shouldAutoTriggerSearch(oVM)) {
+              // the app state will be updated via onSearch handler
+              return this._getFilterBarControl().triggerSearch();
+            } else if (!this._getApplyAutomaticallyOnVariant(oVM, currentVariantKey)) {
+              this.getExtensionAPI().updateAppState();
+            }
+          }, 0);
+        },
+        onVariantSaved() {
+          //TODO: Should remove this setTimeOut once Variant Management provides an api to fetch the current variant key on save!!!
+          setTimeout(() => {
+            this.getExtensionAPI().updateAppState();
+          }, 1000);
+        },
+        onSearch() {
+          const oFilterBar = this._getFilterBarControl();
+          const oInternalModelContext = this.getView().getBindingContext("internal");
+          const oMdcChart = this.getChartControl();
+          const bHideDraft = FilterUtils.getEditStateIsHideDraft(oFilterBar.getConditions());
+          oInternalModelContext.setProperty("hasPendingFilters", false);
+          oInternalModelContext.setProperty("hideDraftInfo", bHideDraft);
+          if (!this._getMultiModeControl()) {
+            this._updateALPNotApplicableFields(oInternalModelContext, oFilterBar);
+          }
+          if (oMdcChart) {
+            // disable bound actions TODO: this clears everything for the chart?
+            oMdcChart.getBindingContext("internal").setProperty("", {});
+            const oPageInternalModelContext = oMdcChart.getBindingContext("pageInternal");
+            const sTemplateContentView = oPageInternalModelContext.getProperty(`${oPageInternalModelContext.getPath()}/alpContentView`);
+            if (sTemplateContentView === TemplateContentView.Chart) {
+              this.hasPendingChartChanges = true;
+            }
+            if (sTemplateContentView === TemplateContentView.Table) {
+              this.hasPendingTableChanges = true;
+            }
+          }
+          // store filter bar conditions to use later while navigation
+          StateUtil.retrieveExternalState(oFilterBar).then(oExternalState => {
+            this.filterBarConditions = oExternalState.filter;
+          }).catch(function (oError) {
+            Log.error("Error while retrieving the external state", oError);
+          });
+          if (this.getView().getViewData().liveMode === false) {
+            this.getExtensionAPI().updateAppState();
+          }
+          if (system.phone) {
+            const oDynamicPage = this._getDynamicListReportControl();
+            oDynamicPage.setHeaderExpanded(false);
+          }
+        },
+        /**
+         * Triggers an outbound navigation when a user chooses the chevron.
+         *
+         * @param oController
+         * @param sOutboundTarget Name of the outbound target (needs to be defined in the manifest)
+         * @param oContext The context that contains the data for the target app
+         * @param sCreatePath Create path when the chevron is created.
+         * @returns Promise which is resolved once the navigation is triggered
+         * @ui5-restricted
+         * @final
+         */
+        onChevronPressNavigateOutBound(oController, sOutboundTarget, oContext, sCreatePath) {
+          return oController._intentBasedNavigation.onChevronPressNavigateOutBound(oController, sOutboundTarget, oContext, sCreatePath);
+        },
+        onChartSelectionChanged(oEvent) {
+          const oMdcChart = oEvent.getSource().getContent(),
+            oTable = this._getTable(),
+            aData = oEvent.getParameter("data"),
+            oInternalModelContext = this.getView().getBindingContext("internal");
+          if (aData) {
+            ChartUtils.setChartFilters(oMdcChart);
+          }
+          const sTemplateContentView = oInternalModelContext.getProperty(`${oInternalModelContext.getPath()}/alpContentView`);
+          if (sTemplateContentView === TemplateContentView.Chart) {
+            this.hasPendingChartChanges = true;
+          } else if (oTable) {
+            oTable.rebind();
+            this.hasPendingChartChanges = false;
+          }
+        },
+        onSegmentedButtonPressed(oEvent) {
+          const sSelectedKey = oEvent.mParameters.key ? oEvent.mParameters.key : null;
+          const oInternalModelContext = this.getView().getBindingContext("internal");
+          oInternalModelContext.setProperty("alpContentView", sSelectedKey);
+          const oChart = this.getChartControl();
+          const oTable = this._getTable();
+          const oSegmentedButtonDelegate = {
+            onAfterRendering() {
+              const aItems = oSegmentedButton.getItems();
+              aItems.forEach(function (oItem) {
+                if (oItem.getKey() === sSelectedKey) {
+                  oItem.focus();
+                }
+              });
+              oSegmentedButton.removeEventDelegate(oSegmentedButtonDelegate);
+            }
+          };
+          const oSegmentedButton = sSelectedKey === TemplateContentView.Table ? this._getSegmentedButton("Table") : this._getSegmentedButton("Chart");
+          if (oSegmentedButton !== oEvent.getSource()) {
+            oSegmentedButton.addEventDelegate(oSegmentedButtonDelegate);
+          }
+          switch (sSelectedKey) {
+            case TemplateContentView.Table:
+              this._updateTable(oTable);
+              break;
+            case TemplateContentView.Chart:
+              this._updateChart(oChart);
+              break;
+            case TemplateContentView.Hybrid:
+              this._updateTable(oTable);
+              this._updateChart(oChart);
+              break;
+            default:
+              break;
+          }
+          this.getExtensionAPI().updateAppState();
+        },
+        onFiltersSegmentedButtonPressed(oEvent) {
+          const isCompact = oEvent.getParameter("key") === "Compact";
+          this._getFilterBarControl().setVisible(isCompact);
+          this._getVisualFilterBarControl().setVisible(!isCompact);
+        },
+        onStateChange() {
+          this.getExtensionAPI().updateAppState();
+        },
+        onDynamicPageTitleStateChanged(oEvent) {
+          const filterBar = this._getFilterBarControl();
+          if (filterBar && filterBar.getSegmentedButton()) {
+            if (oEvent.getParameter("isExpanded")) {
+              filterBar.getSegmentedButton().setVisible(true);
+            } else {
+              filterBar.getSegmentedButton().setVisible(false);
+            }
+          }
+        }
+      };
+      _this.formatters = {
+        setALPControlMessageStrip(aIgnoredFields, bIsChart, oApplySupported) {
+          let sText = "";
+          bIsChart = bIsChart === "true" || bIsChart === true;
+          const oFilterBar = this._getFilterBarControl();
+          if (oFilterBar && Array.isArray(aIgnoredFields) && aIgnoredFields.length > 0 && bIsChart) {
+            const aIgnoredLabels = MessageStrip.getLabels(aIgnoredFields, oFilterBar.data("entityType"), oFilterBar, this.oResourceBundle);
+            const bIsSearchIgnored = !oApplySupported.enableSearch;
+            sText = bIsChart ? MessageStrip.getALPText(aIgnoredLabels, oFilterBar, bIsSearchIgnored) : MessageStrip.getText(aIgnoredLabels, oFilterBar, "", DelegateUtil.getLocalizedText);
+            return sText;
+          }
+        }
+      };
+      return _this;
+    }
+    var _proto = ListReportController.prototype;
+    /**
+     * Get the extension API for the current page.
+     *
+     * @public
+     * @returns The extension API.
+     */
+    _proto.getExtensionAPI = function getExtensionAPI() {
+      if (!this.extensionAPI) {
+        this.extensionAPI = new ExtensionAPI(this);
+      }
+      return this.extensionAPI;
+    };
+    _proto.onInit = function onInit() {
+      PageController.prototype.onInit.apply(this);
+      const oInternalModelContext = this.getView().getBindingContext("internal");
+      oInternalModelContext.setProperty("hasPendingFilters", true);
+      oInternalModelContext.setProperty("appliedFilters", "");
+      oInternalModelContext.setProperty("hideDraftInfo", false);
+      oInternalModelContext.setProperty("uom", {});
+      oInternalModelContext.setProperty("scalefactor", {});
+      oInternalModelContext.setProperty("scalefactorNumber", {});
+      oInternalModelContext.setProperty("currency", {});
+      if (this._hasMultiVisualizations()) {
+        let alpContentView = this._getDefaultPath();
+        if (!system.desktop && alpContentView === TemplateContentView.Hybrid) {
+          alpContentView = TemplateContentView.Chart;
+        }
+        oInternalModelContext.setProperty("alpContentView", alpContentView);
+      }
+
+      // Store conditions from filter bar
+      // this is later used before navigation to get conditions applied on the filter bar
+      this.filterBarConditions = {};
+
+      // As AppStateHandler.applyAppState triggers a navigation we want to make sure it will
+      // happen after the routeMatch event has been processed (otherwise the router gets broken)
+      this.getAppComponent().getRouterProxy().waitForRouteMatchBeforeNavigation();
+
+      // Configure the initial load settings
+      this._setInitLoad();
+    };
+    _proto.onExit = function onExit() {
+      delete this.filterBarConditions;
+      if (this.extensionAPI) {
+        this.extensionAPI.destroy();
+      }
+      delete this.extensionAPI;
+    };
+    _proto._onAfterBinding = function _onAfterBinding() {
+      const aTables = this._getControls("table");
+      if (EditState.isEditStateDirty()) {
+        var _this$_getMultiModeCo, _this$_getTable;
+        (_this$_getMultiModeCo = this._getMultiModeControl()) === null || _this$_getMultiModeCo === void 0 ? void 0 : _this$_getMultiModeCo.invalidateContent();
+        const oTableBinding = (_this$_getTable = this._getTable()) === null || _this$_getTable === void 0 ? void 0 : _this$_getTable.getRowBinding();
+        if (oTableBinding) {
+          if (CommonUtils.getAppComponent(this.getView())._isFclEnabled()) {
+            // there is an issue if we use a timeout with a kept alive context used on another page
+            oTableBinding.refresh();
+          } else {
+            if (!this.sUpdateTimer) {
+              this.sUpdateTimer = setTimeout(() => {
+                oTableBinding.refresh();
+                delete this.sUpdateTimer;
+              }, 0);
+            }
+
+            // Update action enablement and visibility upon table data update.
+            const fnUpdateTableActions = () => {
+              this._updateTableActions(aTables);
+              oTableBinding.detachDataReceived(fnUpdateTableActions);
+            };
+            oTableBinding.attachDataReceived(fnUpdateTableActions);
+          }
+        }
+        EditState.setEditStateProcessed();
+      }
+      if (!this.sUpdateTimer) {
+        this._updateTableActions(aTables);
+      }
+      const internalModelContext = this.getView().getBindingContext("internal");
+      if (!internalModelContext.getProperty("initialVariantApplied")) {
+        const viewId = this.getView().getId();
+        this.pageReady.waitFor(this.getAppComponent().getAppStateHandler().applyAppState(viewId, this.getView()));
+        internalModelContext.setProperty("initialVariantApplied", true);
+      }
+    };
+    _proto.onBeforeRendering = function onBeforeRendering() {
+      PageController.prototype.onBeforeRendering.apply(this);
+    };
+    _proto.onAfterRendering = function onAfterRendering() {
+      this.getView().getModel("sap.fe.i18n").getResourceBundle().then(response => {
+        this.oResourceBundle = response;
+        const aTables = this._getControls();
+        const sEntitySet = this.getView().getViewData().entitySet;
+        const sText = CommonUtils.getTranslatedText("T_TABLE_AND_CHART_NO_DATA_TEXT", this.oResourceBundle, undefined, sEntitySet);
+        aTables.forEach(function (oTable) {
+          oTable.setNoData(sText);
+        });
+      }).catch(function (oError) {
+        Log.error("Error while retrieving the resource bundle", oError);
+      });
+    };
+    _proto.onPageReady = function onPageReady(mParameters) {
+      if (mParameters.forceFocus) {
+        this._setInitialFocus();
+      }
+      // Remove the handler on back navigation that displays Draft confirmation
+      this.getAppComponent().getShellServices().setBackNavigation(undefined);
+    }
+
+    /**
+     * Method called when the content of a custom view used in a list report needs to be refreshed.
+     * This happens either when there is a change on the FilterBar and the search is triggered,
+     * or when a tab with custom content is selected.
+     * This method can be overwritten by the controller extension in case of customization.
+     *
+     * @param mParameters Map containing the filter conditions of the FilterBar, the currentTabID
+     * and the view refresh cause (tabChanged or search).
+     * The map looks like this:
+     * <code><pre>
+     * 	{
+     * 		filterConditions: {
+     * 			Country: [
+     * 				{
+     * 					operator: "EQ"
+     *					validated: "NotValidated"
+     *					values: ["Germany", ...]
+     * 				},
+     * 				...
+     * 			]
+     * 			...
+     * 		},
+     *		currentTabId: "fe::CustomTab::tab1",
+     *		refreshCause: "tabChanged" | "search"
+     *	}
+     * </pre></code>
+     * @public
+     */;
+    _proto.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onViewNeedsRefresh = function onViewNeedsRefresh(mParameters) {
+      /* To be overriden */
+    }
+
+    /**
+     * Method called when a filter or search value has been changed in the FilterBar,
+     * but has not been validated yet by the end user (with the 'Go' or 'Search' button).
+     * Typically, the content of the current tab is greyed out until the filters are validated.
+     * This method can be overwritten by the controller extension in case of customization.
+     *
+     * @public
+     */;
+    _proto.onPendingFilters = function onPendingFilters() {
+      /* To be overriden */
+    };
+    _proto.getCurrentEntitySet = function getCurrentEntitySet() {
+      var _this$_getTable2;
+      return (_this$_getTable2 = this._getTable()) === null || _this$_getTable2 === void 0 ? void 0 : _this$_getTable2.data("targetCollectionPath").slice(1);
+    }
+
+    /**
+     * Method called when the 'Clear' button on the FilterBar is pressed.
+     *
+     * @public
+     */;
+    _proto.onAfterClear = function onAfterClear() {
+      /* To be overriden */
+    }
+
+    /**
+     * This method initiates the update of the enabled state of the DataFieldForAction and the visible state of the DataFieldForIBN buttons.
+     *
+     * @param aTables Array of tables in the list report
+     * @private
+     */;
+    _proto._updateTableActions = function _updateTableActions(aTables) {
+      let aIBNActions = [];
+      aTables.forEach(function (oTable) {
+        aIBNActions = CommonUtils.getIBNActions(oTable, aIBNActions);
+        // Update 'enabled' property of DataFieldForAction buttons on table toolbar
+        // The same is also performed on Table selectionChange event
+        const oInternalModelContext = oTable.getBindingContext("internal"),
+          oActionOperationAvailableMap = JSON.parse(CommonHelper.parseCustomData(DelegateUtil.getCustomData(oTable, "operationAvailableMap"))),
+          aSelectedContexts = oTable.getSelectedContexts();
+        oInternalModelContext.setProperty("selectedContexts", aSelectedContexts);
+        oInternalModelContext.setProperty("numberOfSelectedContexts", aSelectedContexts.length);
+        // Refresh enablement of delete button
+        DeleteHelper.updateDeleteInfoForSelectedContexts(oInternalModelContext, aSelectedContexts);
+        ActionRuntime.setActionEnablement(oInternalModelContext, oActionOperationAvailableMap, aSelectedContexts, "table");
+      });
+      CommonUtils.updateDataFieldForIBNButtonsVisibility(aIBNActions, this.getView());
+    }
+
+    /**
+     * This method scrolls to a specific row on all the available tables.
+     *
+     * @function
+     * @name sap.fe.templates.ListReport.ListReportController.controller#_scrollTablesToRow
+     * @param sRowPath The path of the table row context to be scrolled to
+     */;
+    _proto._scrollTablesToRow = function _scrollTablesToRow(sRowPath) {
+      this._getControls("table").forEach(function (oTable) {
+        TableScroller.scrollTableToRow(oTable, sRowPath);
+      });
+    }
+
+    /**
+     * This method set the initial focus within the List Report according to the UX guide lines.
+     *
+     * @function
+     * @name sap.fe.templates.ListReport.ListReportController.controller#_setInitialFocus
+     */;
+    _proto._setInitialFocus = function _setInitialFocus() {
+      const dynamicPage = this._getDynamicListReportControl(),
+        isHeaderExpanded = dynamicPage.getHeaderExpanded(),
+        filterBar = this._getFilterBarControl();
+      if (filterBar) {
+        if (isHeaderExpanded) {
+          //Enabling mandatory filter fields message dialog
+          if (!filterBar.getShowMessages()) {
+            filterBar.setShowMessages(true);
+          }
+          const firstEmptyMandatoryField = filterBar.getFilterItems().find(function (oFilterItem) {
+            return oFilterItem.getRequired() && oFilterItem.getConditions().length === 0;
+          });
+          //Focusing on the first empty mandatory filter field, or on the first filter field if the table data is loaded
+          if (firstEmptyMandatoryField) {
+            firstEmptyMandatoryField.focus();
+          } else if (this._isInitLoadEnabled() && filterBar.getFilterItems().length > 0) {
+            //BCP: 2380008406 Add check for available filterItems
+            filterBar.getFilterItems()[0].focus();
+          } else {
+            var _this$getView$byId;
+            //Focusing on the Go button
+            (_this$getView$byId = this.getView().byId(`${this._getFilterBarControlId()}-btnSearch`)) === null || _this$getView$byId === void 0 ? void 0 : _this$getView$byId.focus();
+          }
+        } else if (this._isInitLoadEnabled()) {
+          var _this$_getTable3;
+          (_this$_getTable3 = this._getTable()) === null || _this$_getTable3 === void 0 ? void 0 : _this$_getTable3.focusRow(0);
+        }
+      } else {
+        var _this$_getTable4;
+        (_this$_getTable4 = this._getTable()) === null || _this$_getTable4 === void 0 ? void 0 : _this$_getTable4.focusRow(0);
+      }
+    };
+    _proto._getPageTitleInformation = function _getPageTitleInformation() {
+      const oManifestEntry = this.getAppComponent().getManifestEntry("sap.app");
+      return {
+        title: oManifestEntry.title,
+        subtitle: oManifestEntry.subTitle || "",
+        intent: "",
+        icon: ""
+      };
+    };
+    _proto._getFilterBarControl = function _getFilterBarControl() {
+      return this.getView().byId(this._getFilterBarControlId());
+    };
+    _proto._getDynamicListReportControl = function _getDynamicListReportControl() {
+      return this.getView().byId(this._getDynamicListReportControlId());
+    };
+    _proto._getAdaptationFilterBarControl = function _getAdaptationFilterBarControl() {
+      // If the adaptation filter bar is part of the DOM tree, the "Adapt Filter" dialog is open,
+      // and we return the adaptation filter bar as an active control (visible for the user)
+      const adaptationFilterBar = this._getFilterBarControl().getInbuiltFilter();
+      return adaptationFilterBar !== null && adaptationFilterBar !== void 0 && adaptationFilterBar.getParent() ? adaptationFilterBar : undefined;
+    };
+    _proto._getSegmentedButton = function _getSegmentedButton(sControl) {
+      var _ref;
+      const sSegmentedButtonId = (_ref = sControl === "Chart" ? this.getChartControl() : this._getTable()) === null || _ref === void 0 ? void 0 : _ref.data("segmentedButtonId");
+      return this.getView().byId(sSegmentedButtonId);
+    };
+    _proto._getControlFromPageModelProperty = function _getControlFromPageModelProperty(sPath) {
+      var _this$_getPageModel;
+      const controlId = (_this$_getPageModel = this._getPageModel()) === null || _this$_getPageModel === void 0 ? void 0 : _this$_getPageModel.getProperty(sPath);
+      return controlId && this.getView().byId(controlId);
+    };
+    _proto._getDynamicListReportControlId = function _getDynamicListReportControlId() {
+      var _this$_getPageModel2;
+      return ((_this$_getPageModel2 = this._getPageModel()) === null || _this$_getPageModel2 === void 0 ? void 0 : _this$_getPageModel2.getProperty("/dynamicListReportId")) || "";
+    };
+    _proto._getFilterBarControlId = function _getFilterBarControlId() {
+      var _this$_getPageModel3;
+      return ((_this$_getPageModel3 = this._getPageModel()) === null || _this$_getPageModel3 === void 0 ? void 0 : _this$_getPageModel3.getProperty("/filterBarId")) || "";
+    };
+    _proto.getChartControl = function getChartControl() {
+      return this._getControlFromPageModelProperty("/singleChartId");
+    };
+    _proto._getVisualFilterBarControl = function _getVisualFilterBarControl() {
+      const sVisualFilterBarId = StableIdHelper.generate(["visualFilter", this._getFilterBarControlId()]);
+      return sVisualFilterBarId && this.getView().byId(sVisualFilterBarId);
+    };
+    _proto._getFilterBarVariantControl = function _getFilterBarVariantControl() {
+      return this._getControlFromPageModelProperty("/variantManagement/id");
+    };
+    _proto._getMultiModeControl = function _getMultiModeControl() {
+      return this.getView().byId("fe::TabMultipleMode::Control");
+    };
+    _proto._getTable = function _getTable() {
+      if (this._isMultiMode()) {
+        var _this$_getMultiModeCo2, _this$_getMultiModeCo3;
+        const oControl = (_this$_getMultiModeCo2 = this._getMultiModeControl()) === null || _this$_getMultiModeCo2 === void 0 ? void 0 : (_this$_getMultiModeCo3 = _this$_getMultiModeCo2.getSelectedInnerControl()) === null || _this$_getMultiModeCo3 === void 0 ? void 0 : _this$_getMultiModeCo3.content;
+        return oControl !== null && oControl !== void 0 && oControl.isA("sap.ui.mdc.Table") ? oControl : undefined;
+      } else {
+        return this._getControlFromPageModelProperty("/singleTableId");
+      }
+    };
+    _proto._getControls = function _getControls(sKey) {
+      if (this._isMultiMode()) {
+        const aControls = [];
+        const oTabMultiMode = this._getMultiModeControl().content;
+        oTabMultiMode.getItems().forEach(oItem => {
+          const oControl = this.getView().byId(oItem.getKey());
+          if (oControl && sKey) {
+            if (oItem.getKey().indexOf(`fe::${sKey}`) > -1) {
+              aControls.push(oControl);
+            }
+          } else if (oControl !== undefined && oControl !== null) {
+            aControls.push(oControl);
+          }
+        });
+        return aControls;
+      } else if (sKey === "Chart") {
+        const oChart = this.getChartControl();
+        return oChart ? [oChart] : [];
+      } else {
+        const oTable = this._getTable();
+        return oTable ? [oTable] : [];
+      }
+    };
+    _proto._getDefaultPath = function _getDefaultPath() {
+      var _this$_getPageModel4;
+      const defaultPath = ListReportTemplating.getDefaultPath(((_this$_getPageModel4 = this._getPageModel()) === null || _this$_getPageModel4 === void 0 ? void 0 : _this$_getPageModel4.getProperty("/views")) || []);
+      switch (defaultPath) {
+        case "primary":
+          return TemplateContentView.Chart;
+        case "secondary":
+          return TemplateContentView.Table;
+        case "both":
+        default:
+          return TemplateContentView.Hybrid;
+      }
+    }
+
+    /**
+     * Method to know if ListReport is configured with Multiple Table mode.
+     *
+     * @function
+     * @name _isMultiMode
+     * @returns Is Multiple Table mode set?
+     */;
+    _proto._isMultiMode = function _isMultiMode() {
+      var _this$_getPageModel5;
+      return !!((_this$_getPageModel5 = this._getPageModel()) !== null && _this$_getPageModel5 !== void 0 && _this$_getPageModel5.getProperty("/multiViewsControl"));
+    }
+
+    /**
+     * Method to know if ListReport is configured to load data at start up.
+     *
+     * @function
+     * @name _isInitLoadDisabled
+     * @returns Is InitLoad enabled?
+     */;
+    _proto._isInitLoadEnabled = function _isInitLoadEnabled() {
+      const initLoadMode = this.getView().getViewData().initialLoad;
+      return initLoadMode === InitialLoadMode.Enabled;
+    };
+    _proto._hasMultiVisualizations = function _hasMultiVisualizations() {
+      var _this$_getPageModel6;
+      return (_this$_getPageModel6 = this._getPageModel()) === null || _this$_getPageModel6 === void 0 ? void 0 : _this$_getPageModel6.getProperty("/hasMultiVisualizations");
+    }
+
+    /**
+     * Method to suspend search on the filter bar. The initial loading of data is disabled based on the manifest configuration InitLoad - Disabled/Auto.
+     * It is enabled later when the view state is set, when it is possible to realize if there are default filters.
+     */;
+    _proto._disableInitLoad = function _disableInitLoad() {
+      const filterBar = this._getFilterBarControl();
+      // check for filter bar hidden
+      if (filterBar) {
+        filterBar.setSuspendSelection(true);
+      }
+    }
+
+    /**
+     * Method called by flex to determine if the applyAutomatically setting on the variant is valid.
+     * Called only for Standard Variant and only when there is display text set for applyAutomatically (FE only sets it for Auto).
+     *
+     * @returns Boolean true if data should be loaded automatically, false otherwise
+     */;
+    _proto._applyAutomaticallyOnStandardVariant = function _applyAutomaticallyOnStandardVariant() {
+      // We always return false and take care of it when view state is set
+      return false;
+    }
+
+    /**
+     * Configure the settings for initial load based on
+     * - manifest setting initLoad - Enabled/Disabled/Auto
+     * - user's setting of applyAutomatically on variant
+     * - if there are default filters
+     * We disable the filter bar search at the beginning and enable it when view state is set.
+     */;
+    _proto._setInitLoad = function _setInitLoad() {
+      // if initLoad is Disabled or Auto, switch off filter bar search temporarily at start
+      if (!this._isInitLoadEnabled()) {
+        this._disableInitLoad();
+      }
+      // set hook for flex for when standard variant is set (at start or by user at runtime)
+      // required to override the user setting 'apply automatically' behaviour if there are no filters
+      const variantManagementId = ListReportTemplating.getVariantBackReference(this.getView().getViewData(), this._getPageModel());
+      const variantManagement = variantManagementId && this.getView().byId(variantManagementId);
+      if (variantManagement) {
+        variantManagement.registerApplyAutomaticallyOnStandardVariant(this._applyAutomaticallyOnStandardVariant.bind(this));
+      }
+    };
+    _proto._setShareModel = function _setShareModel() {
+      // TODO: deactivated for now - currently there is no _templPriv anymore, to be discussed
+      // this method is currently not called anymore from the init method
+
+      const fnGetUser = ObjectPath.get("sap.ushell.Container.getUser");
+      //var oManifest = this.getOwnerComponent().getAppComponent().getMetadata().getManifestEntry("sap.ui");
+      //var sBookmarkIcon = (oManifest && oManifest.icons && oManifest.icons.icon) || "";
+
+      //shareModel: Holds all the sharing relevant information and info used in XML view
+      const oShareInfo = {
+        bookmarkTitle: document.title,
+        //To name the bookmark according to the app title.
+        bookmarkCustomUrl: function () {
+          const sHash = hasher.getHash();
+          return sHash ? `#${sHash}` : window.location.href;
+        },
+        /*
+        				To be activated once the FLP shows the count - see comment above
+        				bookmarkServiceUrl: function() {
+        					//var oTable = oTable.getInnerTable(); oTable is already the sap.fe table (but not the inner one)
+        					// we should use table.getListBindingInfo instead of the binding
+        					var oBinding = oTable.getBinding("rows") || oTable.getBinding("items");
+        					return oBinding ? fnGetDownloadUrl(oBinding) : "";
+        				},*/
+        isShareInJamActive: !!fnGetUser && fnGetUser().isJamActive()
+      };
+      const oTemplatePrivateModel = this.getOwnerComponent().getModel("_templPriv");
+      oTemplatePrivateModel.setProperty("/listReport/share", oShareInfo);
+    }
+
+    /**
+     * Method to update the local UI model of the page with the fields that are not applicable to the filter bar (this is specific to the ALP scenario).
+     *
+     * @param oInternalModelContext The internal model context
+     * @param oFilterBar MDC filter bar
+     */;
+    _proto._updateALPNotApplicableFields = function _updateALPNotApplicableFields(oInternalModelContext, oFilterBar) {
+      const mCache = {};
+      const ignoredFields = {},
+        aTables = this._getControls("table"),
+        aCharts = this._getControls("Chart");
+      if (!aTables.length || !aCharts.length) {
+        // If there's not a table and a chart, we're not in the ALP case
+        return;
+      }
+
+      // For the moment, there's nothing for tables...
+      aCharts.forEach(function (oChart) {
+        const sChartEntityPath = oChart.data("targetCollectionPath"),
+          sChartEntitySet = sChartEntityPath.slice(1),
+          sCacheKey = `${sChartEntitySet}Chart`;
+        if (!mCache[sCacheKey]) {
+          mCache[sCacheKey] = FilterUtils.getNotApplicableFilters(oFilterBar, oChart);
+        }
+        ignoredFields[sCacheKey] = mCache[sCacheKey];
+      });
+      oInternalModelContext.setProperty("controls/ignoredFields", ignoredFields);
+    };
+    _proto._isFilterBarHidden = function _isFilterBarHidden() {
+      return this.getView().getViewData().hideFilterBar;
+    };
+    _proto._getApplyAutomaticallyOnVariant = function _getApplyAutomaticallyOnVariant(VariantManagement, key) {
+      if (!VariantManagement || !key) {
+        return false;
+      }
+      const variants = VariantManagement.getVariants();
+      const currentVariant = variants.find(function (variant) {
+        return variant && variant.key === key;
+      });
+      return currentVariant && currentVariant.executeOnSelect || false;
+    };
+    _proto._shouldAutoTriggerSearch = function _shouldAutoTriggerSearch(oVM) {
+      if (this.getView().getViewData().initialLoad === InitialLoadMode.Auto && (!oVM || oVM.getStandardVariantKey() === oVM.getCurrentVariantKey())) {
+        const oFilterBar = this._getFilterBarControl();
+        if (oFilterBar) {
+          const oConditions = oFilterBar.getConditions();
+          for (const sKey in oConditions) {
+            // ignore filters starting with $ (e.g. $search, $editState)
+            if (!sKey.startsWith("$") && Array.isArray(oConditions[sKey]) && oConditions[sKey].length) {
+              // load data as per user's setting of applyAutomatically on the variant
+              const standardVariant = oVM.getVariants().find(variant => {
+                return variant.key === oVM.getCurrentVariantKey();
+              });
+              return standardVariant && standardVariant.executeOnSelect;
+            }
+          }
+        }
+      }
+      return false;
+    };
+    _proto._updateTable = function _updateTable(oTable) {
+      if (!oTable.isTableBound() || this.hasPendingChartChanges) {
+        oTable.rebind();
+        this.hasPendingChartChanges = false;
+      }
+    };
+    _proto._updateChart = function _updateChart(oChart) {
+      const oInnerChart = oChart.getControlDelegate()._getChart(oChart);
+      if (!(oInnerChart && oInnerChart.isBound("data")) || this.hasPendingTableChanges) {
+        oChart.getControlDelegate().rebind(oChart, oInnerChart.getBindingInfo("data"));
+        this.hasPendingTableChanges = false;
+      }
+    };
+    return ListReportController;
+  }(PageController), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "_routing", [_dec2], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "_intentBasedNavigation", [_dec3], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "sideEffects", [_dec4], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor4 = _applyDecoratedDescriptor(_class2.prototype, "intentBasedNavigation", [_dec5], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor5 = _applyDecoratedDescriptor(_class2.prototype, "share", [_dec6], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor6 = _applyDecoratedDescriptor(_class2.prototype, "viewState", [_dec7], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor7 = _applyDecoratedDescriptor(_class2.prototype, "kpiManagement", [_dec8], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor8 = _applyDecoratedDescriptor(_class2.prototype, "placeholder", [_dec9], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _descriptor9 = _applyDecoratedDescriptor(_class2.prototype, "massEdit", [_dec10], {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  }), _applyDecoratedDescriptor(_class2.prototype, "getExtensionAPI", [_dec11, _dec12], Object.getOwnPropertyDescriptor(_class2.prototype, "getExtensionAPI"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onPageReady", [_dec13, _dec14], Object.getOwnPropertyDescriptor(_class2.prototype, "onPageReady"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onViewNeedsRefresh", [_dec15, _dec16], Object.getOwnPropertyDescriptor(_class2.prototype, "onViewNeedsRefresh"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onPendingFilters", [_dec17, _dec18], Object.getOwnPropertyDescriptor(_class2.prototype, "onPendingFilters"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onAfterClear", [_dec19, _dec20], Object.getOwnPropertyDescriptor(_class2.prototype, "onAfterClear"), _class2.prototype)), _class2)) || _class);
+  return ListReportController;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["TemplateContentView","CoreLibrary","InitialLoadMode","ListReportController","defineUI5Class","usingExtension","InternalRouting","override","onAfterBinding","getView","getController","_onAfterBinding","InternalIntentBasedNavigation","getEntitySet","base","getCurrentEntitySet","SideEffects","IntentBasedNavigation","IntentBasedNavigationOverride","Share","ShareOverrides","ViewState","ViewStateOverrides","KPIManagement","Placeholder","MassEdit","publicExtension","finalExtension","privateExtension","extensible","OverrideExecution","After","handlers","onFilterSearch","_getFilterBarControl","triggerSearch","onFiltersChanged","oEvent","oFilterBar","oInternalModelContext","getBindingContext","onPendingFilters","setProperty","getAssignedFiltersText","filtersText","getParameter","onVariantSelected","oVM","getSource","currentVariantKey","oMultiModeControl","_getMultiModeControl","invalidateContent","setFreezeContent","setTimeout","_shouldAutoTriggerSearch","_getApplyAutomaticallyOnVariant","getExtensionAPI","updateAppState","onVariantSaved","onSearch","oMdcChart","getChartControl","bHideDraft","FilterUtils","getEditStateIsHideDraft","getConditions","_updateALPNotApplicableFields","oPageInternalModelContext","sTemplateContentView","getProperty","getPath","Chart","hasPendingChartChanges","Table","hasPendingTableChanges","StateUtil","retrieveExternalState","then","oExternalState","filterBarConditions","filter","catch","oError","Log","error","getViewData","liveMode","system","phone","oDynamicPage","_getDynamicListReportControl","setHeaderExpanded","onChevronPressNavigateOutBound","oController","sOutboundTarget","oContext","sCreatePath","_intentBasedNavigation","onChartSelectionChanged","getContent","oTable","_getTable","aData","ChartUtils","setChartFilters","rebind","onSegmentedButtonPressed","sSelectedKey","mParameters","key","oChart","oSegmentedButtonDelegate","onAfterRendering","aItems","oSegmentedButton","getItems","forEach","oItem","getKey","focus","removeEventDelegate","_getSegmentedButton","addEventDelegate","_updateTable","_updateChart","Hybrid","onFiltersSegmentedButtonPressed","isCompact","setVisible","_getVisualFilterBarControl","onStateChange","onDynamicPageTitleStateChanged","filterBar","getSegmentedButton","formatters","setALPControlMessageStrip","aIgnoredFields","bIsChart","oApplySupported","sText","Array","isArray","length","aIgnoredLabels","MessageStrip","getLabels","data","oResourceBundle","bIsSearchIgnored","enableSearch","getALPText","getText","DelegateUtil","getLocalizedText","extensionAPI","ExtensionAPI","onInit","PageController","prototype","apply","_hasMultiVisualizations","alpContentView","_getDefaultPath","desktop","getAppComponent","getRouterProxy","waitForRouteMatchBeforeNavigation","_setInitLoad","onExit","destroy","aTables","_getControls","EditState","isEditStateDirty","oTableBinding","getRowBinding","CommonUtils","_isFclEnabled","refresh","sUpdateTimer","fnUpdateTableActions","_updateTableActions","detachDataReceived","attachDataReceived","setEditStateProcessed","internalModelContext","viewId","getId","pageReady","waitFor","getAppStateHandler","applyAppState","onBeforeRendering","getModel","getResourceBundle","response","sEntitySet","entitySet","getTranslatedText","undefined","setNoData","onPageReady","forceFocus","_setInitialFocus","getShellServices","setBackNavigation","onViewNeedsRefresh","slice","onAfterClear","aIBNActions","getIBNActions","oActionOperationAvailableMap","JSON","parse","CommonHelper","parseCustomData","getCustomData","aSelectedContexts","getSelectedContexts","DeleteHelper","updateDeleteInfoForSelectedContexts","ActionRuntime","setActionEnablement","updateDataFieldForIBNButtonsVisibility","_scrollTablesToRow","sRowPath","TableScroller","scrollTableToRow","dynamicPage","isHeaderExpanded","getHeaderExpanded","getShowMessages","setShowMessages","firstEmptyMandatoryField","getFilterItems","find","oFilterItem","getRequired","_isInitLoadEnabled","byId","_getFilterBarControlId","focusRow","_getPageTitleInformation","oManifestEntry","getManifestEntry","title","subtitle","subTitle","intent","icon","_getDynamicListReportControlId","_getAdaptationFilterBarControl","adaptationFilterBar","getInbuiltFilter","getParent","sControl","sSegmentedButtonId","_getControlFromPageModelProperty","sPath","controlId","_getPageModel","sVisualFilterBarId","StableIdHelper","generate","_getFilterBarVariantControl","_isMultiMode","oControl","getSelectedInnerControl","content","isA","sKey","aControls","oTabMultiMode","indexOf","push","defaultPath","ListReportTemplating","getDefaultPath","initLoadMode","initialLoad","Enabled","_disableInitLoad","setSuspendSelection","_applyAutomaticallyOnStandardVariant","variantManagementId","getVariantBackReference","variantManagement","registerApplyAutomaticallyOnStandardVariant","bind","_setShareModel","fnGetUser","ObjectPath","get","oShareInfo","bookmarkTitle","document","bookmarkCustomUrl","sHash","hasher","getHash","window","location","href","isShareInJamActive","isJamActive","oTemplatePrivateModel","getOwnerComponent","mCache","ignoredFields","aCharts","sChartEntityPath","sChartEntitySet","sCacheKey","getNotApplicableFilters","_isFilterBarHidden","hideFilterBar","VariantManagement","variants","getVariants","currentVariant","variant","executeOnSelect","Auto","getStandardVariantKey","getCurrentVariantKey","oConditions","startsWith","standardVariant","isTableBound","oInnerChart","getControlDelegate","_getChart","isBound","getBindingInfo"],"sourceRoot":".","sources":["ListReportController.controller.ts"],"sourcesContent":["import type ResourceBundle from \"sap/base/i18n/ResourceBundle\";\nimport Log from \"sap/base/Log\";\nimport ObjectPath from \"sap/base/util/ObjectPath\";\nimport type DynamicPage from \"sap/f/DynamicPage\";\nimport ActionRuntime from \"sap/fe/core/ActionRuntime\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport IntentBasedNavigation from \"sap/fe/core/controllerextensions/IntentBasedNavigation\";\nimport InternalIntentBasedNavigation from \"sap/fe/core/controllerextensions/InternalIntentBasedNavigation\";\nimport InternalRouting from \"sap/fe/core/controllerextensions/InternalRouting\";\nimport KPIManagement from \"sap/fe/core/controllerextensions/KPIManagement\";\nimport MassEdit from \"sap/fe/core/controllerextensions/MassEdit\";\nimport Placeholder from \"sap/fe/core/controllerextensions/Placeholder\";\nimport Share from \"sap/fe/core/controllerextensions/Share\";\nimport SideEffects from \"sap/fe/core/controllerextensions/SideEffects\";\nimport ViewState from \"sap/fe/core/controllerextensions/ViewState\";\nimport type FilterBar from \"sap/fe/core/controls/FilterBar\";\nimport {\n\tdefineUI5Class,\n\textensible,\n\tfinalExtension,\n\tprivateExtension,\n\tpublicExtension,\n\tusingExtension\n} from \"sap/fe/core/helpers/ClassSupport\";\nimport DeleteHelper from \"sap/fe/core/helpers/DeleteHelper\";\nimport EditState from \"sap/fe/core/helpers/EditState\";\nimport MessageStrip from \"sap/fe/core/helpers/MessageStrip\";\nimport { InternalModelContext } from \"sap/fe/core/helpers/ModelHelper\";\nimport * as StableIdHelper from \"sap/fe/core/helpers/StableIdHelper\";\nimport CoreLibrary from \"sap/fe/core/library\";\nimport PageController from \"sap/fe/core/PageController\";\nimport ChartUtils from \"sap/fe/macros/chart/ChartUtils\";\nimport CommonHelper from \"sap/fe/macros/CommonHelper\";\nimport DelegateUtil from \"sap/fe/macros/DelegateUtil\";\nimport FilterUtils from \"sap/fe/macros/filter/FilterUtils\";\nimport MultipleModeControl from \"sap/fe/templates/ListReport/controls/MultipleModeControl\";\nimport ExtensionAPI from \"sap/fe/templates/ListReport/ExtensionAPI\";\nimport TableScroller from \"sap/fe/templates/TableScroller\";\nimport type SegmentedButton from \"sap/m/SegmentedButton\";\nimport type Control from \"sap/ui/core/Control\";\nimport OverrideExecution from \"sap/ui/core/mvc/OverrideExecution\";\nimport { system } from \"sap/ui/Device\";\nimport StateUtil from \"sap/ui/mdc/p13n/StateUtil\";\nimport type Table from \"sap/ui/mdc/Table\";\nimport type JSONModel from \"sap/ui/model/json/JSONModel\";\nimport type ResourceModel from \"sap/ui/model/resource/ResourceModel\";\nimport hasher from \"sap/ui/thirdparty/hasher\";\nimport type { V4Context } from \"types/extension_types\";\nimport * as ListReportTemplating from \"./ListReportTemplating\";\nimport IntentBasedNavigationOverride from \"./overrides/IntentBasedNavigation\";\nimport ShareOverrides from \"./overrides/Share\";\nimport ViewStateOverrides from \"./overrides/ViewState\";\n\nconst TemplateContentView = CoreLibrary.TemplateContentView,\n\tInitialLoadMode = CoreLibrary.InitialLoadMode;\n\n/**\n * Controller class for the list report page, used inside an SAP Fiori elements application.\n *\n * @hideconstructor\n * @public\n */\n@defineUI5Class(\"sap.fe.templates.ListReport.ListReportController\")\nclass ListReportController extends PageController {\n\t@usingExtension(\n\t\tInternalRouting.override({\n\t\t\tonAfterBinding: function (this: InternalRouting) {\n\t\t\t\t(this.getView().getController() as ListReportController)._onAfterBinding();\n\t\t\t}\n\t\t})\n\t)\n\t_routing!: InternalRouting;\n\t@usingExtension(\n\t\tInternalIntentBasedNavigation.override({\n\t\t\tgetEntitySet: function (this: InternalIntentBasedNavigation) {\n\t\t\t\treturn (this.base as ListReportController).getCurrentEntitySet();\n\t\t\t}\n\t\t})\n\t)\n\t_intentBasedNavigation!: InternalIntentBasedNavigation;\n\t@usingExtension(SideEffects)\n\tsideEffects!: SideEffects;\n\n\t@usingExtension(IntentBasedNavigation.override(IntentBasedNavigationOverride))\n\tintentBasedNavigation!: IntentBasedNavigation;\n\n\t@usingExtension(Share.override(ShareOverrides))\n\tshare!: Share;\n\n\t@usingExtension(ViewState.override(ViewStateOverrides))\n\tviewState!: ViewState;\n\n\t@usingExtension(KPIManagement)\n\tkpiManagement!: KPIManagement;\n\t@usingExtension(Placeholder)\n\tplaceholder!: Placeholder;\n\t@usingExtension(MassEdit)\n\tmassEdit!: MassEdit;\n\tprotected extensionAPI?: ExtensionAPI;\n\tprivate filterBarConditions?: any;\n\tprivate sUpdateTimer?: any;\n\tprivate oResourceBundle?: ResourceBundle;\n\tprivate hasPendingChartChanges?: boolean;\n\tprivate hasPendingTableChanges?: boolean;\n\n\t/**\n\t * Get the extension API for the current page.\n\t *\n\t * @public\n\t * @returns The extension API.\n\t */\n\t@publicExtension()\n\t@finalExtension()\n\tgetExtensionAPI(): ExtensionAPI {\n\t\tif (!this.extensionAPI) {\n\t\t\tthis.extensionAPI = new ExtensionAPI(this);\n\t\t}\n\t\treturn this.extensionAPI;\n\t}\n\n\tonInit() {\n\t\tPageController.prototype.onInit.apply(this);\n\t\tconst oInternalModelContext = this.getView().getBindingContext(\"internal\") as InternalModelContext;\n\n\t\toInternalModelContext.setProperty(\"hasPendingFilters\", true);\n\t\toInternalModelContext.setProperty(\"appliedFilters\", \"\");\n\t\toInternalModelContext.setProperty(\"hideDraftInfo\", false);\n\t\toInternalModelContext.setProperty(\"uom\", {});\n\t\toInternalModelContext.setProperty(\"scalefactor\", {});\n\t\toInternalModelContext.setProperty(\"scalefactorNumber\", {});\n\t\toInternalModelContext.setProperty(\"currency\", {});\n\n\t\tif (this._hasMultiVisualizations()) {\n\t\t\tlet alpContentView = this._getDefaultPath();\n\t\t\tif (!system.desktop && alpContentView === TemplateContentView.Hybrid) {\n\t\t\t\talpContentView = TemplateContentView.Chart;\n\t\t\t}\n\t\t\toInternalModelContext.setProperty(\"alpContentView\", alpContentView);\n\t\t}\n\n\t\t// Store conditions from filter bar\n\t\t// this is later used before navigation to get conditions applied on the filter bar\n\t\tthis.filterBarConditions = {};\n\n\t\t// As AppStateHandler.applyAppState triggers a navigation we want to make sure it will\n\t\t// happen after the routeMatch event has been processed (otherwise the router gets broken)\n\t\tthis.getAppComponent().getRouterProxy().waitForRouteMatchBeforeNavigation();\n\n\t\t// Configure the initial load settings\n\t\tthis._setInitLoad();\n\t}\n\n\tonExit() {\n\t\tdelete this.filterBarConditions;\n\t\tif (this.extensionAPI) {\n\t\t\tthis.extensionAPI.destroy();\n\t\t}\n\t\tdelete this.extensionAPI;\n\t}\n\n\t_onAfterBinding() {\n\t\tconst aTables = this._getControls(\"table\");\n\t\tif (EditState.isEditStateDirty()) {\n\t\t\tthis._getMultiModeControl()?.invalidateContent();\n\t\t\tconst oTableBinding = this._getTable()?.getRowBinding();\n\t\t\tif (oTableBinding) {\n\t\t\t\tif (CommonUtils.getAppComponent(this.getView())._isFclEnabled()) {\n\t\t\t\t\t// there is an issue if we use a timeout with a kept alive context used on another page\n\t\t\t\t\toTableBinding.refresh();\n\t\t\t\t} else {\n\t\t\t\t\tif (!this.sUpdateTimer) {\n\t\t\t\t\t\tthis.sUpdateTimer = setTimeout(() => {\n\t\t\t\t\t\t\toTableBinding.refresh();\n\t\t\t\t\t\t\tdelete this.sUpdateTimer;\n\t\t\t\t\t\t}, 0);\n\t\t\t\t\t}\n\n\t\t\t\t\t// Update action enablement and visibility upon table data update.\n\t\t\t\t\tconst fnUpdateTableActions = () => {\n\t\t\t\t\t\tthis._updateTableActions(aTables);\n\t\t\t\t\t\toTableBinding.detachDataReceived(fnUpdateTableActions);\n\t\t\t\t\t};\n\t\t\t\t\toTableBinding.attachDataReceived(fnUpdateTableActions);\n\t\t\t\t}\n\t\t\t}\n\t\t\tEditState.setEditStateProcessed();\n\t\t}\n\n\t\tif (!this.sUpdateTimer) {\n\t\t\tthis._updateTableActions(aTables);\n\t\t}\n\n\t\tconst internalModelContext = this.getView().getBindingContext(\"internal\") as InternalModelContext;\n\t\tif (!internalModelContext.getProperty(\"initialVariantApplied\")) {\n\t\t\tconst viewId = this.getView().getId();\n\t\t\tthis.pageReady.waitFor(this.getAppComponent().getAppStateHandler().applyAppState(viewId, this.getView()));\n\t\t\tinternalModelContext.setProperty(\"initialVariantApplied\", true);\n\t\t}\n\t}\n\n\tonBeforeRendering() {\n\t\tPageController.prototype.onBeforeRendering.apply(this);\n\t}\n\n\tonAfterRendering() {\n\t\t((this.getView().getModel(\"sap.fe.i18n\") as ResourceModel).getResourceBundle() as Promise<ResourceBundle>)\n\t\t\t.then((response: any) => {\n\t\t\t\tthis.oResourceBundle = response;\n\t\t\t\tconst aTables = this._getControls() as Table[];\n\t\t\t\tconst sEntitySet = (this.getView().getViewData() as any).entitySet;\n\t\t\t\tconst sText = CommonUtils.getTranslatedText(\n\t\t\t\t\t\"T_TABLE_AND_CHART_NO_DATA_TEXT\",\n\t\t\t\t\tthis.oResourceBundle as ResourceBundle,\n\t\t\t\t\tundefined,\n\t\t\t\t\tsEntitySet\n\t\t\t\t);\n\t\t\t\taTables.forEach(function (oTable: Table) {\n\t\t\t\t\toTable.setNoData(sText);\n\t\t\t\t});\n\t\t\t})\n\t\t\t.catch(function (oError: any) {\n\t\t\t\tLog.error(\"Error while retrieving the resource bundle\", oError);\n\t\t\t});\n\t}\n\n\t@privateExtension()\n\t@extensible(OverrideExecution.After)\n\tonPageReady(mParameters: any) {\n\t\tif (mParameters.forceFocus) {\n\t\t\tthis._setInitialFocus();\n\t\t}\n\t\t// Remove the handler on back navigation that displays Draft confirmation\n\t\tthis.getAppComponent().getShellServices().setBackNavigation(undefined);\n\t}\n\n\t/**\n\t * Method called when the content of a custom view used in a list report needs to be refreshed.\n\t * This happens either when there is a change on the FilterBar and the search is triggered,\n\t * or when a tab with custom content is selected.\n\t * This method can be overwritten by the controller extension in case of customization.\n\t *\n\t * @param mParameters Map containing the filter conditions of the FilterBar, the currentTabID\n\t * and the view refresh cause (tabChanged or search).\n\t * The map looks like this:\n\t * <code><pre>\n\t * \t{\n\t * \t\tfilterConditions: {\n\t * \t\t\tCountry: [\n\t * \t\t\t\t{\n\t * \t\t\t\t\toperator: \"EQ\"\n\t *\t\t\t\t\tvalidated: \"NotValidated\"\n\t *\t\t\t\t\tvalues: [\"Germany\", ...]\n\t * \t\t\t\t},\n\t * \t\t\t\t...\n\t * \t\t\t]\n\t * \t\t\t...\n\t * \t\t},\n\t *\t\tcurrentTabId: \"fe::CustomTab::tab1\",\n\t *\t\trefreshCause: \"tabChanged\" | \"search\"\n\t *\t}\n\t * </pre></code>\n\t * @public\n\t */\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\t// eslint-disable-next-line @typescript-eslint/no-unused-vars\n\tonViewNeedsRefresh(mParameters: any) {\n\t\t/* To be overriden */\n\t}\n\n\t/**\n\t * Method called when a filter or search value has been changed in the FilterBar,\n\t * but has not been validated yet by the end user (with the 'Go' or 'Search' button).\n\t * Typically, the content of the current tab is greyed out until the filters are validated.\n\t * This method can be overwritten by the controller extension in case of customization.\n\t *\n\t * @public\n\t */\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\tonPendingFilters() {\n\t\t/* To be overriden */\n\t}\n\n\tgetCurrentEntitySet() {\n\t\treturn this._getTable()?.data(\"targetCollectionPath\").slice(1);\n\t}\n\n\t/**\n\t * Method called when the 'Clear' button on the FilterBar is pressed.\n\t *\n\t * @public\n\t */\n\t@publicExtension()\n\t@extensible(OverrideExecution.After)\n\tonAfterClear() {\n\t\t/* To be overriden */\n\t}\n\n\t/**\n\t * This method initiates the update of the enabled state of the DataFieldForAction and the visible state of the DataFieldForIBN buttons.\n\t *\n\t * @param aTables Array of tables in the list report\n\t * @private\n\t */\n\t_updateTableActions(aTables: any) {\n\t\tlet aIBNActions: any[] = [];\n\t\taTables.forEach(function (oTable: any) {\n\t\t\taIBNActions = CommonUtils.getIBNActions(oTable, aIBNActions);\n\t\t\t// Update 'enabled' property of DataFieldForAction buttons on table toolbar\n\t\t\t// The same is also performed on Table selectionChange event\n\t\t\tconst oInternalModelContext = oTable.getBindingContext(\"internal\"),\n\t\t\t\toActionOperationAvailableMap = JSON.parse(\n\t\t\t\t\tCommonHelper.parseCustomData(DelegateUtil.getCustomData(oTable, \"operationAvailableMap\"))\n\t\t\t\t),\n\t\t\t\taSelectedContexts = oTable.getSelectedContexts();\n\n\t\t\toInternalModelContext.setProperty(\"selectedContexts\", aSelectedContexts);\n\t\t\toInternalModelContext.setProperty(\"numberOfSelectedContexts\", aSelectedContexts.length);\n\t\t\t// Refresh enablement of delete button\n\t\t\tDeleteHelper.updateDeleteInfoForSelectedContexts(oInternalModelContext, aSelectedContexts);\n\n\t\t\tActionRuntime.setActionEnablement(oInternalModelContext, oActionOperationAvailableMap, aSelectedContexts, \"table\");\n\t\t});\n\t\tCommonUtils.updateDataFieldForIBNButtonsVisibility(aIBNActions, this.getView());\n\t}\n\n\t/**\n\t * This method scrolls to a specific row on all the available tables.\n\t *\n\t * @function\n\t * @name sap.fe.templates.ListReport.ListReportController.controller#_scrollTablesToRow\n\t * @param sRowPath The path of the table row context to be scrolled to\n\t */\n\t_scrollTablesToRow(sRowPath: string) {\n\t\tthis._getControls(\"table\").forEach(function (oTable: any) {\n\t\t\tTableScroller.scrollTableToRow(oTable, sRowPath);\n\t\t});\n\t}\n\n\t/**\n\t * This method set the initial focus within the List Report according to the UX guide lines.\n\t *\n\t * @function\n\t * @name sap.fe.templates.ListReport.ListReportController.controller#_setInitialFocus\n\t */\n\t_setInitialFocus() {\n\t\tconst dynamicPage = this._getDynamicListReportControl(),\n\t\t\tisHeaderExpanded = dynamicPage.getHeaderExpanded(),\n\t\t\tfilterBar = this._getFilterBarControl() as any;\n\t\tif (filterBar) {\n\t\t\tif (isHeaderExpanded) {\n\t\t\t\t//Enabling mandatory filter fields message dialog\n\t\t\t\tif (!filterBar.getShowMessages()) {\n\t\t\t\t\tfilterBar.setShowMessages(true);\n\t\t\t\t}\n\t\t\t\tconst firstEmptyMandatoryField = filterBar.getFilterItems().find(function (oFilterItem: any) {\n\t\t\t\t\treturn oFilterItem.getRequired() && oFilterItem.getConditions().length === 0;\n\t\t\t\t});\n\t\t\t\t//Focusing on the first empty mandatory filter field, or on the first filter field if the table data is loaded\n\t\t\t\tif (firstEmptyMandatoryField) {\n\t\t\t\t\tfirstEmptyMandatoryField.focus();\n\t\t\t\t} else if (this._isInitLoadEnabled() && filterBar.getFilterItems().length > 0) {\n\t\t\t\t\t//BCP: 2380008406 Add check for available filterItems\n\t\t\t\t\tfilterBar.getFilterItems()[0].focus();\n\t\t\t\t} else {\n\t\t\t\t\t//Focusing on the Go button\n\t\t\t\t\tthis.getView().byId(`${this._getFilterBarControlId()}-btnSearch`)?.focus();\n\t\t\t\t}\n\t\t\t} else if (this._isInitLoadEnabled()) {\n\t\t\t\tthis._getTable()?.focusRow(0);\n\t\t\t}\n\t\t} else {\n\t\t\tthis._getTable()?.focusRow(0);\n\t\t}\n\t}\n\n\t_getPageTitleInformation() {\n\t\tconst oManifestEntry = this.getAppComponent().getManifestEntry(\"sap.app\");\n\t\treturn {\n\t\t\ttitle: oManifestEntry.title,\n\t\t\tsubtitle: oManifestEntry.subTitle || \"\",\n\t\t\tintent: \"\",\n\t\t\ticon: \"\"\n\t\t};\n\t}\n\n\t_getFilterBarControl() {\n\t\treturn this.getView().byId(this._getFilterBarControlId()) as FilterBar;\n\t}\n\n\t_getDynamicListReportControl() {\n\t\treturn this.getView().byId(this._getDynamicListReportControlId()) as DynamicPage;\n\t}\n\n\t_getAdaptationFilterBarControl() {\n\t\t// If the adaptation filter bar is part of the DOM tree, the \"Adapt Filter\" dialog is open,\n\t\t// and we return the adaptation filter bar as an active control (visible for the user)\n\t\tconst adaptationFilterBar = (this._getFilterBarControl() as any).getInbuiltFilter();\n\t\treturn adaptationFilterBar?.getParent() ? adaptationFilterBar : undefined;\n\t}\n\n\t_getSegmentedButton(sControl: any) {\n\t\tconst sSegmentedButtonId = (sControl === \"Chart\" ? this.getChartControl() : this._getTable())?.data(\"segmentedButtonId\");\n\t\treturn this.getView().byId(sSegmentedButtonId);\n\t}\n\n\t_getControlFromPageModelProperty(sPath: string) {\n\t\tconst controlId = this._getPageModel()?.getProperty(sPath);\n\t\treturn controlId && this.getView().byId(controlId);\n\t}\n\n\t_getDynamicListReportControlId(): string {\n\t\treturn this._getPageModel()?.getProperty(\"/dynamicListReportId\") || \"\";\n\t}\n\n\t_getFilterBarControlId(): string {\n\t\treturn this._getPageModel()?.getProperty(\"/filterBarId\") || \"\";\n\t}\n\n\tgetChartControl() {\n\t\treturn this._getControlFromPageModelProperty(\"/singleChartId\");\n\t}\n\n\t_getVisualFilterBarControl() {\n\t\tconst sVisualFilterBarId = StableIdHelper.generate([\"visualFilter\", this._getFilterBarControlId()]);\n\t\treturn sVisualFilterBarId && this.getView().byId(sVisualFilterBarId);\n\t}\n\t_getFilterBarVariantControl() {\n\t\treturn this._getControlFromPageModelProperty(\"/variantManagement/id\");\n\t}\n\n\t_getMultiModeControl() {\n\t\treturn this.getView().byId(\"fe::TabMultipleMode::Control\") as MultipleModeControl;\n\t}\n\n\t_getTable(): Table | undefined {\n\t\tif (this._isMultiMode()) {\n\t\t\tconst oControl = this._getMultiModeControl()?.getSelectedInnerControl()?.content;\n\t\t\treturn oControl?.isA(\"sap.ui.mdc.Table\") ? (oControl as Table) : undefined;\n\t\t} else {\n\t\t\treturn this._getControlFromPageModelProperty(\"/singleTableId\") as Table;\n\t\t}\n\t}\n\t_getControls(sKey?: any) {\n\t\tif (this._isMultiMode()) {\n\t\t\tconst aControls: any[] = [];\n\t\t\tconst oTabMultiMode = this._getMultiModeControl().content;\n\t\t\toTabMultiMode.getItems().forEach((oItem: any) => {\n\t\t\t\tconst oControl = this.getView().byId(oItem.getKey());\n\t\t\t\tif (oControl && sKey) {\n\t\t\t\t\tif (oItem.getKey().indexOf(`fe::${sKey}`) > -1) {\n\t\t\t\t\t\taControls.push(oControl);\n\t\t\t\t\t}\n\t\t\t\t} else if (oControl !== undefined && oControl !== null) {\n\t\t\t\t\taControls.push(oControl);\n\t\t\t\t}\n\t\t\t});\n\t\t\treturn aControls;\n\t\t} else if (sKey === \"Chart\") {\n\t\t\tconst oChart = this.getChartControl();\n\t\t\treturn oChart ? [oChart] : [];\n\t\t} else {\n\t\t\tconst oTable = this._getTable();\n\t\t\treturn oTable ? [oTable] : [];\n\t\t}\n\t}\n\n\t_getDefaultPath() {\n\t\tconst defaultPath = ListReportTemplating.getDefaultPath(this._getPageModel()?.getProperty(\"/views\") || []);\n\t\tswitch (defaultPath) {\n\t\t\tcase \"primary\":\n\t\t\t\treturn TemplateContentView.Chart;\n\t\t\tcase \"secondary\":\n\t\t\t\treturn TemplateContentView.Table;\n\t\t\tcase \"both\":\n\t\t\tdefault:\n\t\t\t\treturn TemplateContentView.Hybrid;\n\t\t}\n\t}\n\n\t/**\n\t * Method to know if ListReport is configured with Multiple Table mode.\n\t *\n\t * @function\n\t * @name _isMultiMode\n\t * @returns Is Multiple Table mode set?\n\t */\n\t_isMultiMode(): boolean {\n\t\treturn !!this._getPageModel()?.getProperty(\"/multiViewsControl\");\n\t}\n\n\t/**\n\t * Method to know if ListReport is configured to load data at start up.\n\t *\n\t * @function\n\t * @name _isInitLoadDisabled\n\t * @returns Is InitLoad enabled?\n\t */\n\t_isInitLoadEnabled(): boolean {\n\t\tconst initLoadMode = (this.getView().getViewData() as any).initialLoad;\n\t\treturn initLoadMode === InitialLoadMode.Enabled;\n\t}\n\n\t_hasMultiVisualizations(): boolean {\n\t\treturn this._getPageModel()?.getProperty(\"/hasMultiVisualizations\");\n\t}\n\n\t/**\n\t * Method to suspend search on the filter bar. The initial loading of data is disabled based on the manifest configuration InitLoad - Disabled/Auto.\n\t * It is enabled later when the view state is set, when it is possible to realize if there are default filters.\n\t */\n\t_disableInitLoad() {\n\t\tconst filterBar = this._getFilterBarControl();\n\t\t// check for filter bar hidden\n\t\tif (filterBar) {\n\t\t\tfilterBar.setSuspendSelection(true);\n\t\t}\n\t}\n\n\t/**\n\t * Method called by flex to determine if the applyAutomatically setting on the variant is valid.\n\t * Called only for Standard Variant and only when there is display text set for applyAutomatically (FE only sets it for Auto).\n\t *\n\t * @returns Boolean true if data should be loaded automatically, false otherwise\n\t */\n\t_applyAutomaticallyOnStandardVariant() {\n\t\t// We always return false and take care of it when view state is set\n\t\treturn false;\n\t}\n\n\t/**\n\t * Configure the settings for initial load based on\n\t * - manifest setting initLoad - Enabled/Disabled/Auto\n\t * - user's setting of applyAutomatically on variant\n\t * - if there are default filters\n\t * We disable the filter bar search at the beginning and enable it when view state is set.\n\t */\n\t_setInitLoad() {\n\t\t// if initLoad is Disabled or Auto, switch off filter bar search temporarily at start\n\t\tif (!this._isInitLoadEnabled()) {\n\t\t\tthis._disableInitLoad();\n\t\t}\n\t\t// set hook for flex for when standard variant is set (at start or by user at runtime)\n\t\t// required to override the user setting 'apply automatically' behaviour if there are no filters\n\t\tconst variantManagementId: any = ListReportTemplating.getVariantBackReference(this.getView().getViewData(), this._getPageModel());\n\t\tconst variantManagement = variantManagementId && this.getView().byId(variantManagementId);\n\t\tif (variantManagement) {\n\t\t\tvariantManagement.registerApplyAutomaticallyOnStandardVariant(this._applyAutomaticallyOnStandardVariant.bind(this));\n\t\t}\n\t}\n\n\t_setShareModel() {\n\t\t// TODO: deactivated for now - currently there is no _templPriv anymore, to be discussed\n\t\t// this method is currently not called anymore from the init method\n\n\t\tconst fnGetUser = ObjectPath.get(\"sap.ushell.Container.getUser\");\n\t\t//var oManifest = this.getOwnerComponent().getAppComponent().getMetadata().getManifestEntry(\"sap.ui\");\n\t\t//var sBookmarkIcon = (oManifest && oManifest.icons && oManifest.icons.icon) || \"\";\n\n\t\t//shareModel: Holds all the sharing relevant information and info used in XML view\n\t\tconst oShareInfo = {\n\t\t\tbookmarkTitle: document.title, //To name the bookmark according to the app title.\n\t\t\tbookmarkCustomUrl: function () {\n\t\t\t\tconst sHash = hasher.getHash();\n\t\t\t\treturn sHash ? `#${sHash}` : window.location.href;\n\t\t\t},\n\t\t\t/*\n\t\t\t\t\t\t\tTo be activated once the FLP shows the count - see comment above\n\t\t\t\t\t\t\tbookmarkServiceUrl: function() {\n\t\t\t\t\t\t\t\t//var oTable = oTable.getInnerTable(); oTable is already the sap.fe table (but not the inner one)\n\t\t\t\t\t\t\t\t// we should use table.getListBindingInfo instead of the binding\n\t\t\t\t\t\t\t\tvar oBinding = oTable.getBinding(\"rows\") || oTable.getBinding(\"items\");\n\t\t\t\t\t\t\t\treturn oBinding ? fnGetDownloadUrl(oBinding) : \"\";\n\t\t\t\t\t\t\t},*/\n\t\t\tisShareInJamActive: !!fnGetUser && fnGetUser().isJamActive()\n\t\t};\n\n\t\tconst oTemplatePrivateModel = this.getOwnerComponent().getModel(\"_templPriv\") as JSONModel;\n\t\toTemplatePrivateModel.setProperty(\"/listReport/share\", oShareInfo);\n\t}\n\n\t/**\n\t * Method to update the local UI model of the page with the fields that are not applicable to the filter bar (this is specific to the ALP scenario).\n\t *\n\t * @param oInternalModelContext The internal model context\n\t * @param oFilterBar MDC filter bar\n\t */\n\t_updateALPNotApplicableFields(oInternalModelContext: InternalModelContext, oFilterBar: FilterBar) {\n\t\tconst mCache: any = {};\n\t\tconst ignoredFields: any = {},\n\t\t\taTables = this._getControls(\"table\"),\n\t\t\taCharts = this._getControls(\"Chart\");\n\n\t\tif (!aTables.length || !aCharts.length) {\n\t\t\t// If there's not a table and a chart, we're not in the ALP case\n\t\t\treturn;\n\t\t}\n\n\t\t// For the moment, there's nothing for tables...\n\t\taCharts.forEach(function (oChart: any) {\n\t\t\tconst sChartEntityPath = oChart.data(\"targetCollectionPath\"),\n\t\t\t\tsChartEntitySet = sChartEntityPath.slice(1),\n\t\t\t\tsCacheKey = `${sChartEntitySet}Chart`;\n\t\t\tif (!mCache[sCacheKey]) {\n\t\t\t\tmCache[sCacheKey] = FilterUtils.getNotApplicableFilters(oFilterBar, oChart);\n\t\t\t}\n\t\t\tignoredFields[sCacheKey] = mCache[sCacheKey];\n\t\t});\n\t\toInternalModelContext.setProperty(\"controls/ignoredFields\", ignoredFields);\n\t}\n\n\t_isFilterBarHidden() {\n\t\treturn (this.getView().getViewData() as any).hideFilterBar;\n\t}\n\n\t_getApplyAutomaticallyOnVariant(VariantManagement: any, key: string): Boolean {\n\t\tif (!VariantManagement || !key) {\n\t\t\treturn false;\n\t\t}\n\t\tconst variants = VariantManagement.getVariants();\n\t\tconst currentVariant = variants.find(function (variant: any) {\n\t\t\treturn variant && variant.key === key;\n\t\t});\n\t\treturn (currentVariant && currentVariant.executeOnSelect) || false;\n\t}\n\n\t_shouldAutoTriggerSearch(oVM: any) {\n\t\tif (\n\t\t\t(this.getView().getViewData() as any).initialLoad === InitialLoadMode.Auto &&\n\t\t\t(!oVM || oVM.getStandardVariantKey() === oVM.getCurrentVariantKey())\n\t\t) {\n\t\t\tconst oFilterBar = this._getFilterBarControl();\n\t\t\tif (oFilterBar) {\n\t\t\t\tconst oConditions = oFilterBar.getConditions();\n\t\t\t\tfor (const sKey in oConditions) {\n\t\t\t\t\t// ignore filters starting with $ (e.g. $search, $editState)\n\t\t\t\t\tif (!sKey.startsWith(\"$\") && Array.isArray(oConditions[sKey]) && oConditions[sKey].length) {\n\t\t\t\t\t\t// load data as per user's setting of applyAutomatically on the variant\n\t\t\t\t\t\tconst standardVariant: any = oVM.getVariants().find((variant: any) => {\n\t\t\t\t\t\t\treturn variant.key === oVM.getCurrentVariantKey();\n\t\t\t\t\t\t});\n\t\t\t\t\t\treturn standardVariant && standardVariant.executeOnSelect;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\n\t_updateTable(oTable: any) {\n\t\tif (!oTable.isTableBound() || this.hasPendingChartChanges) {\n\t\t\toTable.rebind();\n\t\t\tthis.hasPendingChartChanges = false;\n\t\t}\n\t}\n\n\t_updateChart(oChart: any) {\n\t\tconst oInnerChart = oChart.getControlDelegate()._getChart(oChart);\n\t\tif (!(oInnerChart && oInnerChart.isBound(\"data\")) || this.hasPendingTableChanges) {\n\t\t\toChart.getControlDelegate().rebind(oChart, oInnerChart.getBindingInfo(\"data\"));\n\t\t\tthis.hasPendingTableChanges = false;\n\t\t}\n\t}\n\n\thandlers = {\n\t\tonFilterSearch(this: ListReportController) {\n\t\t\tthis._getFilterBarControl().triggerSearch();\n\t\t},\n\t\tonFiltersChanged(this: ListReportController, oEvent: any) {\n\t\t\tconst oFilterBar = this._getFilterBarControl();\n\t\t\tif (oFilterBar) {\n\t\t\t\tconst oInternalModelContext = this.getView().getBindingContext(\"internal\") as InternalModelContext;\n\t\t\t\t// Pending filters into FilterBar to be used for custom views\n\t\t\t\tthis.onPendingFilters();\n\t\t\t\toInternalModelContext.setProperty(\"appliedFilters\", oFilterBar.getAssignedFiltersText().filtersText);\n\t\t\t\tif (oEvent.getParameter(\"conditionsBased\")) {\n\t\t\t\t\toInternalModelContext.setProperty(\"hasPendingFilters\", true);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\tonVariantSelected(this: ListReportController, oEvent: any) {\n\t\t\tconst oVM = oEvent.getSource();\n\t\t\tconst currentVariantKey = oEvent.getParameter(\"key\");\n\t\t\tconst oMultiModeControl = this._getMultiModeControl();\n\n\t\t\toMultiModeControl?.invalidateContent();\n\t\t\toMultiModeControl?.setFreezeContent(true);\n\n\t\t\t// setTimeout cause the variant needs to be applied before judging the auto search or updating the app state\n\t\t\tsetTimeout(() => {\n\t\t\t\tif (this._shouldAutoTriggerSearch(oVM)) {\n\t\t\t\t\t// the app state will be updated via onSearch handler\n\t\t\t\t\treturn this._getFilterBarControl().triggerSearch();\n\t\t\t\t} else if (!this._getApplyAutomaticallyOnVariant(oVM, currentVariantKey)) {\n\t\t\t\t\tthis.getExtensionAPI().updateAppState();\n\t\t\t\t}\n\t\t\t}, 0);\n\t\t},\n\t\tonVariantSaved(this: ListReportController) {\n\t\t\t//TODO: Should remove this setTimeOut once Variant Management provides an api to fetch the current variant key on save!!!\n\t\t\tsetTimeout(() => {\n\t\t\t\tthis.getExtensionAPI().updateAppState();\n\t\t\t}, 1000);\n\t\t},\n\t\tonSearch(this: ListReportController) {\n\t\t\tconst oFilterBar = this._getFilterBarControl();\n\t\t\tconst oInternalModelContext = this.getView().getBindingContext(\"internal\") as InternalModelContext;\n\t\t\tconst oMdcChart = this.getChartControl();\n\t\t\tconst bHideDraft = FilterUtils.getEditStateIsHideDraft(oFilterBar.getConditions());\n\t\t\toInternalModelContext.setProperty(\"hasPendingFilters\", false);\n\t\t\toInternalModelContext.setProperty(\"hideDraftInfo\", bHideDraft);\n\n\t\t\tif (!this._getMultiModeControl()) {\n\t\t\t\tthis._updateALPNotApplicableFields(oInternalModelContext, oFilterBar);\n\t\t\t}\n\t\t\tif (oMdcChart) {\n\t\t\t\t// disable bound actions TODO: this clears everything for the chart?\n\t\t\t\t(oMdcChart.getBindingContext(\"internal\") as InternalModelContext).setProperty(\"\", {});\n\n\t\t\t\tconst oPageInternalModelContext = oMdcChart.getBindingContext(\"pageInternal\") as InternalModelContext;\n\t\t\t\tconst sTemplateContentView = oPageInternalModelContext.getProperty(`${oPageInternalModelContext.getPath()}/alpContentView`);\n\t\t\t\tif (sTemplateContentView === TemplateContentView.Chart) {\n\t\t\t\t\tthis.hasPendingChartChanges = true;\n\t\t\t\t}\n\t\t\t\tif (sTemplateContentView === TemplateContentView.Table) {\n\t\t\t\t\tthis.hasPendingTableChanges = true;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// store filter bar conditions to use later while navigation\n\t\t\tStateUtil.retrieveExternalState(oFilterBar)\n\t\t\t\t.then((oExternalState: any) => {\n\t\t\t\t\tthis.filterBarConditions = oExternalState.filter;\n\t\t\t\t})\n\t\t\t\t.catch(function (oError: any) {\n\t\t\t\t\tLog.error(\"Error while retrieving the external state\", oError);\n\t\t\t\t});\n\t\t\tif ((this.getView().getViewData() as any).liveMode === false) {\n\t\t\t\tthis.getExtensionAPI().updateAppState();\n\t\t\t}\n\n\t\t\tif (system.phone) {\n\t\t\t\tconst oDynamicPage = this._getDynamicListReportControl();\n\t\t\t\toDynamicPage.setHeaderExpanded(false);\n\t\t\t}\n\t\t},\n\t\t/**\n\t\t * Triggers an outbound navigation when a user chooses the chevron.\n\t\t *\n\t\t * @param oController\n\t\t * @param sOutboundTarget Name of the outbound target (needs to be defined in the manifest)\n\t\t * @param oContext The context that contains the data for the target app\n\t\t * @param sCreatePath Create path when the chevron is created.\n\t\t * @returns Promise which is resolved once the navigation is triggered\n\t\t * @ui5-restricted\n\t\t * @final\n\t\t */\n\t\tonChevronPressNavigateOutBound(\n\t\t\toController: ListReportController,\n\t\t\tsOutboundTarget: string,\n\t\t\toContext: V4Context,\n\t\t\tsCreatePath: string\n\t\t) {\n\t\t\treturn oController._intentBasedNavigation.onChevronPressNavigateOutBound(oController, sOutboundTarget, oContext, sCreatePath);\n\t\t},\n\t\tonChartSelectionChanged(this: ListReportController, oEvent: any) {\n\t\t\tconst oMdcChart = oEvent.getSource().getContent(),\n\t\t\t\toTable = this._getTable(),\n\t\t\t\taData = oEvent.getParameter(\"data\"),\n\t\t\t\toInternalModelContext = this.getView().getBindingContext(\"internal\") as InternalModelContext;\n\t\t\tif (aData) {\n\t\t\t\tChartUtils.setChartFilters(oMdcChart);\n\t\t\t}\n\t\t\tconst sTemplateContentView = oInternalModelContext.getProperty(`${oInternalModelContext.getPath()}/alpContentView`);\n\t\t\tif (sTemplateContentView === TemplateContentView.Chart) {\n\t\t\t\tthis.hasPendingChartChanges = true;\n\t\t\t} else if (oTable) {\n\t\t\t\t(oTable as any).rebind();\n\t\t\t\tthis.hasPendingChartChanges = false;\n\t\t\t}\n\t\t},\n\t\tonSegmentedButtonPressed(this: ListReportController, oEvent: any) {\n\t\t\tconst sSelectedKey = oEvent.mParameters.key ? oEvent.mParameters.key : null;\n\t\t\tconst oInternalModelContext = this.getView().getBindingContext(\"internal\") as InternalModelContext;\n\t\t\toInternalModelContext.setProperty(\"alpContentView\", sSelectedKey);\n\t\t\tconst oChart = this.getChartControl();\n\t\t\tconst oTable = this._getTable();\n\t\t\tconst oSegmentedButtonDelegate = {\n\t\t\t\tonAfterRendering() {\n\t\t\t\t\tconst aItems = oSegmentedButton.getItems();\n\t\t\t\t\taItems.forEach(function (oItem: any) {\n\t\t\t\t\t\tif (oItem.getKey() === sSelectedKey) {\n\t\t\t\t\t\t\toItem.focus();\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t\toSegmentedButton.removeEventDelegate(oSegmentedButtonDelegate);\n\t\t\t\t}\n\t\t\t};\n\t\t\tconst oSegmentedButton = (\n\t\t\t\tsSelectedKey === TemplateContentView.Table ? this._getSegmentedButton(\"Table\") : this._getSegmentedButton(\"Chart\")\n\t\t\t) as SegmentedButton;\n\t\t\tif (oSegmentedButton !== oEvent.getSource()) {\n\t\t\t\toSegmentedButton.addEventDelegate(oSegmentedButtonDelegate);\n\t\t\t}\n\t\t\tswitch (sSelectedKey) {\n\t\t\t\tcase TemplateContentView.Table:\n\t\t\t\t\tthis._updateTable(oTable);\n\t\t\t\t\tbreak;\n\t\t\t\tcase TemplateContentView.Chart:\n\t\t\t\t\tthis._updateChart(oChart);\n\t\t\t\t\tbreak;\n\t\t\t\tcase TemplateContentView.Hybrid:\n\t\t\t\t\tthis._updateTable(oTable);\n\t\t\t\t\tthis._updateChart(oChart);\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t\tthis.getExtensionAPI().updateAppState();\n\t\t},\n\t\tonFiltersSegmentedButtonPressed(this: ListReportController, oEvent: any) {\n\t\t\tconst isCompact = oEvent.getParameter(\"key\") === \"Compact\";\n\t\t\tthis._getFilterBarControl().setVisible(isCompact);\n\t\t\t(this._getVisualFilterBarControl() as Control).setVisible(!isCompact);\n\t\t},\n\t\tonStateChange(this: ListReportController) {\n\t\t\tthis.getExtensionAPI().updateAppState();\n\t\t},\n\t\tonDynamicPageTitleStateChanged(this: ListReportController, oEvent: any) {\n\t\t\tconst filterBar: any = this._getFilterBarControl();\n\t\t\tif (filterBar && filterBar.getSegmentedButton()) {\n\t\t\t\tif (oEvent.getParameter(\"isExpanded\")) {\n\t\t\t\t\tfilterBar.getSegmentedButton().setVisible(true);\n\t\t\t\t} else {\n\t\t\t\t\tfilterBar.getSegmentedButton().setVisible(false);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\tformatters = {\n\t\tsetALPControlMessageStrip(this: ListReportController, aIgnoredFields: any[], bIsChart: any, oApplySupported?: any) {\n\t\t\tlet sText = \"\";\n\t\t\tbIsChart = bIsChart === \"true\" || bIsChart === true;\n\t\t\tconst oFilterBar = this._getFilterBarControl();\n\t\t\tif (oFilterBar && Array.isArray(aIgnoredFields) && aIgnoredFields.length > 0 && bIsChart) {\n\t\t\t\tconst aIgnoredLabels = MessageStrip.getLabels(\n\t\t\t\t\taIgnoredFields,\n\t\t\t\t\toFilterBar.data(\"entityType\"),\n\t\t\t\t\toFilterBar,\n\t\t\t\t\tthis.oResourceBundle as ResourceBundle\n\t\t\t\t);\n\t\t\t\tconst bIsSearchIgnored = !oApplySupported.enableSearch;\n\t\t\t\tsText = bIsChart\n\t\t\t\t\t? MessageStrip.getALPText(aIgnoredLabels, oFilterBar, bIsSearchIgnored)\n\t\t\t\t\t: MessageStrip.getText(aIgnoredLabels, oFilterBar, \"\", DelegateUtil.getLocalizedText);\n\t\t\t\treturn sText;\n\t\t\t}\n\t\t}\n\t};\n}\n\nexport default ListReportController;\n"],"mappings":"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"}