**TITLE**: Form Facet — Add a header form facet to an Object Page

**INTRODUCTION**: Use a UI.ReferenceFacet in UI.HeaderFacets to add a compact form (field group or identification) into the object page header. The ReferenceFacet's Label becomes the form title and Target points to a UI.FieldGroup or UI.Identification annotation (by qualifier). Use UI.FieldGroup entries to list UI.DataField entries and control importance/visibility via UI.Importance and UI.Hidden.

**TAGS**: fiori-elements-framework, UI.HeaderFacets, UI.ReferenceFacet, UI.FieldGroup, UI.Identification, annotations, XML, ABAP, CDS, object-page, header

**STEP**: 1 — Add a ReferenceFacet to UI.HeaderFacets (XML annotation)

**DESCRIPTION**: Add a UI.ReferenceFacet entry into the UI.HeaderFacets collection. Set Label to the visible title and Target to the annotation path of a UI.FieldGroup (use Qualifier). Define the corresponding UI.FieldGroup annotation that contains UI.DataField items. Use UI.Importance to mark fields (e.g., High) and UI.Hidden to control visibility by path.

**LANGUAGE**: XML

**CODE**:
```xml

<Annotation Term="UI.HeaderFacets">
    <Collection>
        ...
        <Record Type="UI.ReferenceFacet">
            <PropertyValue Property="Label" String="Sales Area" />
            <PropertyValue Property="Target" AnnotationPath="@UI.FieldGroup#OrgData" />
        </Record>
        ...
        ...
    </Collection>
</Annotation>

<Annotation Term="UI.FieldGroup" Qualifier="OrgData">
    <Record Type="UI.FieldGroupType">
        <PropertyValue Property="Data">
            <Collection>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="SalesOrganization"/>
                    <Annotation Term="UI.Importance" EnumMember="UI.ImportanceType/High"/>
                </Record>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="DistributionChannel"/>
                    <Annotation Term="UI.Importance" EnumMember="UI.ImportanceType/High"/>
                    <Annotation Term="UI.Hidden" Path="Delivered"/>
                </Record>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="OrganizationDivision"/>
                    <Annotation Term="UI.Importance" EnumMember="UI.ImportanceType/High"/>
                </Record>
            </Collection>
        </PropertyValue>
    </Record>
</Annotation>
```

**STEP**: 2 — Define equivalent in ABAP CDS annotations

**DESCRIPTION**: For ABAP CDS models, use @UI.Facet to add a FIELDGROUP_REFERENCE facet with targetQualifier matching the field group qualifier. Apply @UI.fieldGroup to the relevant fields with importance, hidden, position, and qualifier.

**LANGUAGE**: ABAP

**CODE**:
```

@UI.Facet: [
  {
    label: '{@i18n>@SalesArea}',
    targetQualifier: 'OrgData',
    type: #FIELDGROUP_REFERENCE,
    purpose: #HEADER
  },
  ...
  ...
]
product;

@UI.fieldGroup: [
  {
    importance: #HIGH,
    position: 10 ,
    qualifier: 'OrgData'
  }
]
SALESORGANIZATION;

@UI.fieldGroup: [
  {
    importance: #HIGH,
    hidden: true,
    position: 20 ,
    qualifier: 'OrgData'
  }
]
DISTRIBUTIONCHANNEL;

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

```

**STEP**: 3 — Define equivalent in CAP CDS annotations

**DESCRIPTION**: In CAP CDS, annotate the service with UI.HeaderFacets containing a UI.ReferenceFacet style object and define UI.FieldGroup using UI.FieldGroupType with Data entries. Use ![@UI.Importance] and ![@UI.Hidden] to set importance/visibility.

**LANGUAGE**: CDS

**CODE**:
```

annotate service.Products with @(
  UI.HeaderFacets : [
    {
        $Type : 'UI.ReferenceFacet',
        Label : '{@i18n>@SalesArea}',
        Target : '@UI.FieldGroup#OrgData'
    },
   ...
   ...
  ],
  UI.FieldGroup #OrgData : {
    $Type : 'UI.FieldGroupType',
    Data : [
        {
            $Type : 'UI.DataField',
            Value : SalesOrganization,
            ![@UI.Importance] : #High
        },
        {
            $Type : 'UI.DataField',
            Value : DistributionChannel,
            ![@UI.Importance] : #High,
            ![@UI.Hidden] : Delivered
        },
        {
            $Type : 'UI.DataField',
            Value : OrganizationDivision,
            ![@UI.Importance] : #High
        }
    ]
  }
);

```


**TITLE**: Formatting Numeric Values in Fiori Elements Overview Pages

**INTRODUCTION**: Configure how numeric values are displayed (number of decimal places) in Fiori elements overview pages. The UI uses SAPUI5's sap.ui.core.format.NumberFormat. You can set decimal places either in the OData metadata (Property Scale) or in annotation documents (UI.DataPoint.ValueFormat with NumberOfFractionalDigits). Use the approach that best fits your service and annotation framework (OData metadata, XML annotations, ABAP CDS or CAP CDS).

**TAGS**: fiori-elements, numeric-formatting, OData, annotations, ui.datapoint, NumberFormat, CDS, ABAP, CAP, sap.ui.core.format.NumberFormat

**STEP**: 1 — Configure decimal places in OData metadata (EntityType Property Scale)

**DESCRIPTION**: Set the Scale attribute on Edm.Decimal properties in the OData metadata (EDMX) to control the number of fractional digits shown in overview pages. The example below sets Scale="3" so Price, Width, Depth, and Height display three decimal places. Keep sap:unit and sap:label attributes if needed for unit and label binding.

**LANGUAGE**: XML

**CODE**:
```xml
<EntityType Name="Product" sap:content-version="1">
    ...
    <Property Name="Price" Type="Edm.Decimal" Precision="16" Scale="3" sap:unit="CurrencyCode" sap:label="Unit Price"/>
    <Property Name="Width" Type="Edm.Decimal" Precision="13" Scale="3" sap:unit="DimUnit" sap:label="Dimensions"/>
    <Property Name="Depth" Type="Edm.Decimal" Precision="13" Scale="3" sap:unit="DimUnit" sap:label="Dimensions"/>
    <Property Name="Height" Type="Edm.Decimal" Precision="13" Scale="3" sap:unit="DimUnit" sap:label="Dimensions"/>
    ...
</EntityType>
```

**STEP**: 2 — Configure decimal places via UI.DataPoint annotation (XML)

**DESCRIPTION**: Use the com.sap.vocabularies.UI.v1.DataPoint annotation with a ValueFormat Record of type com.sap.vocabularies.UI.v1.NumberFormat. Set NumberOfFractionalDigits to the desired number of decimal places. Optionally use ScaleFactor when you need to scale the value (e.g., percent, per-thousand). This affects numeric display formatting for the annotated DataPoint.

**LANGUAGE**: XML

**CODE**:
```xml
<Annotation Term="com.sap.vocabularies.UI.v1.DataPoint" Qualifier="Price">
    <Record Type="com.sap.vocabularies.UI.v1.DataPointType">
        <PropertyValue Property="Title" String="Unit Price"/>
        <PropertyValue Property="Description" Path="Name"/>
        <PropertyValue Property="Value" Path="Price"/>
        <PropertyValue Property="ValueFormat">
            <Record Type="com.sap.vocabularies.UI.v1.NumberFormat">
                <PropertyValue Property="ScaleFactor" Decimal="1000"/>
                <PropertyValue Property="NumberOfFractionalDigits" Iint="1"/>
            </Record>
        </PropertyValue>
    </Record>
</Annotation>
```

**STEP**: 3 — Configure decimal places via ABAP CDS annotation (UI.dataPoint)

**DESCRIPTION**: In ABAP CDS, add a @UI.dataPoint annotation including valueFormat.numberOfFractionalDigits (and scaleFactor if needed). This annotation sets the display formatting for the CDS element in Fiori elements overview UI.

**LANGUAGE**: ABAP CDS

**CODE**:
```
@UI.dataPoint: {
  title: 'Unit Price',
  description: 'Name',
  valueFormat: {
    scaleFactor: 1000,
	numberOfFractionalDigits: 1
  }
}
Price;
```

**STEP**: 4 — Configure decimal places via CAP CDS annotation (UI.DataPoint)

**DESCRIPTION**: In CAP CDS, declare a UI.DataPoint annotation with ValueFormat specifying UI.NumberFormat, ScaleFactor, and NumberOfFractionalDigits. This configures the numeric formatting for the DataPoint in Fiori elements.

**LANGUAGE**: CAP CDS

**CODE**:
```
UI.DataPoint #Price : {
    $Type : 'UI.DataPointType',
    Title : 'Unit Price',
    Description : Name,
    Value : Price,
    ValueFormat : {
        $Type : 'UI.NumberFormat',
        ScaleFactor : 1000,
        NumberOfFractionalDigits : 1
    }
}
```

fiori-elements numeric-formatting OData annotations ui.datapoint NumberFormat CDS ABAP CAP sap.ui.core.format.NumberFormat


**TITLE**: Field Annotation Patterns for SAP Fiori elements (OData V4)

**INTRODUCTION**: Action-focused reference for annotating fields in SAP Fiori elements (OData V4). Contains code-ready examples for text handling, readable IDs, fiscal annotations, visibility/enablement, editability, tooltips, and disabling unit-of-measure decimal validation. Use these annotations in service metadata or CDS to control UI behavior.

**TAGS**: fiori-elements-framework, OData V4, annotations, UI.TextArrangement, Common.Text, Common.ExternalID, fiscal, UI.Hidden, FieldControl, Core.Computed, tooltip, units, decimals

STEP: Text Annotation — XML (property-level)
DESCRIPTION: Use Common.Text on a property to point to a descriptive text property and set UI.TextArrangement to control how code/ID and text are displayed. Example: set TextOnly arrangement for SalesOrganization.
LANGUAGE: XML
CODE:
```xml
<Annotations Target="com.c_salesordermanage_sd/SalesOrganization">
   …
   <Annotation Term="Common.Text" Path="SalesOrganization_Text">
      <Annotation Term="UI.TextArrangement" EnumMember="UI.TextArrangementType/TextOnly"/>
   </Annotation>
   …
</Annotations>
```

