@sapui5/sap.fe.core 1.92.0 → 1.93.3

package/src/sap/fe/core/controllerextensions/KPIManagement.js

@@ -0,0 +1,417 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/ui/core/mvc/ControllerExtension", "sap/fe/core/controllerextensions/ControllerExtensionMetadata", "../helpers/ClassSupport", "sap/ui/model/json/JSONModel", "sap/base/Log", "sap/fe/core/CommonUtils", "sap/fe/core/formatters/TableFormatterTypes", "sap/ui/core/format/NumberFormat", "sap/ui/core/Locale", "sap/ui/model/Filter"], function (ControllerExtension, ControllerExtensionMetadata, ClassSupport, JSONModel, Log, CommonUtils, TableFormatterTypes, NumberFormat, Locale, Filter) {
+  "use strict";
+
+  var _dec, _dec2, _dec3, _class, _class2;
+
+  var _exports = {};
+  var MessageType = TableFormatterTypes.MessageType;
+  var Override = ClassSupport.Override;
+  var UI5Class = ClassSupport.UI5Class;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  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 to calculate a message state from a criticality value.
+   *
+   * @param {number|string} criticalityValue The criticality values.
+   * @returns {MessageType} Returns the corresponding MessageType
+   */
+  function messageTypeFromCriticality(criticalityValue) {
+    var criticalityProperty;
+
+    switch (criticalityValue) {
+      case 1:
+        criticalityProperty = MessageType.Error;
+        break;
+
+      case 2:
+        criticalityProperty = MessageType.Warning;
+        break;
+
+      case 3:
+        criticalityProperty = MessageType.Success;
+        break;
+
+      case 5:
+        criticalityProperty = MessageType.Information;
+        break;
+
+      default:
+        criticalityProperty = MessageType.None;
+    }
+
+    return criticalityProperty;
+  }
+  /**
+   * Function to calculate the message state for a criticality calculation of type 'Target'.
+   *
+   * @param {number} kpiValue The value of the KPI to be tested against.
+   * @param {number[]} aThresholds Thresholds to be used [DeviationRangeLowValue,ToleranceRangeLowValue,AcceptanceRangeLowValue,AcceptanceRangeHighValue,ToleranceRangeHighValue,DeviationRangeHighValue].
+   * @returns {MessageType} Returns the corresponding MessageType
+   */
+
+
+  function messageTypeFromTargetCalculation(kpiValue, aThresholds) {
+    var criticalityProperty;
+
+    if (aThresholds[0] !== undefined && aThresholds[0] !== null && kpiValue < aThresholds[0]) {
+      criticalityProperty = MessageType.Error;
+    } else if (aThresholds[1] !== undefined && aThresholds[1] !== null && kpiValue < aThresholds[1]) {
+      criticalityProperty = MessageType.Warning;
+    } else if (aThresholds[2] !== undefined && aThresholds[2] !== null && kpiValue < aThresholds[2]) {
+      criticalityProperty = MessageType.None;
+    } else if (aThresholds[5] !== undefined && aThresholds[5] !== null && kpiValue > aThresholds[5]) {
+      criticalityProperty = MessageType.Error;
+    } else if (aThresholds[4] !== undefined && aThresholds[4] !== null && kpiValue > aThresholds[4]) {
+      criticalityProperty = MessageType.Warning;
+    } else if (aThresholds[3] !== undefined && aThresholds[3] !== null && kpiValue > aThresholds[3]) {
+      criticalityProperty = MessageType.None;
+    } else {
+      criticalityProperty = MessageType.Success;
+    }
+
+    return criticalityProperty;
+  }
+  /**
+   * Function to calculate the message state for a criticality calculation of type 'Minimize'.
+   *
+   * @param {number} kpiValue The value of the KPI to be tested against.
+   * @param {number[]} aThresholds Thresholds to be used [AcceptanceRangeHighValue,ToleranceRangeHighValue,DeviationRangeHighValue].
+   * @returns {MessageType} Returns the corresponding MessageType
+   */
+
+
+  function messageTypeFromMinimizeCalculation(kpiValue, aThresholds) {
+    var criticalityProperty;
+
+    if (aThresholds[2] !== undefined && aThresholds[2] !== null && kpiValue > aThresholds[2]) {
+      criticalityProperty = MessageType.Error;
+    } else if (aThresholds[1] !== undefined && aThresholds[1] !== null && kpiValue > aThresholds[1]) {
+      criticalityProperty = MessageType.Warning;
+    } else if (aThresholds[0] !== undefined && aThresholds[0] !== null && kpiValue > aThresholds[0]) {
+      criticalityProperty = MessageType.None;
+    } else {
+      criticalityProperty = MessageType.Success;
+    }
+
+    return criticalityProperty;
+  }
+  /**
+   * Function to calculate the message state for a criticality calculation of type 'Maximize'.
+   *
+   * @param {number} kpiValue The value of the KPI to be tested against.
+   * @param {number[]} aThresholds Thresholds to be used [DeviationRangeLowValue,ToleranceRangeLowValue,AcceptanceRangeLowValue].
+   * @returns {MessageType} Returns the corresponding MessageType
+   */
+
+
+  function messageTypeFromMaximizeCalculation(kpiValue, aThresholds) {
+    var criticalityProperty;
+
+    if (aThresholds[0] !== undefined && aThresholds[0] !== null && kpiValue < aThresholds[0]) {
+      criticalityProperty = MessageType.Error;
+    } else if (aThresholds[1] !== undefined && aThresholds[1] !== null && kpiValue < aThresholds[1]) {
+      criticalityProperty = MessageType.Warning;
+    } else if (aThresholds[2] !== undefined && aThresholds[2] !== null && kpiValue < aThresholds[2]) {
+      criticalityProperty = MessageType.None;
+    } else {
+      criticalityProperty = MessageType.Success;
+    }
+
+    return criticalityProperty;
+  }
+  /**
+   * Creates a sap.ui.model.Filter from a filter definition.
+   *
+   * @param filterDefinition The filter definition
+   * @returns Returns a sap.ui.model.Filter from the definition, or undefined if the definition is empty (no ranges)
+   */
+
+
+  function createFilterFromDefinition(filterDefinition) {
+    if (filterDefinition.ranges.length === 0) {
+      return undefined;
+    } else if (filterDefinition.ranges.length === 1) {
+      return new Filter(filterDefinition.propertyPath, filterDefinition.ranges[0].operator, filterDefinition.ranges[0].rangeLow, filterDefinition.ranges[0].rangeHigh);
+    } else {
+      var aRangeFilters = filterDefinition.ranges.map(function (range) {
+        return new Filter(filterDefinition.propertyPath, range.operator, range.rangeLow, range.rangeHigh);
+      });
+      return new Filter({
+        filters: aRangeFilters,
+        and: false
+      });
+    }
+  }
+  /**
+   * @class A controller extension for managing KPI in an AnalyticalListPage
+   *
+   * @name sap.fe.core.controllerextensions.KPIManagement
+   * @hideconstructor
+   *
+   * @private
+   * @since 1.93.0
+   */
+
+
+  _exports.createFilterFromDefinition = createFilterFromDefinition;
+  var KPIManagementControllerExtension = (_dec = UI5Class("sap.fe.core.controllerextensions.KPIManagement", ControllerExtensionMetadata), _dec2 = Override(), _dec3 = Override(), _dec(_class = (_class2 = /*#__PURE__*/function (_ControllerExtension) {
+    _inherits(KPIManagementControllerExtension, _ControllerExtension);
+
+    var _super = _createSuper(KPIManagementControllerExtension);
+
+    function KPIManagementControllerExtension() {
+      _classCallCheck(this, KPIManagementControllerExtension);
+
+      return _super.apply(this, arguments);
+    }
+
+    _createClass(KPIManagementControllerExtension, [{
+      key: "onInit",
+      value: function onInit() {
+        var _this = this;
+
+        this.aKPIDefinitions = this.getKPIData();
+
+        if (this.aKPIDefinitions && this.aKPIDefinitions.length) {
+          var oView = this.getView();
+          this.oAppComponent = CommonUtils.getAppComponent(oView); // Create a JSON model to store KPI data
+
+          var oKPIModel = new JSONModel();
+          oView.setModel(oKPIModel, "kpiModel");
+          this.aKPIDefinitions.forEach(function (kpiDefinition) {
+            // Create the manifest for the KPI card and store it in the KPI model
+            var oCardManifest = {
+              "sap.app": {
+                id: "sap.fe",
+                type: "card"
+              },
+              "sap.ui": {
+                technology: "UI5"
+              },
+              "sap.card": {
+                type: "Analytical",
+                data: {
+                  json: {}
+                },
+                header: {
+                  type: "Numeric",
+                  mainIndicator: {
+                    number: "{mainValue}",
+                    unit: "{mainUnit}"
+                  },
+                  title: "{cardTitle}"
+                },
+                content: {
+                  plotArea: {
+                    "dataLabel": {
+                      "visible": false
+                    },
+                    "categoryAxisText": {
+                      "visible": false
+                    },
+                    "valueAxisText": {
+                      "visible": false
+                    }
+                  },
+                  title: {
+                    text: "{chartTitle}",
+                    visible: true,
+                    alignment: "Left"
+                  },
+                  measureAxis: "valueAxis",
+                  dimensionAxis: "categoryAxis",
+                  data: {
+                    path: "/chartData"
+                  }
+                }
+              }
+            };
+            oKPIModel.setProperty("/" + kpiDefinition.id, {
+              manifest: oCardManifest
+            }); // Load tag data for the KPI
+
+            _this.loadKPITagData(kpiDefinition).catch(function (err) {
+              Log.error(err);
+            });
+          });
+        }
+      }
+    }, {
+      key: "onExit",
+      value: function onExit() {
+        var oKPIModel = this.getView().getModel("kpiModel");
+
+        if (oKPIModel) {
+          oKPIModel.destroy();
+        }
+      }
+    }, {
+      key: "getKPIData",
+      value: function getKPIData() {
+        var oView = this.getView(),
+            sCustomData = oView.getContent()[0].data("KPIData");
+
+        if (sCustomData) {
+          var vData = typeof sCustomData === "string" ? JSON.parse(sCustomData) : sCustomData;
+
+          if ("customData" in vData) {
+            return vData["customData"];
+          } else {
+            return vData;
+          }
+        } else {
+          return undefined;
+        }
+      }
+      /**
+       * Loads tag data for a KPI.
+       *
+       * @param {KPIDefinition} kpiDefinition The definition of the KPI.
+       * @returns {Promise} Returns the Promise that is resolved when data is loaded.
+       */
+
+    }, {
+      key: "loadKPITagData",
+      value: function loadKPITagData(kpiDefinition) {
+        var _kpiDefinition$datapo, _kpiDefinition$select;
+
+        var oModel = this.oAppComponent.getModel();
+        var oKPIModel = this.getView().getModel("kpiModel");
+        var oListBinding = oModel.bindList("/" + kpiDefinition.entitySet);
+        var oAggregate = {}; // Main value + currency/unit
+
+        if ((_kpiDefinition$datapo = kpiDefinition.datapoint.unit) === null || _kpiDefinition$datapo === void 0 ? void 0 : _kpiDefinition$datapo.isPath) {
+          oAggregate[kpiDefinition.datapoint.propertyPath] = {
+            unit: kpiDefinition.datapoint.unit.value
+          };
+        } else {
+          oAggregate[kpiDefinition.datapoint.propertyPath] = {};
+        } // Property for criticality
+
+
+        if (kpiDefinition.datapoint.criticalityPath) {
+          oAggregate[kpiDefinition.datapoint.criticalityPath] = {};
+        }
+
+        oListBinding.setAggregation({
+          aggregate: oAggregate
+        }); // Manage SelectionVariant filters
+
+        if ((_kpiDefinition$select = kpiDefinition.selectionVariantFilterDefinitions) === null || _kpiDefinition$select === void 0 ? void 0 : _kpiDefinition$select.length) {
+          var aFilters = kpiDefinition.selectionVariantFilterDefinitions.map(createFilterFromDefinition);
+          oListBinding.filter(aFilters);
+        }
+
+        return oListBinding.requestContexts(0, 1).then(function (aContexts) {
+          if (aContexts.length) {
+            var _kpiDefinition$datapo2, _kpiDefinition$datapo3;
+
+            var currentLocale = new Locale(sap.ui.getCore().getConfiguration().getLanguage());
+            var rawUnit = ((_kpiDefinition$datapo2 = kpiDefinition.datapoint.unit) === null || _kpiDefinition$datapo2 === void 0 ? void 0 : _kpiDefinition$datapo2.isPath) ? aContexts[0].getProperty(kpiDefinition.datapoint.unit.value) : (_kpiDefinition$datapo3 = kpiDefinition.datapoint.unit) === null || _kpiDefinition$datapo3 === void 0 ? void 0 : _kpiDefinition$datapo3.value;
+
+            if (kpiDefinition.datapoint.unit && !rawUnit) {
+              // A unit/currency is defined, but its value is undefined --> multi-unit situation
+              oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainValue", "*");
+              oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainValueUnscaled", "*");
+              oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainUnit", undefined);
+              oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainCriticality", MessageType.None);
+            } else {
+              var _kpiDefinition$datapo4;
+
+              var isPercentage = ((_kpiDefinition$datapo4 = kpiDefinition.datapoint.unit) === null || _kpiDefinition$datapo4 === void 0 ? void 0 : _kpiDefinition$datapo4.isCurrency) === false && rawUnit === "%"; // Main KPI value
+
+              var rawValue = Number.parseFloat(aContexts[0].getProperty(kpiDefinition.datapoint.propertyPath));
+              var kpiValue = NumberFormat.getFloatInstance({
+                style: isPercentage ? undefined : "short",
+                minFractionDigits: 0,
+                maxFractionDigits: 1,
+                showScale: !isPercentage
+              }, currentLocale).format(rawValue);
+              oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainValue", kpiValue);
+              var kpiValueUnscaled = NumberFormat.getFloatInstance({
+                maxFractionDigits: 2,
+                showScale: false,
+                groupingEnabled: true
+              }, currentLocale).format(rawValue);
+              oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainValueUnscaled", kpiValueUnscaled); // Unit or currency
+
+              if (kpiDefinition.datapoint.unit && rawUnit) {
+                if (kpiDefinition.datapoint.unit.isCurrency) {
+                  oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainUnit", rawUnit);
+                } else {
+                  // In case of unit of measure, we have to format it properly
+                  var kpiUnit = NumberFormat.getUnitInstance({
+                    showNumber: false
+                  }, currentLocale).format(rawValue, rawUnit);
+                  oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainUnit", kpiUnit);
+                }
+              } // Criticality
+
+
+              if (kpiDefinition.datapoint.criticalityValue) {
+                // Criticality is a fixed value
+                oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainCriticality", kpiDefinition.datapoint.criticalityValue);
+              } else if (kpiDefinition.datapoint.criticalityPath) {
+                // Criticality comes from another property (via a path)
+                var criticalityValue = messageTypeFromCriticality(aContexts[0].getProperty(kpiDefinition.datapoint.criticalityPath));
+                oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainCriticality", criticalityValue);
+              } else if (kpiDefinition.datapoint.criticalityCalculationThresholds && kpiDefinition.datapoint.criticalityCalculationMode) {
+                // Criticality calculation
+                var calculatedCriticality;
+
+                switch (kpiDefinition.datapoint.criticalityCalculationMode) {
+                  case "UI.ImprovementDirectionType/Target":
+                    calculatedCriticality = messageTypeFromTargetCalculation(rawValue, kpiDefinition.datapoint.criticalityCalculationThresholds);
+                    break;
+
+                  case "UI.ImprovementDirectionType/Minimize":
+                    calculatedCriticality = messageTypeFromMinimizeCalculation(rawValue, kpiDefinition.datapoint.criticalityCalculationThresholds);
+                    break;
+
+                  case "UI.ImprovementDirectionType/Maximize":
+                  default:
+                    calculatedCriticality = messageTypeFromMaximizeCalculation(rawValue, kpiDefinition.datapoint.criticalityCalculationThresholds);
+                    break;
+                }
+
+                oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainCriticality", calculatedCriticality);
+              } else {
+                // No criticality
+                oKPIModel.setProperty("/" + kpiDefinition.id + "/manifest/sap.card/data/json/mainCriticality", MessageType.None);
+              }
+            }
+          }
+        });
+      }
+    }]);
+
+    return KPIManagementControllerExtension;
+  }(ControllerExtension), (_applyDecoratedDescriptor(_class2.prototype, "onInit", [_dec2], Object.getOwnPropertyDescriptor(_class2.prototype, "onInit"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "onExit", [_dec3], Object.getOwnPropertyDescriptor(_class2.prototype, "onExit"), _class2.prototype)), _class2)) || _class);
+  return KPIManagementControllerExtension;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["KPIManagement.ts"],"names":["messageTypeFromCriticality","criticalityValue","criticalityProperty","MessageType","Error","Warning","Success","Information","None","messageTypeFromTargetCalculation","kpiValue","aThresholds","undefined","messageTypeFromMinimizeCalculation","messageTypeFromMaximizeCalculation","createFilterFromDefinition","filterDefinition","ranges","length","Filter","propertyPath","operator","rangeLow","rangeHigh","aRangeFilters","map","range","filters","and","KPIManagementControllerExtension","UI5Class","ControllerExtensionMetadata","Override","aKPIDefinitions","getKPIData","oView","getView","oAppComponent","CommonUtils","getAppComponent","oKPIModel","JSONModel","setModel","forEach","kpiDefinition","oCardManifest","id","type","technology","data","json","header","mainIndicator","number","unit","title","content","plotArea","text","visible","alignment","measureAxis","dimensionAxis","path","setProperty","manifest","loadKPITagData","catch","err","Log","error","getModel","destroy","sCustomData","getContent","vData","JSON","parse","oModel","oListBinding","bindList","entitySet","oAggregate","datapoint","isPath","value","criticalityPath","setAggregation","aggregate","selectionVariantFilterDefinitions","aFilters","filter","requestContexts","then","aContexts","currentLocale","Locale","sap","ui","getCore","getConfiguration","getLanguage","rawUnit","getProperty","isPercentage","isCurrency","rawValue","Number","parseFloat","NumberFormat","getFloatInstance","style","minFractionDigits","maxFractionDigits","showScale","format","kpiValueUnscaled","groupingEnabled","kpiUnit","getUnitInstance","showNumber","criticalityCalculationThresholds","criticalityCalculationMode","calculatedCriticality","ControllerExtension"],"mappings":"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","sourceRoot":".","sourcesContent":["import { ControllerExtension } from \"sap/ui/core/mvc\";\nimport { ControllerExtensionMetadata } from \"sap/fe/core/controllerextensions\";\nimport { UI5Class, Override } from \"../helpers/ClassSupport\";\nimport { JSONModel } from \"sap/ui/model/json\";\nimport { Log } from \"sap/base\";\nimport { KPIDefinition } from \"sap/fe/core/converters/controls/Common/KPI\";\nimport { CommonUtils } from \"sap/fe/core\";\nimport { Context } from \"sap/ui/model/odata/v4\";\nimport { MessageType } from \"sap/fe/core/formatters/TableFormatterTypes\";\nimport { FilterDefinition } from \"sap/fe/core/converters/helpers/SelectionVariantHelper\";\nimport { NumberFormat } from \"sap/ui/core/format\";\nimport { Locale } from \"sap/ui/core\";\nimport { Filter, FilterOperator } from \"sap/ui/model\";\n\n/**\n * Function to calculate a message state from a criticality value.\n *\n * @param {number|string} criticalityValue The criticality values.\n * @returns {MessageType} Returns the corresponding MessageType\n */\nfunction messageTypeFromCriticality(criticalityValue: number | string): MessageType {\n\tlet criticalityProperty: MessageType;\n\n\tswitch (criticalityValue) {\n\t\tcase 1:\n\t\t\tcriticalityProperty = MessageType.Error;\n\t\t\tbreak;\n\t\tcase 2:\n\t\t\tcriticalityProperty = MessageType.Warning;\n\t\t\tbreak;\n\t\tcase 3:\n\t\t\tcriticalityProperty = MessageType.Success;\n\t\t\tbreak;\n\t\tcase 5:\n\t\t\tcriticalityProperty = MessageType.Information;\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tcriticalityProperty = MessageType.None;\n\t}\n\n\treturn criticalityProperty;\n}\n\n/**\n * Function to calculate the message state for a criticality calculation of type 'Target'.\n *\n * @param {number} kpiValue The value of the KPI to be tested against.\n * @param {number[]} aThresholds Thresholds to be used [DeviationRangeLowValue,ToleranceRangeLowValue,AcceptanceRangeLowValue,AcceptanceRangeHighValue,ToleranceRangeHighValue,DeviationRangeHighValue].\n * @returns {MessageType} Returns the corresponding MessageType\n */\nfunction messageTypeFromTargetCalculation(kpiValue: number, aThresholds: (number | undefined | null)[]): MessageType {\n\tlet criticalityProperty: MessageType;\n\n\tif (aThresholds[0] !== undefined && aThresholds[0] !== null && kpiValue < aThresholds[0]) {\n\t\tcriticalityProperty = MessageType.Error;\n\t} else if (aThresholds[1] !== undefined && aThresholds[1] !== null && kpiValue < aThresholds[1]) {\n\t\tcriticalityProperty = MessageType.Warning;\n\t} else if (aThresholds[2] !== undefined && aThresholds[2] !== null && kpiValue < aThresholds[2]) {\n\t\tcriticalityProperty = MessageType.None;\n\t} else if (aThresholds[5] !== undefined && aThresholds[5] !== null && kpiValue > aThresholds[5]) {\n\t\tcriticalityProperty = MessageType.Error;\n\t} else if (aThresholds[4] !== undefined && aThresholds[4] !== null && kpiValue > aThresholds[4]) {\n\t\tcriticalityProperty = MessageType.Warning;\n\t} else if (aThresholds[3] !== undefined && aThresholds[3] !== null && kpiValue > aThresholds[3]) {\n\t\tcriticalityProperty = MessageType.None;\n\t} else {\n\t\tcriticalityProperty = MessageType.Success;\n\t}\n\n\treturn criticalityProperty;\n}\n\n/**\n * Function to calculate the message state for a criticality calculation of type 'Minimize'.\n *\n * @param {number} kpiValue The value of the KPI to be tested against.\n * @param {number[]} aThresholds Thresholds to be used [AcceptanceRangeHighValue,ToleranceRangeHighValue,DeviationRangeHighValue].\n * @returns {MessageType} Returns the corresponding MessageType\n */\nfunction messageTypeFromMinimizeCalculation(kpiValue: number, aThresholds: (number | undefined | null)[]): MessageType {\n\tlet criticalityProperty: MessageType;\n\n\tif (aThresholds[2] !== undefined && aThresholds[2] !== null && kpiValue > aThresholds[2]) {\n\t\tcriticalityProperty = MessageType.Error;\n\t} else if (aThresholds[1] !== undefined && aThresholds[1] !== null && kpiValue > aThresholds[1]) {\n\t\tcriticalityProperty = MessageType.Warning;\n\t} else if (aThresholds[0] !== undefined && aThresholds[0] !== null && kpiValue > aThresholds[0]) {\n\t\tcriticalityProperty = MessageType.None;\n\t} else {\n\t\tcriticalityProperty = MessageType.Success;\n\t}\n\n\treturn criticalityProperty;\n}\n\n/**\n * Function to calculate the message state for a criticality calculation of type 'Maximize'.\n *\n * @param {number} kpiValue The value of the KPI to be tested against.\n * @param {number[]} aThresholds Thresholds to be used [DeviationRangeLowValue,ToleranceRangeLowValue,AcceptanceRangeLowValue].\n * @returns {MessageType} Returns the corresponding MessageType\n */\nfunction messageTypeFromMaximizeCalculation(kpiValue: number, aThresholds: (number | undefined | null)[]): MessageType {\n\tlet criticalityProperty: MessageType;\n\n\tif (aThresholds[0] !== undefined && aThresholds[0] !== null && kpiValue < aThresholds[0]) {\n\t\tcriticalityProperty = MessageType.Error;\n\t} else if (aThresholds[1] !== undefined && aThresholds[1] !== null && kpiValue < aThresholds[1]) {\n\t\tcriticalityProperty = MessageType.Warning;\n\t} else if (aThresholds[2] !== undefined && aThresholds[2] !== null && kpiValue < aThresholds[2]) {\n\t\tcriticalityProperty = MessageType.None;\n\t} else {\n\t\tcriticalityProperty = MessageType.Success;\n\t}\n\n\treturn criticalityProperty;\n}\n\n/**\n * Creates a sap.ui.model.Filter from a filter definition.\n *\n * @param filterDefinition The filter definition\n * @returns Returns a sap.ui.model.Filter from the definition, or undefined if the definition is empty (no ranges)\n */\nexport function createFilterFromDefinition(filterDefinition: FilterDefinition): Filter | undefined {\n\tif (filterDefinition.ranges.length === 0) {\n\t\treturn undefined;\n\t} else if (filterDefinition.ranges.length === 1) {\n\t\treturn new Filter(\n\t\t\tfilterDefinition.propertyPath,\n\t\t\tfilterDefinition.ranges[0].operator as FilterOperator,\n\t\t\tfilterDefinition.ranges[0].rangeLow,\n\t\t\tfilterDefinition.ranges[0].rangeHigh\n\t\t);\n\t} else {\n\t\tconst aRangeFilters = filterDefinition.ranges.map(range => {\n\t\t\treturn new Filter(filterDefinition.propertyPath, range.operator as FilterOperator, range.rangeLow, range.rangeHigh);\n\t\t});\n\t\treturn new Filter({\n\t\t\tfilters: aRangeFilters,\n\t\t\tand: false\n\t\t});\n\t}\n}\n\n/**\n * @class A controller extension for managing KPI in an AnalyticalListPage\n *\n * @name sap.fe.core.controllerextensions.KPIManagement\n * @hideconstructor\n *\n * @private\n * @since 1.93.0\n */\n@UI5Class(\"sap.fe.core.controllerextensions.KPIManagement\", ControllerExtensionMetadata)\nclass KPIManagementControllerExtension extends ControllerExtension {\n\tprotected aKPIDefinitions?: KPIDefinition[];\n\tprotected oAppComponent!: any;\n\n\t@Override()\n\tpublic onInit(): void {\n\t\tthis.aKPIDefinitions = this.getKPIData();\n\n\t\tif (this.aKPIDefinitions && this.aKPIDefinitions.length) {\n\t\t\tconst oView = this.getView();\n\t\t\tthis.oAppComponent = CommonUtils.getAppComponent(oView);\n\n\t\t\t// Create a JSON model to store KPI data\n\t\t\tconst oKPIModel = new JSONModel();\n\t\t\toView.setModel(oKPIModel, \"kpiModel\");\n\n\t\t\tthis.aKPIDefinitions.forEach(kpiDefinition => {\n\t\t\t\t// Create the manifest for the KPI card and store it in the KPI model\n\t\t\t\tconst oCardManifest = {\n\t\t\t\t\t\"sap.app\": {\n\t\t\t\t\t\tid: \"sap.fe\",\n\t\t\t\t\t\ttype: \"card\"\n\t\t\t\t\t},\n\t\t\t\t\t\"sap.ui\": {\n\t\t\t\t\t\ttechnology: \"UI5\"\n\t\t\t\t\t},\n\t\t\t\t\t\"sap.card\": {\n\t\t\t\t\t\ttype: \"Analytical\",\n\t\t\t\t\t\tdata: {\n\t\t\t\t\t\t\tjson: {}\n\t\t\t\t\t\t},\n\t\t\t\t\t\theader: {\n\t\t\t\t\t\t\ttype: \"Numeric\",\n\t\t\t\t\t\t\tmainIndicator: {\n\t\t\t\t\t\t\t\tnumber: \"{mainValue}\",\n\t\t\t\t\t\t\t\tunit: \"{mainUnit}\"\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\ttitle: \"{cardTitle}\"\n\t\t\t\t\t\t},\n\t\t\t\t\t\tcontent: {\n\t\t\t\t\t\t\tplotArea: {\n\t\t\t\t\t\t\t\t\"dataLabel\": {\n\t\t\t\t\t\t\t\t\t\"visible\": false\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\"categoryAxisText\": {\n\t\t\t\t\t\t\t\t\t\"visible\": false\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\"valueAxisText\": {\n\t\t\t\t\t\t\t\t\t\"visible\": false\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\ttitle: {\n\t\t\t\t\t\t\t\ttext: \"{chartTitle}\",\n\t\t\t\t\t\t\t\tvisible: true,\n\t\t\t\t\t\t\t\talignment: \"Left\"\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tmeasureAxis: \"valueAxis\",\n\t\t\t\t\t\t\tdimensionAxis: \"categoryAxis\",\n\t\t\t\t\t\t\tdata: {\n\t\t\t\t\t\t\t\tpath: \"/chartData\"\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\toKPIModel.setProperty(\"/\" + kpiDefinition.id, {\n\t\t\t\t\tmanifest: oCardManifest\n\t\t\t\t});\n\n\t\t\t\t// Load tag data for the KPI\n\t\t\t\tthis.loadKPITagData(kpiDefinition).catch(function(err: any) {\n\t\t\t\t\tLog.error(err);\n\t\t\t\t});\n\t\t\t});\n\t\t}\n\t}\n\n\t@Override()\n\tpublic onExit(): void {\n\t\tconst oKPIModel = this.getView().getModel(\"kpiModel\") as JSONModel;\n\n\t\tif (oKPIModel) {\n\t\t\toKPIModel.destroy();\n\t\t}\n\t}\n\n\tprivate getKPIData(): KPIDefinition[] | undefined {\n\t\tconst oView = this.getView(),\n\t\t\tsCustomData = oView.getContent()[0].data(\"KPIData\");\n\n\t\tif (sCustomData) {\n\t\t\tconst vData = typeof sCustomData === \"string\" ? JSON.parse(sCustomData) : sCustomData;\n\t\t\tif (\"customData\" in vData) {\n\t\t\t\treturn vData[\"customData\"];\n\t\t\t} else {\n\t\t\t\treturn vData;\n\t\t\t}\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\t/**\n\t * Loads tag data for a KPI.\n\t *\n\t * @param {KPIDefinition} kpiDefinition The definition of the KPI.\n\t * @returns {Promise} Returns the Promise that is resolved when data is loaded.\n\t */\n\tprotected loadKPITagData(kpiDefinition: KPIDefinition): any {\n\t\tconst oModel = this.oAppComponent.getModel();\n\t\tconst oKPIModel = this.getView().getModel(\"kpiModel\") as JSONModel;\n\t\tconst oListBinding = oModel.bindList(\"/\" + kpiDefinition.entitySet);\n\t\tconst oAggregate: Record<string, { unit?: string }> = {};\n\n\t\t// Main value + currency/unit\n\t\tif (kpiDefinition.datapoint.unit?.isPath) {\n\t\t\toAggregate[kpiDefinition.datapoint.propertyPath] = { unit: kpiDefinition.datapoint.unit.value };\n\t\t} else {\n\t\t\toAggregate[kpiDefinition.datapoint.propertyPath] = {};\n\t\t}\n\n\t\t// Property for criticality\n\t\tif (kpiDefinition.datapoint.criticalityPath) {\n\t\t\toAggregate[kpiDefinition.datapoint.criticalityPath] = {};\n\t\t}\n\t\toListBinding.setAggregation({ aggregate: oAggregate });\n\n\t\t// Manage SelectionVariant filters\n\t\tif (kpiDefinition.selectionVariantFilterDefinitions?.length) {\n\t\t\tconst aFilters = kpiDefinition.selectionVariantFilterDefinitions.map(createFilterFromDefinition);\n\t\t\toListBinding.filter(aFilters);\n\t\t}\n\n\t\treturn oListBinding.requestContexts(0, 1).then((aContexts: Context[]) => {\n\t\t\tif (aContexts.length) {\n\t\t\t\tconst currentLocale = new Locale(\n\t\t\t\t\tsap.ui\n\t\t\t\t\t\t.getCore()\n\t\t\t\t\t\t.getConfiguration()\n\t\t\t\t\t\t.getLanguage()\n\t\t\t\t);\n\t\t\t\tconst rawUnit = kpiDefinition.datapoint.unit?.isPath\n\t\t\t\t\t? aContexts[0].getProperty(kpiDefinition.datapoint.unit.value)\n\t\t\t\t\t: kpiDefinition.datapoint.unit?.value;\n\n\t\t\t\tif (kpiDefinition.datapoint.unit && !rawUnit) {\n\t\t\t\t\t// A unit/currency is defined, but its value is undefined --> multi-unit situation\n\t\t\t\t\toKPIModel.setProperty(\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainValue\", \"*\");\n\t\t\t\t\toKPIModel.setProperty(\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainValueUnscaled\", \"*\");\n\t\t\t\t\toKPIModel.setProperty(\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainUnit\", undefined);\n\t\t\t\t\toKPIModel.setProperty(\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainCriticality\", MessageType.None);\n\t\t\t\t} else {\n\t\t\t\t\tconst isPercentage = kpiDefinition.datapoint.unit?.isCurrency === false && rawUnit === \"%\";\n\n\t\t\t\t\t// Main KPI value\n\t\t\t\t\tconst rawValue = Number.parseFloat(aContexts[0].getProperty(kpiDefinition.datapoint.propertyPath));\n\t\t\t\t\tconst kpiValue = NumberFormat.getFloatInstance(\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tstyle: isPercentage ? undefined : \"short\",\n\t\t\t\t\t\t\tminFractionDigits: 0,\n\t\t\t\t\t\t\tmaxFractionDigits: 1,\n\t\t\t\t\t\t\tshowScale: !isPercentage\n\t\t\t\t\t\t},\n\t\t\t\t\t\tcurrentLocale\n\t\t\t\t\t).format(rawValue);\n\t\t\t\t\toKPIModel.setProperty(\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainValue\", kpiValue);\n\t\t\t\t\tconst kpiValueUnscaled = NumberFormat.getFloatInstance(\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tmaxFractionDigits: 2,\n\t\t\t\t\t\t\tshowScale: false,\n\t\t\t\t\t\t\tgroupingEnabled: true\n\t\t\t\t\t\t},\n\t\t\t\t\t\tcurrentLocale\n\t\t\t\t\t).format(rawValue);\n\t\t\t\t\toKPIModel.setProperty(\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainValueUnscaled\", kpiValueUnscaled);\n\n\t\t\t\t\t// Unit or currency\n\t\t\t\t\tif (kpiDefinition.datapoint.unit && rawUnit) {\n\t\t\t\t\t\tif (kpiDefinition.datapoint.unit.isCurrency) {\n\t\t\t\t\t\t\toKPIModel.setProperty(\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainUnit\", rawUnit);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// In case of unit of measure, we have to format it properly\n\t\t\t\t\t\t\tconst kpiUnit = NumberFormat.getUnitInstance({ showNumber: false }, currentLocale).format(rawValue, rawUnit);\n\t\t\t\t\t\t\toKPIModel.setProperty(\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainUnit\", kpiUnit);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Criticality\n\t\t\t\t\tif (kpiDefinition.datapoint.criticalityValue) {\n\t\t\t\t\t\t// Criticality is a fixed value\n\t\t\t\t\t\toKPIModel.setProperty(\n\t\t\t\t\t\t\t\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainCriticality\",\n\t\t\t\t\t\t\tkpiDefinition.datapoint.criticalityValue\n\t\t\t\t\t\t);\n\t\t\t\t\t} else if (kpiDefinition.datapoint.criticalityPath) {\n\t\t\t\t\t\t// Criticality comes from another property (via a path)\n\t\t\t\t\t\tconst criticalityValue = messageTypeFromCriticality(\n\t\t\t\t\t\t\taContexts[0].getProperty(kpiDefinition.datapoint.criticalityPath)\n\t\t\t\t\t\t);\n\t\t\t\t\t\toKPIModel.setProperty(\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainCriticality\", criticalityValue);\n\t\t\t\t\t} else if (\n\t\t\t\t\t\tkpiDefinition.datapoint.criticalityCalculationThresholds &&\n\t\t\t\t\t\tkpiDefinition.datapoint.criticalityCalculationMode\n\t\t\t\t\t) {\n\t\t\t\t\t\t// Criticality calculation\n\t\t\t\t\t\tlet calculatedCriticality: MessageType;\n\t\t\t\t\t\tswitch (kpiDefinition.datapoint.criticalityCalculationMode) {\n\t\t\t\t\t\t\tcase \"UI.ImprovementDirectionType/Target\":\n\t\t\t\t\t\t\t\tcalculatedCriticality = messageTypeFromTargetCalculation(\n\t\t\t\t\t\t\t\t\trawValue,\n\t\t\t\t\t\t\t\t\tkpiDefinition.datapoint.criticalityCalculationThresholds\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase \"UI.ImprovementDirectionType/Minimize\":\n\t\t\t\t\t\t\t\tcalculatedCriticality = messageTypeFromMinimizeCalculation(\n\t\t\t\t\t\t\t\t\trawValue,\n\t\t\t\t\t\t\t\t\tkpiDefinition.datapoint.criticalityCalculationThresholds\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase \"UI.ImprovementDirectionType/Maximize\":\n\t\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\t\tcalculatedCriticality = messageTypeFromMaximizeCalculation(\n\t\t\t\t\t\t\t\t\trawValue,\n\t\t\t\t\t\t\t\t\tkpiDefinition.datapoint.criticalityCalculationThresholds\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\toKPIModel.setProperty(\n\t\t\t\t\t\t\t\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainCriticality\",\n\t\t\t\t\t\t\tcalculatedCriticality\n\t\t\t\t\t\t);\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// No criticality\n\t\t\t\t\t\toKPIModel.setProperty(\"/\" + kpiDefinition.id + \"/manifest/sap.card/data/json/mainCriticality\", MessageType.None);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n}\n\nexport default KPIManagementControllerExtension;\n"]}