**TITLE**: Configuring manifest.json for the Analytical List Page (ALP) — OData V2 & V4

**INTRODUCTION**: Quick, code-focused guide to configure the SAP Fiori Elements Analytical List Page (ALP) in manifest.json for both OData V2 and OData V4 apps. Includes intact manifest examples and explicit guidance on settings you must set or avoid for reliable code generation and runtime behavior.

**TAGS**: fiori-elements-framework, analytical-list-page, manifest.json, ALP, OData V2, OData V4, sap.ui.generic.app, sap.fe.templates.ListReport, KPI, tableSettings

STEP: 1 — Enable ALP (OData V2) and core ALP manifest structure

DESCRIPTION: Add an entry to manifest.json under "sap.ui.generic.app" pages. ALP consumes the first page entry. Use component.name = "sap.suite.ui.generic.template.AnalyticalListPage". Ensure the service is an analytical (aggregate) OData service. The sample below is a complete ALP-focused manifest fragment (keep as-is when scaffolded). Key settings explained below the code: tableSettings (type, multiSelect, selectAll, selectionLimit), qualifier, condensedTableLayout, smartVariantManagement, defaultContentView, defaultFilterMode, showGoButtonOnFilterBar, contentTitle (use i18n key), filterDefaultsFromSelectionVariant, allFiltersAsInParameters, keyPerformanceIndicators (model, entitySet, qualifier, detailNavigation, groupId / KPI batching). For inner navigation from ALP to a template, use pages[] inside the ALP page entry (ALP does inner app navigation by default; use navigation.display to configure external target via crossNavigation outbounds).

LANGUAGE: JSON

CODE:
```json
{
  "sap.ui.generic.app": {
    "_version": "1.2.0",
    "settings": {
      "flexibleColumnLayout": {
        "defaultTwoColumnLayoutType": "TwoColumnsBeginExpanded"
      }
    },
    "pages": [
      {
        // This can have multiple page definitions within it. ALP only consumes the first page.
        "entitySet": "SEPMRA_C_ALP_SlsOrdItemCube",
        /*
        Represents the entity set that is used to populate the main content area.
        For parametrized entity set, use result entity set name instead of parametrized entity set.
        */
        "component": {
          "name": "sap.suite.ui.generic.template.AnalyticalListPage", // Should not be changed.
          "list": true,
          "settings": {
            "tableSettings": {
              "type": "GridTable or AnalyticalTable or ResponsiveTable",
              /*
              Use these settings to select a table in ALP. Supports three table types: "AnalyticalTable", "GridTable" & "ResponsiveTable".
              By default, ALP determines the table type when undefined or if there is an incorrect value.
              Note: Do not set "tableType" to "AnalyticalTable" if the underlying service for the main entity set
              is not an aggregate service.
              */
              "multiSelect": true,
              /*
              When true, multiple records in the tabular display can be
              selected. This setting takes effect only if the service has
              defined Actions in annotation or inside ControllerExtension.
              Else, the selection is always single.
              */
              "selectAll": true,
              /*
              Use this setting to select all the rows that are available in the back end with the current filters.
              It triggers only one batch call to select all the records.
              */
              "selectionLimit": 20
              /*
              You can only select 20 rows at a time while selecting a range of rows in the table.
              If selectionLimit is not provided, then a default value of 200 is set to selectionLimit.
              Note: Select all and selection limit are applicable only for GridTable and AnalyticalTable
              */
            },
            "qualifier": "DefaultPresentationVariant",
            /*
            Represents the SelectionPresentationVariant qualifier.
            ALP looks for SelectionPresentationVariant with this qualifier
            and if not found, it looks for PresentationVariant with this qualifier.
            This setting is optional, if this is not provided ALP looks for
            Default LineItem and Chart without qualifiers.
            */
            "condensedTableLayout": true, // When set to false, compact style will be used to render the table.
            "smartVariantManagement": true, // When false, control level variant management is used instead of page level variant management
            "defaultContentView": "charttable", // Determines the visualization of content area. Possible other values: chart or table.
            "defaultFilterMode": "visual", // Determines the filter mode that is used. Possible other value: compact
            "showGoButtonOnFilterBar": false, // Go button is displayed for compact filters when this is set to true
            "contentTitle": "{{contentAreaTitle}}", // Lets you define title for the content area. Ensure that the contentAreaTitle is also defined in i18n.properties
            "autoHide": false,
            "filterDefaultsFromSelectionVariant": false, // Lets you to add default values for FilterBar using SelectionVariant annotation.
            "allFiltersAsInParameters": true, // All filter fields will be set as in parameter.
            "keyPerformanceIndicators": {
              // The first 3 KPIs listed here show up in the KPI tags
              "KPIRevenue": {
                // First KPI
                "model": "kpi",
                /*
                Links to the item in "models" section which provides additional information,
                for example, the data source for the KPI from which we could further obtain the
                data source and annotation corresponding to this KPI. This property must not be empty.
                */
                "entitySet": "SEPMRA_C_ALP_TotalSalesKPI", // Entity set used for bringing up the details displayed within the KPI tag/card.
                "qualifier": "KPIRevenue",
                /* Refers to the UI.KPI annotation. */
                "detailNavigation": "OverviewPage",
                /*
                Points to an element within "outbounds" property of the
                "crossNavigation" section. The details there help us in determining
                the target application as well as the parameters that need to be passed
                upon navigation from the KPI card footer.
                */
                "groupId": "mainKpiGroup"
                /*
                To achieve faster end-to-end response time within analytical list page, enable
                batching of KPIs by defining groupId in the KPI section of the manifest
                file. You can determine which KPIs should be grouped together in a
                given batch call.
                Note:
                -> The KPIs with same data source are batched together. KPIs with same
                groupId and different data source triggers different batch calls.
                -> Batching of KPIs may increase the number of batch calls to the back end.
                */
              }
            } // End of KPIs
          } // End of settings
        },
        "pages": [
          {
            // ALP does an inner app navigation to the smart template specified below
            "entitySet": "SEPMRA_C_ALP_SlsOrdItemCube",
            "component": {
              "name": "<sap.suite.ui.generic.template.ObjectPage>"
            },
            "navigation": {
              // Optional (If specified ALP navigates to the target Application specified below through external app navigation)
              "display": {
                "path": "sap.apps.crossNavigation.outbounds",
                "target": "<NavigateToCTRItem>"
              }
            }
          }
        ]
      }
    ] // End of outer pages
  }
}
```

STEP: 2 — V2 ALP key constraints & actionable rules (compact list for code generation)

DESCRIPTION: Follow these rules when generating or validating manifest.json programmatically:
- ALP requires an analytical (aggregate) backend service. Do not set tableSettings.type to "AnalyticalTable" when service is not aggregate.
- selectionLimit: if omitted defaults to 200. selectAll and selectionLimit apply only to GridTable and AnalyticalTable.
- multiSelect: works only if Actions are defined in annotations or ControllerExtension; otherwise selection remains single.
- qualifier: optional; ALP looks for SelectionPresentationVariant with that qualifier, then PresentationVariant. If absent, ALP uses default LineItem/Chart without qualifier.
- KPI groupId: use to group KPIs into a single batch call (KPIs with same data source AND same groupId are batched). Different data source + same groupId -> separate batch calls.
- contentTitle should reference an i18n key present in i18n.properties.
- Inner navigation: ALP uses pages[] for inner app navigation; use navigation.display.path = "sap.apps.crossNavigation.outbounds" and target = outbound key for external app navigation.

LANGUAGE: text

CODE:
```text
Rules:
- Ensure component.name === "sap.suite.ui.generic.template.AnalyticalListPage"
- Ensure main page is the first element in "sap.ui.generic.app.pages"
- Validate selectionLimit default (200) and allowed use-cases for selectAll/multiSelect
- Validate KPI model/entitySet/qualifier/detailNavigation/groupId presence when using KPIs
```

STEP: 3 — Enable ALP flavor for OData V4 (List Report with views)

DESCRIPTION: In OData V4, ALP is a flavor of the List Report template. Configure the target (usually under "sap.ui5" -> "routing" -> "targets" or in Fiori Launchpad target config) to use "sap.fe.templates.ListReport" and add "options.settings.views" to specify primary/secondary annotation paths and defaultPath ("primary", "secondary", "both"). Primary annotation paths accept UI.Chart, UI.PresentationVariant, or UI.SelectionPresentationVariant. If PresentationVariant/SelectionPresentationVariant is referenced, FE will pick the first chart visualization. If PresentationVariant lacks chart, fallback to default UI.Chart (unqualified). If not found -> blank chart. Secondary supports UI.LineItem, UI.PresentationVariant, UI.SelectionPresentationVariant; similarly, PresentationVariant fallback tries UI.LineItem (unqualified) then blank. Important: do not use arrays for "paths", "primary" or "secondary" — FE does not support arrays here; missing annotationPath leads to app load failure.

LANGUAGE: JSON

CODE:
```json
"targets": {
     "BusinessPartnersList": {
          ………
          "name": "sap.fe.templates.ListReport",
          "options": {
               "settings": {
                    "contextPath": "/BusinessPartners",
                    ………
                    "views": {
                         "paths": [{
                              "primary": [{
                                   "annotationPath": "com.sap.vocabularies.UI.v1.PresentationVariant#ProductSalesPV"
                              }],
                              "secondary": [{
                                   "annotationPath": "com.sap.vocabularies.UI.v1.LineItem"
                              }],
                              "defaultPath": "both"
                         }]
                    },
                    ………
                    ………
               }
          }
     }
}
```

STEP: 4 — V4 annotationPath behavior, defaultPath values, and constraints (reference snippets)

DESCRIPTION: Use these concrete examples when generating manifest fragments or validating annotation references.

LANGUAGE: JSON

CODE:
```json
// defaultPath examples:
{ "defaultPath": "primary" }   // chart-only view
{ "defaultPath": "secondary" } // table-only view
{ "defaultPath": "both" }      // hybrid chart + table view

// Primary annotation path types (allowed):
// - UI.Chart
// - UI.PresentationVariant (FE picks first chart inside it)
// - UI.SelectionPresentationVariant (FE picks first chart inside it)

// Secondary annotation path types (allowed):
// - UI.LineItem
// - UI.PresentationVariant (FE picks first LineItem inside it)
// - UI.SelectionPresentationVariant (FE picks first LineItem inside it)

// Important constraint:
 // Do not use arrays for the "paths", "primary", or "secondary" properties — FE does not support array fallback semantics here.
```

fiori-elements-framework
analytical-list-page
manifest.json
ALP
OData V2
OData V4
sap.ui.generic.app
sap.fe.templates.ListReport
KPI
tableSettings


**TITLE**: Configuring the Overview Page via manifest.json (OVP)

**INTRODUCTION**: Instructions and ready-to-use manifest.json fragments for initializing and configuring a Fiori Overview Page (OVP) application. Includes card definitions, global filter settings, lazy rendering, data load behavior, and container layout options. Use these snippets directly in your app's manifest.json root.

**TAGS**: fiori-elements-framework, SAPUI5, overview-page, manifest.json, OVP, cards, lazy-loading

**STEP**: 1 — Add or update the "sap.ovp" section in manifest.json

**DESCRIPTION**: Add the "sap.ovp" object at the root of your manifest.json to define OVP-specific settings: global filter model/entity, container layout, variant management, date formatting, live filter behavior, data load settings, image support, analytical parameter handling, refresh interval, date range control, lazy rendering, and card definitions. Replace model/entity names and card settings with values appropriate to your app.

**LANGUAGE**: JSON

