@sapui5/sap.fe.core 1.95.0 → 1.98.0

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

@@ -3,11 +3,20 @@ import { Property } from "@sap-ux/annotation-converter";
 import {
 	AnnotationTerm,
 	UIAnnotationTerms,
+	UIAnnotationTypes,
 	PathAnnotationExpression,
 	CriticalityType,
 	ImprovementDirectionType
 } from "@sap-ux/vocabularies-types";
-import { KPIType, PresentationVariant, ChartDefinitionTypeTypes, DataPoint, TrendType } from "@sap-ux/vocabularies-types/dist/generated/UI";
+import {
+	KPIType,
+	SelectionPresentationVariantType,
+	PresentationVariant,
+	SelectionVariant,
+	DataPoint,
+	Chart,
+	TrendType
+} from "@sap-ux/vocabularies-types/dist/generated/UI";
 import { PropertyPath } from "@sap-ux/vocabularies-types/dist/Edm";
 import ConverterContext from "sap/fe/core/converters/ConverterContext";
 import { KPIID } from "../../helpers/ID";
@@ -17,15 +26,21 @@ 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";
+import { CommonAnnotationTerms, SemanticObject } from "@sap-ux/vocabularies-types/dist/generated/Common";
 
-type KPICardDefinition = {
-	dimensions: string[];
-	measures: string[];
-	cardContentManifest: {
-		chartType: string;
-		dimensions: { label: string; value: string }[];
-		measures: { label: string; value: string }[];
-	};
+export type NavigationInfo = {
+	semanticObject?: string;
+	action?: string;
+	unavailableActions?: string[];
+	outboundNavigation?: string;
+};
+
+export type KPIChartDefinition = {
+	chartType: string;
+	dimensions: { name: string; label: string; role?: string }[];
+	measures: { name: string; label: string; role?: string }[];
+	sortOrder?: { name: string; descending: boolean }[];
+	maxItems?: number;
 };
 
 export type KPIDefinition = {
@@ -54,86 +69,244 @@ export type KPIDefinition = {
 		targetValue?: number;
 		targetPath?: string;
 	};
-	card: KPICardDefinition;
+	chart: KPIChartDefinition;
 	selectionVariantFilterDefinitions?: FilterDefinition[];
+	navigation?: NavigationInfo;
 };
 
-/**
- * Gets a DeviationIndicator enum value from a TrendType enum value.
- *
- * @param {TrendType} trendEnum The trend enum value
- * @returns {DeviationIndicator} Returns the DeviationIndicator enum value
- */
-function getDeviationIndicatorFromTrendType(trendEnum: TrendType): string {
-	let deviationIndicator: string;
-	switch (trendEnum) {
-		case "UI.TrendType/StrongUp":
-		case "UI.TrendType/Up":
-			deviationIndicator = "Up";
-			break;
-		case "UI.TrendType/StrongDown":
-		case "UI.TrendType/Down":
-			deviationIndicator = "Down";
-			break;
-		default:
-			deviationIndicator = "None";
+const DeviationIndicatorFromTrendType: Record<string, string> = {
+	"UI.TrendType/StrongUp": "Up",
+	"UI.TrendType/Up": "Up",
+	"UI.TrendType/StrongDown": "Down",
+	"UI.TrendType/Down": "Down",
+	"UI.TrendType/Sideways": "None"
+};
+
+const KPIChartTypeFromUI: Record<string, string> = {
+	"UI.ChartType/ColumnStacked": "StackedColumn",
+	"UI.ChartType/BarStacked": "StackedBar",
+	"UI.ChartType/Donut": "Donut",
+	"UI.ChartType/Line": "Line",
+	"UI.ChartType/Bubble": "bubble",
+	"UI.ChartType/Column": "column",
+	"UI.ChartType/Bar": "bar",
+	"UI.ChartType/VerticalBullet": "vertical_bullet",
+	"UI.ChartType/Combination": "combination",
+	"UI.ChartType/Scatter": "scatter"
+};
+
+function convertKPIChart(chartAnnotation: Chart, presentationVariantAnnotation: PresentationVariant): KPIChartDefinition | undefined {
+	if (chartAnnotation.Measures === undefined) {
+		// We need at least 1 measure (but no dimension is allowed, e.g. for bubble chart)
+		return undefined;
 	}
-	return deviationIndicator;
-}
 
-function convertKPICardContent(
-	datapointAnnotation: DataPoint,
-	presentationVariantAnnotation?: PresentationVariant
-): KPICardDefinition | undefined {
-	// Find the chart visualization
-	const chart = presentationVariantAnnotation?.Visualizations?.find((viz: any) => {
-		return viz.$target.$Type === "com.sap.vocabularies.UI.v1.ChartDefinitionType";
+	const charDimensions = chartAnnotation.Dimensions
+		? (chartAnnotation.Dimensions as PropertyPath[]).map(propertyPath => {
+				const dimAttribute = chartAnnotation.DimensionAttributes?.find(attribute => {
+					return attribute.Dimension?.value === propertyPath.value;
+				});
+				return {
+					name: propertyPath.value,
+					label: propertyPath.$target.annotations.Common?.Label?.toString() || propertyPath.value,
+					role: dimAttribute?.Role?.replace("UI.ChartDimensionRoleType/", "")
+				};
+		  })
+		: [];
+
+	const chartMeasures = (chartAnnotation.Measures as PropertyPath[]).map(propertyPath => {
+		const measureAttribute = chartAnnotation.MeasureAttributes?.find(attribute => {
+			return attribute.Measure?.value === propertyPath.value;
+		});
+		return {
+			name: propertyPath.value,
+			label: propertyPath.$target.annotations.Common?.Label?.toString() || propertyPath.value,
+			role: measureAttribute?.Role?.replace("UI.ChartMeasureRoleType/", "")
+		};
 	});
 
-	if (chart) {
-		const chartAnnotation = chart.$target as ChartDefinitionTypeTypes;
+	return {
+		chartType: KPIChartTypeFromUI[chartAnnotation.ChartType] || "Line",
+		dimensions: charDimensions,
+		measures: chartMeasures,
+		sortOrder: presentationVariantAnnotation?.SortOrder?.map(sortOrder => {
+			return { name: sortOrder.Property?.value || "", descending: !!sortOrder.Descending };
+		}),
+		maxItems: presentationVariantAnnotation?.MaxItems?.valueOf() as number
+	};
+}
 
-		let chartType: string;
-		switch (chartAnnotation.ChartType) {
-			case "UI.ChartType/ColumnStacked":
-				chartType = "StackedColumn";
-				break;
+function updateCurrency(datapointAnnotation: DataPoint, kpiDef: KPIDefinition): void {
+	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
+			};
+		}
+	}
+}
 
-			case "UI.ChartType/BarStacked":
-				chartType = "StackedBar";
+function updateCriticality(datapointAnnotation: DataPoint, aggregationHelper: AggregationHelper, kpiDef: KPIDefinition): void {
+	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.ChartType/Donut":
-				chartType = "Donut";
+			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:
-				chartType = "Line";
+				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;
+	}
+}
 
-		if (!chartAnnotation.Dimensions || !chartAnnotation.Measures) {
-			return undefined;
+function updateTrend(datapointAnnotation: DataPoint, aggregationHelper: AggregationHelper, kpiDef: KPIDefinition): void {
+	if (datapointAnnotation.Trend) {
+		if (typeof datapointAnnotation.Trend === "object") {
+			// Trend is a path --> check if the corresponding property is aggregatable
+			const trendProperty = (datapointAnnotation.Trend as PathAnnotationExpression<TrendType>).$target as Property;
+			if (aggregationHelper.isPropertyAggregatable(trendProperty)) {
+				kpiDef.datapoint.trendPath = (datapointAnnotation.Trend as PathAnnotationExpression<TrendType>).path;
+			} else {
+				// The property isn't aggregatable --> we ignore it
+				kpiDef.datapoint.trendValue = "None";
+			}
 		} else {
-			return {
-				dimensions: (chartAnnotation.Dimensions as PropertyPath[]).map(propertyPath => propertyPath.value),
-				measures: (chartAnnotation.Measures as PropertyPath[]).map(propertyPath => propertyPath.value),
-				cardContentManifest: {
-					chartType: chartType,
-					dimensions: (chartAnnotation.Dimensions as PropertyPath[]).map(propertyPath => {
-						return {
-							label: propertyPath.$target.annotations.Common?.Label?.toString() || propertyPath.value,
-							value: "{" + propertyPath.value + "}"
-						};
-					}),
-					measures: (chartAnnotation.Measures as PropertyPath[]).map(propertyPath => {
-						return {
-							label: propertyPath.$target.annotations.Common?.Label?.toString() || propertyPath.value,
-							value: "{" + propertyPath.value + "}"
-						};
-					})
-				}
-			};
+			// Trend is an enum Value --> get the corresponding static value
+			kpiDef.datapoint.trendValue = DeviationIndicatorFromTrendType[datapointAnnotation.Trend] || "None";
+		}
+	} else if (datapointAnnotation.TrendCalculation) {
+		kpiDef.datapoint.trendCalculationIsRelative = datapointAnnotation.TrendCalculation.IsRelativeDifference ? true : false;
+		if (datapointAnnotation.TrendCalculation.ReferenceValue.$target) {
+			// Reference value is a path --> check if the corresponding property is aggregatable
+			const referenceProperty = datapointAnnotation.TrendCalculation.ReferenceValue.$target as Property;
+			if (aggregationHelper.isPropertyAggregatable(referenceProperty)) {
+				kpiDef.datapoint.trendCalculationReferencePath = datapointAnnotation.TrendCalculation.ReferenceValue.path;
+			} else {
+				// The property isn't aggregatable --> we ignore it and switch back to trend 'None'
+				kpiDef.datapoint.trendValue = "None";
+			}
+		} else {
+			// Reference value is a static value
+			kpiDef.datapoint.trendCalculationReferenceValue = datapointAnnotation.TrendCalculation.ReferenceValue;
+		}
+		if (kpiDef.datapoint.trendCalculationReferencePath !== undefined || kpiDef.datapoint.trendCalculationReferenceValue !== undefined) {
+			kpiDef.datapoint.trendCalculationTresholds = [
+				datapointAnnotation.TrendCalculation.StrongDownDifference.valueOf() as number,
+				datapointAnnotation.TrendCalculation.DownDifference.valueOf() as number,
+				datapointAnnotation.TrendCalculation.UpDifference.valueOf() as number,
+				datapointAnnotation.TrendCalculation.StrongUpDifference.valueOf() as number
+			];
+		}
+	} else {
+		kpiDef.datapoint.trendValue = "None";
+	}
+}
+
+function updateTarget(datapointAnnotation: DataPoint, aggregationHelper: AggregationHelper, kpiDef: KPIDefinition): void {
+	if (datapointAnnotation.TargetValue) {
+		if (datapointAnnotation.TargetValue.$target) {
+			// Target value is a path --> check if the corresponding property is aggregatable (otherwise ignore)
+			const targetProperty = datapointAnnotation.TargetValue.$target as Property;
+			if (aggregationHelper.isPropertyAggregatable(targetProperty)) {
+				kpiDef.datapoint.targetPath = datapointAnnotation.TargetValue.path;
+			}
+		} else {
+			// Target value is a static value
+			kpiDef.datapoint.targetValue = datapointAnnotation.TargetValue;
+		}
+	}
+}
+
+function getNavigationInfoFromProperty(property: Property): NavigationInfo | undefined {
+	const annotations: Record<string, AnnotationTerm<any>> = property.annotations["Common"] || {};
+
+	// Look for the semanticObject annotation (if any)
+	let semanticObjectAnnotation: AnnotationTerm<SemanticObject> | undefined;
+	Object.keys(annotations).forEach(annotationKey => {
+		const annotation = annotations[annotationKey];
+		if (annotation.term === CommonAnnotationTerms.SemanticObject) {
+			if (!annotation.qualifier || !semanticObjectAnnotation) {
+				// We always take the annotation without qualifier if there's one, otherwise we take the first one
+				semanticObjectAnnotation = annotation;
+			}
+		}
+	});
+
+	if (semanticObjectAnnotation) {
+		const result = {
+			semanticObject: semanticObjectAnnotation.toString(),
+			unavailableActions: []
+		};
+
+		// Look for the unavailable actions (if any)
+		const annotationKey = Object.keys(annotations).find(key => {
+			return (
+				annotations[key].term === CommonAnnotationTerms.SemanticObjectUnavailableActions &&
+				annotations[key].qualifier === semanticObjectAnnotation?.qualifier
+			);
+		});
+		if (annotationKey) {
+			result.unavailableActions = annotations[annotationKey];
 		}
+
+		return result;
 	} else {
 		return undefined;
 	}
@@ -141,241 +314,136 @@ function convertKPICardContent(
 
 function createKPIDefinition(kpiName: string, kpiConfig: KPIConfiguration, converterContext: ConverterContext): KPIDefinition | undefined {
 	const kpiConverterContext = converterContext.getConverterContextFor("/" + kpiConfig.entitySet);
+	const aggregationHelper = new AggregationHelper(kpiConverterContext.getEntityType(), kpiConverterContext);
+
+	if (!aggregationHelper.isAnalyticsSupported()) {
+		// The entity doesn't support analytical queries
+		converterContext
+			.getDiagnostics()
+			.addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.NO_ANALYTICS + kpiConfig.entitySet);
+
+		return undefined;
+	}
+
+	let selectionVariantAnnotation: SelectionVariant | undefined;
+	let datapointAnnotation: DataPoint | undefined;
+	let presentationVariantAnnotation: PresentationVariant | undefined;
+	let chartAnnotation: Chart | undefined;
+	let navigationInfo: NavigationInfo | undefined;
+
+	// Search for a KPI with the qualifier frmo the manifest
 	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) {
+		datapointAnnotation = targetKPI.DataPoint;
+		selectionVariantAnnotation = targetKPI.SelectionVariant;
+		presentationVariantAnnotation = targetKPI.Detail?.DefaultPresentationVariant;
+		chartAnnotation = presentationVariantAnnotation?.Visualizations?.find((viz: any) => {
+			return viz.$target.$Type === UIAnnotationTypes.ChartDefinitionType;
+		})?.$target as Chart;
 
-	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;
+		if (targetKPI.Detail?.SemanticObject) {
+			navigationInfo = {
+				semanticObject: targetKPI.Detail.SemanticObject.toString(),
+				action: targetKPI.Detail.Action?.toString(),
+				unavailableActions: []
+			};
 		}
-
-		// Chart
-		const cardDef = convertKPICardContent(datapointAnnotation, targetKPI.Detail.DefaultPresentationVariant);
-		if (!cardDef) {
-			// Can't find info for the chart
+	} else {
+		// Fallback: try to find a SPV with the same qualifier
+		const aSPVAnnotations = kpiConverterContext.getAnnotationsByTerm(
+			"UI",
+			UIAnnotationTerms.SelectionPresentationVariant
+		) as AnnotationTerm<SelectionPresentationVariantType>[];
+		const targetSPV = aSPVAnnotations.find(spv => {
+			return spv.qualifier === kpiConfig.qualifier;
+		});
+		if (targetSPV) {
+			selectionVariantAnnotation = targetSPV.SelectionVariant;
+			presentationVariantAnnotation = targetSPV.PresentationVariant;
+			datapointAnnotation = presentationVariantAnnotation?.Visualizations?.find((viz: any) => {
+				return viz.$target.$Type === UIAnnotationTypes.DataPointType;
+			})?.$target as DataPoint;
+			chartAnnotation = presentationVariantAnnotation?.Visualizations?.find((viz: any) => {
+				return viz.$target.$Type === UIAnnotationTypes.ChartDefinitionType;
+			})?.$target as Chart;
+		} else {
+			// Couldn't find a KPI or a SPV annotation with the qualifier from the manifest
 			converterContext
 				.getDiagnostics()
-				.addIssue(
-					IssueCategory.Annotation,
-					IssueSeverity.Medium,
-					IssueType.KPI_ISSUES.NO_CHART_VISUALIZATION + kpiConfig.qualifier
-				);
+				.addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.KPI_NOT_FOUND + kpiConfig.qualifier);
+
 			return undefined;
 		}
+	}
 
-		const kpiDef: KPIDefinition = {
-			id: kpiID,
-			entitySet: kpiConfig.entitySet,
-			datapoint: {
-				propertyPath: datapointAnnotation.Value.path,
-				annotationPath: kpiConverterContext.getEntitySetBasedAnnotationPath(datapointAnnotation.fullyQualifiedName),
-				title: datapointAnnotation.Title?.toString(),
-				description: datapointAnnotation.Description?.toString()
-			},
-			selectionVariantFilterDefinitions: targetKPI.SelectionVariant
-				? getFilterDefinitionsFromSelectionVariant(targetKPI.SelectionVariant)
-				: undefined,
-			card: cardDef
-		};
+	if (!presentationVariantAnnotation || !datapointAnnotation || !chartAnnotation) {
+		// Couldn't find a chart or datapoint definition
+		converterContext
+			.getDiagnostics()
+			.addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.KPI_DETAIL_NOT_FOUND + kpiConfig.qualifier);
 
-		// 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
-				};
-			}
-		}
+		return undefined;
+	}
 
-		// 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;
-		}
+	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;
+	}
 