STEP: Text Annotation — ABAP CDS (property-level)
DESCRIPTION: ABAP CDS example to mark a text element and set text arrangement (#TEXT_ONLY) for SalesOrganization.
LANGUAGE: ABAP CDS
CODE:
```
…
@ObjectModel.text.element:  [ ' SalesOrganization_Text,' ]
@UI.textArrangement: #TEXT_ONLY
SalesOrganization
…
```

STEP: Text Annotation — CAP CDS (property-level)
DESCRIPTION: CAP CDS example to annotate SalesOrganization with Common.Text and TextArrangement (#TextOnly).
LANGUAGE: CDS
CODE:
```
annotate com.c_salesordermanage_sd with {
    ...
    SalesOrganization @(
             Common : {
              Text: SalesOrganization_Text,
              TextArrangement : #TextOnly
            })
    ...
};
```

STEP: Text Arrangement — XML (entity-set fallback)
DESCRIPTION: Define a fallback TextArrangement at the entity set level. Property-level TextArrangement takes precedence over entity set level.
LANGUAGE: XML
CODE:
```xml
<Annotations Target="SalesOrder"> //Main EntitySet
  <Annotation Term="com.sap.vocabularies.UI.v1.TextArrangement" EnumMember="com.sap.vocabularies.UI.v1.TextArrangementType/TextFirst"/>
</Annotations>
```

STEP: Display Readable IDs — XML (Common.ExternalID)
DESCRIPTION: For an Edm.Guid property (myGuidProperty), point Common.ExternalID to the readable identifier property (externalId). The readable ID will be shown in the UI; Common.Text/TextArrangement apply to the readable ID property.
LANGUAGE: XML
CODE:
```
      <Annotations Target="ExternalIdService.Entities/myGuidProperty">
        <Annotation Term="Common.ExternalID" Path="externalId"/>
      </Annotations>
```

STEP: Display Readable IDs — CAP CDS
DESCRIPTION: CAP CDS sample annotating myGuidProperty with Common.ExternalID to externalId.
LANGUAGE: CDS
CODE:
```
annotate ExternalIdService.Entities : myGuidProperty with @(Common: {ExternalID: externalId});
```

STEP: Fiscal Annotations — patterns and mapping
DESCRIPTION: Annotate Edm.String properties that represent fiscal dates. Use CAP CDS annotations (IsFiscal*) or ABAP CDS semantics (Semantics.fiscal.*). Patterns: YYYYPPP (yearPeriod), d (dayOfFiscalYear), PPP (period), Q (quarter), WW (week), YYYY (year), YYYYQ (yearQuarter), YYYYWW (yearWeek). Use IsDigitSequence where required.
LANGUAGE: Text
CODE:
```text
CAP CDS -> ABAP CDS mapping:
IsFiscalYearPeriod     -> Semantics.fiscal.yearPeriod      (pattern YYYYPPP)
IsDayOfFiscalYear      -> N/A                              (pattern d)
IsFiscalPeriod         -> Semantics.fiscal.period          (pattern PPP)
IsFiscalQuarter        -> Semantics.fiscal.quarter         (pattern Q)
IsFiscalWeek           -> Semantics.fiscal.week            (pattern WW)
IsFiscalYear           -> Semantics.fiscal.year            (pattern YYYY)
IsFiscalYearQuarter    -> Semantics.fiscal.yearQuarter     (pattern YYYYQ)
IsFiscalYearWeek       -> Semantics.fiscal.yearWeek        (pattern YYYYWW)
Semantics.fiscal.yearVariant -> N/A
```

STEP: Fiscal Annotations — XML (examples)
DESCRIPTION: XML examples marking multiple properties as fiscal types and adding labels.
LANGUAGE: XML
CODE:
```xml
<Annotations Target="sap.fe.manageitems.TechnicalTestingService.LineItems/fiscalYearPeriod">
  <Annotation Term="Common.IsFiscalYearPeriod" Bool="true"/>
  <Annotation Term="Common.Label" String="Fiscal Year Period"/>
</Annotations>
<Annotations Target="sap.fe.manageitems.TechnicalTestingService.LineItems/fiscalDayOfYear">
  <Annotation Term="Common.IsDayOfFiscalYear" Bool="true"/>
  <Annotation Term="Common.Label" String="Fiscal Day Of Year"/>
</Annotations>
<Annotations Target="sap.fe.manageitems.TechnicalTestingService.LineItems/fiscalPeriod">
  <Annotation Term="Common.IsFiscalPeriod" Bool="true"/>
  <Annotation Term="Common.Label" String="Fiscal Period"/>
</Annotations>
<Annotations Target="sap.fe.manageitems.TechnicalTestingService.LineItems/fiscalQuarter">
  <Annotation Term="Common.IsFiscalQuarter" Bool="true"/>
  <Annotation Term="Common.Label" String="Fiscal Quarter"/>
</Annotations>
<Annotations Target="sap.fe.manageitems.TechnicalTestingService.LineItems/fiscalWeek">
  <Annotation Term="Common.IsFiscalWeek" Bool="true"/>
  <Annotation Term="Common.Label" String="Fiscal Week"/>
</Annotations>
<Annotations Target="sap.fe.manageitems.TechnicalTestingService.LineItems/fiscalYear">
  <Annotation Term="Common.IsFiscalYear" Bool="true"/>
  <Annotation Term="Common.Label" String="Fiscal Year"/>
</Annotations>
<Annotations Target="sap.fe.manageitems.TechnicalTestingService.LineItems/fiscalYearQuarter">
  <Annotation Term="Common.IsFiscalYearQuarter" Bool="true"/>
  <Annotation Term="Common.IsDigitSequence" Bool="true"/>
  <Annotation Term="Common.Label" String="Fiscal Year Quarter"/>
</Annotations>
<Annotations Target="sap.fe.manageitems.TechnicalTestingService.LineItems/fiscalWeekYear">
  <Annotation Term="Common.IsFiscalYearWeek" Bool="true"/>
  <Annotation Term="Common.Label" String="Fiscal Week Year"/>
</Annotations>
```

STEP: Fiscal Annotations — ABAP CDS (example)
DESCRIPTION: ABAP CDS view example marking fiscal semantics on fields.
LANGUAGE: ABAP CDS
CODE:
```
DEFINE VIEW SalesOrderItemHistoryOvw as select from ...
{
    ...

    @Semantics.fiscal.yearPeriod: true
    fiscalYearPeriod,

    @Semantics.fiscal.period: true
    fiscalPeriod,

    @Semantics.fiscal.year: true
    fiscalYear,

    ...
}
```

STEP: Fiscal Annotations — CAP CDS (example)
DESCRIPTION: CAP CDS schema fields annotated for fiscal semantics and titles.
LANGUAGE: CDS
CODE:
```
fiscalYearPeriod  : String     @title: 'Fiscal Year Period'   @Common.IsFiscalYearPeriod : true;
fiscalDayOfYear   : String     @title: 'Fiscal Day Of Year'   @Common.IsDayOfFiscalYear  : true;
fiscalPeriod      : String     @title: 'Fiscal Period'        @Common.IsFiscalPeriod     : true;
fiscalQuarter     : String(1)  @title: 'Fiscal Quarter'       @Common.IsFiscalQuarter    : true;
fiscalWeek        : String     @title: 'Fiscal Week'          @Common.IsFiscalWeek       : true;
fiscalYear        : String     @title: 'Fiscal Year'          @Common.IsFiscalYear       : true;
fiscalYearQuarter : String(5) @title: 'Fiscal Year Quarter' @Common.IsFiscalYearQuarter: true @Common.IsDigitSequence: true;
fiscalWeekYear    : String     @title: 'Fiscal Week Year'     @Common.IsFiscalYearWeek   : true;
```

STEP: Visibility — UI.Hidden within DataField (XML)
DESCRIPTION: Control visibility per UI.DataField using UI.Hidden annotation inside the DataField record.
LANGUAGE: XML
CODE:
```xml
<Record Type="UI.DataField">
   <PropertyValue Property="Value" Path="TotalNetAmount" />
   <Annotation Term="UI.Hidden" Bool="false" />
</Record>
```

STEP: Visibility — UI.Hidden within DataField (ABAP CDS)
DESCRIPTION: ABAP CDS representation for a data field with hidden attribute.
LANGUAGE: ABAP CDS
CODE:
```
{
    value: 'TOTALNETAMOUNT',
    type: #STANDARD
}
@UI.hidden: true
TOTALNETAMOUNT;
```

STEP: Visibility — UI.Hidden within DataField (CAP CDS)
DESCRIPTION: CAP CDS JSON-like UI.DataField with UI.Hidden set.
LANGUAGE: CDS
CODE:
```
{
    $Type : 'UI.DataField',
    Value : 'TotalNetAmount',
    ![@UI.Hidden] : false
}
```

STEP: Visibility — UI.Hidden on a Property (XML)
DESCRIPTION: Hide a property across the UI by annotating the property with UI.Hidden.
LANGUAGE: XML
CODE:
```xml
<Annotations Target="com.c_salesordermanage_sd.SalesOrderManage/TotalNetAmount">
    <Annotation Term="Common.Label" String="Net Amount"/>
    <Annotation Term="Measures.ISOCurrency" Path="TransactionCurrency"/>
    <Annotation Term="UI.Hidden" Bool="true" />
</Annotations>
```

STEP: Visibility — UI.Hidden on a Property (CAP CDS)
DESCRIPTION: CAP CDS to annotate TotalNetAmount property with UI.Hidden and Measures.ISOCurrency.
LANGUAGE: CDS
CODE:
```
annotate com.c_salesordermanage_sd. SalesOrderManage with {
  TotalNetAmount
  @UI.Hidden
  @Common.Label : 'Net Amount'
  @Measures.ISOCurrency :  TransactionCurrency ;
};
```

STEP: Visibility — ProductsType ID always hidden
DESCRIPTION: Examples to always hide the property ID of ProductsType.
LANGUAGE: XML
CODE:
```xml
<Annotations Target="SAP__self.ProductsType/ID">
    <Annotation Term="SAP__UI.Hidden"/>
</Annotations>
```

STEP: Visibility — ProductsType ID always hidden (ABAP CDS)
DESCRIPTION: ABAP CDS annotation to hide id in PRODUCTSTYPE.
LANGUAGE: ABAP CDS
CODE:
```
annotate view PRODUCTSTYPE with {
@UI.hidden: true
id;
}
```

STEP: Visibility — ProductsType ID always hidden (CAP CDS)
DESCRIPTION: CAP CDS to hide ID on ProductsType.
LANGUAGE: CDS
CODE:
```
annotate ProductsType with {
  ID @UI.Hidden;
};
```

STEP: Visibility — Path-based UI.Hidden (FieldGroup qualifier)
DESCRIPTION: Use a path for UI.Hidden inside a FieldGroup to hide ModifiedAt in that FieldGroup when HasDraftEntity is true. Note: ABAP CDS does not support path-based UI.hidden; use local XML annotation there.
LANGUAGE: XML
CODE:
```xml
<Annotations Target="SAP__self.ProductsType">
    <Annotation Term="SAP__UI.FieldGroup" Qualifier="AdministrativeData">
        <Record>
            <PropertyValue Property="Data">
                <Collection>
                    <Record Type="SAP__UI.DataField">
                        <Annotation Term="SAP__UI.Hidden" Path=="HasDraftEntity"/>
                        <PropertyValue Property="Label" String="Modified at"/>
                        <PropertyValue Property="Value" Path="ModifiedAt"/>
                    </Record>
```

STEP: Visibility — Path-based UI.Hidden (CAP CDS FieldGroup)
DESCRIPTION: CAP CDS FieldGroup with UI.Hidden bound to HasDraftEntity for the specific DataField.
LANGUAGE: CDS
CODE:
```
entity ProductsType : {
    UI.FieldGroup #AdministrativeData : {
    Data : [
        {
            $Type : 'UI.DataField',
            Label : 'Modified at',
            Value : ModifiedAt,
            ![@UI.Hidden] : HasDraftEntity,
        },
    ],
},
}
```

STEP: Visibility — Always hide ModifiedAt when HasDraftEntity true (XML)
DESCRIPTION: Hide ModifiedAt property everywhere by setting UI.Hidden Path to HasDraftEntity on the property.
LANGUAGE: XML
CODE:
```xml
<Annotations Target="SAP__self.ProductsType/ModifiedAt">
    <Annotation Term="SAP__UI.Hidden" Path="HasDraftEntity"/>
</Annotations>
```

STEP: Visibility — Always hide ModifiedAt when HasDraftEntity true (CAP CDS)
DESCRIPTION: CAP CDS property-level UI.Hidden bound to HasDraftEntity.
LANGUAGE: CDS
CODE:
```
entity ProductsType :{
    ModifiedAt : {
               ![@UI.Hidden] : HasDraftEntity
    }
}
```

STEP: Enablement — FieldControl (metadata-level)
DESCRIPTION: Use common.FieldControl to set field enablement behavior. You can set static EnumMember values or point to a path (path must be Edm.Byte). Examples below show Mandatory, ReadOnly usage.
LANGUAGE: XML
CODE:
```xml
<Annotations Target="SAP__self.ArtistsType/Name">
   <Annotation Term="SAP__common.FieldControl" EnumMember="SAP__common.FieldControlType/Mandatory"/>
   ....
   ....
</Annotations>
```

STEP: Enablement — FieldControl (ABAP CDS)
DESCRIPTION: ABAP CDS uses @ObjectModel.mandatory exposed as mandatory; @ObjectModel.readOnly is not exposed via metadata extensions.
LANGUAGE: ABAP CDS
CODE:
```
@ObjectModel.mandatory: true
Name;
```

STEP: Enablement — FieldControl (CAP CDS)
DESCRIPTION: CAP CDS example to mark Name FieldControl as Mandatory.
LANGUAGE: CDS
CODE:
```
entity Artist : {
    Name : {
        FieldControl : #Mandatory
    }
}
```

STEP: FieldControl within DataField — XML
DESCRIPTION: Control enablement/read-only per UI.DataField using common.FieldControl inside the DataField record (useful to vary in table vs form).
LANGUAGE: XML
CODE:
```xml
<Record Type="UI.DataField">
   <PropertyValue Property="Value" Path="TotalNetAmount" />
   <Annotation Term=" SAP__common.FieldControl" EnumMember="SAP__common.FieldControlType/ReadOnly"/>
</Record>
```

STEP: FieldControl within DataField — CAP CDS
DESCRIPTION: CAP CDS DataField with Common.FieldControl set to #ReadOnly.
LANGUAGE: CDS
CODE:
```
{
            $Type : 'UI.DataField',
            Value : TotalNetAmount,
            ![@Common.FieldControl] : #ReadOnly,
}
```

STEP: FieldControl — Values and behaviors
DESCRIPTION: Map FieldControl enum values to behaviors and EnumMembers for metadata:
LANGUAGE: Text
CODE:
```text
Mandatory:
 - Behavior: Property must be non-null for save/update (backend validation required).
 - EnumMember: SAP__common.FieldControlType/Mandatory

Optional:
 - Behavior: Property can be null.
 - EnumMember: SAP__common.FieldControlType/Optional

ReadOnly:
 - Behavior: Property value cannot be changed (read-only in edit mode).
 - EnumMember: SAP__common.FieldControlType/ReadOnly

Inapplicable:
 - Behavior: Property has no meaning in current state and is disabled; dynamic Inapplicable renders as disabled.
 - EnumMember: SAP__common.FieldControlType/Inapplicable

Notes:
 - Path-based FieldControl must point to an Edm.Byte property.
 - Fields in Insert/Update RequiredProperties are marked mandatory only in create/update flows.
 - Static Inapplicable is ignored by Fiori elements (treat as absent).
```

STEP: Editability — Core.Computed and Core.Immutable (CreatedAt example)
DESCRIPTION: Core.Computed=true marks property always non-editable (read-only). Core.Immutable is read-only in edit mode but editable in create mode.
LANGUAGE: XML
CODE:
```xml
<Annotations Target="SAP__self.ProductsType/CreatedAt">
    <Annotation Term="SAP__Core.Computed"/>
</Annotations>
```

STEP: Editability — Core.Computed (CAP CDS)
DESCRIPTION: CAP CDS example setting CreatedAt as Core.Computed.
LANGUAGE: CDS
CODE:
```
entity ProductsType : {
    CreatedAt : {
        Core.Computed: true
    }
}
```

STEP: Editability — FieldControl ReadOnly (SupplierName example)
DESCRIPTION: Make SupplierName always read-only for this application using Common.FieldControl on the property.
LANGUAGE: XML
CODE:
```xml
<Annotations Target="SAP__self.ProductsType/SupplierName">
    <Annotation Term="SAP__Common.FieldControl" EnumMember="com.sap.vocabularies.Common.v1.FieldControl/ReadOnly"/>
</Annotations>
```

STEP: Editability — FieldControl ReadOnly (CAP CDS)
DESCRIPTION: CAP CDS example marking SupplierName as read-only using Common.FieldControl.
LANGUAGE: CDS
CODE:
```
entity ProductsType : {
    SupplierName : {
        Common.FieldControl : #ReadOnly
    }
}
```

STEP: Editability — FieldControl path-based (AvailabilityCode example)
DESCRIPTION: Make AvailabilityCode read-only when __FieldControl/AvailabilityCode_FC equals 1 by using a path for Common.FieldControl (use local XML if ABAP CDS required).
LANGUAGE: XML
CODE:
```xml
<Annotations Target="SAP__self.ReviewsType/AvailabilityCode">
    <Annotation Term=" SAP__Common.FieldControl" Path="__FieldControl/AvailabilityCode_FC"/>
</Annotations>
```

STEP: Editability — FieldControl path-based (CAP CDS)
DESCRIPTION: CAP CDS mapping of Common.FieldControl to a field path.
LANGUAGE: CDS
CODE:
```
entity ReviewsType : {
    Common.FieldControl : __FieldControl.AvailabilityCode_FC
}
```

STEP: Tooltip for a Data Point — XML
DESCRIPTION: Use Common.QuickInfo inside a UI.DataPoint record to provide a tooltip. The tooltip displays when no explicit label exists for the data point.
LANGUAGE: XML
CODE:
```xml
<Annotation Term="UI.DataPoint" Qualifier="Rating">
    <Record Type="UI.DataPointType">
        <Annotation Term="Common.QuickInfo" String="Rating Indicator "/>
        <PropertyValue Property="TargetValue" Int="5"/>
        <PropertyValue Property="Title" String="Rating"/>
        <PropertyValue Property="Value" Path="Rating"/>
        <PropertyValue Property="Visualization" EnumMember="UI.VisualizationType/Rating"/>
    </Record>
</Annotation>
```

STEP: Tooltip for a Data Point — ABAP CDS
DESCRIPTION: ABAP CDS dataPoint example; note Common.QuickInfo is not supported for dataPoint in ABAP CDS and qualifier is auto-generated.
LANGUAGE: ABAP CDS
CODE:
```
@UI.dataPoint: {
  title: 'Rating',
  visualization: #RATING
  targetValue: 5
}
Rating;
```

STEP: Tooltip for a Data Point — CAP CDS
DESCRIPTION: CAP CDS UI.DataPoint with Common.QuickInfo provided via ![@Common.QuickInfo].
LANGUAGE: CDS
CODE:
```
UI.DataPoint #Rating : {
    $Type : 'UI.DataPointType',
    TargetValue : 5,
    Title : 'Rating',
    Value : Rating,
    Visualization : #Rating,
    ![@Common.QuickInfo] : 'Rating Indicator ',
}
```

STEP: Decimal Validation for Units of Measure
DESCRIPTION: Use com.sap.vocabularies.UI.v1.DoNotCheckScaleOfMeasuredQuantity (Bool) to disable central validation of allowed decimal places for measured quantities (units/currencies). false => enforce central validation; true => skip central validation (allows more fractional digits). Note: field-internal max decimal places still apply and cannot be exceeded.
LANGUAGE: Text
CODE:
```text
Annotation: com.sap.vocabularies.UI.v1.DoNotCheckScaleOfMeasuredQuantity
 - Bool="true"  => skip central UoM/currency decimal validation (allows more fractional digits)
 - Bool="false" => enforce central UoM/currency decimal validation
Note: The field's own max-decimal definition is still enforced.
```


**TITLE**: Further Post-Generation Steps for SAP Fiori elements Apps

**INTRODUCTION**: After generating a SAP Fiori elements application, adjust default behavior and enable features by editing the app manifest and annotations. You can also extend the generated app using SAP Fiori tools or manually. This document lists the actionable post-generation tasks and shows practical examples for manifest and annotation edits.

**TAGS**: fiori-elements-framework, sap, manifest.json, annotations, fiori-tools, extension, post-generation

**STEP**: 1 — Edit manifest.json to enable or modify default features

**DESCRIPTION**: Open the app's manifest.json and change configuration entries to enable or customize features (routing, models, annotation references, UI5 settings, extension points, etc.). Typical edits include registering annotation files as data sources and adding annotation URIs to the sap.ui5 models section. Apply changes, then test the app.

**LANGUAGE**: JSON

**CODE**:
```json
{
  "sap.app": {
    "id": "my.company.app",
    "applicationVersion": { "version": "1.0.0" },
    "dataSources": {
      "annotations": {
        "uri": "annotations/annotations.xml",
        "type": "ODataAnnotation"
      },
      "mainService": {
        "uri": "/sap/opu/odata/sap/ZSERVICE_SRV/",
        "type": "OData",
        "settings": { "localUri": "localService/metadata.xml" }
      }
    }
  },
  "sap.ui5": {
    "models": {
      "": {
        "dataSource": "mainService"
      },
      "sap.fe.annotation": {
        "dataSource": "annotations",
        "settings": {
          "annotationURI": ["annotations/annotations.xml"]
        }
      }
    },
    "routing": {
      "routes": [],
      "targets": {}
    }
  }
}
```

**STEP**: 2 — Adapt and extend annotation files

**DESCRIPTION**: Locate the annotation files referenced in manifest.json (commonly under the annotations/ folder). Update or create annotation XML files to adjust UI behavior, semantic keys, facets, line items, and other metadata-driven features. Keep annotation targets and term names accurate to your OData service metadata.

**LANGUAGE**: XML

**CODE**:
```xml
<Annotations xmlns="http://docs.oasis-open.org/odata/ns/edm">
  <!-- Example: add UI.LineItem for an entity type -->
  <Annotations Target="MyNamespace.MyEntityType">
    <Annotation Term="UI.LineItem">
      <Collection>
        <Record Type="UI.DataField">
          <PropertyValue Property="Value" Path="PropertyA"/>
        </Record>
        <Record Type="UI.DataField">
          <PropertyValue Property="Value" Path="PropertyB"/>
        </Record>
      </Collection>
    </Annotation>
  </Annotations>
  <!-- Add more annotations (UI.Facets, UI.HeaderInfo, Common.SemanticKey, etc.) -->
</Annotations>
```

**STEP**: 3 — Extend the generated app using SAP Fiori tools (recommended)

**DESCRIPTION**: Use SAP Fiori tools in Visual Studio Code to scaffold extensions, add controller hooks, adapt views, and run local testing. The VS Code extension lets you configure page elements and generate extension artifacts safely, preserving the generated base.

**LANGUAGE**: Bash

**CODE**:
```bash
# In VS Code:
# 1. Install SAP Fiori tools extensions (Fiori tools - Extension Pack)
# 2. Open the generated project folder
# 3. Use Command Palette -> "Fiori: Configure App" or "Fiori: Add Extension"
# 4. Run the app locally with: npm start or the launch configuration provided
#
# Reference: https://help.sap.com/docs/SAP_FIORI_tools/17d50220bcd848aa854c9c182d65b699/047507c86afa4e96bb3d284adb9f4726.html
```

**STEP**: 4 — Manually extend SAP Fiori elements-based apps

**DESCRIPTION**: For manual extension (outside of Fiori tools), follow SAP guidance for adding custom controllers, fragments, and component overrides. Ensure changes are compatible with the Fiori elements lifecycle and the manifest configuration.

**LANGUAGE**: text

**CODE**:
```
See the manual extension guide:
- Extending SAP Fiori Elements-Based Apps: extending-sap-fiori-elements-based-apps-358cf25.md
Follow practices:
- Use extension hooks and controller fragments
- Avoid modifying generated core views; extend via fragments or controller hooks
- Keep manifest.json consistent with custom artifacts
```

**STEP**: 5 — Floorplan-specific configuration and enhancement

**DESCRIPTION**: Depending on the app floorplan, apply the corresponding post-generation adjustments and annotation patterns. Follow each floorplan guide to enable features specific to that template.

**LANGUAGE**: text

**CODE**:
```
Relevant floorplan guides:
- List Report and Object Page: list-report-and-object-page-c0eec49.md
- Worklist: worklist-d1d588f.md
- Analytical List Page: analytical-list-page-3d33684.md
- Overview Pages: overview-pages-c64ef8c.md
```

fiori-elements-framework sap manifest.json annotations fiori-tools extension post-generation


**TITLE**: General Concepts for SAP Fiori Elements Framework (Developer-Focused)

**INTRODUCTION**: Practical, code-focused overview of core concepts and files when building Fiori Elements applications. Use these steps and code snippets as templates for project scaffolding, manifest configuration, annotations, OData/CDS service definitions, extensibility points, routing/pages setup, and local testing with a mock server.

**TAGS**: fiori-elements, sapui5, odata, annotations, manifest.json, cds, mockserver, routing, extensibility

STEP: 1 - Project scaffold & main files
DESCRIPTION: Create the minimal file structure and key files for a Fiori Elements app. Keep these files at the root of your UI project.
LANGUAGE: JSON
CODE:
```json
// Project structure (example)
{
  "webapp/": [
    "index.html",
    "manifest.json",
    "Component.js",
    "view/",
    "controller/",
    "model/",
    "annotations/",
    "localService/"
  ],
  "srv/": [
    "cat-service.cds" // for CAP backend
  ],
  "package.json": {}
}
```

STEP: 2 - manifest.json: register app, templates, OData models
DESCRIPTION: Configure the app-level manifest. Use sap.ui.generic.app to declare pages and templates (ListReport/ObjectPage). Define dataSources and sap.ui5 models. Replace placeholder URIs and IDs.
LANGUAGE: JSON
CODE:
```json
{
  "sap.app": {
    "id": "com.example.app",
    "applicationVersion": { "version": "1.0.0" },
    "title": "Fiori Elements App"
  },
  "sap.ui": {
    "technology": "UI5"
  },
  "sap.ui5": {
    "models": {
      "": {
        "dataSource": "mainService",
        "settings": { "defaultBindingMode": "TwoWay" }
      },
      "i18n": {
        "type": "sap.ui.model.resource.ResourceModel",
        "settings": { "bundleName": "com.example.app.i18n.i18n" }
      }
    },
    "resources": {}
  },
  "sap.app": {},
  "sap.ui.generic.app": {
    "pages": [
      {
        "entitySet": "Products",
        "component": {
          "name": "sap.suite.ui.generic.template.ListReport",
          "settings": {}
        }
      },
      {
        "entitySet": "Products",
        "component": {
          "name": "sap.suite.ui.generic.template.ObjectPage",
          "settings": {}
        }
      }
    ]
  },
  "sap.cloud": {},
  "sap.platform.hcp": {}
}
```

STEP: 3 - Define OData data source in manifest
DESCRIPTION: Add dataSources under manifest root to map the UI to the OData service (use annotation files if applicable).
LANGUAGE: JSON
CODE:
```json
{
  "sap.app": {},
  "sap.ui5": {},
  "dataSources": {
    "mainService": {
      "uri": "/sap/opu/odata/sap/ZMY_SRV/",
      "type": "OData",
      "settings": {
        "odataVersion": "2.0",
        "localUri": "localService/metadata.xml" // local metadata for offline/mock testing
      }
    },
    "annotations": {
      "uri": "annotations/annotations.xml",
      "type": "OData"
    }
  }
}
```

STEP: 4 - CDS model and service (SAP CAP) - define entities and exposures
DESCRIPTION: For CAP projects, define a CDS entity and service that the Fiori app consumes. Annotate for UI where needed. Activate the service in srv/cat-service.cds.
LANGUAGE: CDS
CODE:
```cds
// db/schema.cds
namespace my.bookshop;

entity Books {
  key ID   : UUID;
  title    : String(111);
  author   : String(111);
  stock    : Integer;
}

// srv/cat-service.cds
using my.bookshop as my from '../db/schema';

service CatalogService @(path:'/catalog') {
  entity Books as projection on my.Books;
}
```

STEP: 5 - OData annotations (XML) for UI (HeaderInfo, FieldGroup, LineItem)
DESCRIPTION: Provide OData annotations consumed by Fiori Elements for page layout, columns, and header. Store under webapp/annotations/ and reference in manifest (dataSources or sap.ui5 models).
LANGUAGE: XML
CODE:
```xml
<?xml version="1.0" encoding="utf-8"?>
<edmx:Edmx xmlns:edmx="http://docs.oasis-open.org/odata/ns/edmx" Version="4.0">
  <edmx:Annotation Term="UI.HeaderInfo">
    <Record>
      <PropertyValue Property="TypeName" String="Book"/>
      <PropertyValue Property="Title" Path="title"/>
    </Record>
  </edmx:Annotation>

  <edmx:Annotation Term="UI.LineItem">
    <Collection>
      <Record Type="UI.DataField">
        <PropertyValue Property="Value" Path="title"/>
      </Record>
      <Record Type="UI.DataField">
        <PropertyValue Property="Value" Path="author"/>
      </Record>
      <Record Type="UI.DataField">
        <PropertyValue Property="Value" Path="stock"/>
      </Record>
    </Collection>
  </edmx:Annotation>
</edmx:Edmx>
```

STEP: 6 - Component.js bootstrap
DESCRIPTION: Standard Component.js for UI5/fiori elements apps; it bootstraps the UI and uses manifest.
LANGUAGE: JavaScript
CODE:
```javascript
sap.ui.define([
  "sap/ui/core/UIComponent"
], function (UIComponent) {
  "use strict";
  return UIComponent.extend("com.example.app.Component", {
    metadata: {
      manifest: "json"
    },

    init: function () {
      UIComponent.prototype.init.apply(this, arguments);
      // Additional initialization if required
    }
  });
});
```

STEP: 7 - Extensibility: controller extension registration (manifest snippet)
DESCRIPTION: Register controller or view extensions in manifest to provide custom logic or UI extensions for Fiori Elements templates.
LANGUAGE: JSON
CODE:
```json
{
  "sap.ui5": {
    "extends": {
      "extensions": {
        "sap.ui.controllerExtensions": {
          "sap.suite.ui.generic.template.ListReport.view.ListReport": {
            "controllerName": "com.example.app.ext.ListReportExtension"
          }
        }
      }
    }
  }
}
```

STEP: 8 - Local testing: UI5 MockServer setup (index.html or localService)
DESCRIPTION: Use UI5 MockServer to serve local metadata.xml and mock OData payloads during frontend development. Point manifest dataSource to localUri.
LANGUAGE: JavaScript
CODE:
```javascript
// webapp/localService/mockserver.js
sap.ui.define([
  "sap/ui/core/util/MockServer"
], function (MockServer) {
  "use strict";
  return {
    init: function () {
      var oMockServer = new MockServer({
        rootUri: "/sap/opu/odata/sap/ZMY_SRV/"
      });
      MockServer.config({
        autoRespond: true,
        autoRespondAfter: 100
      });
      oMockServer.simulate("localService/metadata.xml", "localService/mockdata");
      oMockServer.start();
      jQuery.sap.log.info("Mock server started");
    }
  };
});
```

STEP: 9 - Routing & Pages (simplified reference)
DESCRIPTION: Fiori Elements routes are primarily driven by sap.ui.generic.app pages in manifest.json. For custom navigation inside extensions, use Router and CrossApplicationNavigation if needed.
LANGUAGE: JSON
CODE:
```json
{
  "sap.ui.generic.app": {
    "pages": [
      {
        "entitySet": "Books",
        "component": {
          "name": "sap.suite.ui.generic.template.ListReport"
        }
      },
      {
        "entitySet": "Books",
        "component": {
          "name": "sap.suite.ui.generic.template.ObjectPage"
        }
      }
    ]
  }
}
```

STEP: 10 - Debugging & common checks
DESCRIPTION: Checklist for common issues during development:
- Validate manifest.json syntax and dataSources localUri paths.
- Ensure annotations file path is referenced in manifest or metadata.
- Confirm OData metadata (metadata.xml) matches annotation target names (entity/namespace).
- Enable UI5 debug libs by appending ?sap-ui-debug=true to the URL.
LANGUAGE: JSON
CODE:
```json
// Example CLI command to run CAP + UI locally (dev setup)
{
  "scripts": {
    "start": "cds run --open && ui5 serve --config=ui5-local.yaml"
  }
}
```

fiori-elements sapui5 odata annotations manifest.json cds mockserver routing extensibility


**TITLE**: General Concepts and Configuration (fiori-elements-framework)

**INTRODUCTION**: Central reference for general concepts and configuration points used in SAP Fiori elements applications. Use this to find focused configuration topics (actions, messages, layout, titles, variants, responsiveness, value help, images/icons, keyboard shortcuts, and table expansion) and their canonical documentation file paths for programmatic linking or automation.

**TAGS**: fiori-elements, configuration, annotations, UI, responsiveness, value-help, images, keyboard-shortcuts, variants, flexible-column-layout, messages, application-title

STEP: 1 — Overview / Related documentation index

DESCRIPTION: Use this step as the index to all related configuration topics. Each item below is the canonical documentation filename to reference or embed in generated documentation, navigation UIs, or RAG retrieval prompts.

LANGUAGE: Text

CODE:
```text
Actions: actions-cbf16c5.md
Using Messages: using-messages-239b192.md
Enabling the Flexible Column Layout: enabling-the-flexible-column-layout-e762257.md
Configuring the Application Title: configuring-the-application-title-ac70343.md
Managing Variants: managing-variants-8ce658e.md
Responsiveness Options: responsiveness-options-example-69efbe7.md
Value Help as a Dropdown List: value-help-as-a-dropdown-list-2a0a630.md
Using Images, Initials, and Icons: using-images-initials-and-icons-5760b63.md
Keyboard Shortcuts: keyboard-shortcuts-0cd318c.md
Initial Expansion Level for Tables: initial-expansion-level-for-tables-in-list-reports-analytical-list-pages-bc05d35.md
```

STEP: 2 — Actions (generic and application-specific)

DESCRIPTION: Implement generic Fiori elements actions or application-specific actions through annotations or extension points. Reference the actions documentation file for available generic actions and recommended extension patterns.

LANGUAGE: Text

CODE:
```text
Reference documentation: actions-cbf16c5.md
Usage: Use annotations or extension points as described in the file to add action handlers, configure intent/navigation, or wire custom action UI.
```

STEP: 3 — Messages (system-generated messages)

DESCRIPTION: Handle messages that the SAP system generates in response to user actions. Use the messages documentation to implement message handling, user-visible message formatting, and mapping to UI components.

LANGUAGE: Text

CODE:
```text
Reference documentation: using-messages-239b192.md
Usage: Follow the document for mapping backend messages to UI messages and for implementing message handling flows in the application.
```

STEP: 4 — Flexible Column Layout (two- or three-column pages)

DESCRIPTION: Enable and configure the flexible column layout to show two or three columns on a single page according to responsive layout needs. Use the referenced file for configuration options and integration steps.

LANGUAGE: Text

CODE:
```text
Reference documentation: enabling-the-flexible-column-layout-e762257.md
Usage: Configure routing and target aggregation for 2/3 column behavior as described in the file.
```

STEP: 5 — Application Title (SAP Fiori launchpad title configuration)

DESCRIPTION: Configure the application title generated by the SAP Fiori launchpad if customization is required. Use the provided document to adjust title configuration and fallback behavior.

LANGUAGE: Text

CODE:
```text
Reference documentation: configuring-the-application-title-ac70343.md
Usage: Adjust title configuration via manifest or launchpad settings as documented.
```

STEP: 6 — Managing Variants (filter & content area variants)

DESCRIPTION: Implement variant management that supports different structures for filters and content. Use the managing-variants document to wire variant persistence, default variants, and variant switching.

LANGUAGE: Text

CODE:
```text
Reference documentation: managing-variants-8ce658e.md
Usage: Follow the variant lifecycle and persistence patterns in the file for consistent behavior.
```

STEP: 7 — Responsiveness Options (importance-based field evaluation)

DESCRIPTION: Configure responsiveness options for pages with toolbars (list report tables, object page tables, smart chart toolbars). The system evaluates com.sap.vocabularies.UI.v1.Importance for each field; use the responsiveness options document to tune field visibility and priority.

LANGUAGE: Text

CODE:
```text
Reference documentation: responsiveness-options-example-69efbe7.md
Annotation to consider: com.sap.vocabularies.UI.v1.Importance
Usage: Annotate fields with Importance to control field rendering priority in toolbar and responsive layouts.
```

STEP: 8 — Value Help as a Dropdown List (fixed number of values)

DESCRIPTION: If a value help contains a fixed number of values, render it as a dropdown list. Refer to the value-help document to detect fixed lists and implement dropdown rendering.

LANGUAGE: Text

CODE:
```text
Reference documentation: value-help-as-a-dropdown-list-2a0a630.md
Usage: Detect fixed-value value helps and apply dropdown rendering patterns from the file.
```

STEP: 9 — Using Images, Initials, and Icons

DESCRIPTION: Support images, generated initials, and icons in UI entities. Use the linked documentation to understand supported annotation patterns, image sizes, and fallbacks.

LANGUAGE: Text

CODE:
```text
Reference documentation: using-images-initials-and-icons-5760b63.md
Usage: Use image and icon annotations and fallback rules from the document to render avatars, thumbnails, and icons.
```

STEP: 10 — Keyboard Shortcuts (basic operations)

DESCRIPTION: Implement keyboard shortcuts for basic operations in SAP Fiori elements apps. Follow the keyboard-shortcuts file to add and document shortcuts, including accessibility considerations.

LANGUAGE: Text

CODE:
```text
Reference documentation: keyboard-shortcuts-0cd318c.md
Usage: Define and register shortcut keys per the recommended patterns to enable keyboard accessibility.
```

STEP: 11 — Initial Expansion Level for Tables (List Reports & Analytical List Pages)

DESCRIPTION: Set the number of expanded levels for tables using the initialExpansionLevel property of the PresentationVariant annotation. Use the referenced file to find exact annotation usage and placement.

LANGUAGE: Text

CODE:
```text
Reference documentation: initial-expansion-level-for-tables-in-list-reports-analytical-list-pages-bc05d35.md
Annotation/property: PresentationVariant.initialExpansionLevel
Usage: Annotate the PresentationVariant with initialExpansionLevel to control tree/table expansion on initial render.
```

fiori-elements configuration annotations UI responsiveness value-help images keyboard-shortcuts variants flexible-column-layout messages application-title


**TITLE**: Generative AI Features for SAP Fiori elements

**INTRODUCTION**: This document describes the generative AI features available in SAP Fiori elements: AI-Assisted Easy Filter (natural-language filtering on List Reports) and AI-Assisted Smart Summarization (summaries on Object Pages). It lists prerequisites, usage examples, image references, and links to official help topics. Use the examples as direct prompts/inputs for automated test cases or UI automation that interacts with these features.

**TAGS**: fiori-elements, sap-s4hana-cloud, generative-ai, ai-assisted, easy-filter, smart-summarization, ux

**STEP**: 1 — Prerequisites and Entitlements

**DESCRIPTION**: Verify entitlements and authorizations required to enable generative AI features in SAP S/4HANA Cloud Public Edition. Confirm tenant-level settings and user role assignments before attempting to use AI-Assisted Easy Filter or AI-Assisted Smart Summarization.

- Note: Additional entitlement and authorization may be required for these generative AI features in SAP S/4HANA Cloud Public Edition.
- Keep image references available for UI validation:
  - images/AI-Assisted_Easy_Filter_6254f19.png
  - images/AI-Assisted_Smart_Summarization_e3ea9c8.png
- Official help links (use for implementation and admin guidance):
  - AI-Assisted Easy Filter: https://help.sap.com/docs/SAP_S4HANA_CLOUD/4fc8d03390c342da8a60f8ee387bca1a/804ed39a7dd34720912483ddfb847087.html
  - AI-Assisted Smart Summarization: https://help.sap.com/docs/SAP_S4HANA_CLOUD/4fc8d03390c342da8a60f8ee387bca1a/6c1bc21f01c840cba336404fb249cf95.html

**LANGUAGE**: Text

**CODE**:
```text
Prerequisites:
- Validate tenant entitlements for generative AI features in SAP S/4HANA Cloud Public Edition.
- Ensure user roles include access to AI-assisted features.
- Prepare screenshots for UI verification:
  - images/AI-Assisted_Easy_Filter_6254f19.png
  - images/AI-Assisted_Smart_Summarization_e3ea9c8.png
- Reference admin docs:
  - Easy Filter: https://help.sap.com/.../804ed39a7dd34720912483ddfb847087.html
  - Smart Summarization: https://help.sap.com/.../6c1bc21f01c840cba336404fb249cf95.html
```

**STEP**: 2 — AI-Assisted Easy Filter: Usage and Example Queries

**DESCRIPTION**: Use the AI-Assisted Easy Filter on List Reports to allow end users to enter natural-language filter queries instead of manually setting filter fields. Capture and validate example queries as integration test inputs or prompts for RAG-based agents interacting with the List Report.

- Validate UI displays suggestion/help for natural-language inputs.
- Ensure filter results match expected backend queries or OData filters.

**LANGUAGE**: Natural Language

**CODE**:
```text
Example natural-language filter queries for AI-Assisted Easy Filter:
- "Show open sales orders for customer 12345 in the last 30 days"
- "Display purchase orders with amount greater than 10,000 and status 'Pending'"
- "Show active customers in Germany with revenue above 1M in 2025"
- "Open invoices due in the next 7 days for vendor ACME"
- "List sales orders created by John Doe and not yet shipped"

Validation checklist:
- Each query returns expected records in the List Report.
- Generated filter criteria match the intended OData/$filter expressions.
- UI shows applied filters and allows toggling back to manual filter controls.
```

**STEP**: 3 — AI-Assisted Smart Summarization: Usage and Example Prompts/Outputs

**DESCRIPTION**: Use AI-Assisted Smart Summarization on Object Pages to generate concise business summaries suitable for copy/paste into collaboration tools. Use these examples to validate summarization quality, formatting, and copy/share behavior.

- Confirm summarization button or action is available on Object Pages.
- Verify summary can be copied and is shareable via external collaboration tools.

**LANGUAGE**: Natural Language

**CODE**:
```text
Example input scenarios for Smart Summarization:
- Object: Sales Order 50012345
  Prompt: "Summarize the key details and outstanding actions for Sales Order 50012345."

- Object: Customer Account 200987
  Prompt: "Provide a short executive summary of Customer 200987 including revenue trends, open issues, and recommended next steps."

Expected example summary outputs:
- "Sales Order 50012345 — Key points: Order date 2026-01-10, Total value EUR 45,000, Items: 3. Delivery status: Partially shipped (1 of 3). Outstanding actions: Confirm delivery dates for item 2; follow up with logistics. Contact: Jane Smith (+49 123 4567)."
- "Customer 200987 — Summary: Steady growth over last 4 quarters; major revenue from product line X. Current open support tickets: 2 (billing & delivery). Recommended: Schedule account review and propose 10% volume discount."

Validation checklist:
- Summary is concise (one paragraph or bullet list).
- Key business facts and actionable items are present.
- Copy action exports plain text suitable for email/Slack/Teams.
```

**STEP**: 4 — UI/Automation Artifacts and Image References

**DESCRIPTION**: Store provided image assets for UI validation and include them in test artifacts or documentation bundles.

**LANGUAGE**: Text

**CODE**:
```text
Image assets (store alongside docs/tests):
- images/AI-Assisted_Easy_Filter_6254f19.png
- images/AI-Assisted_Smart_Summarization_e3ea9c8.png

Use cases:
- Visual regression tests should compare current UI against these images.
- Include images in user guides and automated onboarding flows.
```

fiori-elements sap-s4hana-cloud generative-ai ai-assisted easy-filter smart-summarization ux


**TITLE**: Generic Action Buttons in Object Page Tables — creatable-path and deletable-path Annotations (OData V2 & V4)

**INTRODUCTION**: This document explains how to control the display and enablement of generic Create and Delete action buttons for tables on the Object Page using annotations. It provides exact annotation snippets for SAP Fiori elements for both OData V2 and OData V4 (including CAP CDS), plus behavior notes required for correct implementation.

**TAGS**: fiori-elements, odata-v2, odata-v4, annotations, object-page, table, creatable-path, deletable-path, CAP, CDS

STEP: Create Button Display Behavior

DESCRIPTION: The Create button on a table toolbar of the Object Page is displayed only when the Object Page is in Edit mode. The creatable-path annotation controls visibility: it must point to a Boolean property on the root entity (not on the navigation target). If that property evaluates to true, the Create button is shown; if false, it is hidden. Reference image: images/CreatablePath_ObPTable_1d6a9b1.png. See also: adding-actions-to-tables-b623e0b.md

LANGUAGE: Text

CODE:
```Text
Behavior:
- Create button is displayed only in Edit mode.
- creatable-path must reference a Boolean property on the root entity.
- If the referenced property is true => Create button is visible.
- If false => Create button is hidden.
Image: images/CreatablePath_ObPTable_1d6a9b1.png
Reference: adding-actions-to-tables-b623e0b.md
```

STEP: Enable Create Button — OData V2 (creatable-path on NavigationProperty)

DESCRIPTION: Use sap:creatable-path on the NavigationProperty element. The attribute value must be the name of a Boolean property on the root entity. When that property is true, the Create button appears in the table toolbar (only in Edit mode).

LANGUAGE: XML

CODE:
```xml
<NavigationProperty Name="to_ProductText" sap:creatable-path="CanCreateProductText".../>
```

STEP: Enable Create Button — OData V4 (InsertRestrictions / NonInsertableNavigationProperties)

DESCRIPTION: For OData V4, express create restrictions using Capabilities.InsertRestrictions. Use NonInsertableNavigationProperties with conditional logic referencing a Boolean property on the root entity (CanCreateProductText). The example below marks to_ProductText as non-insertable when CanCreateProductText is false (using an If + Not + Path construct).

LANGUAGE: XML

CODE:
```xml

<Annotations Target="STTA_PROD_MAN.STTA_PROD_MAN_Entities/STTA_C_MP_Product">
    <Annotation Term="Capabilities.InsertRestrictions">
        <Record>
            <PropertyValue Property="NonInsertableNavigationProperties">
                <Collection>
                    <If>
                        <Not>
                            <Path>CanCreateProductText</Path>
                        </Not>
                        <NavigationPropertyPath>to_ProductText</NavigationPropertyPath>
                    </If>
                </Collection>
            </PropertyValue>
        </Record>
    </Annotation>
</Annotations>
```

STEP: Enable/Disable Delete Button — OData V2 (sap:deletable-path on EntitySet)

DESCRIPTION: For OData V2, set sap:deletable-path on the EntitySet element to the name of a Boolean property (Delete_mc) on the entity type. The Delete button in the table toolbar is enabled for a selected row if that property is true. If the table supports multi-selection, the Delete button is enabled when at least one selected item is deletable.

LANGUAGE: XML

CODE:
```xml

<EntitySet Name="STTA_C_MP_ProductText"
           EntityType="STTA_PROD_MAN.STTA_C_MP_ProductTextType"
           sap:deletable-path="Delete_mc"
           sap:content-version="1"/>
```

STEP: Enable/Disable Delete Button — OData V4 (XML Annotation)

DESCRIPTION: For OData V4, use Org.OData.Capabilities.V1.DeleteRestrictions and set Deletable to the Boolean property via PropertyValue Path. This controls whether Delete is enabled for individual items.

LANGUAGE: XML

CODE:
```xml
<Annotations Target="STTA_PROD_MAN.STTA_PROD_MAN_Entities/STTA_C_MP_ProductText">
   <Annotation Term="Org.OData.Capabilities.V1.DeleteRestrictions">
        <Record>
            <PropertyValue Property="Deletable" Path="Delete_mc"/>
        </Record>
    </Annotation>
</Annotations>
```

STEP: Enable/Disable Delete Button — OData V4 (CAP CDS Annotation)

DESCRIPTION: For CAP CDS, annotate the entity with Capabilities.DeleteRestrictions and set Deletable to the Boolean property name. This produces the equivalent OData V4 DeleteRestrictions annotation.

LANGUAGE: CDS

CODE:
```
annotate STTA_PROD_MAN.STTA_C_MP_ProductText with @(
  Capabilities.DeleteRestrictions : {
    Deletable : Delete_mc
  }
);
```

STEP: Implementation Notes and Rules

DESCRIPTION: Consolidated rules to implement and validate behavior in backend annotations:
- creatable-path must reference a Boolean property on the root entity; controls Create button visibility (only in Edit mode).
- For OData V2 use sap:creatable-path on the NavigationProperty; for OData V4 use Capabilities.InsertRestrictions / NonInsertableNavigationProperties conditionally referencing the root property.
- deletable-path (OData V2) or Deletable property (OData V4/CDS) must reference a Boolean property on the entity.
- Delete button behavior:
  - Single selection: enabled when selected item's deletable property is true.
  - Multi-selection: enabled if at least one selected item has deletable=true.
- Preserve exact target names and property names (e.g., STTA_PROD_MAN.STTA_C_MP_Product, to_ProductText, CanCreateProductText, Delete_mc).
- Related example: example-adding-custom-filter-fields-in-table-toolbar-e34f78f.md

LANGUAGE: Text

CODE:
```Text
Rules summary:
- creatable-path -> Boolean property on root entity.
- OData V2: sap:creatable-path on NavigationProperty.
- OData V4: Use Capabilities.InsertRestrictions -> NonInsertableNavigationProperties with conditional Path checks.
- deletable-path (V2) or Capabilities.DeleteRestrictions.Deletable (V4/CDS) -> Boolean property on entity.
- Delete button enabled if property true; multi-select enabled if at least one selected row is deletable.
Related files:
- adding-actions-to-tables-b623e0b.md
- example-adding-custom-filter-fields-in-table-toolbar-e34f78f.md
Image: images/CreatablePath_ObPTable_1d6a9b1.png
```

fiori-elements odata-v2 odata-v4 annotations object-page table creatable-path deletable-path CAP CDS


**TITLE**: Grouping Fields with UI.FieldGroup and UI.ConnectedFields (Fiori Elements)

**INTRODUCTION**: This document provides concise, action-oriented examples and configuration steps to group related fields in SAP Fiori Elements apps. It covers UI.FieldGroup usage for forms and tables, linking FieldGroups in facets and line items, semantically connected fields (connected date/time or multi-field templates), OData V2/V4 differences, manifest settings for table label display and TextArea merging, and checkbox groups. Include the provided XML, ABAP CDS, CAP CDS, and manifest code snippets directly in your project metadata.

**TAGS**: fiori-elements-framework, UI.FieldGroup, UI.ConnectedFields, annotations, OData, ABAP, CAP, XML, JSON, manifest, LineItem, Facets, Table, Form, Checkbox

**STEP**: Form Implementation — Define a UI.FieldGroup
**DESCRIPTION**: Define a UI.FieldGroup to group related fields (e.g., dimensions). Use this FieldGroup in object page sections or pass it to an OData form via UI.ReferenceFacet. If all grouped fields are hidden, the container is hidden. Supported code formats: XML annotation, ABAP CDS metadata extension, CAP CDS.
**LANGUAGE**: XML
**CODE**:
```xml
<Annotation Term="UI.FieldGroup" Qualifier="Dimensions">
   <Record>
      <PropertyValue Property="Label" String="Dimensions"/>
      <PropertyValue Property="Data">
         <Collection>
            <Record Type="UI.DataField">
               <PropertyValue Property="Value" Path="BaseUnit"/>
            </Record>
            <Record Type="UI.DataField">
               <PropertyValue Property="Value" Path="Height"/>
            </Record>
            <Record Type="UI.DataField">
               <PropertyValue Property="Value" Path="Width"/>
            </Record>
            <Record Type="UI.DataField">
               <PropertyValue Property="Value" Path="Depth"/>
            </Record>
            <Record Type="UI.DataField">
               <PropertyValue Property="Value" Path="Weight"/>
            </Record>
         </Collection>
      </PropertyValue>
   </Record>
</Annotation>
```

**LANGUAGE**: ABAP CDS
**CODE**:
```
@UI.fieldGroup: [
  {
    type: #STANDARD,
    position: 1 ,
    qualifier: 'Dimensions',
    groupLabel: 'Dimensions'
  }
]
BaseUnit;

@UI.fieldGroup: [
  {
    type: #STANDARD,
    position: 2 ,
    qualifier: 'Dimensions'
  }
]
Height;

@UI.fieldGroup: [
  {
    type: #STANDARD,
    position: 3 ,
    qualifier: 'Dimensions'
  }
]
Width;

@UI.fieldGroup: [
  {
    type: #STANDARD,
    position: 4 ,
    qualifier: 'Dimensions'
  }
]
Depth;

@UI.fieldGroup: [
  {
    type: #STANDARD,
    position: 5 ,
    qualifier: 'Dimensions'
  }
]
Weight;
```

**LANGUAGE**: CAP CDS
**CODE**:
```
UI.FieldGroup #Dimensions : {
    $Type : 'UI.FieldGroupType',
    Label : 'Dimensions',
    Data : [
        {
            $Type : 'UI.DataField',
            Value : BaseUnit
        },
        {
            $Type : 'UI.DataField',
            Value : Height
        },
        {
            $Type : 'UI.DataField',
            Value : Width
        },
	{
            $Type : 'UI.DataField',
            Value : Depth
        },
	{
            $Type : 'UI.DataField',
            Value : Weight
        }
    ]
}
```

**STEP**: Reference UI.FieldGroup in UI.Facets (Object Page)
**DESCRIPTION**: Add a ReferenceFacet in UI.Facets that targets the FieldGroup qualifier. This links the FieldGroup to an object page facet (section) for forms.
**LANGUAGE**: XML
**CODE**:
```xml
<Annotation Term="UI.Facets">
   <Collection>
      <Record Type="UI.ReferenceFacet">
         <PropertyValue Property="Label" String="Dimensions" />
         <PropertyValue Property="Target"AnnotationPath="@UI.FieldGroup#Dimensions"/>
      </Record>
   </Collection>
</Annotation>
```

**LANGUAGE**: ABAP CDS
**CODE**:
```
@UI.Facet: [
  {
    label: 'Dimensions',
    targetQualifier: 'Dimensions',
    type: #FIELDGROUP_REFERENCE,
    purpose: #STANDARD
  }
]
```

**LANGUAGE**: CAP CDS
**CODE**:
```
UI.Facets : [
    {
        $Type : 'UI.ReferenceFacet',
        Label : 'Dimensions',
        Target : '@UI.FieldGroup#Dimensions'
    }
]
```

**STEP**: Table Implementation — Use UI.FieldGroup inside LineItem
**DESCRIPTION**: To display multiple fields stacked inside a table cell, reference a UI.FieldGroup from UI.LineItem via UI.DataFieldForAnnotation. Supported nested types: DataField, DataFieldForAction, DataFieldForAnnotation. Ensure Label omission on the DataFieldForAnnotation if you want to hide the column header when using multiple DataFieldForAction buttons.
**LANGUAGE**: XML
**CODE**:
```xml
<Annotation Term="UI.LineItem">
    <Collection>
        …………
        …………
        <Record Type="UI.DataFieldForAnnotation">
            <PropertyValue Property="Target" AnnotationPath="@UI.FieldGroup#FieldGroup1" />
            <PropertyValue Property="Label" String="Type Information"/>
        </Record>
        …………
        …………
    </Collection>
</Annotation>
```

**LANGUAGE**: ABAP CDS
**CODE**:
```
@UI.lineItem: [
  {
    label: 'Type Information',
    type: #AS_FIELDGROUP,
    valueQualifier: 'FieldGroup1'
  }
]
producttype;
```

**LANGUAGE**: CAP CDS
**CODE**:
```
UI.LineItem : [
    {
        $Type : 'UI.DataFieldForAnnotation',
        Target : '@UI.FieldGroup#FieldGroup1',
        Label : 'Type Information'
    }
]
```

**STEP**: Define UI.FieldGroup used in LineItem (Table cell content)
**DESCRIPTION**: Define the FieldGroup which contains DataField and DataFieldForAction entries used inside line items (table cells). Note: UI.FieldGroup is not supported in grid/tree/analytical tables.
**LANGUAGE**: XML
**CODE**:
```xml
<Annotation Term="UI.FieldGroup" Qualifier="FieldGroup1">
    <Record>
        <PropertyValue Property="Data">
            <Collection>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="ContractType"/>
                </Record>
                <Record Type="UI.DataFieldForAction">
                    <PropertyValue Property="Label" String="Dummy Button"/>
                    <PropertyValue Property="Action" String="com.sap.gateway.srvd.sadl_gw_appmusicdr_definition.v0001.SOME_ACTION_2"/>
                </Record>
            </Collection>
        </PropertyValue>
    </Record>
</Annotation>
```

**LANGUAGE**: ABAP CDS
**CODE**:
```
@UI.fieldGroup: [
  {
    type: #STANDARD,
    position: 1 ,
    qualifier: 'FieldGroup1'
  }
]
ContractType;

@UI.fieldGroup: [
  {
    label: 'Dummy Button',
    dataAction: 'com.sap.gateway.srvd.sadl_gw_appmusicdr_definition.v0001.SOME_ACTION_2',
    type: #FOR_ACTION,
    position: 2 ,
    qualifier: 'FieldGroup1'
  }
]
contractName;
```

**LANGUAGE**: CAP CDS
**CODE**:
```
UI.FieldGroup #FieldGroup1 : {
    Data : [
        {
            $Type : 'UI.DataField',
            Value : ContractType
        },
        {
            $Type : 'UI.DataFieldForAction',
            Label : 'Dummy Button',
            Action : 'com.sap.gateway.srvd.sadl_gw_appmusicdr_definition.v0001.SOME_ACTION_2'
        }
    ]
}
```

**STEP**: Semantically Connected Fields — Use UI.ConnectedFields (display side-by-side)
**DESCRIPTION**: Use UI.ConnectedFields to display related properties side-by-side and optionally render them with a template (e.g., "{OrderDate}/{DeliveryDate}"). Connected fields can be edited separately but shown under one label. ConnectedFields must be configured in form sections (not header sections). Below are OData V2 XML examples and OData V4 XML/ABAP/CAP examples.
**LANGUAGE**: XML (OData V2 example)
**CODE**:
```xml
<Annotation Term="com.sap.vocabularies.UI.v1.ConnectedFields" Qualifier="ConnectedDateTime">
    <Record >
        <PropertyValue Property="Data">
            <Record >
                <PropertyValue Property="SalesOrderDate">
                    <Record Type="com.sap.vocabularies.UI.v1.DataField">
                        <PropertyValue Property="Value" Path="SalesOrderDate"/>
                    </Record>
                </PropertyValue>
                <PropertyValue Property="SalesOrderTime">
                    <Record Type="com.sap.vocabularies.UI.v1.DataField">
                        <PropertyValue Property="Value" Path="TrialTOD"/>
                    </Record>
                </PropertyValue>
            </Record>
        </PropertyValue>
        <PropertyValue Property="Label" String="Connected DateTime"/>
        <PropertyValue Property="Template" String="{SalesOrderDate} / {SalesOrderTime}"/>
    </Record>
</Annotation>

<Annotation Term="com.sap.vocabularies.UI.v1.ConnectedFields" Qualifier="ConnectedData">
    <Record >
        <PropertyValue Property="Data">
            <Record >
                <PropertyValue Property="PurchaseOrderByCustomer">
                    <Record Type="com.sap.vocabularies.UI.v1.DataField">
                        <PropertyValue Property="Value" Path="PurchaseOrderByCustomer"/>
                    </Record>
                </PropertyValue>
                <PropertyValue Property="ShippingCondition">
                    <Record Type="com.sap.vocabularies.UI.v1.DataField">
                        <PropertyValue Property="Value" Path="ShippingCondition"/>
                    </Record>
                </PropertyValue>
            </Record>
        </PropertyValue>
        <PropertyValue Property="Label" String="Connected Data"/>
        <PropertyValue Property="Template" String="{ShippingCondition} - {PurchaseOrderByCustomer}"/>
    </Record>
</Annotation>

.....
<Annotation Term="com.sap.vocabularies.UI.v1.FieldGroup" Qualifier="OrderData">
    <Record >
        <PropertyValue Property="Data">
            <Collection>
                <Record Type="com.sap.vocabularies.UI.v1.DataFieldForAnnotation">
                    <PropertyValue Property="Target" AnnotationPath="@UI.ConnectedFields#ConnectedDateTime"/>
                    <Annotation Term="UI.Importance" EnumMember="UI.ImportanceType/High"/>
                </Record>
                <Record Type="com.sap.vocabularies.UI.v1.DataFieldForAnnotation">
                    <PropertyValue Property="Target" AnnotationPath="@UI.ConnectedFields#ConnectedData"/>
                    <Annotation Term="UI.Importance" EnumMember="UI.ImportanceType/High"/>
                </Record>
            </Collection>
        </PropertyValue>
    </Record>
</Annotation>
```

**LANGUAGE**: XML (OData V4 example)
**CODE**:
```
...
<Annotation Term="UI.FieldGroup" Qualifier="OrderData">
    <Record Type="UI.FieldGroupType">
        <PropertyValue Property="Data">
            <Collection>
                <Record Type="UI.DataFieldForAnnotation">
                    <PropertyValue Property="Target" AnnotationPath="@UI.ConnectedFields#ConnectedOrderDates"/>
                </Record>
            </Collection>
        </PropertyValue>
    </Record>
</Annotation>
...
<Annotation Term="SAP__UI.ConnectedFields" Qualifier="ConnectedOrderDates">
<Record>
    <PropertyValue Property="Label" String="Order / Delivery"/>
    <PropertyValue Property="Template" String="{OrderDate}/{DeliveryDate}"/>
    <PropertyValue Property="Data">
        <Record Type="Core.Dictionary">
            <PropertyValue Property="OrderDate">
                <Record Type="SAP__UI.DataField">
                    <PropertyValue Property="Value" Path="OrderDate"/>
                </Record>
            </PropertyValue>
            <PropertyValue Property="DeliveryDate">
                <Record Type="SAP__UI.DataField">
                    <PropertyValue Property="Value" Path="DeliveryDate"/>
                </Record>
            </PropertyValue>
        </Record>
    </PropertyValue>
</Record>
</Annotation>
...
```

**LANGUAGE**: ABAP CDS (OData V4 example)
**CODE**:
```
annotate view SALESORDER with {
  ...
  @UI.facet: [
    {
      id: 'idIdentification',
      type: #IDENTIFICATION_REFERENCE,
    },
    ...
  ]
  ...
  @UI: {
    identification: [
      { type: #AS_CONNECTED_FIELDS, valueQualifier: 'ConnectedOrderDates' }
    ],
    connectedFields: [
      {
        name: 'OrderDate',
        qualifier: 'ConnectedOrderDates',
        template: '{OrderDate}/{DeliveryDate}',
        groupLabel: 'Order / Delivery'
      }
    ]
  }
  OrderDate;

  @UI: {
    connectedFields: [
      { name: 'DeliveryDate', qualifier: 'ConnectedOrderDates' }
    ]
  }
  DeliveryDate;

  ...
}
```

**LANGUAGE**: CAP CDS (OData V4 example)
**CODE**:
```
annotate SalesOrderService.SalesOrder with @UI : {

  FieldGroup #OrderData : {
    Data : [
      { $Type : 'UI.DataFieldForAnnotation', Target: '@UI.ConnectedFields#ConnectedOrderDates' }
    ]
  },
  ...

  ConnectedFields #ConnectedOrderDates: {
    $Type   : 'UI.ConnectedFieldsType',
    Label   : 'Order / Delivery',
    Template: '{OrderDate}/{DeliveryDate}',
    Data    : {
      $Type        : 'Core.Dictionary',
      OrderDate    : { $Type : 'UI.DataField', Value : OrderDate },
      DeliveryDate : { $Type : 'UI.DataField', Value : DeliveryDate }
    }
  },
  ...
}
```

**STEP**: Navigation for Semantically Connected Fields
**DESCRIPTION**: To enable navigation from connected fields, define navigation on the underlying data fields. Allowed navigation types: DataFieldWithURL, DataFieldWithIntentBasedNavigation (SemanticObject or Action), DataFieldWithNavigationPath. Configure the navigation terms on each DataField inside the ConnectedFields annotation.
**LANGUAGE**: (no code snippet required)
**CODE**:
```
(Define DataFieldWithURL / DataFieldWithIntentBasedNavigation / DataFieldWithNavigationPath on the DataField elements inside ConnectedFields.)
```

**STEP**: Show Field Labels in FieldGroup Column (OData V4 Table)
**DESCRIPTION**: To render labels for fields inside a FieldGroup displayed inside a table column, set controlConfiguration → LineItem column key → showDataFieldsLabel true in manifest.json. Use the column key format DataFieldForAnnotation::FieldGroup::<qualifier>.
**LANGUAGE**: JSON
**CODE**:
```
"controlConfiguration": {
   "@com.sap.vocabularies.UI.v1.LineItem": {
      columns: {
         "DataFieldForAnnotation::FieldGroup::myFieldGroup": {
            "showDataFieldsLabel": true
         }
      }
   }
}
```

**STEP**: Merge TextArea Label with Section/Subsection Title (manifest.json)
**DESCRIPTION**: If a FieldGroup contains only a single UI.MultiLineText property and you want to hide the standalone TextArea label and show only the section title, set useSingleTextAreaFieldAsNotes true at the section-level in manifest.json. Ensure accessible labeling for screen readers. Mandatory text areas always show labels in edit mode.
**LANGUAGE**: JSON
**CODE**:
```
"sap.ui5": {
        "routing": {
            "targets": {
                "SalesOrderManageObjectPage": {
                    "options": {
                        "settings": {
                            "content": {
                                "body": {
                                    "sections": {
                                        "ReferenceFacet1": {
                                            "useSingleTextAreaFieldAsNotes": true
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
```

**STEP**: Grouping Checkboxes — Define a Checkbox Group with UI.FieldGroup
**DESCRIPTION**: Group multiple Boolean properties into a single checkbox group by defining a nested FieldGroup for the checkboxes and referencing it from a parent FieldGroup via DataFieldForAnnotation. Restrictions: only Boolean properties allowed, not supported in header forms/filter bars/tables, dynamic instantiation not supported. Define FieldControl (Common.FieldControl) in behavior/metadata as needed.
**LANGUAGE**: XML
**CODE**:
```
<Annotation Term="UI.FieldGroup" Qualifier="GeneralInformation">
    <Record Type="UI.FieldGroupType">
        <PropertyValue Property="Label" String="Line item data"/>
        <PropertyValue Property="Data">
            <Collection>
                <Record Type="UI.DataFieldForAnnotation">
                    <PropertyValue Property="Target" AnnotationPath="@UI.FieldGroup#CheckBoxGroup"/>
                </Record>
            </Collection>
        </PropertyValue>
    </Record>
</Annotation>
<Annotation Term="UI.FieldGroup" Qualifier="CheckBoxGroup">
    <Record Type="UI.FieldGroupType">
        <PropertyValue Property="Label" String="Standard CheckBoxGroup"/>
        <PropertyValue Property="Data">
            <Collection>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="Boolean1"/>
                    <PropertyValue Property="Label" String="Checkbox One"/>
                </Record>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="Boolean2"/>
                    <PropertyValue Property="Label" String="Checkbox Two"/>
                </Record>
                <Record Type="UI.DataField">
                    <PropertyValue Property="Value" Path="Boolean3"/>
                    <PropertyValue Property="Label" String="Checkbox Three"/>
                </Record>
            </Collection>
        </PropertyValue>
    </Record>
</Annotation>

<Annotations Target="sap.fe.core.FieldGroup.Products/Boolean1">
    <Annotation Term="Common.FieldControl" Int="7"/>
</Annotations>
<Annotations Target="sap.fe.core.FieldGroup.Products/Boolean3">
    <Annotation Term="Common.FieldControl">
        <If>
                <Path>Boolean2</Path>
                <Int>0</Int>
                <Int>3</Int>
        </If>
    </Annotation>
</Annotations>
```

**LANGUAGE**: ABAP CDS
**CODE**:
```
Define the following in the metadata extension of the data definition containing the Boolean fields:
...
@UI: {
    fieldGroup: [
        { qualifier: 'GeneralInformation', type: #AS_FIELDGROUP, valueQualifier: 'CheckBoxGroup', position: 10, label: 'CheckBox Group Label' },
        { qualifier: 'CheckBoxGroup', position: 10, label: 'Checkbox One' }
    ]
}
Boolean1;
    @UI: {
        fieldGroup: [
            { qualifier: 'CheckBoxGroup', position: 20, label: 'Checkbox Two'  }
        ]
    }
Boolean2;
    @UI: {
        fieldGroup: [
            { qualifier: 'CheckBoxGroup', position: 30, label: 'Checkbox Three'  }
        ]
    }
Boolean3;
...
```

**LANGUAGE**: CAP CDS
**CODE**:
```
...
Boolean1            : Boolean @Common.FieldControl: #Mandatory;
Boolean2            : Boolean;
Boolean3            : Boolean @Common.FieldControl: (Boolean2 ? 0 : 3);
// FieldControl can also be set as path based reference to property or expression binding
...
FieldGroup #CheckBoxGroup: {
    $Type: 'UI.FieldGroupType',
    Label: 'CheckBox Group Label',
    Data : [
        {
            $Type: 'UI.DataField',
            Value: Boolean1,
            Label: 'Checkbox One'
        },
        {
            $Type: 'UI.DataField',
            Value: Boolean2,
            Label: 'Checkbox Two'
        },
        {
            $Type: 'UI.DataField',
            Value: Boolean3,
            Label: 'Checkbox Three'
        }
    ]
},
...
FieldGroup #GeneralInformation: {
    Label: 'Line item data',
	Data : [
    {
        $Type : 'UI.DataFieldForAnnotation',
        Target: '@UI.FieldGroup#CheckBoxGroup'
    }
    ]
}
```

**STEP**: Checkbox Group Layout — Enable Horizontal Layout (manifest.json)
**DESCRIPTION**: To align checkbox group items horizontally, set horizontalLayout true for the subsection in manifest.json under the target entity/section. This setting applies to all text area controls in the section when used for TextArea merging.
**LANGUAGE**: JSON
**CODE**:
```
"options": {
    "settings": {
         "entitySet": "Products",
         "content": {
             "body": {
                 "sections": {
                     "@com.sap.vocabularies.UI.v1.FieldGroup#CheckBoxGroups": {
                         "subSections": {
                            "@com.sap.vocabularies.UI.v1.FieldGroup#CheckBoxGroupH1": {
                                "horizontalLayout": true
             }
           }
          }
         }
       }
      }
    }
  }
}
```

**STEP**: Warnings & Restrictions (quick reference)
**DESCRIPTION**: Keep these restrictions in mind when designing FieldGroups and ConnectedFields:
- UI.FieldGroup is not supported in grid tables, tree tables, and analytical tables.
- Table implementation with FieldGroup cannot show individual labels per field unless using showDataFieldsLabel (OData V4).
- ConnectedFields can only be used in form sections (not header sections).
- Checkbox groups: only Boolean properties; not supported in header forms/filter bars/tables; dynamic instantiation not supported; mandatory checkbox-group requiring at least one selection not supported (use MultiComboBox instead).
- If no HeaderFacet annotation and headerinfo has no images, expand/collapse and pin buttons are hidden in object page header.
- If subsection contains only one group and subsection title equals group title, the group title is hidden.

**STEP**: Related resources and image references
**DESCRIPTION**: Reference images and design guidelines for UI/UX:
- Example images referenced in the original documentation: images/Related_Fields_Using_a_Form_Implementation_b9b30bd.png, images/DataField_with_Dummy_Button_8c91e4e.png, images/Semantically_Connected_Fields_eb0b024.png, images/FieldGroup_Column_Sold-To_Party_with_Field_Labels_81e38b2.png, images/Display_Mode_b991a5e.png, images/Edit_Mode_459aa56.png, images/Horizontal_Layout_a9399bb.png
- Design guidelines: https://experience.sap.com/fiori-design-web/form/ and https://experience.sap.com/fiori-design-web/object-page/#forms

fiori-elements-framework UI.FieldGroup UI.ConnectedFields annotations OData ABAP CAP XML JSON manifest LineItem Facets Table Form Checkbox