**CODE**:
```json
"sap.ovp" : { //section for ovp-specific app manifest settings
    "globalFilterModel": "ZModelName", //OData model that contains entity definitions relevant for global filters
    "globalFilterEntityType": "ZFilterEntityType", //Represents the entity to use as a global filter in the smart filter bar control. Deprecated since SAPUI5 1.54.
    "globalFilterEntitySet": "ZFilterEntitySet", //Represents the entity set to use as a global filter in the smart filter bar control. Available from SAPUI5 1.54 onwards.
    "containerLayout": "resizable", //Represents the layout of the card container.
    "smartVariantRequired": true, //Represents a switch to activate smart variant management in the global filters. The default value is true.
    "showDateInRelativeFormat": false, //Represents a switch to enable or disable relative/normal date formatting in OVP applications.
    "enableLiveFilter": false, //Represents the switch to activate live update in the global filters, otherwise a manual update is required by clicking the Go button.
    "dataLoadSettings": {
        "loadDataOnAppLaunch": "ifAnyFilterExist" //Defines the data load behaviour on app launch. Values: 'ifAnyFilterExist'/'always' to auto load data and 'never' to stop the auto data load during application launch.
    },
    "imageSupported": true, //Allows the condensed list card to show images or icons.
    "considerAnalyticalParameters": true, //Flag to enable/disable analytical parameter support for the smart filter bar.
    "refreshIntervalInMinutes": 2, //Time interval in minutes to auto refresh the card models.
    "useDateRangeType": true, //Flag to enable or disable the semantic date range control for the smart filter bar. The default value is false.
    "enableLazyRendering": true, //Cards in the visible view port get rendered. Additional cards are rendered when scrolling. Default value is false.

    "cards": { //An object of cards
        "card01": { //each card contains the following
            "model": "ZCard1Model", //Model for the card
            "template": "sap.ovp.cards.list", //Card component path to use for this card.
            "settings": {
                "title": "card title", //Language-dependent title of the card - used in the card header.
                "subTitle": "sub title", //Language-dependent subtitle of the card - used in the card header.
                "entitySet": "zCard1EntitySet", //Entity set displayed in this card.
                "valueSelectionInfo": "text for KPI Header", //Additional information relevant for the KPI Header.
                "listFlavor": "Standard", //Represents the flavor of the list to use in this card. The flavor can be bar or standard.
                "listType": "Extended", //Represents the type of list to use for this card. The list can be extended to display more information or condensed to take up less space on the card.
                "sortBy": "zPropertyForSort", //Property name to sort by this entity set.
                "sortOrder": "Ascending", //Sort order - ascending or descending.
                "showRefresh": false, // Show or hide the Refresh option under More Actions. The default value is true.
                "staticContent": {}, //Applicable for static link list cards.
                "annotationPath": "", // Represents the annotation path.
                "kpiAnnotationPath": "com.sap.vocabularies.UI.v1.KPI#AllActualCosts", // Represents the KPI annotation path "selectionAnnotationPath": "", // Represents the selection annotation path.
                "chartAnnotationPath": "", //Represents the chart annotation path.
                "presentationAnnotationPath": "", //Represents the presentation annotation path.
                "dataPointAnnotationPath": "", //Represents the data point annotation path.
                "identificationAnnotationPath": "", //Represents the identification annotation path.
                "dynamicSubtitleAnnotationPath": "dynamicSubtitle", //Represents the dynamic subtitle annotation path.
                "requireAppAuthorization": "", //Represents the cards for which authorization is required.
                "chartAnnotationPath": "com.sap.vocabularies.UI.v1.Chart#SalesShareBubble",
                "presentationAnnotationPath": "com.sap.vocabularies.UI.v1.PresentationVariant#SalesShareBubble",
                "identificationAnnotationPath": "com.sap.vocabularies.UI.v1.Identification#Eval_by_Currency_Scatter",
                "selectionAnnotationPath": "com.sap.vocabularies.UI.v1.SelectionVariant#Eval_by_Currency_ColumnStacked",
                "navigation": "noHeaderNav" //Allows you to disable navigation from the analytical list card header area.
            }
        }
    }
}
```

**STEP**: 2 — Important properties and valid values (quick reference)

**DESCRIPTION**: Quick actionable reference for frequently used properties. Copy/paste these fragments into your manifest or use them as models when generating code.

- containerLayout: "resizable" or "fixed"
- enableLazyRendering: true | false
- dataLoadSettings.loadDataOnAppLaunch: "ifAnyFilterExist" | "always" | "never"
- smartVariantRequired: true | false
- enableLiveFilter: true | false
- refreshIntervalInMinutes: integer (minutes)
- imageSupported: true | false
- useDateRangeType: true | false
- globalFilterModel, globalFilterEntitySet: use your OData model and entity set names

**LANGUAGE**: JSON

**CODE**:
```json
{
  "sap.ovp": {
    "containerLayout": "resizable",
    "enableLazyRendering": true,
    "dataLoadSettings": {
      "loadDataOnAppLaunch": "ifAnyFilterExist"
    },
    "smartVariantRequired": true,
    "refreshIntervalInMinutes": 2
  }
}
```

**STEP**: 3 — Enable lazy loading during performance testing (URL parameter)

**DESCRIPTION**: For performance testing or to mimic manifest lazy rendering behavior without changing manifest.json, append the URL parameter sap-fe-xx-lazyloadingtest=true to the app URL. This behaves like setting "enableLazyRendering": true in the manifest.

**LANGUAGE**: text

**CODE**:
```
https://<host>:<port>/sap/bc/ui5_ui5/sap/<app>/index.html?sap-fe-xx-lazyloadingtest=true
```

**STEP**: 4 — Choose and configure Overview Page layout: fixed vs resizable

**DESCRIPTION**: Configure container layout in manifest.json to control card sizing and behavior.

- Resizable layout (recommended): set "containerLayout" to "resizable". End users can resize cards horizontally and vertically within the grid.
- Fixed layout (deprecated): set "containerLayout" to "fixed". Cards have fixed widths; configure default sizes per card. Supports up to four columns. Note: fixed layout deprecated as of SAPUI5 1.142.

When switching from fixed -> resizable, the following end-user/key-user changes made in fixed layout are NOT retained:
- Card arrangements changed by end users using drag and drop.
- Card order changes made by key users using cut and paste.

**LANGUAGE**: JSON

**CODE**:
```json
{
  "sap.ovp": {
    "containerLayout": "fixed"
  }
}
```

```json
{
  "sap.ovp": {
    "containerLayout": "resizable"
  }
}
```

**STEP**: 5 — File location and integration note

**DESCRIPTION**: Put or update the "sap.ovp" section in your project's manifest.json (application root manifest). Ensure models referenced by "globalFilterModel" and each card "model" are declared under the "models" section of manifest.json and that entitySet/annotation paths match your service metadata and annotations.

**LANGUAGE**: JSON

**CODE**:
```json
// manifest.json (root)
{
  "sap.app": { /* app descriptor */ },
  "sap.ui5": {
    "models": {
      "ZModelName": { /* model config */ },
      "ZCard1Model": { /* model config */ }
    }
  },
  "sap.ovp": { /* use fragments from STEP 1 */ }
}
```

fiori-elements-framework SAPUI5 overview-page manifest.json OVP cards lazy-loading


**TITLE**: Configuring the Object Page Header Title and Description

**INTRODUCTION**: Use annotations to set or change the Object Page header Title and Description in SAP Fiori elements. This guide shows three annotation approaches (OData XML annotations, ABAP CDS annotations, and CAP CDS annotations). Each example demonstrates mapping Title and Description to entity properties (including navigation properties) so code generation tools can apply them directly to a service or metadata file.

**TAGS**: fiori-elements-framework, annotations, UI.HeaderInfo, OData, ABAP CDS, CAP CDS, object-page, header, title, description

**STEP**: 1 — OData XML Annotation: Add UI.HeaderInfo to an entity type

**DESCRIPTION**: Edit your OData annotations XML file and add a UI.HeaderInfo annotation targeting the entity type. Set Title and Description as UI.DataField records pointing to the desired properties (can be simple properties or navigation property paths). The example targets STTA_PROD_MAN.STTA_C_MP_ProductType, maps Title to a navigation property to_ProductTextInOriginalLang/Name and Description to ProductForEdit.

**LANGUAGE**: XML

**CODE**:
```xml
<Annotations Target="STTA_PROD_MAN.STTA_C_MP_ProductType">
    <Annotation Term="UI.HeaderInfo">
        <Record>
            <PropertyValue Property="Title">
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="to_ProductTextInOriginalLang/Name"/>
                </Record>
            </PropertyValue>
            <PropertyValue Property="Description">
                <Record Type="UI.DataField">
                     <PropertyValue Property="Value" Path="ProductForEdit"/>
                </Record>
            </PropertyValue>
        </Record>
    </Annotation>
</Annotations>
```

**STEP**: 2 — ABAP CDS Annotation: Add @UI.headerInfo to a CDS view

**DESCRIPTION**: In an ABAP CDS view, use the @UI.headerInfo annotation to define title and description for the UI. Use the title.value and description.value entries to reference fields or localized text identifiers. The example shows a headerInfo block for view STTA_C_MP_PRODUCT (note the annotate statement included for completeness).

**LANGUAGE**: ABAP CDS

**CODE**:
```
@UI.headerInfo: {
  title: {
    value: '_PRODUCTTEXTINORIGINALLANG.NAME',
    type: #STANDARD
  },
  description: {
    value: 'PRODUCTFOREDIT',
    type: #STANDARD
  }
}
annotate view STTA_C_MP_PRODUCT with {

}
```

**STEP**: 3 — CAP CDS Annotation: Annotate entity type with UI.HeaderInfo

**DESCRIPTION**: For CAP (Core Data Services) projects, add an annotation block to the service's CDS where you annotate the entity type. Use UI.HeaderInfo with Title and Description configured as UI.DataField entries. The example annotates STTA_PROD_MAN.STTA_C_MP_ProductType and maps Title to to_ProductTextInOriginalLang.Name and Description to ProductForEdit.

**LANGUAGE**: CDS

**CODE**:
```
annotate STTA_PROD_MAN.STTA_C_MP_ProductType with @(
  UI.HeaderInfo : {
    Title : {
        $Type : 'UI.DataField',
        Value : to_ProductTextInOriginalLang.Name
    },
    Description : {
        $Type : 'UI.DataField',
        Value : ProductForEdit
    }
  }
);
```

**STEP**: 4 — Reference screenshot and related information

**DESCRIPTION**: Visual reference image for the Object Page header: images/Object_Page_Title_and_Subtitle_0430d3e.png. For additional guidance about default titles of new/unnamed objects, see: changing-default-titles-of-new-and-unnamed-objects-63946c0.md.

fiori-elements-framework
annotations
UI.HeaderInfo
OData
ABAP CDS
CAP CDS
object-page
header
title
description


**TITLE**: Configure Table Selection Mode (multiSelect / selectionMode / selectAll / selectionLimit)

**INTRODUCTION**: This guide shows exactly where and how to configure row selection behavior for tables in SAP Fiori Elements apps (OData V2 and V4). It covers switching between single/multiple selection, enabling Select All / Clear All, and limiting selection size. Use the manifest.json settings shown below to apply configuration at the List Report, Object Page, page-level, or table-level.

**TAGS**: fiori-elements-framework, manifest.json, tableSettings, multiSelect, selectionMode, selectAll, selectionLimit, ListReport, ObjectPage, ODataV2, ODataV4

STEP: 1 — OData V2: Enable multiple selection for List Report tables

DESCRIPTION: Set multiSelect:true under the List Report page's tableSettings in manifest.json to switch a table from single selection (default) to multiple selection.

LANGUAGE: JSON

CODE:
```json
"sap.ui.generic.app": {
  "_version": "1.3.0",
  "pages": {
  "ListReport|STTA_C_MP_Product": {
    "entitySet": "STTA_C_MP_Product",
    "component": {
    "name": "sap.suite.ui.generic.template.ListReport",
    "list": true,
    "settings" : {
      "tableSettings": {
        "multiSelect": true
      }
    }

```

