@sapui5/sap.fe.core 1.92.0 → 1.93.3

package/src/sap/fe/core/converters/controls/Common/KPI.js

@@ -0,0 +1,181 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["../../helpers/ID", "sap/fe/core/templating/PropertyHelper", "sap/fe/core/formatters/TableFormatterTypes", "../../helpers/Aggregation", "sap/fe/core/converters/helpers/IssueManager", "./Criticality", "sap/fe/core/converters/helpers/SelectionVariantHelper"], function (ID, PropertyHelper, TableFormatterTypes, Aggregation, IssueManager, Criticality, SelectionVariantHelper) {
+  "use strict";
+
+  var _exports = {};
+  var getFilterDefinitionsFromSelectionVariant = SelectionVariantHelper.getFilterDefinitionsFromSelectionVariant;
+  var getMessageTypeFromCriticalityType = Criticality.getMessageTypeFromCriticalityType;
+  var IssueType = IssueManager.IssueType;
+  var IssueSeverity = IssueManager.IssueSeverity;
+  var IssueCategory = IssueManager.IssueCategory;
+  var AggregationHelper = Aggregation.AggregationHelper;
+  var MessageType = TableFormatterTypes.MessageType;
+  var isPathExpression = PropertyHelper.isPathExpression;
+  var KPIID = ID.KPIID;
+
+  function createKPIDefinition(kpiName, kpiConfig, converterContext) {
+    var _targetKPI$Detail;
+
+    var kpiConverterContext = converterContext.getConverterContextFor("/" + kpiConfig.entitySet);
+    var aKPIAnnotations = kpiConverterContext.getAnnotationsByTerm("UI", "com.sap.vocabularies.UI.v1.KPI");
+    var targetKPI = aKPIAnnotations.find(function (kpi) {
+      return kpi.qualifier === kpiConfig.qualifier;
+    });
+    var aggregationHelper = new AggregationHelper(kpiConverterContext.getEntityType(), kpiConverterContext);
+
+    if (targetKPI && ((_targetKPI$Detail = targetKPI.Detail) === null || _targetKPI$Detail === void 0 ? void 0 : _targetKPI$Detail.DefaultPresentationVariant) && aggregationHelper.isAnalyticsSupported()) {
+      var _targetValueProperty$, _targetValueProperty$3;
+
+      var kpiID = KPIID(kpiName); // Datapoint
+
+      var datapointAnnotation = targetKPI.DataPoint;
+      var datapointProperty = datapointAnnotation.Value.$target;
+
+      if (!aggregationHelper.isPropertyAggregatable(datapointProperty)) {
+        // The main property of the KPI is not aggregatable --> We can't calculate its value so we ignore the KPI
+        converterContext.getDiagnostics().addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.MAIN_PROPERTY_NOT_AGGREGATABLE + kpiConfig.qualifier);
+        return undefined;
+      }
+
+      var kpiDef = {
+        id: kpiID,
+        entitySet: kpiConfig.entitySet,
+        datapoint: {
+          propertyPath: datapointAnnotation.Value.path,
+          annotationPath: kpiConverterContext.getEntitySetBasedAnnotationPath(datapointAnnotation.fullyQualifiedName)
+        },
+        selectionVariantFilterDefinitions: targetKPI.SelectionVariant ? getFilterDefinitionsFromSelectionVariant(targetKPI.SelectionVariant) : undefined
+      }; // Unit or currency
+
+      var targetValueProperty = datapointAnnotation.Value.$target;
+
+      if ((_targetValueProperty$ = targetValueProperty.annotations.Measures) === null || _targetValueProperty$ === void 0 ? void 0 : _targetValueProperty$.ISOCurrency) {
+        var _targetValueProperty$2;
+
+        var currency = (_targetValueProperty$2 = targetValueProperty.annotations.Measures) === null || _targetValueProperty$2 === void 0 ? void 0 : _targetValueProperty$2.ISOCurrency;
+
+        if (isPathExpression(currency)) {
+          kpiDef.datapoint.unit = {
+            value: currency.$target.name,
+            isCurrency: true,
+            isPath: true
+          };
+        } else {
+          kpiDef.datapoint.unit = {
+            value: currency.toString(),
+            isCurrency: true,
+            isPath: false
+          };
+        }
+      } else if ((_targetValueProperty$3 = targetValueProperty.annotations.Measures) === null || _targetValueProperty$3 === void 0 ? void 0 : _targetValueProperty$3.Unit) {
+        var _targetValueProperty$4;
+
+        var unit = (_targetValueProperty$4 = targetValueProperty.annotations.Measures) === null || _targetValueProperty$4 === void 0 ? void 0 : _targetValueProperty$4.Unit;
+
+        if (isPathExpression(unit)) {
+          kpiDef.datapoint.unit = {
+            value: unit.$target.name,
+            isCurrency: false,
+            isPath: true
+          };
+        } else {
+          kpiDef.datapoint.unit = {
+            value: unit.toString(),
+            isCurrency: false,
+            isPath: false
+          };
+        }
+      } // Criticality
+
+
+      if (datapointAnnotation.Criticality) {
+        if (typeof datapointAnnotation.Criticality === "object") {
+          // Criticality is a path --> check if the corresponding property is aggregatable
+          var criticalityProperty = datapointAnnotation.Criticality.$target;
+
+          if (aggregationHelper.isPropertyAggregatable(criticalityProperty)) {
+            kpiDef.datapoint.criticalityPath = datapointAnnotation.Criticality.path;
+          } else {
+            // The property isn't aggregatable --> we ignore it
+            kpiDef.datapoint.criticalityValue = MessageType.None;
+          }
+        } else {
+          // Criticality is an enum Value --> get the corresponding static value
+          kpiDef.datapoint.criticalityValue = getMessageTypeFromCriticalityType(datapointAnnotation.Criticality);
+        }
+      } else if (datapointAnnotation.CriticalityCalculation) {
+        kpiDef.datapoint.criticalityCalculationMode = datapointAnnotation.CriticalityCalculation.ImprovementDirection;
+        kpiDef.datapoint.criticalityCalculationThresholds = [];
+
+        switch (kpiDef.datapoint.criticalityCalculationMode) {
+          case "UI.ImprovementDirectionType/Target":
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.DeviationRangeLowValue);
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.ToleranceRangeLowValue);
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.AcceptanceRangeLowValue);
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.AcceptanceRangeHighValue);
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.ToleranceRangeHighValue);
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.DeviationRangeHighValue);
+            break;
+
+          case "UI.ImprovementDirectionType/Minimize":
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.AcceptanceRangeHighValue);
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.ToleranceRangeHighValue);
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.DeviationRangeHighValue);
+            break;
+
+          case "UI.ImprovementDirectionType/Maximize":
+          default:
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.DeviationRangeLowValue);
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.ToleranceRangeLowValue);
+            kpiDef.datapoint.criticalityCalculationThresholds.push(datapointAnnotation.CriticalityCalculation.AcceptanceRangeLowValue);
+        }
+      } else {
+        kpiDef.datapoint.criticalityValue = MessageType.None;
+      }
+
+      return kpiDef;
+    } else {
+      var _targetKPI$Detail2;
+
+      if (!targetKPI) {
+        // Couldn't find a KPI with the qualifier specified in the manifest
+        converterContext.getDiagnostics().addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.KPI_NOT_FOUND + kpiConfig.qualifier);
+      } else if (!((_targetKPI$Detail2 = targetKPI.Detail) === null || _targetKPI$Detail2 === void 0 ? void 0 : _targetKPI$Detail2.DefaultPresentationVariant)) {
+        // No KPI detail/default presentation variant
+        converterContext.getDiagnostics().addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.KPI_DETAIL_NOT_FOUND + kpiConfig.qualifier);
+      } else {
+        // Entity doesn't support analytics
+        converterContext.getDiagnostics().addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.NO_ANALYTICS + kpiConfig.entitySet);
+      }
+
+      return undefined;
+    }
+  }
+  /**
+   * Creates the KPI definitions from the manifest and the annotations.
+   *
+   * @param {ConverterContext} converterContext The converter context for the page
+   * @returns {KPIDefinition[]} Returns an array of KPI definitions
+   */
+
+
+  function getKPIDefinitions(converterContext) {
+    var kpiConfigs = converterContext.getManifestWrapper().getKPIConfiguration(),
+        kpiDefs = [];
+    Object.keys(kpiConfigs).forEach(function (kpiName) {
+      var oDef = createKPIDefinition(kpiName, kpiConfigs[kpiName], converterContext);
+
+      if (oDef) {
+        kpiDefs.push(oDef);
+      }
+    });
+    return kpiDefs;
+  }
+
+  _exports.getKPIDefinitions = getKPIDefinitions;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["KPI.ts"],"names":["createKPIDefinition","kpiName","kpiConfig","converterContext","kpiConverterContext","getConverterContextFor","entitySet","aKPIAnnotations","getAnnotationsByTerm","targetKPI","find","kpi","qualifier","aggregationHelper","AggregationHelper","getEntityType","Detail","DefaultPresentationVariant","isAnalyticsSupported","kpiID","KPIID","datapointAnnotation","DataPoint","datapointProperty","Value","$target","isPropertyAggregatable","getDiagnostics","addIssue","IssueCategory","Annotation","IssueSeverity","Medium","IssueType","KPI_ISSUES","MAIN_PROPERTY_NOT_AGGREGATABLE","undefined","kpiDef","id","datapoint","propertyPath","path","annotationPath","getEntitySetBasedAnnotationPath","fullyQualifiedName","selectionVariantFilterDefinitions","SelectionVariant","getFilterDefinitionsFromSelectionVariant","targetValueProperty","annotations","Measures","ISOCurrency","currency","isPathExpression","unit","value","name","isCurrency","isPath","toString","Unit","Criticality","criticalityProperty","criticalityPath","criticalityValue","MessageType","None","getMessageTypeFromCriticalityType","CriticalityCalculation","criticalityCalculationMode","ImprovementDirection","criticalityCalculationThresholds","push","DeviationRangeLowValue","ToleranceRangeLowValue","AcceptanceRangeLowValue","AcceptanceRangeHighValue","ToleranceRangeHighValue","DeviationRangeHighValue","KPI_NOT_FOUND","KPI_DETAIL_NOT_FOUND","NO_ANALYTICS","getKPIDefinitions","kpiConfigs","getManifestWrapper","getKPIConfiguration","kpiDefs","Object","keys","forEach","oDef"],"mappings":"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","sourceRoot":".","sourcesContent":["import { KPIConfiguration } from \"../../ManifestSettings\";\nimport { Property } from \"@sap-ux/annotation-converter\";\nimport {\n\tAnnotationTerm,\n\tUIAnnotationTerms,\n\tPathAnnotationExpression,\n\tCriticalityType,\n\tImprovementDirectionType\n} from \"@sap-ux/vocabularies-types\";\nimport { KPIType } from \"@sap-ux/vocabularies-types/dist/generated/UI\";\nimport ConverterContext from \"sap/fe/core/converters/ConverterContext\";\nimport { KPIID } from \"../../helpers/ID\";\nimport { isPathExpression } from \"sap/fe/core/templating/PropertyHelper\";\nimport { MessageType } from \"sap/fe/core/formatters/TableFormatterTypes\";\nimport { AggregationHelper } from \"../../helpers/Aggregation\";\nimport { IssueCategory, IssueSeverity, IssueType } from \"sap/fe/core/converters/helpers/IssueManager\";\nimport { getMessageTypeFromCriticalityType } from \"./Criticality\";\nimport { getFilterDefinitionsFromSelectionVariant, FilterDefinition } from \"sap/fe/core/converters/helpers/SelectionVariantHelper\";\n\nexport type KPIDefinition = {\n\tid: string;\n\tentitySet: string;\n\tdatapoint: {\n\t\tannotationPath: string;\n\t\tpropertyPath: string;\n\t\tunit?: {\n\t\t\tvalue: string;\n\t\t\tisPath: boolean;\n\t\t\tisCurrency: boolean;\n\t\t};\n\t\tcriticalityPath?: string;\n\t\tcriticalityValue?: MessageType;\n\t\tcriticalityCalculationMode?: ImprovementDirectionType;\n\t\tcriticalityCalculationThresholds?: (number | undefined | null)[];\n\t};\n\tselectionVariantFilterDefinitions?: FilterDefinition[];\n};\n\nfunction createKPIDefinition(kpiName: string, kpiConfig: KPIConfiguration, converterContext: ConverterContext): KPIDefinition | undefined {\n\tconst kpiConverterContext = converterContext.getConverterContextFor(\"/\" + kpiConfig.entitySet);\n\tconst aKPIAnnotations = kpiConverterContext.getAnnotationsByTerm(\"UI\", UIAnnotationTerms.KPI) as AnnotationTerm<KPIType>[];\n\tconst targetKPI = aKPIAnnotations.find(kpi => {\n\t\treturn kpi.qualifier === kpiConfig.qualifier;\n\t});\n\tconst aggregationHelper = new AggregationHelper(kpiConverterContext.getEntityType(), kpiConverterContext);\n\n\tif (targetKPI && targetKPI.Detail?.DefaultPresentationVariant && aggregationHelper.isAnalyticsSupported()) {\n\t\tconst kpiID = KPIID(kpiName);\n\n\t\t// Datapoint\n\t\tconst datapointAnnotation = targetKPI.DataPoint;\n\t\tconst datapointProperty = datapointAnnotation.Value.$target as Property;\n\t\tif (!aggregationHelper.isPropertyAggregatable(datapointProperty)) {\n\t\t\t// The main property of the KPI is not aggregatable --> We can't calculate its value so we ignore the KPI\n\t\t\tconverterContext\n\t\t\t\t.getDiagnostics()\n\t\t\t\t.addIssue(\n\t\t\t\t\tIssueCategory.Annotation,\n\t\t\t\t\tIssueSeverity.Medium,\n\t\t\t\t\tIssueType.KPI_ISSUES.MAIN_PROPERTY_NOT_AGGREGATABLE + kpiConfig.qualifier\n\t\t\t\t);\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst kpiDef: KPIDefinition = {\n\t\t\tid: kpiID,\n\t\t\tentitySet: kpiConfig.entitySet,\n\t\t\tdatapoint: {\n\t\t\t\tpropertyPath: datapointAnnotation.Value.path,\n\t\t\t\tannotationPath: kpiConverterContext.getEntitySetBasedAnnotationPath(datapointAnnotation.fullyQualifiedName)\n\t\t\t},\n\t\t\tselectionVariantFilterDefinitions: targetKPI.SelectionVariant\n\t\t\t\t? getFilterDefinitionsFromSelectionVariant(targetKPI.SelectionVariant)\n\t\t\t\t: undefined\n\t\t};\n\n\t\t// Unit or currency\n\t\tconst targetValueProperty = datapointAnnotation.Value.$target as Property;\n\t\tif (targetValueProperty.annotations.Measures?.ISOCurrency) {\n\t\t\tconst currency = targetValueProperty.annotations.Measures?.ISOCurrency;\n\t\t\tif (isPathExpression(currency)) {\n\t\t\t\tkpiDef.datapoint.unit = {\n\t\t\t\t\tvalue: ((currency.$target as unknown) as Property).name,\n\t\t\t\t\tisCurrency: true,\n\t\t\t\t\tisPath: true\n\t\t\t\t};\n\t\t\t} else {\n\t\t\t\tkpiDef.datapoint.unit = {\n\t\t\t\t\tvalue: currency.toString(),\n\t\t\t\t\tisCurrency: true,\n\t\t\t\t\tisPath: false\n\t\t\t\t};\n\t\t\t}\n\t\t} else if (targetValueProperty.annotations.Measures?.Unit) {\n\t\t\tconst unit = targetValueProperty.annotations.Measures?.Unit;\n\t\t\tif (isPathExpression(unit)) {\n\t\t\t\tkpiDef.datapoint.unit = {\n\t\t\t\t\tvalue: ((unit.$target as unknown) as Property).name,\n\t\t\t\t\tisCurrency: false,\n\t\t\t\t\tisPath: true\n\t\t\t\t};\n\t\t\t} else {\n\t\t\t\tkpiDef.datapoint.unit = {\n\t\t\t\t\tvalue: unit.toString(),\n\t\t\t\t\tisCurrency: false,\n\t\t\t\t\tisPath: false\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\t// Criticality\n\t\tif (datapointAnnotation.Criticality) {\n\t\t\tif (typeof datapointAnnotation.Criticality === \"object\") {\n\t\t\t\t// Criticality is a path --> check if the corresponding property is aggregatable\n\t\t\t\tconst criticalityProperty = (datapointAnnotation.Criticality as PathAnnotationExpression<CriticalityType>)\n\t\t\t\t\t.$target as Property;\n\t\t\t\tif (aggregationHelper.isPropertyAggregatable(criticalityProperty)) {\n\t\t\t\t\tkpiDef.datapoint.criticalityPath = (datapointAnnotation.Criticality as PathAnnotationExpression<CriticalityType>).path;\n\t\t\t\t} else {\n\t\t\t\t\t// The property isn't aggregatable --> we ignore it\n\t\t\t\t\tkpiDef.datapoint.criticalityValue = MessageType.None;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// Criticality is an enum Value --> get the corresponding static value\n\t\t\t\tkpiDef.datapoint.criticalityValue = getMessageTypeFromCriticalityType(datapointAnnotation.Criticality);\n\t\t\t}\n\t\t} else if (datapointAnnotation.CriticalityCalculation) {\n\t\t\tkpiDef.datapoint.criticalityCalculationMode = datapointAnnotation.CriticalityCalculation.ImprovementDirection;\n\t\t\tkpiDef.datapoint.criticalityCalculationThresholds = [];\n\t\t\tswitch (kpiDef.datapoint.criticalityCalculationMode) {\n\t\t\t\tcase \"UI.ImprovementDirectionType/Target\":\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.DeviationRangeLowValue\n\t\t\t\t\t);\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.ToleranceRangeLowValue\n\t\t\t\t\t);\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.AcceptanceRangeLowValue\n\t\t\t\t\t);\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.AcceptanceRangeHighValue\n\t\t\t\t\t);\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.ToleranceRangeHighValue\n\t\t\t\t\t);\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.DeviationRangeHighValue\n\t\t\t\t\t);\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"UI.ImprovementDirectionType/Minimize\":\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.AcceptanceRangeHighValue\n\t\t\t\t\t);\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.ToleranceRangeHighValue\n\t\t\t\t\t);\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.DeviationRangeHighValue\n\t\t\t\t\t);\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"UI.ImprovementDirectionType/Maximize\":\n\t\t\t\tdefault:\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.DeviationRangeLowValue\n\t\t\t\t\t);\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.ToleranceRangeLowValue\n\t\t\t\t\t);\n\t\t\t\t\tkpiDef.datapoint.criticalityCalculationThresholds.push(\n\t\t\t\t\t\tdatapointAnnotation.CriticalityCalculation.AcceptanceRangeLowValue\n\t\t\t\t\t);\n\t\t\t}\n\t\t} else {\n\t\t\tkpiDef.datapoint.criticalityValue = MessageType.None;\n\t\t}\n\n\t\treturn kpiDef;\n\t} else {\n\t\tif (!targetKPI) {\n\t\t\t// Couldn't find a KPI with the qualifier specified in the manifest\n\t\t\tconverterContext\n\t\t\t\t.getDiagnostics()\n\t\t\t\t.addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.KPI_NOT_FOUND + kpiConfig.qualifier);\n\t\t} else if (!targetKPI.Detail?.DefaultPresentationVariant) {\n\t\t\t// No KPI detail/default presentation variant\n\t\t\tconverterContext\n\t\t\t\t.getDiagnostics()\n\t\t\t\t.addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.KPI_DETAIL_NOT_FOUND + kpiConfig.qualifier);\n\t\t} else {\n\t\t\t// Entity doesn't support analytics\n\t\t\tconverterContext\n\t\t\t\t.getDiagnostics()\n\t\t\t\t.addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.NO_ANALYTICS + kpiConfig.entitySet);\n\t\t}\n\t\treturn undefined;\n\t}\n}\n\n/**\n * Creates the KPI definitions from the manifest and the annotations.\n *\n * @param {ConverterContext} converterContext The converter context for the page\n * @returns {KPIDefinition[]} Returns an array of KPI definitions\n */\nexport function getKPIDefinitions(converterContext: ConverterContext): KPIDefinition[] {\n\tconst kpiConfigs = converterContext.getManifestWrapper().getKPIConfiguration(),\n\t\tkpiDefs: KPIDefinition[] = [];\n\n\tObject.keys(kpiConfigs).forEach(kpiName => {\n\t\tconst oDef = createKPIDefinition(kpiName, kpiConfigs[kpiName], converterContext);\n\t\tif (oDef) {\n\t\t\tkpiDefs.push(oDef);\n\t\t}\n\t});\n\n\treturn kpiDefs;\n}\n"]}