-		// Trend
-		if (datapointAnnotation.Trend) {
-			if (typeof datapointAnnotation.Trend === "object") {
-				// Trend is a path --> check if the corresponding property is aggregatable
-				const trendProperty = (datapointAnnotation.Trend as PathAnnotationExpression<TrendType>).$target as Property;
-				if (aggregationHelper.isPropertyAggregatable(trendProperty)) {
-					kpiDef.datapoint.trendPath = (datapointAnnotation.Trend as PathAnnotationExpression<TrendType>).path;
-				} else {
-					// The property isn't aggregatable --> we ignore it
-					kpiDef.datapoint.trendValue = "None";
-				}
-			} else {
-				// Trend is an enum Value --> get the corresponding static value
-				kpiDef.datapoint.trendValue = getDeviationIndicatorFromTrendType(datapointAnnotation.Trend);
-			}
-		} else if (datapointAnnotation.TrendCalculation) {
-			kpiDef.datapoint.trendCalculationIsRelative = datapointAnnotation.TrendCalculation.IsRelativeDifference ? true : false;
-			if (datapointAnnotation.TrendCalculation.ReferenceValue.$target) {
-				// Reference value is a path --> check if the corresponding property is aggregatable
-				const referenceProperty = datapointAnnotation.TrendCalculation.ReferenceValue.$target as Property;
-				if (aggregationHelper.isPropertyAggregatable(referenceProperty)) {
-					kpiDef.datapoint.trendCalculationReferencePath = datapointAnnotation.TrendCalculation.ReferenceValue.path;
-				} else {
-					// The property isn't aggregatable --> we ignore it and switch back to trend 'None'
-					kpiDef.datapoint.trendValue = "None";
-				}
-			} else {
-				// Reference value is a static value
-				kpiDef.datapoint.trendCalculationReferenceValue = datapointAnnotation.TrendCalculation.ReferenceValue;
-			}
-			if (
-				kpiDef.datapoint.trendCalculationReferencePath !== undefined ||
-				kpiDef.datapoint.trendCalculationReferenceValue !== undefined
-			) {
-				kpiDef.datapoint.trendCalculationTresholds = [
-					datapointAnnotation.TrendCalculation.StrongDownDifference.valueOf() as number,
-					datapointAnnotation.TrendCalculation.DownDifference.valueOf() as number,
-					datapointAnnotation.TrendCalculation.UpDifference.valueOf() as number,
-					datapointAnnotation.TrendCalculation.StrongUpDifference.valueOf() as number
-				];
-			}
-		} else {
-			kpiDef.datapoint.trendValue = "None";
-		}
+	// Chart definition
+	const chartDef = convertKPIChart(chartAnnotation, presentationVariantAnnotation);
+	if (!chartDef) {
+		return undefined;
+	}
 