STEP: 2 — OData V2: Enable multiple selection for Object Page (page-level)

DESCRIPTION: To enable multiple selection for all tables on an Object Page, set multiSelect:true in the page-level tableSettings.

LANGUAGE: JSON

CODE:
```json
"pages": {
  "ObjectPage|STTA_C_MP_Product": {
  "entitySet": "STTA_C_MP_Product",
  "name": "sap.suite.ui.generic.template.ObjectPage",
    "settings": {
      "showRelatedApps": true,
      "editableHeaderContent": true,
      "tableSettings": {
        "multiSelect": true
      },
      "sections": {
        "to_ProductText::com.sap.vocabularies.UI.v1.LineItem": {
          "navigationProperty": "to_ProductText",
          "entitySet": "STTA_C_MP_ProductText",
          "createMode": "inline"
        }
```

STEP: 3 — OData V2: Enable multiple selection for a specific table (table-level)

DESCRIPTION: To enable multiple selection only for a specific section/table on an Object Page, add tableSettings.multiSelect:true inside that section definition.

LANGUAGE: JSON

CODE:
```json
"pages": {
  "ObjectPage|STTA_C_MP_Product": {
  "entitySet": "STTA_C_MP_Product",
  "name": "sap.suite.ui.generic.template.ObjectPage",
    "settings": {
      "showRelatedApps": true,
      "editableHeaderContent": true,
      "sections": {
        "to_ProductText::com.sap.vocabularies.UI.v1.LineItem": {
          "navigationProperty": "to_ProductText",
          "entitySet": "STTA_C_MP_ProductText",
          "createMode": "inline",
          "tableSettings": {
            "multiSelect": true
          }
        }
```

STEP: 4 — OData V2: Configure Select All / Clear All and selectionLimit

DESCRIPTION: For responsive tables: Select All checkbox appears by default when multiSelect is enabled. To show Clear All instead, set selectAll:false. For Grid/Analytical/Tree tables, Clear All is visible by default when multiSelect is enabled. Use selectionLimit to restrict how many rows can be selected when selectAll is false. Default selectionLimit = 200 (if not configured). selectionLimit applies only to Grid/Analytical/Tree tables.

LANGUAGE: JSON

CODE:
```json
     "tableSettings": {
           "multiSelect": true,
           "selectAll": true/false,
           "selectionLimit": 150  //Applicable only for Grid/Analytical/Tree table types
     }
```

STEP: 5 — OData V2: Notes on Select All behavior and performance

DESCRIPTION: When selectAll:true on Grid/Analytical/Tree tables, the system loads all backend data in multiple sequential requests — enable only if data volume is reasonable. In responsive tables selectAll selects only loaded rows and shows a toast with the number of selected records.

LANGUAGE: JSON

CODE:
```json
// No extra code: behavior note applied when using tableSettings.selectAll in manifest.json
```

STEP: 6 — OData V4: selectionMode values and evaluation rules

DESCRIPTION: Use selectionMode in manifest.json to control selection in Fiori Elements V4. Possible values:
- "Multi" (default): In display mode, multiple selection allowed only if toolbar has actions requiring context (or DataFieldForIntentBasedNavigation). In edit mode, Multi is allowed if a Delete button exists when no context actions.
- "Single": Similar logic but for single selection.
- "None": No selection in display mode; in edit mode selection can still occur if Delete button available.
- "Auto": deprecated.
Note: If bound actions are not enabled for the user, selectionMode evaluates to "None" even if manifest sets "Multi" or "Single". You can force selection via "ForceMulti" or "ForceSingle".

LANGUAGE: JSON

CODE:
```json
// No single code snippet: set selectionMode in tableSettings/controlConfiguration as shown in steps below.
```

STEP: 7 — OData V4: Enable multiple selection for List Report tables

DESCRIPTION: For List Report in V4, set controlConfiguration -> @com.sap.vocabularies.UI.v1.LineItem -> tableSettings -> selectionMode:"Multi" and specify type if needed.

LANGUAGE: JSON

CODE:
```json
"SalesOrderManageList":{
         "type":"Component",
         "id":"SalesOrderManageList",
         "name":"sap.fe.templates.ListReport",
         "options":{
            "settings":{
               "contextPath":"/SalesOrderManage",
               "controlConfiguration":{
                  "@com.sap.vocabularies.UI.v1.LineItem":{
                     "tableSettings":{
                        "type":"ResponsiveTable",
                        "selectionMode":"Multi"
                     }
                  }
               }
            }
         }
      }
```

STEP: 8 — OData V4: Enable multiple selection for Object Page tables (table-level)

DESCRIPTION: Configure selectionMode:"Multi" inside controlConfiguration per LineItem to enable multi selection for a specific table on the Object Page. Also set table type (GridTable, etc.).

LANGUAGE: JSON

CODE:
```json
"SalesOrderManageObjectPage":{
      "type":"Component",
      "id":"SalesOrderManageObjectPage",
      "name":"sap.fe.templates.ObjectPage",
      "options":{
         "settings":{
            "contextPath":"/SalesOrderManage",
            "sectionLayout":"Tabs",
            "controlConfiguration":{
               "_Item/@com.sap.vocabularies.UI.v1.LineItem":{
                  "tableSettings":{
                     "type":"GridTable",
                     "selectionMode":"Multi"
                  }
               }
            }
         }
      }
   }
```

STEP: 9 — OData V4: Configure Select All behavior and override defaults

DESCRIPTION: On List Report: Responsive tables show Select All by default; non-responsive show Clear All by default. On Object Page: Select All default depends on page layout (anchor bar -> enabled, tab bar -> disabled). Override defaults by setting selectAll:true/false in tableSettings within controlConfiguration.

LANGUAGE: JSON

CODE:
```json
"controlConfiguration":{
	"_Item/@com.sap.vocabularies.UI.v1.LineItem":{
		"tableSettings":{
            "type":"GridTable",
            "selectionMode":"Multi",
            "selectAll": true
        }
    }
}
```

STEP: 10 — OData V4: Limit selected rows using selectionLimit

DESCRIPTION: Set selectionLimit in manifest.json (controlConfiguration tableSettings) to limit how many rows can be selected at once in Grid/Tree/Analytical tables. If unset, default = 200.

LANGUAGE: JSON

CODE:
```json
// manifest.json
"SalesOrderManageObjectPage":{
      "type":"Component",
      "id":"SalesOrderManageObjectPage",
      "name":"sap.fe.templates.ObjectPage",
      "options":{
         "settings":{
            "contextPath":"/SalesOrderManage",
            "sectionLayout":"Tabs",
            "controlConfiguration":{
               "_Item/@com.sap.vocabularies.UI.v1.LineItem":{
                  "tableSettings":{
                     "type":"GridTable",
                     "selectionMode":"Multi",
                     "selectionLimit": "50"
                  }
               }
            }
         }
      }
   }
```

STEP: 11 — Summary of key actionable rules

DESCRIPTION:
- For OData V2 use tableSettings.multiSelect (boolean).
- For OData V4 use tableSettings.selectionMode with values "Multi", "Single", "None" (or force variants).
- Use tableSettings.selectAll:true/false to control Select All vs Clear All visibility.
- Use tableSettings.selectionLimit (Grid/Analytical/Tree) to cap selectable rows; default = 200 if not provided.
- Consider performance: selectAll:true on non-responsive tables triggers backend-wide loading in multiple requests — enable only for modest data volumes. In responsive tables selectAll only selects loaded rows and shows a toast.

fiori-elements-framework manifest.json tableSettings multiSelect selectionMode selectAll selectionLimit ListReport ObjectPage ODataV2 ODataV4


**TITLE**: Configuring the Static Link List Card

**INTRODUCTION**: Configure a static link list card (sap.ovp.cards.linklist) to display static items (links, images, icons) as a standard list or carousel. Use listFlavor to choose presentation and populate staticContent with per-item display and navigation properties (URL-based or intent-based).

**TAGS**: fiori-elements-framework, sap.ovp.cards.linklist, linklist, staticContent, listFlavor, targetUri, semanticObject, action, openInNewWindow

**STEP**: 1 — Set card metadata and list flavor

**DESCRIPTION**: Define the card title, subtitle and listFlavor to choose between "standard" (list) or "carousel" presentation. Apply other general settings (e.g., defaultSpan) at the card root as needed.

**LANGUAGE**: JSON

**CODE**:
```json
{
  "card010_QuickLinks": {
    "model": "salesOrder",
    "template": "sap.ovp.cards.linklist",
    "settings": {
      "title": "Quick Links",
      "subTitle": "Standard Link List With Static Data",
      "listFlavor": "standard"
    }
  }
}
```

**STEP**: 2 — Provide staticContent items (display properties)