package/src/sap/fe/core/converters/controls/Common/KPI.ts

@@ -0,0 +1,220 @@
+import { KPIConfiguration } from "../../ManifestSettings";
+import { Property } from "@sap-ux/annotation-converter";
+import {
+	AnnotationTerm,
+	UIAnnotationTerms,
+	PathAnnotationExpression,
+	CriticalityType,
+	ImprovementDirectionType
+} from "@sap-ux/vocabularies-types";
+import { KPIType } from "@sap-ux/vocabularies-types/dist/generated/UI";
+import ConverterContext from "sap/fe/core/converters/ConverterContext";
+import { KPIID } from "../../helpers/ID";
+import { isPathExpression } from "sap/fe/core/templating/PropertyHelper";
+import { MessageType } from "sap/fe/core/formatters/TableFormatterTypes";
+import { AggregationHelper } from "../../helpers/Aggregation";
+import { IssueCategory, IssueSeverity, IssueType } from "sap/fe/core/converters/helpers/IssueManager";
+import { getMessageTypeFromCriticalityType } from "./Criticality";
+import { getFilterDefinitionsFromSelectionVariant, FilterDefinition } from "sap/fe/core/converters/helpers/SelectionVariantHelper";
+
+export type KPIDefinition = {
+	id: string;
+	entitySet: string;
+	datapoint: {
+		annotationPath: string;
+		propertyPath: string;
+		unit?: {
+			value: string;
+			isPath: boolean;
+			isCurrency: boolean;
+		};
+		criticalityPath?: string;
+		criticalityValue?: MessageType;
+		criticalityCalculationMode?: ImprovementDirectionType;
+		criticalityCalculationThresholds?: (number | undefined | null)[];
+	};
+	selectionVariantFilterDefinitions?: FilterDefinition[];
+};
+
+function createKPIDefinition(kpiName: string, kpiConfig: KPIConfiguration, converterContext: ConverterContext): KPIDefinition | undefined {
+	const kpiConverterContext = converterContext.getConverterContextFor("/" + kpiConfig.entitySet);
+	const aKPIAnnotations = kpiConverterContext.getAnnotationsByTerm("UI", UIAnnotationTerms.KPI) as AnnotationTerm<KPIType>[];
+	const targetKPI = aKPIAnnotations.find(kpi => {
+		return kpi.qualifier === kpiConfig.qualifier;
+	});
+	const aggregationHelper = new AggregationHelper(kpiConverterContext.getEntityType(), kpiConverterContext);
+
+	if (targetKPI && targetKPI.Detail?.DefaultPresentationVariant && aggregationHelper.isAnalyticsSupported()) {
+		const kpiID = KPIID(kpiName);
+
+		// Datapoint
+		const datapointAnnotation = targetKPI.DataPoint;
+		const datapointProperty = datapointAnnotation.Value.$target as Property;
+		if (!aggregationHelper.isPropertyAggregatable(datapointProperty)) {
+			// The main property of the KPI is not aggregatable --> We can't calculate its value so we ignore the KPI
+			converterContext
+				.getDiagnostics()
+				.addIssue(
+					IssueCategory.Annotation,
+					IssueSeverity.Medium,
+					IssueType.KPI_ISSUES.MAIN_PROPERTY_NOT_AGGREGATABLE + kpiConfig.qualifier
+				);
+			return undefined;
+		}
+
+		const kpiDef: KPIDefinition = {
+			id: kpiID,
+			entitySet: kpiConfig.entitySet,
+			datapoint: {
+				propertyPath: datapointAnnotation.Value.path,
+				annotationPath: kpiConverterContext.getEntitySetBasedAnnotationPath(datapointAnnotation.fullyQualifiedName)
+			},
+			selectionVariantFilterDefinitions: targetKPI.SelectionVariant
+				? getFilterDefinitionsFromSelectionVariant(targetKPI.SelectionVariant)
+				: undefined
+		};
+
+		// Unit or currency
+		const targetValueProperty = datapointAnnotation.Value.$target as Property;
+		if (targetValueProperty.annotations.Measures?.ISOCurrency) {
+			const currency = targetValueProperty.annotations.Measures?.ISOCurrency;
+			if (isPathExpression(currency)) {
+				kpiDef.datapoint.unit = {
+					value: ((currency.$target as unknown) as Property).name,
+					isCurrency: true,
+					isPath: true
+				};
+			} else {
+				kpiDef.datapoint.unit = {
+					value: currency.toString(),
+					isCurrency: true,
+					isPath: false
+				};
+			}
+		} else if (targetValueProperty.annotations.Measures?.Unit) {
+			const unit = targetValueProperty.annotations.Measures?.Unit;
+			if (isPathExpression(unit)) {
+				kpiDef.datapoint.unit = {
+					value: ((unit.$target as unknown) as Property).name,
+					isCurrency: false,
+					isPath: true
+				};
+			} else {
+				kpiDef.datapoint.unit = {
+					value: unit.toString(),
+					isCurrency: false,
+					isPath: false
+				};
+			}
+		}
+
+		// Criticality
+		if (datapointAnnotation.Criticality) {
+			if (typeof datapointAnnotation.Criticality === "object") {
+				// Criticality is a path --> check if the corresponding property is aggregatable
+				const criticalityProperty = (datapointAnnotation.Criticality as PathAnnotationExpression<CriticalityType>)
+					.$target as Property;
+				if (aggregationHelper.isPropertyAggregatable(criticalityProperty)) {
+					kpiDef.datapoint.criticalityPath = (datapointAnnotation.Criticality as PathAnnotationExpression<CriticalityType>).path;
+				} else {
+					// The property isn't aggregatable --> we ignore it
+					kpiDef.datapoint.criticalityValue = MessageType.None;
+				}
+			} else {
+				// Criticality is an enum Value --> get the corresponding static value
+				kpiDef.datapoint.criticalityValue = getMessageTypeFromCriticalityType(datapointAnnotation.Criticality);
+			}
+		} else if (datapointAnnotation.CriticalityCalculation) {
+			kpiDef.datapoint.criticalityCalculationMode = datapointAnnotation.CriticalityCalculation.ImprovementDirection;
+			kpiDef.datapoint.criticalityCalculationThresholds = [];
+			switch (kpiDef.datapoint.criticalityCalculationMode) {
+				case "UI.ImprovementDirectionType/Target":
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.DeviationRangeLowValue
+					);
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.ToleranceRangeLowValue
+					);
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.AcceptanceRangeLowValue
+					);
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.AcceptanceRangeHighValue
+					);
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.ToleranceRangeHighValue
+					);
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.DeviationRangeHighValue
+					);
+					break;
+
+				case "UI.ImprovementDirectionType/Minimize":
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.AcceptanceRangeHighValue
+					);
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.ToleranceRangeHighValue
+					);
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.DeviationRangeHighValue
+					);
+					break;
+
+				case "UI.ImprovementDirectionType/Maximize":
+				default:
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.DeviationRangeLowValue
+					);
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.ToleranceRangeLowValue
+					);
+					kpiDef.datapoint.criticalityCalculationThresholds.push(
+						datapointAnnotation.CriticalityCalculation.AcceptanceRangeLowValue
+					);
+			}
+		} else {
+			kpiDef.datapoint.criticalityValue = MessageType.None;
+		}
+
+		return kpiDef;
+	} else {
+		if (!targetKPI) {
+			// Couldn't find a KPI with the qualifier specified in the manifest
+			converterContext
+				.getDiagnostics()
+				.addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.KPI_NOT_FOUND + kpiConfig.qualifier);
+		} else if (!targetKPI.Detail?.DefaultPresentationVariant) {
+			// No KPI detail/default presentation variant
+			converterContext
+				.getDiagnostics()
+				.addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.KPI_DETAIL_NOT_FOUND + kpiConfig.qualifier);
+		} else {
+			// Entity doesn't support analytics
+			converterContext
+				.getDiagnostics()
+				.addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.NO_ANALYTICS + kpiConfig.entitySet);
+		}
+		return undefined;
+	}
+}
+
+/**
+ * Creates the KPI definitions from the manifest and the annotations.
+ *
+ * @param {ConverterContext} converterContext The converter context for the page
+ * @returns {KPIDefinition[]} Returns an array of KPI definitions
+ */
+export function getKPIDefinitions(converterContext: ConverterContext): KPIDefinition[] {
+	const kpiConfigs = converterContext.getManifestWrapper().getKPIConfiguration(),
+		kpiDefs: KPIDefinition[] = [];
+
+	Object.keys(kpiConfigs).forEach(kpiName => {
+		const oDef = createKPIDefinition(kpiName, kpiConfigs[kpiName], converterContext);
+		if (oDef) {
+			kpiDefs.push(oDef);
+		}
+	});
+
+	return kpiDefs;
+}