-		// Target value
-		if (datapointAnnotation.TargetValue) {
-			if (datapointAnnotation.TargetValue.$target) {
-				// Target value is a path --> check if the corresponding property is aggregatable (otherwise ignore)
-				const targetProperty = datapointAnnotation.TargetValue.$target as Property;
-				if (aggregationHelper.isPropertyAggregatable(targetProperty)) {
-					kpiDef.datapoint.targetPath = datapointAnnotation.TargetValue.path;
-				}
-			} else {
-				// Target value is a static value
-				kpiDef.datapoint.targetValue = datapointAnnotation.TargetValue;
-			}
-		}
+	const kpiDef: KPIDefinition = {
+		id: KPIID(kpiName),
+		entitySet: kpiConfig.entitySet,
+		datapoint: {
+			propertyPath: datapointAnnotation.Value.path,
+			annotationPath: kpiConverterContext.getEntitySetBasedAnnotationPath(datapointAnnotation.fullyQualifiedName),
+			title: datapointAnnotation.Title?.toString(),
+			description: datapointAnnotation.Description?.toString()
+		},
+		selectionVariantFilterDefinitions: selectionVariantAnnotation
+			? getFilterDefinitionsFromSelectionVariant(selectionVariantAnnotation)
+			: undefined,
+		chart: chartDef
+	};
 
-		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);
+	// Navigation
+	if (!navigationInfo) {
+		// No navigationInfo was found in the KPI annotation --> try the outbound navigation from the manifest
+		if (kpiConfig.detailNavigation) {
+			navigationInfo = {
+				outboundNavigation: kpiConfig.detailNavigation
+			};
 		} else {
-			// Entity doesn't support analytics
-			converterContext
-				.getDiagnostics()
-				.addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.KPI_ISSUES.NO_ANALYTICS + kpiConfig.entitySet);
+			// No outbound navigation in the manifest --> try the semantic object on the Datapoint value
+			navigationInfo = getNavigationInfoFromProperty(datapointProperty);
 		}
-		return undefined;
 	}
+	if (navigationInfo) {
+		kpiDef.navigation = navigationInfo;
+	}
+
+	updateCurrency(datapointAnnotation, kpiDef);
+	updateCriticality(datapointAnnotation, aggregationHelper, kpiDef);
+	updateTrend(datapointAnnotation, aggregationHelper, kpiDef);
+	updateTarget(datapointAnnotation, aggregationHelper, kpiDef);
+
+	return kpiDef;
 }
 
 /**