**DESCRIPTION**: Populate settings.staticContent with an array of items. Each item supports display fields: title, subTitle, imageUri, imageAltText. Images can be local paths (e.g., img/JD.png) or SAP icon URIs (sap-icon://...). Keep display fields filled to ensure accessibility (imageAltText).

**LANGUAGE**: JSON

**CODE**:
```json
"staticContent": [
  {
    "title": "Jim Smith",
    "subTitle": "Sales",
    "imageUri": "img/JD.png",
    "imageAltText": "Jim Smith"
  },
  {
    "title": "Alice Wilson",
    "subTitle": "Sales",
    "imageUri": "img/AW.png",
    "imageAltText": "Alice Wilson"
  }
]
```

**STEP**: 3 — Configure URL-based navigation per item

**DESCRIPTION**: For link navigation to external or internal URLs, add targetUri and openInNewWindow (boolean). When openInNewWindow is true, the card opens the target in a new browser window/tab.

**LANGUAGE**: JSON

**CODE**:
```json
"card010_QuickLinks": {
  "model": "salesOrder",
  "template": "sap.ovp.cards.linklist",
  "settings": {
    "title": "Quick Links",
    "subTitle": "Standard Link List With Static Data",
    "listFlavor": "standard",
    "staticContent": [
      {
        "title": "Jim Smith",
        "subTitle": "Sales",
        "imageUri": "img/JD.png",
        "imageAltText": "Jim Smith",
        "targetUri": "https://abc.com",
        "openInNewWindow": true
      },
      {
        "title": "Alice Wilson",
        "subTitle": "Sales",
        "imageUri": "img/AW.png",
        "imageAltText": "Jim Smith",
        "targetUri": "https://abc.com",
        "openInNewWindow": true
      }
    ]
  }
}
```

**STEP**: 4 — Configure Intent-Based Navigation per item

**DESCRIPTION**: For SAP Fiori intent navigation, set semanticObject and action on each item. Optionally include display properties and additional flags like disableInCard. Use sap-icon URIs for icons when appropriate. You can also include card-level layout settings (e.g., defaultSpan).

**LANGUAGE**: JSON

**CODE**:
```json
"card010_QuickLinks": {
  "model": "salesOrder",
  "template": "sap.ovp.cards.linklist",
  "settings": {
    "title": "Quick Links",
    "subTitle": "Standard Link List With Static Data",
    "listFlavor": "standard",
    "defaultSpan": {
      "rows": 15,
      "cols": 1
    },
    "staticContent": [
      {
        "title": "Create Purchase Order",
        "imageUri": "sap-icon://Fiori6/F0865",
        "imageAltText": "{{card30_icon_prod_man}}",
        "semanticObject": "Action",
        "action": "toappnavsample",
        "disableInCard": true
      },
      {
        "title": "Create Supplier",
        "imageUri": "sap-icon://Fiori2/F0246",
        "imageAltText": "{{card30_icon_so_man}}",
        "semanticObject": "Action",
        "action": "toappnavsample"
      },
      {
        "title": "Create Contact",
        "imageUri": "sap-icon://Fiori6/F0866",
        "imageAltText": "{{card30_icon_so_man}}",
        "semanticObject": "Action",
        "action": "toappnavsample"
      }
    ]
  }
}
```

Configuring the Static Link List Card

fiori-elements-framework sap.ovp.cards.linklist linklist staticContent listFlavor targetUri semanticObject action openInNewWindow


**TITLE**: Configuring the Table Area (LineItem, DataField, DataFieldForAnnotation, Navigation)

**INTRODUCTION**: This document instructs how to configure table columns for Fiori elements using the UI.LineItem annotation and related annotations. It provides concrete examples in XML annotations, ABAP CDS, and CAP CDS to define column labels, values, numeric DataPoints, contact quick views, and navigation properties.

**TAGS**: fiori-elements-framework, UI.LineItem, DataField, DataFieldForAnnotation, DataPoint, Contact, DataFieldForIntentBasedNavigation, DataFieldWithUrl, ABAP CDS, CAP CDS, XML

**STEP**: 1 — Define LineItem DataField entries for table columns

**DESCRIPTION**: Add UI.LineItem (qualified) entries to define table columns. Use DataField records to set Label (column header) and Value (path to property). Examples include standard value paths, navigation property paths, and referencing a DataPoint via DataFieldForAnnotation.

**LANGUAGE**: XML

**CODE**:
```xml
<Annotation Term="com.sap.vocabularies.UI.v1.LineItem" Qualifier="View4">
   <Collection>
      <Record Type="com.sap.vocabularies.UI.v1.DataField">
         <PropertyValue Property="Label" String="Order ID" />
         <PropertyValue Property="Value" Path="SalesOrderID" />
      </Record>
      <Record Type="com.sap.vocabularies.UI.v1.DataField">
         <PropertyValue Property="Label" String="Customer" />
         <PropertyValue Property="Value" Path="ToBusinessPartner/EmailAddress" />
      </Record>
      <Record Type="com.sap.vocabularies.UI.v1.DataField">
         <PropertyValue Property="Label" String="Customer" />
         <PropertyValue Property="Value" Path="CustomerName" />
      </Record>
      <Record Type="com.sap.vocabularies.UI.v1.DataFieldForAnnotation">
         <PropertyValue Property="Label" String="TaxAmount" />
         <PropertyValue Property="Target" AnnotationPath="@com.sap.vocabularies.UI.v1.DataPoint#TaxAmount" />
      </Record>
   </Collection>
</Annotation>
```

**LANGUAGE**: ABAP CDS

**CODE**:
```abap
@UI.lineItem: [
  {
    label: 'Order ID',
    position: 10 ,
    qualifier: 'View4'
  }
]
SALESORDERID;

@UI.lineItem: [
  {
    label: 'Customer',
    value: '_BUSINESSPARTNER.EMAILADDRESS',
    position: 20 ,
    qualifier: 'View4'
  }
]
_BUSINESSPARTNER;

@UI.lineItem: [
  {
    label: 'Customer',
    position: 30,
    qualifier: 'View4'
  }
]
CUSTOMERNAME;

@UI.lineItem: [
  {
    label: 'TaxAmount',
    valueQualifier: 'TaxAmount',
    type: #AS_DATAPOINT,
    position: 40,
    qualifier: 'View4'
  }
]
PROPERT_NAME;
```

**LANGUAGE**: CAP CDS

**CODE**:
```cds
UI.LineItem #View4 : [
    {
        $Type : 'UI.DataField',
        Label : 'Order ID',
        Value : SalesOrderID
    },
    {
        $Type : 'UI.DataField',
        Label : 'Customer',
        Value : ToBusinessPartner.EmailAddress
    },
    {
        $Type : 'UI.DataField',
        Label : 'Customer',
        Value : CustomerName
    },
    {
        $Type : 'UI.DataFieldForAnnotation',
        Label : 'TaxAmount',
        Target : '@UI.DataPoint#TaxAmount'
    }
]
```

**STEP**: 2 — (Optional) Use DataFieldForAnnotation: DataPoint (numeric values)

**DESCRIPTION**: Create a DataPoint annotation and reference it from a DataFieldForAnnotation in the LineItem to render numeric values with DataPoint semantics (title and value). Examples show XML, ABAP CDS, and CAP CDS DataPoint definitions. Reference the DataPoint via AnnotationPath / valueQualifier or Target depending on notation.

**LANGUAGE**: XML

**CODE**:
```xml
<Annotation Term="com.sap.vocabularies.UI.v1.DataPoint" Qualifier="TaxAmount">
   <Record Type="com.sap.vocabularies.UI.v1.DataPointType">
      <PropertyValue Property="Title" String="TaxAmount" />
      <PropertyValue Property="Value" Path="TaxAmount" />
   </Record>
</Annotation>
```

**LANGUAGE**: ABAP CDS

**CODE**:
```abap
@UI.dataPoint: {
  title: 'TaxAmount'
}
TaxAmount;
```

**LANGUAGE**: CAP CDS

**CODE**:
```cds
UI.DataPoint #TaxAmount : {
    $Type : 'UI.DataPointType',
    Title : 'TaxAmount',
    Value : TaxAmount
}
```

**STEP**: 3 — (Optional) Use DataFieldForAnnotation: Contact (quick view contact info)

**DESCRIPTION**: Define a Contact annotation to provide quick-view contact details such as telephone and email that can be surfaced in the table (card quick view). Examples provided for XML and CAP CDS show tel and email collections and types.

**LANGUAGE**: XML

**CODE**:
```xml
<Annotation Term="com.sap.vocabularies.Communication.v1.Contact">
   <Record>
      <PropertyValue Property="tel">
         <Collection>
            <Record>
               <PropertyValue Property="type" EnumMember="com.sap.vocabularies.Communication.v1.PhoneType/fax" />
               <PropertyValue Property="uri" Path="FaxNumber" />
            </Record>
            <Record>
               <PropertyValue Property="type" EnumMember="com.sap.vocabularies.Communication.v1.PhoneType/work com.sap.vocabularies.Communication.v1.PhoneType/preferred"/>
               <PropertyValue Property="uri" Path="PhoneNumber" />
            </Record>
         </Collection>
      </PropertyValue>
      <PropertyValue Property="email">
         <Collection>
            <Record>
               <PropertyValue Property="type" EnumMember="com.sap.vocabularies.Communication.v1.ContactInformationType/preferred com.sap.vocabularies.Communication.v1.ContactInformationType/work" />
               <PropertyValue Property="address" Path="EmailAddress" />
            </Record>
         </Collection>
      </PropertyValue>
   </Record>
</Annotation>
```

**LANGUAGE**: CAP CDS

**CODE**:
```cds
Communication.Contact : {
    tel : [
        {
            type : #fax,
            uri : FaxNumber
        },
        {
            type : [ #work, #pref ],
            uri : PhoneNumber
        }
    ],
    email : [
        {
            type : [ #pref, #work ],
            address : EmailAddress
        }
    ]
}
```

**STEP**: 4 — (Optional) Configure navigation for table entries

**DESCRIPTION**: For navigation from table rows or cells, prefer DataFieldForIntentBasedNavigation to configure intent-based (Fiori launchpad) navigation. Use DataFieldWithUrl when linking to a specific application route or external website (non-target-map route). The overview page will treat DataFieldWithUrl as intent-based navigation and open the application in the same tab with context.

**LANGUAGE**: Text

**CODE**:
```text
- Use com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation to define intent-based navigation to SAP Fiori applications.
- Use com.sap.vocabularies.UI.v1.DataFieldWithUrl to configure navigation to external apps and websites or specific application routes not in the target mapping.

Note:
The recommended way to configure intent-based navigation is by using the DataFieldForIntentBasedNavigation property. However, you can also use DataFieldWithUrl for navigating to a specific application route that is not configured as target map. The overview page identifies this as an intent-based navigation and opens the application in the same tab with relevant context.
```

fiori-elements-framework
UI.LineItem
DataField
DataFieldForAnnotation
DataPoint
Contact
DataFieldForIntentBasedNavigation
DataFieldWithUrl
ABAP CDS
CAP CDS
XML


**TITLE**: Configuring the Table Card Header Area (Optional)

**INTRODUCTION**: Steps and code samples to configure the table card header in an SAP Fiori Elements OVP app: set title/subtitle in manifest.json, point the card to a KPI DataPoint annotation, provide DataPoint annotation examples (XML, ABAP CDS, CAP CDS), configure card-level view switch (tabs) and selection, and define criticality settings for KPI visualization. Use these exact snippets in your app descriptor and metadata annotations.

**TAGS**: fiori-elements-framework, sap.ovp, manifest.json, DataPoint, KPI, table-card, header, view-switch, annotations

STEP: 1 — Configure card title and subtitle in manifest.json

DESCRIPTION: In the application descriptor (manifest.json) set the card title, subTitle and entitySet under sap.ovp.cards.<cardId>. Use the card template "sap.ovp.cards.table" and set the model and entitySet for the table card.

LANGUAGE: JSON

CODE:
```json
"sap.ovp": {
"globalFilterModel": "salesOrder",
"globalFilterEntityType": "GlobalFilters", //Deprecated since SAPUI5 1.54.
"globalFilterEntitySet": "GlobalFilters", //Available from SAPUI5 1.54.
      ...
      ...
"cards": {
  "card014": {
    "model": "salesOrder",
    "template": "sap.ovp.cards.table",
    "settings": {
       "title": "Sales Forecast",
       "subTitle": "per Supplier",
       "entitySet": "SalesShare",
    ...
    ...
      }
    ]
  }
},
```

STEP: 2 — Point the card to a KPI annotation path (kpiAnnotationPath) in manifest.json

DESCRIPTION: Use kpiAnnotationPath under sap.ovp to reference an existing KPI/DataPoint annotation qualifier. This tells the card which KPI annotation to render in the header.

LANGUAGE: JSON

CODE:
```json
"sap.ovp": {//section for ovp-specific app descriptor settings
	...
	"kpiAnnotationPath":"com.sap.vocabularies.UI.v1.KPI#AllActualCosts", // Represents the KPI annotation path
     ...
}
}
```

STEP: 3 — Define the UI.DataPoint annotation (XML example)

DESCRIPTION: Add a UI.DataPoint annotation in the service metadata (XML) to define the KPI shown in the card header. Include Title, Value, ValueFormat, CriticalityCalculation, TargetValue, TrendCalculation. Use Qualifier to reference the annotation from kpiAnnotationPath or card settings.

LANGUAGE: XML

CODE:
```xml
<Annotation Term="UI.DataPoint" Qualifier="Eval_by_Country_Generic">
   <Record Type="UI.DataPointType">
      <PropertyValue Property="Title" String="Sales India - Generic Card" />
      <PropertyValue Property="Value" Path="Sales" />
      <PropertyValue Property="ValueFormat">
         <Record>
            <PropertyValue Property="ScaleFactor" Decimal="2" />
            <PropertyValue Property="NumberOfFractionalDigits" Int="1" />
         </Record>
      </PropertyValue>
      <PropertyValue Property="CriticalityCalculation">
         <Record>
            <PropertyValue Property="ImprovementDirection" EnumMember="UI.ImprovementDirectionType/Minimize" />
            <PropertyValue Property="DeviationRangeHighValue" String="7300" />
            <PropertyValue Property="ToleranceRangeHighValue" String="7200" />
         </Record>
      </PropertyValue>
      <PropertyValue Property="TargetValue" String="2.000 " />
      <PropertyValue Property="TrendCalculation">
         <Record>
            <PropertyValue Property="ReferenceValue" String="5201680" />
            <PropertyValue Property="DownDifference" Decimal="10000000.0" />
         </Record>
      </PropertyValue>
   </Record>
</Annotation>
```

STEP: 4 — Define the DataPoint in ABAP CDS (example)

DESCRIPTION: If using ABAP CDS, add UI.dataPoint annotation with same properties—title, valueFormat, criticalityCalculation, targetValue, trendCalculation—so the card can consume the KPI.

LANGUAGE: ABAP

CODE:
```
@UI.dataPoint: {
	 title: 'Sales India - Generic Card',
	 valueFormat: { scaleFactor: 2, numberOfFractionalDigits: 1 },
	 criticalityCalculation: {
	   improvementDirection: #MINIMIZE,
	   deviationRangeHighValue: 7300,
	   toleranceRangeHighValue: 7200
	 },
	 targetValue: 2.000,
	 trendCalculation: { referenceValue: 'refValElement', downDifference: 10000000.0 }
}
Sales;
```

STEP: 5 — Define the DataPoint in CAP CDS (example)

DESCRIPTION: For CAP-based projects, add a UI.DataPoint annotation block in your CDS model with the same fields. Use the qualifier name to reference it.

LANGUAGE: CDS

CODE:
```
UI.DataPoint #Eval_by_Country-Generic : {
    $Type : 'UI.DataPointType',
    Title : 'Sales India - Generic Card',
    Value : Sales,
    ValueFormat : {
        ScaleFactor : 2,
        NumberOfFractionalDigits : 1
    },
    CriticalityCalculation : {
        ImprovementDirection : #Minimizing,
        DeviationRangeHighValue : '7300',
        ToleranceRangeHighValue : '7200'
    },
    TargetValue : '2.000 ',
    TrendCalculation : {
        ReferenceValue : '5201680',
        DownDifference : 10000000.0
    }
}
```

STEP: 6 — Configure View Switch (tabs) in manifest.json for card-level dropdowns

DESCRIPTION: Use the tabs array under the card's settings to configure a dropdown (view switch) that maps different annotationPath / selectionAnnotationPath / presentationAnnotationPath to each tab. Each tab can also reference a dataPointAnnotationPath and a UI text value (e.g., binding string placeholders).

LANGUAGE: JSON

CODE:
```json
"sap.ovp": {
	"globalFilterModel": "salesOrder",
	"globalFilterEntityType": "GlobalFilters", //Deprecated since SAPUI5 1.54.
     "globalFilterEntitySet": "GlobalFilters", //Available from SAPUI5 1.54.
	"showDateInRelativeFormat": false,
	"disableTableCardFlexibility": false,
	"considerAnalyticalParameters": true,
	"useDateRangeType": false,
	"cards": {
     "card014": {
         "model": "salesOrder",
         "template": "sap.ovp.cards.table",
         "settings": {
     "title": "Sales Forecast",
     "subTitle": "per Supplier",
     "valueSelectionInfo": "Value Selection Info",
     "entitySet": "SalesShare",
     "tabs": [
           {
     "dynamicSubtitleAnnotationPath": "com.sap.vocabularies.UI.v1.HeaderInfo#dynamicSubtitle",
     "annotationPath": "com.sap.vocabularies.UI.v1.LineItem#View1",
     "selectionAnnotationPath": "com.sap.vocabularies.UI.v1.SelectionVariant#line1",
     "presentationAnnotationPath": "com.sap.vocabularies.UI.v1.PresentationVariant#line",
     "identificationAnnotationPath": "com.sap.vocabularies.UI.v1.Identification",
     "dataPointAnnotationPath": "com.sap.vocabularies.UI.v1.DataPoint#line",
     "value": "{{dropdown_value2}}"
           },
           {
     "dynamicSubtitleAnnotationPath": "com.sap.vocabularies.UI.v1.HeaderInfo#dynamicSubtitle",
     "annotationPath": "com.sap.vocabularies.UI.v1.LineItem#View4",
     "identificationAnnotationPath": "com.sap.vocabularies.UI.v1.Identification#item2",
     "dataPointAnnotationPath": "com.sap.vocabularies.UI.v1.DataPoint#line",
     "value": "{{dropdown_value4}}"
    }
   ]
  }
},DescriptorSettings
```

STEP: 7 — DataPoint properties and criticality options (how to set them)

DESCRIPTION: For KPI header behavior use these DataPoint properties:
- Title: shown in header and as column name
- Value: KPI measure (Path or constant)
- ValueFormat: number formatting (ScaleFactor, NumberOfFractionalDigits)
- CriticalityCalculation or Criticality: highlight KPI (enum or path)
- TargetValue: expected value shown in KPI
- TrendCalculation: reference, differences for trend

Criticality can be provided as an EnumMember or via a numeric path that returns 0–3. Supported enum values:
- com.sap.vocabularies.UI.v1.CriticalityType/Neutral — default neutral color
- com.sap.vocabularies.UI.v1.CriticalityType/Negative — red
- com.sap.vocabularies.UI.v1.CriticalityType/Critical — orange
- com.sap.vocabularies.UI.v1.CriticalityType/Positive — green

If using a path, the service must return numeric values:
- 0 = Neutral (default neutral color)
- 1 = Negative (red)
- 2 = Critical (orange)
- 3 = Positive (green)

LANGUAGE: JSON

CODE:
```json
// Example: criticality using enum
"Criticality": "com.sap.vocabularies.UI.v1.CriticalityType/Positive"

// Example: criticality using path (service returns 0..3)
"Criticality": { "Path": "CriticalityValue" }
```

STEP: 8 — Configure Table Header Navigation (Identification annotation)

DESCRIPTION: Use the Identification annotation to configure navigation targets from header and table areas. Note: For table area navigation, navigation settings defined in LineItem take precedence over Identification settings. Ensure your identification annotations are present and referenced properly in manifest settings (identificationAnnotationPath).

LANGUAGE: None

CODE:
```text
Note:
- Use UI.Identification annotations in metadata to define header navigation targets.
- For table area navigation, UI.LineItem navigation settings override UI.Identification.
```

fiori-elements-framework sap.ovp manifest.json DataPoint KPI table-card header view-switch annotations


**TITLE**: Configure Table-Only View as Default for Analytical List Page (ALP)

**INTRODUCTION**: Instructions to set the Analytical List Page (ALP) to load the table-only view by default, configure the table type, and adjust column widths. Includes manifest examples for OData V2 and OData V4 and notes on table display modes and deprecated determining actions.

**TAGS**: fiori-elements-framework, analytical-list-page, ALP, manifest.json, OData V2, OData V4, table-only, tableSettings, MaxLength, Precision

**STEP**: 1 — Configure Table-Only View (OData V2)

**DESCRIPTION**: Update the sap.ui.generic.app pages entry in manifest.json to load the Analytical List Page as a list (table-only view). Choose the table implementation via tableSettings.type. Apply this snippet under your application manifest where you define pages for the entity set.

**LANGUAGE**: JSON

**CODE**:
```json
{
  "sap.ui.generic.app": {
    "pages": [
      {
        "entitySet": "SEPMRA_C_ALP_SlsOrdItemCube",
        "component": {
          "name": "sap.suite.ui.generic.template.AnalyticalListPage",
          "list": true,
          "settings": {
            "tableSettings": {
              "type": "GridTable or AnalyticalTable or ResponsiveTable"
            }
          }
        }
      }
    ]
  }
}
```

**STEP**: 2 — Adjust Column Widths and Table Display Mode

**DESCRIPTION**: Control column widths via metadata: set MaxLength for text properties and Precision for decimal properties to influence column width. Note that ALP defaults to condensed table display; change the related manifest setting if you require compact mode instead.

**LANGUAGE**: text

**CODE**:
```
Adjust metadata:
- Text properties: set MaxLength
- Decimal properties: set Precision

Note: ALP default = condensed mode. Modify manifest table display setting to use compact mode if needed.
```

**STEP**: 3 — ALP Configuration to Load Table-Only View by Default (OData V4)

**DESCRIPTION**: For OData V4, set the default annotation path to the "secondary" view so the table-only view is loaded by default. Add the provided views.paths.defaultPath entry to your manifest.

**LANGUAGE**: JSON

**CODE**:
```json
{
  "views": {
    "paths": [
      {
        "defaultPath": "secondary"
      }
    ]
  }
}
```

**STEP**: 4 — Determining Actions (Deprecated)

**DESCRIPTION**: The determining actions feature is deprecated and retained only for compatibility. Avoid adding new determining buttons; prefer alternative action patterns. For legacy references, see the defining-determining-actions-in-list-reports documentation.

**LANGUAGE**: text

**CODE**:
```
Reference: defining-determining-actions-in-list-reports-d719982.md
Recommendation: Do not use determining buttons for new development (deprecated).
```

**STEP**: 5 — Related Files and Further Reading

**DESCRIPTION**: Quick references to related configuration topics to continue setup or tune table behavior.

**LANGUAGE**: text

**CODE**:
```
- Configuring Tables: configuring-tables-f4eb70f.md
- Configuring the Manifest for the Analytical List Page: configuring-the-manifest-for-the-analytical-list-page-2a9df06.md
- Configuring the Content Area: configuring-the-content-area-fc7d73c.md
- Setting the Table Type: setting-the-table-type-7f844f1.md
```

fiori-elements-framework
analytical-list-page
ALP
manifest.json
OData V2
OData V4
table-only
tableSettings
MaxLength
Precision


**TITLE**: Configuring the Title Area (Analytical List Page - Header / KPI)

**INTRODUCTION**: This document explains how to configure the dynamic title/header area of an Analytical List Page (ALP) in SAP Fiori elements (OData V2). It covers enabling built-in header features (variants, filter modes, filter customization, share) and configuring UI.KPI annotation mapping through the manifest.json to display and enable navigation for KPI cards.

**TAGS**: fiori-elements-framework, analytical-list-page, ALP, UI.KPI, manifest.json, KPI, variants, filter-modes, OData V2

**STEP**: 1 — Header area built-in features

**DESCRIPTION**: Enable or use the ALP header area to expose built-in Fiori elements functionality. These options are available to include in the header/title area:
- Manage page variants (variants of filter and content settings)
- Choose filter modes (compact or visual)
- Customize the filter area (show/hide or rearrange filter controls)
- Share the analytical list page

Implement these features using standard ALP configuration in your app (manifest/annotations as required). Use the Managing Variants and Choosing Filter Modes docs for concrete implementation details.

**LANGUAGE**: Documentation / Configuration

**CODE**:
```none
(no code sample required for this step; configure via standard ALP manifest and annotation settings)
```

**STEP**: 2 — Display KPIs using UI.KPI annotation

**DESCRIPTION**: Use the UI.KPI annotation to display KPI cards in the ALP header. Map a qualifier in the manifest.json to the UI.KPI annotation so the ALP can load the KPI definition. If UI.KPI is not configured, the UI.SelectionPresentationVariant annotation with the same qualifier will be used instead. Prefer using a centralized SAP-wide KPI gallery created by standard SAP KPI tools (for consistency and reuse).

- Define the KPI mapping in the manifest.json with the model, entitySet and qualifier.
- Keep the same qualifier name between manifest mapping and annotations (UI.KPI and/or UI.SelectionPresentationVariant).

**LANGUAGE**: JSON (manifest.json)

**CODE**:
```json
"KPIQuantity": {
                "model": "kpi",
                "entitySet": "SEPMRA_C_ALP_SlsOrdItemCubeALPResults",
                "qualifier": "KPIQuantity
}
```

**STEP**: 3 — Enable navigation for KPI cards

**DESCRIPTION**: To allow navigation from a KPI card to a target (for example, smart business application), define the following inside the UI.KPI annotation:
- semanticObject: target semantic object
- action: the action to invoke
- KPI ID: a unique KPI identifier

At runtime the KPI ID is passed to the target application as the EvaluationId parameter to launch the smart business app. Ensure your annotation includes these properties and that the target application can accept EvaluationId.

**LANGUAGE**: Annotation configuration / XML or CDS (depending on your annotation source)

**CODE**:
```none
(Configure UI.KPI annotation with semanticObject, action and KPI ID in your annotation source (EDMX/Annotations XML or CDS). Example fields: semanticObject, action, EvaluationId)
```

**STEP**: 4 — Related resources (for implementation details)

**DESCRIPTION**: Refer to these related pages for step-by-step examples and additional configuration patterns:
- Analytical List Page: analytical-list-page-3d33684.md
- Managing Variants: managing-variants-8ce658e.md
- Creating Key Performance Indicator Tags: creating-key-performance-indicator-tags-d80a360.md
- Choosing Filter Modes: choosing-filter-modes-00c19e1.md

**LANGUAGE**: Documentation links

**CODE**:
```none
(See the referenced markdown files for detailed examples and implementation code)
```

fiori-elements-framework
analytical-list-page
ALP
UI.KPI
manifest.json
KPI
variants
filter-modes
OData V2


**TITLE**: Configuring the Visual Filter Bar (Fiori Elements)

**INTRODUCTION**: This guide explains how to enable and configure the Visual Filter Bar in SAP Fiori elements applications. It covers required annotations, manifest.json settings for OData V4 apps, aggregation requirements for the value list entity, availability options, and limitations when using draft-enabled entities.

**TAGS**: fiori-elements-framework, visual-filters, manifest.json, valueList, aggregation, OData V4, draft

STEP: 1 — Purpose and prerequisites

DESCRIPTION:
- The Visual Filter Bar lets end users select filter values based on associated measure values in addition to regular filter fields.
- Visual filter values are synchronized with the regular filter bar.
- Visual filters only apply to filter fields that accept single or multiple values (not range-based fields).
- Semantic dates are not supported.
- To enable visual filters, define value list annotations for each filter field. See: Enhancing ValueList Annotations for Visual Filters (enhancing-valuelist-annotations-for-visual-filters-16d43eb.md).

LANGUAGE: Text

CODE:
```text
Prerequisites:
- Filter fields must accept single or multiple value selection (no range fields).
- Semantic dates are not supported.
- Define value list annotations for each filter field.
- For OData V4 apps, enhance manifest.json as described in the following steps.
```

STEP: 2 — manifest.json settings for OData V4 (enable visual filters and control layout)

DESCRIPTION:
- For OData V4 Fiori elements apps, ensure manifest.json contains a settings.controlConfiguration entry for @com.sap.vocabularies.UI.v1.SelectionFields.
- Use "layout" to indicate Compact vs CompactVisual (CompactVisual means both compact and visual filters present).
- Use "initialLayout" to specify default filter mode (Visual or Compact).
- Add a "filterFields" object listing each filter field to control availability and link the visual filter to a valueList annotation path.
- Set the "visualFilter.valueList" to the path of the value list annotation for this visual filter.

LANGUAGE: JSON

CODE:
```json
"settings" : {
   "contextPath" : "/SalesOrderManage",
   "controlConfiguration" : {
      "@com.sap.vocabularies.UI.v1.SelectionFields" : {
         "layout": "CompactVisual" , // Possible Values: "Compact" (if only compact filter is present) and "CompactVisual" if both compact and visual filters are present
         "initialLayout": "Visual" , // Specifies the default filter mode on initial load. Possible values: "Visual" and "Compact"
         "filterFields": {
            "ItemRating": { // Below this are all the settings for "ItemRating" filter field
               "availability": "Default", // see below for possible values
               "visualFilter": { // Only available if there is a visual filter configured for this filter field and holds all information specific to visual filter configuration
                  "valueList": "<pathToValueList>" // Should point to the valuelist annotation corresponding to the visual filter representation
               }
            }
         }
      }
   }
}
```

STEP: 3 — availability property values and behavior

DESCRIPTION:
- Configure availability per filter field in manifest.json under filterFields.<Field>.availability.
- Possible values and their behavior:
  - Default: Shown by default in the filter bar (regular and visual filters, if defined).
  - Adaptation: Initially hidden in filter bar; available under Adapt Filters dialog.
  - Hidden: Not visible in filter bar or Adapt Filters dialog.

LANGUAGE: Text

CODE:
```text
"availability" values:
- "Default"  => shown by default in filter bar (regular + visual if defined)
- "Adaptation" => hidden by default; available under "Adapt Filters"
- "Hidden" => not visible in filter bar or "Adapt Filters"
```

STEP: 4 — Aggregation requirements for the valueList entity

DESCRIPTION:
- The entity referenced by visualFilter.valueList must have aggregation enabled in the back end.
- Where to place aggregation annotations:
  - Non-parameterized valueList entity: define aggregation at the entity set level for visual filters.
  - Parameterized valueList entity: define aggregation against the EntityType.
- See Configuring Charts -> Enabling Aggregation in the Back End (configuring-charts-653ed0f.md#...__enabling_aggregation_subsection) for more details.

LANGUAGE: Text

CODE:
```text
Aggregation placement rules:
- Non-parameterized valueList entity:
  - Define aggregation annotations at the entity set level (for visual filters).
- Parameterized valueList entity:
  - Define aggregation annotations on the EntityType.
Ensure the valueList entity is enabled for aggregation in the backend.
Reference: configuring-charts-653ed0f.md#loio653ed0f4f0d743dbb33ace4f68886c4e__enabling_aggregation_subsection
```

STEP: 5 — Visual filters on draft-enabled entities (behavior, notes, and restrictions)

DESCRIPTION:
- You can define visual filters/charts against draft-enabled entities; only active data is used for chart display.
- Important notes:
  - CAP Node.js: sorting on virtual properties and measures can cause issues unless @sap/cds >= 6.0.0 (fix present in 6.0.0).
  - ABAP CDS: Aggregations on draft-enabled entities are not supported because SADL does not support $apply on draft/transactional entities.
- Restrictions (visual filters not supported in these cases):
  - Donut charts are not supported.
  - Properties (measures, dimensions, text associations) from "associated entity sets" (value help entity set related) are not supported.
  - For line charts, use only fields of types Edm.Date, Edm.Time, or Edm.DateTime. String-based time/date fields are not supported.
  - Selection of values outside the chart is enabled only for value-help-based fields (not for drop-down lists or date/time fields).
  - Visual filters inside the Adapt Filters dialog are not supported.
  - Visual Filters do not support correct formatting for fiscal periods or for string-based dimensions annotated as time-based.
  - Path-based UI.Criticality annotation values and CriticalityCalculation-based semantic coloring are not supported.
  - You cannot configure a visual filter for a filter field that already has a custom filter defined.

LANGUAGE: Text

CODE:
```text
Draft-enabled entities:
- Charts/visual filters on draft-enabled entities use only active data.

Notes:
- CAP Node.js: sorting on virtual properties/measures issues fixed in @sap/cds 6.0.0.
- ABAP CDS: Aggregations on draft-enabled entities are not supported (SADL limitation on $apply).

Restrictions:
- No donut charts.
- No properties from associated entity sets (value help entity set) supported.
- Line charts: use only Edm.Date, Edm.Time, Edm.DateTime fields (no string-based dates).
- External selection support only for value-help-based fields (not for drop-downs or date/time).
- Visual filters are not available in Adapt Filters dialog.
- No correct formatting for fiscal periods or string-based time dimensions.
- No path-based UI.Criticality or CriticalityCalculation-based semantic coloring.
- Cannot configure visual filter if a custom filter exists for the same field.
```

STEP: 6 — Related documentation (file references)

DESCRIPTION:
- Reference these internal docs for detailed guidance and examples:
  - Analytical List Page: analytical-list-page-3d33684.md
  - Visual Filters: visual-filters-1714720.md
  - Enhancing ValueList Annotations for Visual Filters: enhancing-valuelist-annotations-for-visual-filters-16d43eb.md
  - Configuring Charts (aggregation guidance): configuring-charts-653ed0f.md

LANGUAGE: Text

CODE:
```text
Related docs:
- analytical-list-page-3d33684.md
- visual-filters-1714720.md
- enhancing-valuelist-annotations-for-visual-filters-16d43eb.md
- configuring-charts-653ed0f.md
```

fiori-elements-framework
visual-filters
manifest.json
valueList
aggregation
OData V4
draft


**TITLE**: Configuring View Switch for OVP Cards

**INTRODUCTION**: Configure a view-switch dropdown for SAP Fiori elements (OVP) cards to filter or present different views of data at the card level. Use either a single entitySet with multiple tab definitions or define multiple entitySets per tab. The view switch entries map to annotation paths, data points, and bindings (e.g., value bindings such as "{{dropdown_value1}}"). You can extend behavior based on filter conditions or custom configuration — see Extending Custom View Switch (extending-custom-view-switch-ecd9f10.md).

**TAGS**: fiori-elements-framework, ovp, view-switch, card, annotations, JSON, SAPUI5

**STEP**: 1 — Define a view switch with a single entity set

**DESCRIPTION**: Use settings.entitySet to specify one entity set shared across tabs. Inside settings.tabs, define each tab entry (annotation paths, selection/presentation paths, dataPoint, value binding, etc.). This creates dropdown options that switch views while using the same entity set.

**LANGUAGE**: JSON

**CODE**:
```json
"settings": {
    "entitySet": "SalesOrderSet"
    "tabs": [
        {
            ...
        },
        {
            ...
        }
    ]
}
```

**STEP**: 2 — Define a view switch with multiple entity sets

**DESCRIPTION**: Omit a top-level settings.entitySet and specify entitySet per tab inside settings.tabs. Each tab can target different entity sets and annotation definitions. Use this when dropdown entries should switch between different entity sets (e.g., SalesOrderSet and ProductSet).

**LANGUAGE**: JSON

**CODE**:
```json
"settings": {
    "tabs": [
        {
            "entitySet": "SalesOrderSet"
		  ...
        },
        {
            "entitySet": " ProductSet"
		  ...
        }
    ]
}
```

**STEP**: 3 — Full card example with multiple tabs, annotations, and value bindings

**DESCRIPTION**: Example of a complete card configuration (card009) that uses a view-switch dropdown with three tabs. Two tabs use the SalesOrderSet with different annotation/presentation paths and one tab uses ProductSet. Each tab includes annotation path references (annotationPath, presentationAnnotationPath, selectionAnnotationPath, dynamicSubtitleAnnotationPath, identificationAnnotationPath, dataPointAnnotationPath) and a value binding string for the dropdown selection (e.g., "{{dropdown_value2}}"). Copy this structure into your card JSON to implement the view switch behavior.

**LANGUAGE**: JSON

**CODE**:
```json
"card009": {
  "model": "salesOrder",
  "template": "sap.ovp.cards.list",
  "settings": {
    "title": "Contract Monitoring",
    "subTitle": "Per Supplier",
    "valueSelectionInfo": "Total contract volume",
    "listFlavor": "bar",
    "listType": "extended",
    "showLineItemDetail":true,
    "tabs": [
      {
        "entitySet": "SalesOrderSet",
        "dynamicSubtitleAnnotationPath": "com.sap.vocabularies.UI.v1.HeaderInfo#dynamicSubtitle",
        "annotationPath": "com.sap.vocabularies.UI.v1.LineItem#View1",
        "selectionAnnotationPath": "com.sap.vocabularies.UI.v1.SelectionVariant#line1",
        "presentationAnnotationPath": "com.sap.vocabularies.UI.v1.PresentationVariant#line",
        "identificationAnnotationPath": "com.sap.vocabularies.UI.v1.Identification",
        "dataPointAnnotationPath": "com.sap.vocabularies.UI.v1.DataPoint#line",
        "value": "{{dropdown_value2}}"
       },
      {
        "entitySet": "SalesOrderSet",
        "dynamicSubtitleAnnotationPath": "com.sap.vocabularies.UI.v1.HeaderInfo#dynamicSubtitle",
        "annotationPath": "com.sap.vocabularies.UI.v1.LineItem#View3",
        "presentationAnnotationPath": "com.sap.vocabularies.UI.v1.PresentationVariant#SP3",
        "identificationAnnotationPath": "com.sap.vocabularies.UI.v1.Identification",
        "dataPointAnnotationPath": "com.sap.vocabularies.UI.v1.DataPoint#line",
        "value": "{{dropdown_value3}}"
       },
      {
        "entitySet": "ProductSet",
        "annotationPath": "com.sap.vocabularies.UI.v1.LineItem",
        "identificationAnnotationPath": "com.sap.vocabularies.UI.v1.Identification#identify1",
        "value": "{{dropdown_value1}}"
       }
    ]
  }
}
```

**STEP**: 4 — Extension and customization note

**DESCRIPTION**: To implement custom reactions to selection changes (e.g., apply additional filters or dynamic behavior), extend the view-switch feature as required. For guidance and implementation patterns, refer to Extending Custom View Switch: extending-custom-view-switch-ecd9f10.md

**LANGUAGE**: Markdown

**CODE**:
```markdown
See: extending-custom-view-switch-ecd9f10.md
```

Configuring View Switch for OVP Cards

fiori-elements-framework ovp view-switch card annotations JSON SAPUI5


**TITLE**: Configure Confirmation Popups in SAP Fiori Elements (OData V2 & V4)

**INTRODUCTION**: Action-oriented reference for configuring confirmation popups in SAP Fiori Elements: draft-discard dialogs, 412 (Precondition Failed) warning dialogs, suppression behavior, disabling strict handling (to turn off 412 dialogs), legacy object-page activation confirmations, and i18n title customization. Use these manifest.json and API examples to enable/disable behaviors per application or per action.

**TAGS**: fiori-elements, confirmation, draft, 412, manifest.json, OData V2, OData V4, i18n, disableStrictHandling, invokeAction

STEP: 1 — 412 Confirmation Flow (how it works)
DESCRIPTION: Exact runtime flow for 412-driven confirmation popups. Use this to design back-end responses and front-end retry logic.
LANGUAGE: text
CODE:
```text
- Client sends request with header: Prefer:handling=strict
- Back end can:
    - Ignore unknown preference -> action proceeds normally
    - Return HTTP 412 ("Precondition Failed") indicating warnings that block processing
- UI displays confirmation popup with back-end message
- If user confirms:
    - UI resends request WITHOUT Prefer:handling=strict
    - Back end executes action and responds (success or failure)
    - If back end sends the same message again, the UI suppresses repeated message (see suppression attributes)
- If user cancels:
    - Operation terminated
```

STEP: 2 — Turn off Draft-Activation Confirmation for External Navigation (OData V2)
DESCRIPTION: Disable the default draft discard confirmation for external navigation in OData V2 apps by adding draftDiscardConfirmationSettings in sap.ui.generic.app settings.
LANGUAGE: JSON
CODE:
```json
"sap.ui.generic.app": {
              "_version": "1.3.0",
              "settings": {
                             "draftDiscardConfirmationSettings": {
                                           "enabled": "restricted"
                             }
              }
}
.
.
.
```

STEP: 3 — Turn off Draft-Activation Confirmation for External Navigation (OData V4)
DESCRIPTION: Disable the default draft discard confirmation for external navigation in OData V4 apps by setting silentlyKeepDraftOnForwardNavigation in sap.fe.app.
LANGUAGE: JSON
CODE:
```json
"sap.fe": {
     "app": {
          "silentlyKeepDraftOnForwardNavigation": true
     }
}
```

STEP: 4 — Disable 412 Confirmation Popups at Application Level (OData V4)
DESCRIPTION: Turn off strict handling globally for the application so 412 confirmation dialogs are not shown.
LANGUAGE: JSON
CODE:
```json
"sap.fe": {
    "app": {
       "disableStrictHandling": true
    }
}
```

STEP: 5 — Disable 412 Confirmation Popups for a Specific Table Action (OData V4)
DESCRIPTION: Disable strict handling for a specific action defined in the LineItem annotation so that the action does not cause a 412 confirmation popup.
LANGUAGE: JSON
CODE:
```json
"@com.sap.vocabularies.UI.v1.LineItem": {
     "actions": {
        "DataFieldForAction::YourActionWith412Handling": {
           "disableStrictHandling": true
        }
     }
}
```

STEP: 6 — Disable 412 Confirmation Popups for a Header Action on an Object Page (OData V4)
DESCRIPTION: Disable strict handling for a specific header action on an object page.
LANGUAGE: JSON
CODE:
```json
"content": {
    "header": {
        "actions": {
            "DataFieldForAction::YourActionWith412Handling": {
                "disableStrictHandling": true,
            }
        }
    }
}
```

STEP: 7 — Disable 412 Confirmation Popups Programmatically via invokeAction API (OData V4)
DESCRIPTION: Use invokeAction with disableStrictHandling:true to bypass 412 confirmation for a programmatic action invocation.
LANGUAGE: JavaScript
CODE:
```javascript
this.base.editFlow.invokeAction("com.c_salesordermanage_sd.EntityContainer/message412", {
     contexts: context,
     model: this.base.getView().getModel(),
     disableStrictHandling: true
});
```

STEP: 8 — Legacy: Additional Confirmation Popup for Save/Activation on Object Pages (UI-level)
DESCRIPTION: Legacy option to show an extra confirmation dialog before activation/save on object pages if front-end warnings exist. Prefer 412 handling; use this only if required for older scenarios.
LANGUAGE: JSON
CODE:
```json
"pages": {
              "ObjectPage|STTA_C_MP_Product": {
                             "entitySet": "STTA_C_MP_Product",
                             "component": {
                                           "name": "sap.suite.ui.generic.template.ObjectPage",
                                           "settings": {
                                                          "showRelatedApps": true,
                                                          "tableType": "ResponsiveTable",
                                                          "editableHeaderContent": true,
                                                          "showConfirmationOnDraftActivate": true,
                                                          "sections": {
                                                                        "to_ProductText::com.sap.vocabularies.UI.v1.LineItem": {
                                                                                "navigationProperty": "to_ProductText",
                                                                                "entitySet": "STTA_C_MP_ProductText",
                                                                                "multiSelect": true,
                                                                                "createMode": "inline",
                                                                                "tableType": "ResponsiveTable"
                                                                        }
                                                          }
                                           }
                             }
              }
}
```

STEP: 9 — Customize Confirmation Dialog Title Text (i18n keys)
DESCRIPTION: Override dialog titles and button text in i18n to provide application-specific UI copy for draft discard and save/create actions.
LANGUAGE: text
CODE:
```text
i18n keys to override:
- ST_KEEP_DRAFT_MESSAGE_CREATE   (title text for Create scenario)
- ST_KEEP_DRAFT_MESSAGE_EDIT     (title text for Edit scenario)
- CREATE                         (button/text label for create mode)
- SAVE                           (button/text label for save mode)
```

STEP: 10 — Suppression Matching Attributes for Repeated 412 Messages (OData V2)
DESCRIPTION: For OData V2, repeated messages are suppressed only if subsequent messages match the original in all listed attributes.
LANGUAGE: text
CODE:
```text
Suppression attributes (OData V2):
- code
- message
- severity
- target        (targets considered equal if they resolve to the same model element)
- transition flag (absent = treated as true)
```

STEP: 11 — Suppression Matching Attributes for Repeated 412 Messages (OData V4)
DESCRIPTION: For OData V4, repeated messages are suppressed only if subsequent messages match the original in all listed attributes.
LANGUAGE: text
CODE:
```text
Suppression attributes (OData V4):
- code
- message
- numericSeverity
- longtextUrl       (equal if both null/absent; may contain variables not present in message string)
- target and additionalTargets (equal if they resolve to same model element)
- transition flag (absent = treated as true)
```

STEP: 12 — Handling Rules, Message Types, Multi-select Behavior, and Restrictions
DESCRIPTION: Back-end and front-end configuration rules and known restrictions to consider when implementing 412 handling and draft confirmations.
LANGUAGE: text
CODE:
```text
- For SAP Fiori elements, 412 indicates warnings that block processing but users can confirm to continue.
- You must configure 412 messages from the back end as transition messages (not state) for save, delete, and function import actions (OData V4).
- For activation, a back end state message or transition is configurable (OData V2 notes).
- Deletion: 412 handling is NOT applied when a record is deleted (OData V4 restriction).
- CAP back ends: 412 handling may fail if action is executed with InvocationGrouping=UI.OperationGroupingType/Isolated (multiple contexts executed in same changeset).
- Deletion triggered from a table in an object page: you cannot configure 412 confirmation popups for this scenario (restriction).
- Multi-select actions: if only some selected items return warnings, processing fails and the UI asks the user to act on individual objects.
```

STEP: 13 — Critical Actions Confirmation (reference)
DESCRIPTION: You can mark actions as critical so the UI displays a confirmation popup before execution. See "Adding Confirmation Popovers for Actions" for annotation/manifest specifics (refer to the referenced guide for implementation details).
LANGUAGE: text
CODE:
```text
- Configure actions as critical to trigger confirmation popovers.
- Implementation details are in "Adding Confirmation Popovers for Actions" (external doc).
```

fiori-elements
confirmation
draft
412
manifest.json
OData V2
OData V4
i18n
disableStrictHandling
invokeAction


**TITLE**: Contact Facet (Communication.Contact) — SAP Fiori Elements (OData V2 & V4)

**INTRODUCTION**: Enable a quick-view contact in a header form facet by using the Communication.Contact annotation. This document provides action-oriented code examples for OData V2 and OData V4, including XML annotations, ABAP CDS examples, and CAP CDS variants. Use the UI.DataFieldForAnnotation (or UI.DataFieldForAnnotation / UI.DataFieldForAnnotationType equivalents) in the header field group to reference the contact annotation on a related 1:1 entity. Define the Communication.Contact annotation on the referenced entity to populate the popover (fn, email, tel, adr, photo).

**TAGS**: fiori-elements-framework, Communication.Contact, contact-facet, odata-v2, odata-v4, abap-cds, cap-cds, xml, annotations

**STEP**: 1 — Contact link (OData V2 XML)
**DESCRIPTION**: Add a UI.DataFieldForAnnotation to the header facet (field group) that targets the related entity’s Communication.Contact annotation via AnnotationPath. This displays the contact label from UI.DataFieldForAnnotation and the contact name from the contact annotation fn property.
**LANGUAGE**: XML
**CODE**:
```XML

<Record Type="UI.DataFieldForAnnotation">
       <PropertyValue Property="Label" String="Supplier [ContactQV]"/>
       <PropertyValue Property="Target" AnnotationPath="to_Supplier/@Communication.Contact"/>
       <Annotation Term="UI.Importance" EnumMember="UI.ImportanceType/High"/>
</Record>
```

**STEP**: 2 — Contact link (OData V2 ABAP CDS)
**DESCRIPTION**: Equivalent ABAP CDS field group entry to mark a field as contact type in the header field group. Use type: #AS_CONTACT and value pointing to the navigation element.
**LANGUAGE**: ABAP
**CODE**:
```ABAP

@UI.fieldGroup: [
  {
    importance: #LOW,
    value: '_STOCKAVAILABILITY.QUANTITY',
    position: 10 ,
    qualifier: 'GeneralInformationForHeader',
    groupLabel: '{@i18n>@GeneralInfoFieldGroupLabel}'
  }
]
_STOCKAVAILABILITY;

@UI.fieldGroup: [
  {
    importance: #HIGH,
    position: 20 ,
    qualifier: 'GeneralInformationForHeader'
  }
]
WEIGHT;

@UI.fieldGroup: [
  {
    importance: #HIGH,
    label: 'WeightUnit [SmLiQv]',
    position: 30 ,
    qualifier: 'GeneralInformationForHeader'
  }
]
WEIGHTUNIT;

@UI.fieldGroup: [
  {
    importance: #HIGH,
    label: 'Supplier [ContactQV]',
    value: '_SUPPLIER',
    type: #AS_CONTACT,
    position: 40 ,
    qualifier: 'GeneralInformationForHeader'
  }
]
MANAGER;
```

**STEP**: 3 — Popover (OData V2 XML)
**DESCRIPTION**: Define the Communication.Contact annotation on the target entity. Map fn, email, and tel properties to entity properties using Path, and build collections for multiple email/phone entries. This provides the content shown in the contact popover.
**LANGUAGE**: XML
**CODE**:
```XML
<Annotation Term="Communication.Contact">
                          <Record>
                               <PropertyValue Property="fn" Path="CompanyName"/>
                               <PropertyValue Property="email">
                                    <Collection>
                                          <Record>
                                               <PropertyValue Property="type" EnumMember="Communication.ContactInformationType/work"/>
                                               <PropertyValue Property="address" Path="EmailAddress"/>
                                          </Record>
                                    </Collection>
                               </PropertyValue>
                               <PropertyValue Property="tel">
                                    <Collection>
                                          <Record>
                                               <PropertyValue Property="type" EnumMember="Communication.PhoneType/preferred Communication.PhoneType/work"/>
                                               <PropertyValue Property="uri" Path="PhoneNumber"/>
                                          </Record>
                                          <Record>
                                               <PropertyValue Property="type" EnumMember="Communication.PhoneType/fax"/>
                                               <PropertyValue Property="uri" Path="FaxNumber"/>
                                          </Record>
                                    </Collection>
                               </PropertyValue>
                          </Record>
                     </Annotation>
```

**STEP**: 4 — Popover (OData V2 ABAP CDS)
**DESCRIPTION**: ABAP CDS example defining fields used by the Communication.Contact mapping. Add Semantics annotations to identify e-mail and telephone semantic roles and types.
**LANGUAGE**: ABAP
**CODE**:
```ABAP

define view VIEWNAME
{

 @Semantics.name.fullName: true
  CompanyName,

  @Semantics.eMail.address: true
  @Semantics.eMail.type:  [#WORK]
  EmailAddress,

  @Semantics.telephone.type:  [ #CELL ]
  PhoneNumber,

  @Semantics.telephone.type: [ #FAX ]
  FaxNumber,
}

```

**STEP**: 5 — Contact link (OData V4 XML)
**DESCRIPTION**: Add a UI.FieldGroup / UI.DataFieldForAnnotation entry that targets _SoldToParty/@Communication.Contact (or the appropriate navigation path) to display the contact in the header. Example shows using UI.FieldGroup Qualifier "OrderData".
**LANGUAGE**: XML
**CODE**:
```XML

<Annotation Term="UI.FieldGroup" Qualifier="OrderData">
    <Record Type="UI.FieldGroupType">
        <PropertyValue Property="Data">
            <Collection>
                <Record Type="UI.DataFieldWithNavigationPath">
                    <PropertyValue Property="Label" String="Referenced Sales Order"/>
                    <PropertyValue Property="Value" Path="_ReferencedSalesOrder/SalesOrder"/>
                    <PropertyValue Property="Target" NavigationPropertyPath="SalesOrderManage"/>
                </Record>
                <Record Type="UI.DataFieldForAnnotation">
                    <PropertyValue Property="Target" AnnotationPath="_SoldToParty/@Communication.Contact"/>
                    <PropertyValue Property="Label" String="Sold-To-Party"/>
                </Record>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="PurchaseOrderByCustomer"/>
                    <Annotation Term="UI.Importance" EnumMember="UI.ImportanceType/High"/>
                </Record>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="SalesOrderDate"/>
                    <Annotation Term="UI.Importance" EnumMember="UI.ImportanceType/High"/>
                    <Annotation Term="UI.Hidden" Path="Delivered"/>
                </Record>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="ShippingCondition"/>
                    <Annotation Term="UI.Importance" EnumMember="UI.ImportanceType/High"/>
                </Record>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="OverallSDProcessStatus"/>
                    <Annotation Term="UI.Importance" EnumMember="UI.ImportanceType/High"/>
                    <PropertyValue Property="Criticality" Path="StatusCriticality"/>
                </Record>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="DescriptionFieldForOPACleanup"/>
                    <Annotation Term="UI.Importance" EnumMember="UI.ImportanceType/High"/>
                </Record>
            </Collection>
        </PropertyValue>
    </Record>
</Annotation>
```

**STEP**: 6 — Contact link (OData V4 ABAP CDS)
**DESCRIPTION**: ABAP CDS field group entries to mark the element as contact type in OData V4 (use type: #AS_CONTACT and value referencing the navigation element). Use qualifier to scope to the field group.
**LANGUAGE**: ABAP
**CODE**:
```ABAP

@UI.fieldGroup: [
  {
    targetelement: 'SALESORDERMANAGE',
    label: 'Referenced Sales Order',
    value: '_REFERENCEDSALESORDER.SALESORDER',
    type: #WITH_NAVIGATION_PATH,
    position: 10,
    qualifier: 'OrderData'
  }
]
_REFERENCEDSALESORDER;

@UI.fieldGroup: [
  {
    value: '_SOLDTOPARTY',
    label: 'Sold-To-Party',
    type: #AS_CONTACT,
    position: 20 ,
    qualifier: 'OrderData'
  }
]
_SOLDTOPARTY;

@UI.fieldGroup: [
  {
    importance: #HIGH,
    position: 30 ,
    qualifier: 'OrderData'
  }
]
PURCHASEORDERBYCUSTOMER;

@UI.fieldGroup: [
  {
    importance: #HIGH,
    hidden: true,
    position: 40 ,
    qualifier: 'OrderData'
  }
]
SALESORDERDATE;

@UI.fieldGroup: [
  {
    importance: #HIGH,
    position: 50 ,
    qualifier: 'OrderData'
  }
]
SHIPPINGCONDITION;

@UI.fieldGroup: [
  {
    importance: #HIGH,
    criticality: 'STATUSCRITICALITY',
    position: 60 ,
    qualifier: 'OrderData'
  }
]
OVERALLSDPROCESSSTATUS;

@UI.fieldGroup: [
  {
    importance: #HIGH,
    position: 70 ,
    qualifier: 'OrderData'
  }
]
DESCRIPTIONFIELDFOROPACLEANUP;
```

**STEP**: 7 — Contact link (OData V4 CAP CDS)
**DESCRIPTION**: CAP CDS (CSN) representation of the same UI.FieldGroup including DataFieldForAnnotation Target pointing to _SoldToParty/@Communication.Contact.
**LANGUAGE**: CDS
**CODE**:
```CDS

UI.FieldGroup #OrderData : {
    $Type : 'UI.FieldGroupType',
    Data : [
        {
            $Type : 'UI.DataFieldWithNavigationPath',
            Label : 'Referenced Sales Order',
            Value : _ReferencedSalesOrder.SalesOrder,
            Target : SalesOrderManage
        },
        {
            $Type : 'UI.DataFieldForAnnotation',
            Target : '_SoldToParty/@Communication.Contact',
            Label : 'Sold-To-Party'
        },
        {
            $Type : 'UI.DataField',
            Value : PurchaseOrderByCustomer,
            ![@UI.Importance] : #High
        },
        {
            $Type : 'UI.DataField',
            Value : SalesOrderDate,
            ![@UI.Importance] : #High,
            ![@UI.Hidden] : Delivered
        },
        {
            $Type : 'UI.DataField',
            Value : ShippingCondition,
            ![@UI.Importance] : #High
        },
        {
            $Type : 'UI.DataField',
            Value : OverallSDProcessStatus,
            Criticality : StatusCriticality,
            ![@UI.Importance] : #High
        },
        {
            $Type : 'UI.DataField',
            Value : DescriptionFieldForOPACleanup,
            ![@UI.Importance] : #High
        }
    ]
}
```

**STEP**: 8 — Popover (OData V4 XML)
**DESCRIPTION**: Define Communication.Contact on the referenced entity for OData V4. Map address (adr), email, fn, tel, and photo properties to entity fields. Use types (EnumMember) for address and phone types where applicable.
**LANGUAGE**: XML
**CODE**:
```XML

<Annotation Term="Communication.Contact">
    <Record Type="Communication.ContactType">
        <PropertyValue Property="adr">
            <Collection>
                <Record Type="Communication.AddressType">
                    <PropertyValue Property="type" EnumMember="Communication.ContactInformationType/work"/>
                    <PropertyValue Property="uri" Path="InternationalPhoneNumber"/>
                    <PropertyValue Property="code" Path="PostalCode"/>
                    <PropertyValue Property="country" Path="Country"/>
                    <PropertyValue Property="locality" Path="CityName"/>
                </Record>
            </Collection>
        </PropertyValue>
        <PropertyValue Property="email">
            <Collection>
                <Record Type="Communication.EmailAddressType">
                    <PropertyValue Property="type" EnumMember="Communication.ContactInformationType/work"/>
                    <PropertyValue Property="address" Path="EmailAddress"/>
                </Record>
            </Collection>
        </PropertyValue>
        <PropertyValue Property="fn" Path="CustomerName"/>
        <PropertyValue Property="tel">
            <Collection>
                <Record Type="Communication.PhoneNumberType">
                    <PropertyValue Property="type" EnumMember="Communication.PhoneType/fax"/>
                    <PropertyValue Property="uri" Path="InternationalPhoneNumber"/>
                </Record>
            </Collection>
        </PropertyValue>
        <PropertyValue Property="photo" Path="CustomerImg"/>
    </Record>
</Annotation>
```

**STEP**: 9 — Popover (OData V4 ABAP CDS)
**DESCRIPTION**: ABAP CDS view fields with semantic annotations used to supply values for the Communication.Contact annotation (CustomerName, EmailAddress, InternationalPhoneNumber, PostalCode, Country, CityName, CustomerImg).
**LANGUAGE**: ABAP
**CODE**:
```ABAP

define view VIEWNAME
{
  @Semantics.name.fullName: true
  CustomerName,

  @Semantics.eMail.address: true
  @Semantics.eMail.type:  [#WORK]
  EmailAddress,

  @Semantics.telephone.type:  [ #FAX ]
  InternationalPhoneNumber,

  @Semantics.address : { zipCode: true }
  PostalCode,

  @Semantics.address : { country: true }
  Country,

  @Semantics.address : { city: true }
  CityName,

  @Semantics.contact.photo: true
  CustomerImg
}
```

**STEP**: 10 — Popover (OData V4 CAP CDS)
**DESCRIPTION**: CAP CDS (CSN) representation of the Communication.Contact structure mapping to entity fields. Use this to place in annotation section for the referenced entity.
**LANGUAGE**: CDS
**CODE**:
```CDS

Communication.Contact : {
    $Type : 'Communication.ContactType',
    adr : [
        {
            $Type : 'Communication.AddressType',
            type : #work,
            uri : InternationalPhoneNumber,
            code : PostalCode,
            country : Country,
            locality : CityName
        }
    ],
    email : [
        {
            $Type : 'Communication.EmailAddressType',
            type : #work,
            address : EmailAddress
        }
    ],
    fn : CustomerName,
    tel : [
        {
            $Type : 'Communication.PhoneNumberType',
            type : #fax,
            uri : InternationalPhoneNumber
        }
    ],
    photo : CustomerImg
},
```

**STEP**: 11 — Related Link
**DESCRIPTION**: Additional documentation reference for implementation details.
**LANGUAGE**: TEXT
**CODE**:
```
Adding a Contact Facet: adding-a-contact-facet-a6a8c0c.md
```

fiori-elements-framework Communication.Contact contact-facet odata-v2 odata-v4 abap-cds cap-cds xml annotations