SAP Community - SAP BTP, ABAP environment

Old Tile Still Appearing in SAP Build Work Zone After Complete Re‑Exposure from S/4HANA

2026-03-10T18:21:19.051000+01:00

Hello Experts,

I am facing an issue with federated content from an on‑premise S/4HANA system to SAP Build Work Zone (Standard Edition).
Our authorization team has removed the old tile and assigned a new tile to the correct custom role, custom catalog, and custom group in S/4HANA.

To ensure a clean setup, I deleted the previous exposure configuration and re‑created the full setup from scratch in:

/UI2/CDM3_EXP_SCOPE (content exposure)
SAP BTP → Build Work Zone → Content Provider → Synchronize Content

Despite repeating the full process multiple times, the old tile continues to appear in Build Work Zone instead of the new one.
The authorization consultant has verified both the new role and the tile assignments several times on the S/4HANA side, and everything looks correct there — but Build Work Zone keeps federating only the old tile.

Has anyone experienced something similar?

I am trying to understand:

Why outdated tile information is still being federated
Whether additional cleanup is required on the CDM or content provider side
If there are any cache layers (S/4HANA, BTP, or Build Work Zone) that must be explicitly cleared
Whether Exposure Version 2 requires specific steps to refresh or replace previously published app IDs

Any advice, known issues, or guidance on how to force Build Work Zone to pick up the updated tile would be greatly appreciated.

Thank you!

Custom Adobe Forms in SAP S/4 HANA Public Cloud using Developer Extensibility

2026-03-12T06:27:10.315000+01:00

Introduction

Custom Adobe forms can be created in SAP S/4 HANA Public Cloud using Developer Extensibility using Form Objects.
OData Service can be created to get Form details.

Process to Develop Custom Adobe Forms in SAP S4HANA Public Cloud using Developer Extensibility

Forms Objects

Creating Forms Objects in the Form editor allows for the generation of print and interactive forms using Adobe Document Services.
Forms Objects can be created in the Form editor.
Print and interactive forms can be generated using Adobe Document Services (ADS) by the Forms Object.
The main part of Forms Object is layout form design file (XDP format by Adobe).
Adobe LiveCycle Designer is required for the development of XDP layout file.

Creating Form Objects

A Form Object can be created in ABAP development tools for Eclipse (ADT) using the creation wizard

Print Forms

ADS Rendering in ABAP environment

In the ABAP environment with Adobe Document Services (ADS), rendering refers to the process of taking an Adobe XML Form (XFA) which is essentially a structured template containing layout, design, and data placeholders and producing a final output document.
The Adobe Document Services (ADS) can render Adobe XML Forms (XFA) to PDF documents and other print formats.
The application sends the data and the form template using a secure connection and the service returns the rendered document.
The rendered documents can be used by the applications for the screen output or for the output into the print queue.

Retrieve Stored Form Templates

Form templates designed with the Adobe LiveCycle Designer can be uploaded directly to the system using ABAP development tools for Eclipse.

The class CL_FP_FORM_READER enables the usage of uploaded form templates during runtime.

Initiate the Form Template Reader

Initiate the class by providing the name of the uploaded form template.

data(lo_reader) = cl_fp_form_reader=>create_form_reader( 'MY_FORM_NAME' ).

Read Layout Content to be Used by ADS Rendering Call

The layout can also be retrieved by the reader class.

The GET_LAYOUT method has the returning parameter RV_LAYOUT, it returns XML as XSTRING

RAP Data Services for Print Forms

The XML data for print form rendering can be obtained from the RAP Business Services.
The data model can be defined just as well as the RAP Service Definition.
The CL_FP_FDP_SERVICES class provides the ABAP API to receive the data in xml format for the use in print forms.
XML Schema Definition (XSD) used for the design of print forms in the Adobe LiveCycle Designer.

Initiate Business Data Reader

To supply the rendering operation with business data, a reuse service can be applied.

Service definition needs to be created previously.

The service definition doesn't need a binding for RAP Data Services for print forms.

Initiate the reuse utility by specifying the service definition.

DATA(lo_fdp_api) = cl_fp_fdp_services=>get_instance( ‘FP_FDP_SERVICE_EX1’ ).

Specify the key parameters.

This is required to read the data for a specific item.

The reuse utility offers the functionality to retrieve all key fields for the service definition.

DATA(lt_keys)    = lo_fdp_api->get_keys( ).

Once the array with key values has been retrieved, the keys that fit are assigned to the document to be output.

lt_keys[ name = 'UUID' ]-value = '4500000001'.

Retrieve XML Data from Service Definition

The READ_TO_XML_V2 method retrieves the data structure of the service definition for a specific item.

It has the Importing parameters IT_SELECT - Key parameters, IV_LANGUAGE (Optional).

It has the returning parameter RV_XML - Resulting XML as XSTRING.

TRY.
    DATA(lv_data) = lo_fdp_api->read_to_xml_v2( lt_keys ).
CATCH cx_fp_fdp_error INTO DATA(lo_exception).
ENDTRY.

Retrieve XML Schema Definition from Service Definition

The GET_XSD_V2 method retrieves the XML Schema Definition (XSD) for the service definition.

It has the returning parameter RV_XML, it returns XSD as XSTRING.

TRY.
   DATA(lv_xml)     = lo_fdp_api->get_xsd_v2(  ).
CATCH cx_fp_fdp_error INTO DATA(lo_exception).
ENDTRY

Runtime API for ADS Rendering Calls

The CL_FP_ADS_UTIL class provides the ABAP Runtime API for Adobe Document Services (ADS) rendering calls.

It contains the public method RENDER_PDF to be used for the Rendering PDF.

The PDF rendering process on ADS creates the PDF file to be printed (or print output format) using both formats

XDP form template file
Data for the form filling in XML format, for example, data from the RAP Data Services for Print Forms.

The XDP form template file is a description of the form layout design in Adobe XFA format.

The supported data binding type is an XML data schema.

The data XML file contains the data that corresponds to the used data schema in the XDP form template.

Rendering PDF

The RENDER_PDF method calls the ADS to render print PDF using the XDP form file and the XML data file.

TRY.

*Render PDF
    cl_fp_ads_util=>render_pdf(
                             EXPORTING
                                   iv_xml_data      = lv_xml_data
                                   iv_xdp_layout    = lv_xdp
                                   iv_locale        = 'de_DE'
                                   is_options       = ls_options
                             IMPORTING
                                   ev_pdf           = ev_pdf
                                   ev_pages         = ev_pages
                                  ev_trace_string  = ev_trace_string ).
  CATCH cx_fp_ads_util INTO lx_fp_ads_util.
ENDTRY.

Importing Parameters

IV_XML_DATA - XML data

IV_XDP_LAYOUT - Adobe XDP form template

IV_LOCALE - Locale for rendering the language language_COUNTRY, (en_US)

IS_OPTIONS - PDF rendering parameters (optional)

Exporting Parameters

EV_PDF - PDF rendering result

EV_PAGES - Pages

EV_TRACE_STRING - Trace string

Creating Data Provider

Create Data Model

Create a data model, add the annotation to the CDS View to act a data provider for FORM Object.

@ObjectModel.supportedCapabilities: [ #OUTPUT_FORM_DATA_PROVIDER ]

supportedCapabilities defines which features or capabilities are supported by the CDS view or entity.

#OUTPUT_FORM_DATA_PROVIDER is a specific capability flag that indicates the CDS entity can act as a data provider for output forms.

CDS View – ZI_FORM_PO_HD

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Form PO'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.supportedCapabilities: [ #OUTPUT_FORM_DATA_PROVIDER ]
define root view entity ZI_FORM_PO_HD
  as select from ZI_PO_HD_DT
{
  key PoNum,
      Supplier,
      PurOrg,
      CompCod,
      PurGrp,
      CrDt,
      _its
}

Data Source CDS View – ZI_PO_HD_DT

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'PO Header'
@Metadata.ignorePropagatedAnnotations: true
define root view entity ZI_PO_HD_DT
  as select from ztb_po_hdr
  association [0..*] to ZI_PO_ITS as _its on $projection.PoNum = _its.PoNum
{
  key po_num   as PoNum,
      supplier as Supplier,
      pur_org  as PurOrg,
      comp_cod as CompCod,
      pur_grp  as PurGrp,
      cr_dt    as CrDt,
      _its
}

Custom Table

@EndUserText.label : 'PO Header'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #ALLOWED
define table ztb_po_hdr {

  key client : abap.clnt not null;
  key po_num : abap.char(10) not null;
  supplier   : abap.char(10);
  pur_org    : abap.char(5);
  comp_cod   : abap.char(5);
  pur_grp    : abap.char(5);
  cr_dt      : abap.dats;

}

Create Service Definition

For a service definition, a leading entity can be defined using annotation

@ObjectModel.leadingEntity.name: ''

Add the CDS View as a leading entity.

@EndUserText.label: 'Service Definition of PO Form'
@ObjectModel.leadingEntity.name: 'ZI_FORM_PO_HD'
define service ZSR_FORM_PO_HD {
  expose ZI_FORM_PO_HD;
}

Service Definition ZSR_FORM_PO_HD is a Data provider for Form Object.

Service Binding

The service definition doesn't need a binding for RAP Data Services for print forms.

Creating Form Object

Create a Form Object with creation wizard from the main menu, toolbar, Project Explorer, or using a shortcut.

Enter the name and description of a form.

Select Next, assign a transport request, and select finish.

A new form is created and opened in the Form Editor.

A Data Provider now needs to be specified, which is defined in the system as a service containing the business data for this form.

In the General Information section, define the properties of the form

In the Data provider field, specify the service definition that should be used for fetching the business data for a form.
The Embed Font field should be enabled if the fonts are to be embedded into the generated PDF.
The Reduce Data Volume field should be enabled if the generated business data is to be filtered to only contain fields bound by fields in the form layout.

Choose Browse option to view the list of Data Providers.

Added the Data Provider ZSR_FORM_PO_HD to the Form

In the action menu, three options

Download Schema: Download the schema of the linked Data provider as an xsd file which can be imported into Adobe LiveCycle Designer for SAP solutions.
Upload Layout: Upload a layout file (*.xdp) created by Adobe LiveCycle Designer for SAP solutions (make sure the form should save before uploading a layout file).
Download Layout: Download the current layout uploaded to the form.

Choose Download Schema to create a new layout for the form.

Export and save schema to local files.

Open the Adobe Life Cycle Designer

Create a new blank form

Blank Form is created

Choose File -> New Data Connection

Choose XML Schema

Import the XML Schema File

Data Connection is added.

Design the layout

Save the layout file (XDP file) to local files.

Upload the Layout to the Form Object

Layout is uploaded, save the form object

Activate the Form Object

Layout can be downloaded with Download Layout option

Consuming the Form using Custom Entity

Custom Entity

Create a custom entity, add the form related fields and add the annotation to make its content as attachment.

@Semantics.largeObject:{ mimeType: 'MimyType', fileName: 'FileName',         
                         contentDispositionPreference: #ATTACHMENT }

Add the ABAP Class to implement the form access.

@EndUserText.label: 'PO Form'
@Metadata.allowExtensions: true
@ObjectModel.query.implementedBy: 'ABAP:ZCL_FORM_PO'
define custom entity ZI_FORM_PO

{
  key PO       : ebeln;
      @Semantics.largeObject:{ mimeType: 'MimyType', fileName: 'FileName', contentDispositionPreference: #ATTACHMENT }
      Form     : abap.rawstring( 0 );
      FileName : abap.char( 30 );
      MimyType : abap.char( 50 );
}

Class- ZCL_FORM_PO

CLASS zcl_form_po DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_rap_query_provider. 
PROTECTED SECTION.
PRIVATE SECTION.
ENDCLASS

CLASS zcl_form_po IMPLEMENTATION.

 METHOD if_rep_query_provider~select
     
      DATA: 1s_form TYPE zi_form_po,
            it_form TYPE TABLE OF zi_form_po.

      TRY.

           DATA(it_filter_conds) = io_request->get_filter()->get_as_ranges(). 
           LOOP AT it_filter_conds INTO DATA(1s_filter_conds).
            IF ls_filter_conds-name EQ 'PO'.
              READ TABLE ls_filter_conds-range INTO DATA(ls_rng) INDEX 1.
              IF sy-subrc EQ 0.
               DATA(lv_po) = ls_rng-low.
              ENDIF.
            ENDIF
            CLEAR: ls_rng.
           ENDLOOP.

         DATA(lv_paging) = io_request->get_paging( )->get_offset( ).
         DATA(lv_filters) = io_request->get_filter( )->get_as_sql_string( ).

       CATCH cx_rap_query_filter_no_range INTO DATA(cx_mg).

       IF 1v_po 15 INITIAL.
        lv_po = '4500000001'.
       ENDIF.

      TRY.
       "Initiate the Fore Template Reader
        DATA(lo_reader) = cl_fp_form_reader->create_form_reader( iv_formname = 'ZFORM_PO' ).
       "Read Layout Content to be Used by ADS Rendering Call 
        DATA(lv_layout) = lo_reader-get_layout().
      CATCH cx_fp_form_reader INTO DATA(ls_cx_fp_form_reader). 
      ENDTRY.

      TRY.
      "Get instance of Form
      DATA(lo_fdp_api) = cl_fdp_services->get instance(
                                  iv service definition = 'ZSR_FORM_PO_HD'
                                "  iv root node =
                                  iv_max_depth = 1 ).

      "Retrieve x Data from Service Definition
       DATA(ls_keys) = lo_fdp_api->get_keys( ).
       it_keys[ name = 'PONUM' ]->value = lv_po.
       
       DATA(lv_data) = lo_fdp_api->read_to_xml_v2( 
                                   it select = it_keys
                                  "it_select_add = 
                                  "iv_language = SY-LANGU 
                                     ).

       "Retrive XML Schema Definition from Definition
        DATA(lv_xml) = lo_fdp_api->get_xsd_v2( ).

      CATCH cx_fp_fdp_error INTO DATA(lo_exception).
     ENDTRY.

    TRY.
   "Rendering PDF
    cl_fp_ads_util=>render_pdf(
        EXPORTING
          iv_xml_data = lv_data   
          iv_xdp_layout = lv_layout
          iv_locale  = 'en_US'
       "   i_options = 
         IMPORTING
           ev_pdf = DATA(ev_pdf)
         ev_pages = 
         ev_trace_string =  
        ).
   
 CATCH cx_fp_ads_util INTO DATA(lo_fp_ads_util).

ENDTRY.

ls_form-po = lv_po.
ls_form-filename = 'Form_PO.pdf'.
ls_form-mimytype = 'application/pdf'.
ls_form-form = ev_pdf.
APPEND ls_form TO it_form.

io_response->set_data( it_form ).
io_response->set_total_number_of_records( lines( it_form ) ).

ENDMETHOD.
ENDCLASS.

Service Definition

Create a Service Definition, expose the entity.

@EndUserText.label: 'FORM_PO'
define service ZSD_FORM_PO {
  expose ZI_FORM_PO;
}

Service Binding – Web API

Create a Service Binding with type OData V4 – Web API

Click on Service URL to access it.

Service URL

Access form details

Download Form with URL

Download the Form with accessing the service URL by passing document number.

/sap/opu/odata4/sap/zsrb_form_po/srvd_a2x/sap/zsd_form_po/0001/ZI_FORM_PO('4500000001')/Form

Form is downloaded

Service Binding – UI

Create a Service Binding with type OData V4 – UI

Download Form with UI

Choose Preview in service binding to view UI

Click on Form to download the Form

Form is downloaded

Debugging the Form Logic

Toggle Breakpoint is set

Click on Form to trigger the breakpoint.

Debugger got triggered.

Variables with values

Using CDS Views

CDS View

Create a CDS View with field having URL of Form

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'PO Header'
@Metadata.ignorePropagatedAnnotations: true
@Metadata.allowExtensions: true
define root view entity ZI_PO_HD
  as select from ztb_po_hdr

  association [0..*] to ZI_PO_ITS as _its on $projection.PoNum = _its.PoNum
{
  key po_num                                                                                                               as PoNum,
      supplier                                                                                                             as Supplier,
      pur_org                                                                                                              as PurOrg,
      comp_cod                                                                                                             as CompCod,
      pur_grp                                                                                                              as PurGrp,
      cr_dt                                                                                                                as CrDt,

      //      cast( 'PO Form.pdf' as abap.char( 20 ))                                                                              as FileName,
      //
      //      cast( 'application/pdf' as abap.char( 30 ))                                                                          as MimeType,

      concat( '/sap/opu/odata4/sap/zsb_form_po/srvd_a2x/sap/zsd_form_po/0001/ZI_FORM_PO(''', concat( po_num, ''')/Form' )) as FormURL,

      'Print PDF'                                                                                                          as Form,

      _its


}

Metadata Extension

Create metadata extension, add the fields with annotations and add the parameter type with #WITH_URL value, also url with value contains url field name

@Metadata.layer: #CORE
annotate entity ZI_PO_HD with
{
@UI.lineItem: [{ position: 10, label: 'PO' )]
@UI.identification: [{ position: 10, label: 'PO' }]
PoNum;

@UI.lineItem: [{ position: 40, label: 'Form URL', type: WITH URL, url:'FormURL' }} 
@UI.identification: [{ position: 40, label: 'Form URL', type: WITH URL, url: 'FormURL' }]
FormURL;

@UI.lineItem: [{position: 30,type: WITH URL, url: 'FormURL' }]
@UI.identification: [{ position: 30, type: #WITH URL, url: 'FormURL' }]
Form;
}

Service Definition

Create a Service Definition, expose the entity.

@EndUserText.label: 'PO Hdr'
define service ZSR_POHDR_PR {
  expose ZI_PO_HD;
}

Service Binding – UI

Create a Service Binding with type OData V4 – UI

Download Form with UI

Choose Preview in service binding to view UI

Click on Print PDF to download the Form

Form is downloaded

Click on Form URL to download the Form

Form is downloaded

References

Conclusion

Steps included to develop Custom Adobe Form in SAP S/4 HANA Public Cloud using Developer Extensibility

Creating Data Provider
Creating Form Objects
Consume the Form using Custom Entity

Build Partner Add-on with IDE Action

2026-03-12T09:36:28.552000+01:00

Disclaimer: The namespace /ITAPC3/ is used throughout this document as an example namespace only. Replace it with your own namespace in real implementations. The coding style/naming conventions used in this blog are not recommendations on naming/design

This blog post covers a step-by-step guide to how partners implement IDE Actions as Partner Add-ons in the SAP BTP ABAP Environment. This enables SAP partners to deliver customized tools in the form of custom action in ABAP Development Tools that increase developer productivity. By combining IDE Actions with the installable add-on option of the BTP ABAP Environment, partners have a potentially monetizable option to extend the ABAP Developer tools. It covers the key concepts and technologies – how to extend ABAP Development Tools with IDE Actions and how to leverage the SAP Business Technology Platform ABAP Environment alongside the Landscape Portal to deliver installable add-on products.

Here we will look into a partner persona, where they can provide the business solution to their consumer with an installable add-on by providing certain action in the ABAP development tools, and also look into the consumer side of how they can consume the solution which caters to the needs of their developer using ABAP development tools (ADT).

Why IDE actions and Installable add-ons?

By combining IDE actions and installable add-ons, partners who have been extending software can now also extend the ABAP Development Tools (ADT).

The IDE action framework allows extending the ABAP development tools (ADT) with custom server-driven context-aware actions. IDE Actions allow partners to automate repetitive tasks, such as creating specialized development objects, enhancing code analysis, or automating some code generation within ABAP Development Tools (ADT) for Eclipse. The implementation is completely server-driven using ABAP only. You can also use these custom functionalities with AI integration and XCO libraries.

Installable add-ons are a set of software components bundled together as an add-on by a partner with the intent of providing a solution to their customers.

The Landscape Portal acts as a central tool to allow service providers to perform administration tasks such as hibernating systems, creating test tenants and support users, selecting systems for a pre-upgrade, but also lifecycle management operations such as building, deploying and updating product versions, and even guides you through the configuration and deployment of multitenant SaaS solutions.

Business scenario:

The developer can document development objects in the Knowledge Transfer Document Editor using Markdown syntax. Here partner is offering a translation action with the help of IDE Action as Add-on for the Knowledge Transfer Document and can use the ABAP AI SDK powered by Intelligent Scenario Lifecycle Management (ISLM) to translate the Markdown syntax and display the output of translated Knowledge Transfer Document. Consumer (The partner's customer) can consume this solution from the partner through landscape portal as Installable add-on and can use customized action in ABAP Development Tools for their development scenario.

Prerequisites: (Partner)

You’ve purchased entitlements that are necessary for the account setup. See Prepare

You’ve registered a namespace at SAP, for example /NAMESPC/. See Register a Namespace

You’ve registered your add-on at SAP, for example /NAMESPC/PRODUCTX. See Register a Product

You are subscribed to the Landscape Portal

You have a user with the Landscape Portal Admin role collection assigned

Install ABAP development tools for Eclipse (ADT) on your computer. If you already have ADT, make sure it's updated to the latest version. For more information, see ABAP Development Tools.

You need to have access to an SAP BTP ABAP Environment Instance

Business Catalog SAP_A4C_BC_DEV_AIA_PC required for creating and editing IDE actions

Prerequisites: (Consumer)

The Landscape Portal Application has been subscribed to and your user has the landscape portal admin role collection assigned

Install ABAP development tools for Eclipse (ADT) on your computer. If you already have ADT, make sure it's updated to the latest version. For more information, see ABAP Development Tools.

Steps to Implement as a Partner

1. Create Software Components

To open the "Manage Software Components" application, log in to your SAP BTP ABAP Environment Fiori Launchpad as an administrator and Search for "Manage Software Components" in the search bar.

use the “Create” button in the “Manage Software Components” app to open the dialog and fill in the information. We enter the name of the software component and a description. In the namespace dropdown you can use your reserved namespace. (Disclaimer: /ITAPC3/ being an example namespace used in this blog)

You clone the software component into the development system. When cloning, the main branch is checked out for the system, a package is created in the system that has the same name as the software component and is also assigned to it. At the same time, you can also set how the clone of the repository behaves in the system (push/pull or just pull).
The software component with the selected branch is now imported into your current system instance. The Clone button turns into a Pull button. From now on, you can use it to pull (remotely available) changes of your software component to your system. Now you can see package under the selected software component in your system.

2. Development (Intelligent Scenario)

Here in this scenario, we would be using ABAP AI Capabilities is our IDE Action implementation class to translate the markdown content into the target language with the help of ABAP AI SDK powered by ISLM. To learn more about Developing AI Enabled Applications with ABAP AI SDK powered by ISLM, refer to the blog post.

2.1 Create ISLM Scenario:

Select your package, right-click, New → Other → Intelligent Scenario → /ITAPC3/ADT_INT_SCE

Enter a name and description. Select SIDEBYSIDE for Scenario Technology field. Choose Next and then click Finish.

2.2 Create ISLM Model:

Select your package, right-click, New → Other → Intelligent Scenario Model

Fill the Description and Model Name fields. Assign the previously created scenario in Intelligent Scenario Name. Choose Next.

Enter the ExecutableID and Large Language Model Name and Large Language Model Version and Activate the object.

3. Development (IDE Action)

In this section we will look at the IDE action which translates the markdown content into the selected language with the help of intelligent scenario created in the previous step.

Partners can utilize the ABAP AI SDK powered by ISLM to embed Generative AI features in IDE action implementation class.

From ABAP Development Tools, locate and add to the favorite package “/ITAPC3/IDE_ACTION_EXTENSIONS“ that was created during Create Software Components process. The package has the same name as the software component.
Create a new IDE action either from the main menu, project explorer, or toolbar.

In the main menu, choose File->New->Other... and select IDE Action. The creation wizard opens.

In the creation wizard, enter the project and package details if they are not already filled. Also, provide a name and description for the IDE action.

Choose Next, assign a transport request if needed and Choose Finish.

After we have created the action in the system, we then fill the form with the relevant information to create the action and the Input UI Configuration Class. In the Filter: Cardinality section, decide the number of focused resources that can be selected when running an IDE action. If you want to use your IDE action for any object type, add *ALL as value for the object type. Save and activate your IDE action.

3.1 Defining UI

In the first step we need an action dialog to enable the user to enter data. To do this we can create a new class using the link in the IDE Action. This implements the interface IF_AIA_SD_ACTION_INPUT, but only the method CREATE_INPUT_CONFIG is defined here; the other three methods can be implemented optionally. We define a public type in the class as the structure for the input; we can give the fields certain properties using the ABAP Docs. A list of properties can be found in the documentation, with certain properties being set via configuration.

CLASS /itapc3/cl_trans_ui_info DEFINITION 
  PUBLIC 
  FINAL 
  CREATE PUBLIC . 
  PUBLIC SECTION. 
  INTERFACES if_aia_sd_action_input. 
     "! <p class="shorttext">Simple Controls</p> 
      BEGIN OF ty_input, 
      "! <p class="shorttext">Select the language</p> 
      custom_value_help_text_field TYPE string, 
      "! <p class="shorttext">Enter the markdown source for the translation</p> 
        multiline_text_field         TYPE string, 
      END OF ty_input. 
  PROTECTED SECTION. 
  PRIVATE SECTION. 
ENDCLASS. 

CLASS /ITAPC3/CL_TRANS_UI_INFO IMPLEMENTATION. 
  METHOD if_aia_sd_action_input~create_input_config. 
  " Create the input data with default values 
  DATA(input_data) = VALUE ty_input( ) ##NO_TEXT. 
  " Create the configuration via the factory 
  DATA(configuration) = ui_information_factory>get_configuration_factory( 
                                       )->create_for_data( input_data ). 
  " Set the layout 
  configuration->set_layout( if_sd_config_element=>layout-grid ). 
  " Set configuration for elements 
  “To enable a custom value help for an element, the corresponding configuration must be set via the API: 
   configuration->get_element( 'custom_value_help_text_field' )->set_values( if_sd_config_element=>values_kind-domain_specific_named_items ). 
    configuration->get_element( 'multiline_text_field' )->set_multiline( if_sd_config_element=>height-large ). 
  " Create and return the UI information 
 result = ui_information_factory->for_abap_type( abap_type     = input_data 
             configuration = configuration ). 
 ENDMETHOD. 
 METHOD if_aia_sd_action_input~get_value_help_provider. 
  " Return a reference to your value help handler via the value help provider 
   result = cl_sd_value_help_provider=>create( NEW /ITAPC3/CL_TRAN_VALUE_HELP( ) ). 
  ENDMETHOD. 
ENDCLASS.

3.2 Implement a Custom Value Help:

To implement a custom value help that returns domain-specific named items, a handler class must be provided that implements the if_sd_value_help_dsni interface. The get_value_help_items method returns the values for the value help. The values to be returned are of type if_sd_value_help_dsni=>ty_named_item_list.

CLASS /itapc3/cl_trans_ide_action DEFINITION 
  PUBLIC 
  FINAL 
  CREATE PUBLIC. 
  PUBLIC SECTION. 
  INTERFACES if_aia_action. 
  PROTECTED SECTION. 
  PRIVATE SECTION. 
  METHODS get_input_as_html 
      IMPORTING ui_input      TYPE /itapc3/cl_trans_ui_info=>ty_input 
      RETURNING VALUE(result) TYPE string. 
ENDCLASS. 

CLASS /ITAPC3/CL_TRANS_IDE_ACTION IMPLEMENTATION. 
 METHOD get_input_as_html. 
    FINAL(nl) = cl_abap_char_utilities=>newline. 
    TRY. 
        DATA(completion_api) = cl_aic_islm_compl_api_factory=>get( )->create_instance( '/ITAPC3/ADT_INT_SCE' ). 
        DATA(prompt) = |You are a translator. Reject Hate Speech. Translate the given text into { ui_input-custom_value_help_text_field }:{ nl }{ ui_input-multiline_text_field }| ##NO_TEXT. 
        DATA(translation) = completion_api->execute_for_string( prompt )->get_completion( ). 
      CATCH cx_aic_api_factory INTO DATA(aic_api_factory_ex). 
      RETURN. 
      CATCH cx_aic_completion_api INTO DATA(aic_completion_api_ex). 
      RETURN. 
    ENDTRY. 
    result =  '<h3 style="color:gray">Translate to (' && ui_input-custom_value_help_text_field && ')</h3>' && nl  && '<pre>' && translation && '</pre>'. 
  ENDMETHOD. 

  METHOD if_aia_action~run. 
  DATA(focused_resource) = context->get_focused_resource( ). 
    TRY. 
        DATA ui_input TYPE /itapc3/cl_trans_ui_info=>ty_input. 
        context->get_input_config_content( )->get_as_structure( IMPORTING result = ui_input ). 
      CATCH cx_sd_invalid_data INTO DATA(exception). 
        CLEAR ui_input. 
    ENDTRY. 
    DATA(popup_result) = cl_aia_result_factory=>create_html_popup_result( ). 
    popup_result->set_content( get_input_as_html( ui_input ) ). 
    result = popup_result. 
  ENDMETHOD. 
ENDCLASS.

To start the action in Eclipse, we can copy the markdown source from any KTD Editor and use  use the shortcut Ctrl + Alt + R for Windows or CMD + OPT + R for Mac or choose Run->ABAP IDE Action... from the main menu to start the Action Dialog, where our IDE Action should now be available.

Once all the required objects are created and the action is working as per our expectation, we have to release the Transport Request.

4. Create Add-on Product using Landscape Portal

The Landscape Portal acts as a central tool to allow service providers to perform administration tasks such as hibernating systems, creating test tenants and support users, selecting systems for a pre-upgrade, but also lifecycle management operations such as building, deploying and updating product versions, and even guides you through the configuration and deployment of multitenant SaaS solutions.

Here partner can create a new Add-on product, register your product, build a product version via pipelines and deploy a product version.

4.1 Register Product

A product refers to an ABAP add-on that can be installed on SAP BTP, ABAP environment.

Log into the Landscape Portal. For more information, see Landscape Portal

Click on the Register Product tile to open the app.

A list of all your created products, including their product ID, namespace and registration status, is displayed. The registration status indicates whether a product has already been registered to the global account you are currently logged in to.

Click the Create button in the top right corner.

Enter the name of the product you want to create and confirm with Create. Your request for creation has been sent and the registration status of the product changes to “Pending…”. The namespace is automatically determined from the product name you entered, and the product ID is generated as part of the creation process.

4.2 Build Product Version

You can use the Build Product Version app to easily trigger the build of new product versions via pipelines based on templates that you can configure for different use cases such as new (test or production) release deliveries, (test or production) support packages or (test or production) hotfixes/patch deliveries.

Log in to the Landscape Portal and click on the tile Build Product Version. For more information, see Build Product Version

Select one of your products from the list. You will be forwarded to the Product Versions tab. Here, you can see a table listing all the existing versions of this product, their type, when they were created, as well as their delivery status.

You also need to Configure a Pipeline Template for release build. For more information, see Configure a Pipeline Template and Create a template for release build.

To create a new product version, click the Create button, choose Release Delivery and select the desired type. The resulting product version will be calculated automatically.

Select software components to be included in your new product version. To add additional software components, click the Add button on the right. For each software component, define a component version, enter the desired branch and commit ID as seen in the Manage Software Components app, and select in which languages your product version should be built. To get relevant commit ID for the software component involved in the build, you can refer the help page to get more details on this. Identify the commit based on which you wish to build your add-on product.

Click the Build Product Version button to trigger the build of the pipeline for your new product version.

You will be redirected to the Pipeline Status screen, where you can track the progress of your build.

4.3 Check Product Version

The Check Product Version app lets you view the results of product version delivery infrastructure checks to see if your product version is ready for delivery. 

Click on the Check Product Version tile to open the app. For more information, see Check Product Version

A list of all your products is displayed. Select one of the products from the list.

Ready for production (P): The product version is ready for production use.

4.4 Publish Product

You, as a partner, have developed a product that you want to make available to your customers as an add-on that they can install into their system. You can use the Publish Product app to publish your product in a specific version for use by customers. Your customer can then use the Discover Product app to view all product versions that were published, i.e. made available, for them and can register a product, thus adding a product to their pool of product versions available for deployment.

Log into the Landscape Portal.

Click the Publish Product tile to open the app. For more information, see Publish Product

Select the product from the list. You are forwarded to the configuration page. Click the Edit button.

In the Product Configuration section, select the Product Version that you want to publish and choose SAP Store as the Distribution Channel.

Click the Publish button to publish your product version

Steps performed from the Consumer

1. Discover Product

Once Partner has made their product available and has published a product version using the Publish Product app, customers can register the product via Discover Product app.

After registrations customers can deploy the product using Deploy Product.

2. Deploy Product

You can use the Deploy Product app to deploy or update your product version in specific systems.

Click on the Deploy Product tile to open the app.

On the left side, under Product and Product Version Selection, select which product and version you want to deploy or update from the drop-down menu.

In the Available Systems section, select at least one system in which you want to deploy or update the product version. You can also select multiple systems at once.

Click the Deploy button. A dialog box will open. Fill in the remaining details:

Title: Choose a title for your update.

From: Select the time the update can begin.

To: The estimated time at which the product version update will be completed.

Confirm with Schedule.

Check the list under Product Version Update Status. Here, all update requests as well as their current status and progress are displayed. The update you just scheduled has been added to the list.

Once the product is deployed successfully then Customer can access the product in target system.

SAP BTP automatically activates the software component provided from the partner in the ABAP environment, makes packages visible and registers IDE extensions.

3. Test IDE Action

Create/Use ABAP Cloud project in the ABAP instance where you have deployed the product.This should be a development system.

Open any Knowledge Transfer Document in the editor and copy the content.

To open the Run ABAP IDE Action dialog, use the shortcut Ctrl + Alt + R for Windows or CMD + OPT + R for Mac or choose Run->ABAP IDE Action... from the main menu.

Select the IDE action “Translate markdown content” you would like to run Select Run.

It will open the action input dialog where you can select the target language you want to translate and in next text box area provide the Knowledge Transfer Document content.

Select Run.

The result dialog for the selected IDE action opens the result dialog where it translates the Knowledge Transfer Document to the selected language option from the input dialog.

SAP BTP ABAP Environment – Pre-Upgrade Option for Release 2605

2026-03-12T12:13:39.797000+01:00

Overview

Providing a significant number of new features is an important goal of release upgrades to deliver innovations to our customers and partners. There are four major release upgrades per year following a predefined schedule as described in this blog post.

An upgrade is intended as a “no event” for customers and partners. For example, only compatible changes of released objects (APIs) will be delivered. We recommend performing a test of the custom-built productive apps in a test environment for the new release. The complexity of the technical dependencies between the custom-built apps and the underlying environment cannot be tested isolated, only including the ABAP environment on SAP-side. Therefore, we offer you to pre-upgrade selected systems 29 days in advance to test the applications prior to the planned standard-upgrade.

Purpose

This option enables a customer or partner to test the applications they have already developed on top of the new release a couple of days before the standard-upgrade. With SAP BTP ABAP Environment (aka "Steampunk"), we follow the approach of keeping released objects stable and provide all enhancements in a compatible fashion. Early testing is an additional measure to ensure proper software quality and might be used to detect unforeseen regressions. However, this option is not intended to test new features or to consume new features earlier.

Approach

The standard-upgrade of all systems to release 2605 is planned for May 16/17.

A customer or partner can nominate one or more already existing systems for the pre-upgrade. A nominated system will be upgraded on April 17 within a planned downtime from 8:00 to 16:00 CET. Depending on the system settings, the actual technical downtime might be only ~20 min within the mentioned timeframe. Please refer to this blog post about the downtime-optimized upgrade.

We recommend nominating a non-development system, such as a test system. The nomination of a development system is technically also possible, but fixes or other changes must not be imported into another system with a lower release. The nomination of a productive system doesn’t make sense because the purpose of the pre-upgrade is the re-test of the existing application before the productive system gets the new release.

According to the approach explained above, this offer is only relevant for customers or partners having at least two systems.

There might be situations where a correction of custom objects needs to be deployed. Such corrections are possible if the development / correction system is on the older release and is imported into the pre-upgraded system with the higher release.

Except potential fixes, the pre-upgrade is based on the same version as the standard-upgrade. It is planned to perform the pre-upgrade based on hotfix collection 1. The pre-upgrade systems will get the import of hotfix collection 2 after 2 weeks in the middle of the entire pre-upgrade test phase. It is planned to perform the standard-upgrade based on hotfix collection 3 and import this hotfix collection 3 to the pre-upgrade systems prior to the upgrade weekend on May 15.

Costs

This offering is optional and free of any additional charges.

Planned New Features

The planned new features will be published on the What's New for SAP BTP ABAP Environment on April 10. This list gives you an overview of potential areas for re-testing. The purpose of the pre-upgrade is not to consume these features before the standard-upgrade, because the documentation on help.sap.com will be delivered later before the standard-upgrade. It would also not be possible to transport code of such an adoption, because subsequent systems are not yet on the new release during the pre-upgrade phase.

Independent of the upgrades of the SAP BTP ABAP Environment, we recommend developing automated tests for the custom-built apps to detect regressions early on and without manual effort for re-testing. Such automated tests are perfectly suited to be run in the pre-upgrade test phase.

Time Schedule

The following figure summarizes the general approach:

Milestones for release 2605:

March 17: Nomination of system(s) is possible in the Landscape Portal
April 10: Announcement of the planned new features
April 13: Pre-upgrade systems are known
April 17: Pre-upgrade (with hotfix collection 1)
April 30: Import of hotfix collection 2 into pre-upgrade systems
May 13: Potential decision to postpone the upgrade
May 15: Import of hotfix collection 3 into pre-upgrade systems
May 16/17: Standard-upgrade (with hotfix collection 3)

System Nomination

To nominate a system, please register the system(s) by April 13 (EOB) latest by using the Landscape Portal. You can find further information about Accessing the Landscape Portal and about Register Systems for Pre-Upgrade. Please do not create customer tickets for system nomination like in previous pre-upgrades.

With such a nomination, the customer agrees to an extraordinary planned maintenance on April 17 for the pre-upgrade and on April 30 and May 15 for the import of hotfix collections (see above).

Report an Issue

Issues should be reported as part of the regression test phase by Mai 1 (EOB) to allow for a sufficient time frame for issue analysis and potential corrections on SAP-side.

Please create a customer ticket by using component BC-CP-ABA.

If a detected issue is likely to endanger the productive use after the standard-upgrade, you should use ticket priority very high despite the fact that the pre-upgrade system is not a productive system.

Exceptional Process in Case of Unresolved Priority Very High Issues

In case of the aligned decision on Wednesday, May 13 (based on unresolved priority very high tickets) to postpone the upgrade, a dedicated mitigation process needs to be started together with the respective customer or partner, with the following boundary conditions:

Resolving the open priority very high issues remains the highest priority for both, SAP and the customer or partner, as it is also the prerequisite for the upgrade.
According to the estimated issue resolution, catching up the upgrade needs to be planned.
The upgrade leads to a business downtime of 6 – 8 hours.
The upgrade must be scheduled within 7 calendar days the latest after fixing all remaining open priority very high issues.
We will not provide any fixes for the old release after the original date of the standard-upgrade to the new release.

In case business-critical issues are detected after the upgrade:

Issues need to be reported as priority very high issues and will be processed accordingly.
Going back to the release before upgrade is not an option. Therefore, resolving the issues in the new release with the appropriate priority is the required approach.

Summary

We recommend performing regression tests in pre-upgraded test systems to avoid day-1 impacts of productive custom apps after the standard-upgrade.

CDS Custom Entities

2026-03-13T06:56:29.491000+01:00

Introduction

A CDS custom entity is to implement own data retrieval using ABAP.

A CDS custom entity is linked with an ABAP class, and the data retrieval is executed on the application server.

Custom entities are used for data models whose runtime is implemented manually.

At the CDS level, only an interface is defined.

Runtime of a CDS Custom Entity

It shows that the data retrieval is implemented by an ABAP class and the data source does not have to be a database table.

CDS custom entities transient entities, which means they aren't created as a database object and can't be accessed using ABAP SQL.

In ABAP RESTful Application Programming Model (RAP), custom entities are used as a data model basis for RAP unmanaged queries, the ABAP query is executed by the RAP query engine.

A CDS custom entity cannot be used as a data source in other CDS entities or in ABAP SQL.

Syntax

// optional header annotations
@ObjectModel.query.implementedBy : 'ClassName'
define [root] custom entity EntityName
[with parameters ...]
{
  [field]
  [association]
  [annotation]
}

Creating a CDS Custom Entity

Defining the Data Model in a CDS Custom Entity

A custom entity defines an element list that can consist of elements or associations to other CDS entities.

It binds an ABAP class with annotation @ObjectModel.query.implementedBy.

Annotations and input parameters are optional.

The element list of a custom entity can contain single fields or CDS associations:

Individual fields have a name and a data type. The data type can be specified using a CDS built-in type, a CDS simple type, a CDS enumerated type, or a DDIC data element.
Associations can be regular associations or specialized associations, i.e. to-parent associations or to-child associations. They can be used to define a relationship to another table entity, thereby adding the association target as an additional data source.
Annotations at the element level can be used to add semantic information, such as text labels.

@EndUserText.label: 'PO Header'
define custom entity ZI_PO_HEAD
 with parameters parameter_name : parameter_type
{
  key key_element_name : key_element_type;
  element_name : element_types;
}

Header Entity

@EndUserText.label: 'PO Header' 
define custom entity ZI_PO_HEAD
//with parameters parameter_name: parameter_type
{
   key po_num : ebeln;
   doc_cat    : bstyp;
   type       : abap.char(2);
   org        : ekorg;
   comp_code  : bukrs;
   status     : abap.char(1);
   vendor     : Lifnrs
   plant      : werks_d;
}

Item Entity

@EndUserText.label: 'PO Items'
define custom entity ZI_PO_ITS
// with parameters parameter_name : parameter_type
{
   key po num    : ebeln;
   key po_item   : ebelp;
   item_text     : abap.char (40);
   material      : abap.char(40);
   plant         : werks_d;
   stor_loc      : Lgort_d;
   @Semantics.quantity.unitOfMeasure: 'uom
   qty           : abap.quan(13,3);
   uom           : abap.unit (3);
   @Semantics.amount.currencyCode: 'price_unit'
   product_price : abap.curr(10,2);
   price_unit    : abap.cuky;
}

Header Entity as Root Entity

@EndUserText.label: 'PO Header' 
define root custom entity ZI_PO_HEAD
//with parameters parameter_name: parameter_type
{
   key po_num : ebeln;
   doc_cat    : bstyp;
   type       : abap.char(2);
   org        : ekorg;
   comp_code  : bukrs;
   status     : abap.char(1);
   vendor     : Lifnrs
   plant      : werks_d;
}

Relationships in CDS Custom Entity

@EndUserText.label: 'PO Header' 
define root custom entity ZI_PO_HEAD
//with parameters parameter_name: parameter_type
{
   key po_num : ebeln;
   doc_cat    : bstyp;
   type       : abap.char(2);
   org        : ekorg;
   comp_code  : bukrs;
   status     : abap.char(1);
   vendor     : Lifnrs
   plant      : werks_d;
   _itms      : composition [1..*] of ZI_PO_ITS;
}

@EndUserText.label: 'PO Items'
define custom entity ZI_PO_ITS
// with parameters parameter_name : parameter_type
{
   key po num    : ebeln;
   key po_item   : ebelp;
   item_text     : abap.char (40);
   material      : abap.char(40);
   plant         : werks_d;
   stor_loc      : Lgort_d;
   @Semantics.quantity.unitOfMeasure: 'uom
   qty           : abap.quan(13,3);
   uom           : abap.unit (3);
   @Semantics.amount.currencyCode: 'price_unit'
   product_price : abap.curr(10,2);
   price_unit    : abap.cuky;
   _HD           : association to parent ZI_PO_HEAD
                   on $projection.po_num = _hd.po_num;
}

Creating the Query Implementation Class

The runtime of a CDS custom entity must be implemented manually.

It requires an ABAP class that implements the select method of the interface IF_RAP_QUERY_PROVIDER to handle query requests by the client.

This class is referenced by the custom entity and is dedicated to implementing the OData client data requests.

CLASS zcl_po_hd DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC.

PUBLIC SECTION.
 
  INTERFACES if rap_query_provider. 
PROTECTED SECTION.
PRIVATE SECTION.
ENDCLASS.

CLASS zcl_po_hd IMPLEMENTATION.

METHOD if_rap_query_provider~select.
ENDMETHOD.

ENDCLASS.

Adding Query Implementation Class to the CDS Custom Entities- Header and Items

@EndUserText.label: 'PO Header' 
@ObjectModel.query.implementedBy: 'ABAP:ZCL_PO_HD'
define root custom entity ZI_PO_HEAD
//with parameters parameter_name: parameter_type
{
   key po_num : ebeln;
   doc_cat    : bstyp;
   type       : abap.char(2);
   org        : ekorg;
   comp_code  : bukrs;
   status     : abap.char(1);
   vendor     : Lifnrs
   plant      : werks_d;
   _itms      : composition [1..*] of ZI_PO_ITS;
}

@EndUserText.label: 'PO Items'
@ObjectModel.query.implementedBy: 'ABAP:ZCL_PO_HD
define custom entity ZI_PO_ITS
// with parameters parameter_name : parameter_type
{
   key po num    : ebeln;
   key po_item   : ebelp;
   item_text     : abap.char (40);
   material      : abap.char(40);
   plant         : werks_d;
   stor_loc      : Lgort_d;
   @Semantics.quantity.unitOfMeasure: 'uom
   qty           : abap.quan(13,3);
   uom           : abap.unit (3);
   @Semantics.amount.currencyCode: 'price_unit'
   product_price : abap.curr(10,2);
   price_unit    : abap.cuky;
   _HD           : association to parent ZI_PO_HEAD
                   on $projection.po_num = _hd.po_num;
}

Implementation

CLASS zcl_po_hd DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC.

PUBLIC SECTION.
 
  INTERFACES if rap_query_provider. 
PROTECTED SECTION.
PRIVATE SECTION.
ENDCLASS.

CLASS zcl_po_hd IMPLEMENTATION.

METHOD if_rap_query_provider~select.
 
 DATA: it_hd TYPE TABLE OF zi_po_head, 
       it_itms TYPE TABLE OF zi_po_its.

 CASE io_request-get_entity_id( ).

  WHEN 'ZI_PO_HEAD'
     
     DATA(lv_hd_fs) = io_request-get_filter( )->get_as_sql_string( ). 
     DATA(lo_paging) = io_request->get_paging( ).
     DATA(lv_skip) = io_request->get_paging( )->get_offset( ).
     DATA(lv_top) = io_request->get_paging( )->get_page_size( ).
     If lv_top < 0.
         lv_top = 1.
     ENDIF
      
     DATA(it_sort) = io_request->get_sort_elements( ).
     READ TABLE it_sort INTO DATA(ls_sort) INDEX 1.
     IF ls_sort-descending = abap_true.
        DATA(lv_order) = |'{ ls_sort-element_name } DESCENDING'|.
     ELSE.
         lv_order = |'{ ls_sort-element_name } ASCENDING'|.
     ENDIF.
     
     IF lv_order IS INITIAL.
      lv_order = 'po_num'.
     ENDIF.

     SELECT * FROM ztb_po_header
              WHERE (lv_hd_fs)
              ORDER BY (lv_order)
              INTO CORRESPONDING FIELDS OF TABLE _hd.
     
      io_response->set_total_number_of_records( lines( it_hd ) ).
      
      IF lv_hd_fs IS INITIAL.
       IF lv_skip EQ 0.
        DELETE it_hd FROM lv_top + 1.
       ELSE.
        DELETE it_hd FROM lv_top + lv_skip + 1 TO lines( it_hd ).
        DELETE it_hd FROM 1 TO lv_skip.
        ENDIF.
      ENDIF.
      
      io_response->set_data( it_hd ).

     
   WHEN 'ZI_PO_ITS'
     
      DATA(lv_item_fs) = io_request-get_filter( )->get_as_sql_string( ). 
      DATA(lv_skips) = io_request->get_paging( )->get_offset( ).
      DATA(lv_tops) = io_request->get_paging( )->get_page_size( ).
      If lv_top < 0.
         lv_top = 1.
      ENDIF
      

     SELECT * FROM ztb_po_item
              WHERE (lv_item_fs)
              ORDER BY po_num
              INTO CORRESPONDING FIELDS OF TABLE _itms.
     
      io_response->set_total_number_of_records( lines( it_itms ) ).
      
      io_response->set_data( it_itms ).

   ENDCASE.


ENDMETHOD.

ENDCLASS.

Metadata Extension

Header

@Metadata.layer: #CORE 
@UI:{ headerInfo: { 
          typeName: 'Purchase Order', 
          typeNamePlural: 'Purchase Orders', 
         title: {
              type: #STANDARD,
              value: 'po_num' 
           }
 } }
annotate entity ZI_PO_HEAD with
{
@UI.facet: [[ 
     id: 'po_num',
     purpose: #STANDARD,  
     position: 10,
     type:#IDENTIFICATION REFERENCE, 
    // type:#COLLECTION,
     label: 'Purchase Order Header'
},
{
id: 'POItems', 
purpose: #STANDARD,
type:#LINEITEM_REFERENCE, 
position: 20,
targetElement: '_itms',
label: 'Purchase Order Items'
}
]


@UI.lineItem: [{position: 10, label: 'Purchase Order'}]
@UI.selectionField: [{ position: 10 }]
@UI.identification: [{ position: 10, label: 'Purchase Order' }]
po_num;

@UI.lineItem: [{position: 30,label: 'Order Type', importance: #HIGH }] 
@UI.identification: [{position: 30,label: 'Order Type' }]
type;

@UI.lineItem: [{position: 40, label: 'Company Code', importance: HIGH }] 
@UI.identification: [{ position: 40,label: 'Company Code' }]
comp_code;

@UI.lineItem: [{position: 50, label: 'Organization', importance: #HIGH }] 
@UI.identification: [{position: 50, label: 'Organization' }]
org;

@UI.lineItem: [{ position: 60, label: 'Vendor' }]
@UI.identification: [{ position: 60, label: 'Vendor' }]
vendor;

@UI.lineItem: [{ position: 70, label: 'Plant' }]
@UI.selectionfield: [{ position: 70 }]
@UI.identification: [{ position: 70, label: 'Plant' }]
plant;

@UI.lineItem: [{ position: 80, label: 'Status' }]
@UI.identification: [{ position: 80, label: 'Purchase Status' }]
status;

@UI.lineItem: [{ position: 90, label: 'Purchase Cat' }]
@UI.identification: [{ position: 90, label: 'Purchase Cat' }]
doc_cat;

}

Items

@Metadata.layer: #CORE 
@UI:headerInfo: {  
         title: {
              label: 'PurchaseItemInfo'
              type: #STANDARD,
              value: '_hd' 
           }
 } }
annotate entity ZI_PO_ITS with
{
@UI.facet: [[ 
     id: 'ItemID',
     purpose: #STANDARD,  
     position: 10,
     type:#IDENTIFICATION REFERENCE, 
     label: 'Item Information'
} ]

@UI.lineItem: [{position: 10, label: 'Purchase Order'}]
@UI.identification: [{ position: 10, label: 'Purchase Order' }]
po_num;

@UI.lineItem: [{position: 20,label: 'Item Number'}] 
@UI.identification: [{position: 20,label: 'Item Number' }]
po_item;

@UI.lineItem: [{position: 30,label: 'Short text' }] 
@UI.identification: [{position: 30,label: 'Short text' }]
item_text;

@UI.lineItem: [{position: 40, label: 'Material'}] 
@UI.identification: [{ position: 40,label: 'Material' }]
material;

@UI.lineItem: [{position: 50, label: 'Plant' }] 
@UI.identification: [{position: 50, label: 'Plant' }]
plant;

@UI.lineItem: [{ position: 60, label: 'Storage Location' }]
@UI.identification: [{ position: 60, label: 'Storage Location' }]
stor_loc;

@UI.lineItem: [{ position: 70, label: 'Order Quantity' }]
@UI.identification: [{ position: 70, label: 'Order Quantity' }]
qty;

@UI.lineItem: [{ position: 80, label: 'Product Price' }]
@UI.identification: [{ position: 80, label: 'Product Price' }]
product_price;

}

Service Definition

Expose the Custom Entities

@EndUserText.label: 'PO' 
define service ZUI_PO_HO { 
  expose ZI_PO_HEAD as PO; 
  expose ZI_PO_ITS as Item;
}

Service Binding

Preview the Application

Choose Preview

Choose Go, then Implementation class is executed.

Navigate to items details.

References

Conclusion

A CDS custom entity is used to write the custom logic with an ABAP class, and the data retrieval logic is executed on the application server .

Service definition and Binding can be created for a custom entity with a Binding type Web API and UI.

Week 3 : Use RAP Business Logic Prediction to Implement Validation

2026-03-16T05:30:00.017000+01:00

Last week we had created a RAP Application and added some entries in it. We also explored how to use Joule's 'Explain' feature to understand a simple code added in the CDS Data Definition.

This week let us go one step further and explore another very interesting feature of Joule's ABAP AI capability - The RAP Business Logic Prediction.

Quick Links

Please use this separate thread to ask your questions and discuss issues.

Sample Scenario

Here let us think about any simple scenario like changing a field to ‘Mandatory’ and then create a new entry without filling value for this field. Empty values should not be accepted for the mandatory field and we can use the ‘validation’ keyword to check if its kept empty. Here use Joule’s ‘RAP Predict Business Logic’ capability to suggest the code to raise an error message in the implementation method of the validation function. Let’s see the steps in detail.

Task1: Create a validation and implement the corresponding method.

Create a validation in the BDEF of the CDS view. Open your behavior definition and specify one of the fields as mandatory.Define Mandatory Field
Define the Validation in same BDEF of the CDS view.Validation Defenition
In order to have draft instances being checked by validations before they become active, they have to be specified for the draft determine action prepare in the behavior definition. Replace the code line draft determine action Prepare; in your BDEF with the following code snippet as shown on the screenshot below.Prepare Action
Save and activate the changes.
Now you can notice a small icon to the left of the validation definition. Click on it to create the implementation method for adding validation logic in the local handler class of the behavior pool of your entity. Save and activate the changes. Hint: You can right click on the new method name and choose Quick Fix as well.Implement ValidationFor additional information on Validations and its syntax and use you can refer the BDEF ‘/DMO/R_Travel_D’. Alternatively you can also refer https://github.com/SAP-samples/abap-platform-rap100/tree/main/exercises/ex05

Task2: Enhance validation with RAP Predict Business Logic

Use Joule's RAP Predict Business Logic to add the logic to check whether the mandatory field created in Task 1 is filled while creating a new entry. If it is left empty throw an error message.

Note:- The logic and examples are mentioned just for your reference and to make the purpose of the challenge easy to understand. Please feel free to use your own logic and dataset.

To know how to use RAP Predict Business Logic follow this tutorial. Hint: You can right click on the new method name and choose Quick Fix as well.

Good luck and wait for the last challenge next week. Until then Stay Jouled !!!

RAP New Feature : Generating Managed RAP Applications With Table Entity

2026-03-16T12:19:37.144000+01:00

Traditionally, when developing a managed RAP application, we create multiple artifacts such as CDS view entities, behavior definitions, service definitions, and service bindings. However, with the introduction of Table Entity, SAP allows us to directly expose database tables in a RAP-compliant way, significantly reducing boilerplate development effort.

This feature is especially useful when:

You want to quickly generate a managed RAP application
The table structure already satisfies your business requirements
You want to minimize intermediate CDS modeling layers
You are building internal or utility applications with simple transactional needs
In this blog, we will explore:
- What a Table Entity is in RAP
- How it differs from traditional CDS view entities
- Step-by-step creation of a Managed RAP application using Table Entity
- Service exposure and preview in Fiori Elements
  Table Entity:
  - Read and write access is possible using ABAP SQL SELECT, UPDATE, MODIFY, INSERT, and DELETE.
  - A table entity can be used as a data type in ABAP.
    Properties of Table Entities:
    Key Fields – You can define one or more elements as the primary key using the keyword KEY. However, unlike database tables, key fields are optional and it is also possible to have a table entity without a primary key.
    Note: The access pattern of a table entity without a primary key is that it is always read completely, which can result in longer processing times. Single record access is not provided.
    Client Dependency
    Client handling is defined using the header annotation @ClientHandling.type. The possible annotation values are #CLIENT_DEPENDENT or #CLIENT_INDEPENDENT.
    Flag for Null Values
    A null value on the database is an undefined value. Columns of table entities are by default created as NOT NULL on the SAP HANA database. It is possible to override this default behavior by using the optional addition NULL for a column.
    Delivery Class
    The delivery class of a table entity controls the transport of table data in installations, upgrades, or client copies, and in transports between customer systems. Annotation @AbapCatalog.deliveryClass is used to specify delivery class.
    - select table entity template.

@ClientHandling.type: #CLIENT_DEPENDENT
@AbapCatalog.deliveryClass: #APPLICATION_DATA
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'travel information'
define table entity ztb_travel
{
  key travel_id : /dmo/travel_id;
  description   : /dmo/description;
  status        : /dmo/travel_status;
    lastchangedat : timestampl;

create report/class to insert entries.

select travel_id, description, status,lastchangedat FROM /dmo/travel into TABLE (lt_travel).
if sy-subrc eq 0.
insert ztb_travel FROM TABLE _TRAVEL.
if sy-subrc eq 0.
out->write( 'travel data inserted successfully' ).
else.
out->write( 'failed to insert' ).
ENDIF.
endif.

Lets make our table entity as root entity so that will create rap application as well

@ClientHandling.type: #CLIENT_DEPENDENT
@AbapCatalog.deliveryClass: #APPLICATION_DATA
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'travel information'
define root table entity ztb_travel
{
  key travel_id : /dmo/travel_id;
  description   : /dmo/description;
  status        : /dmo/travel_status;
    lastchangedat : timestampl;    
}

Projection View:

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'consumption view for travel table entity'
@Metadata.ignorePropagatedAnnotations: true
define root view entity zcb_travel as projection on ztb_travel
{

@UI.facet: [{ label: 'Travel Info', type: #IDENTIFICATION_REFERENCE }]
@UI.lineItem: [{ position: 10 }]
@UI.identification: [{ position: 10 }]
    key travel_id,
    .lineItem: [{ position: 20 }]
@UI.identification: [{ position: 20 }]
    
    description,
    .lineItem: [{ position: 30 }]
@UI.identification: [{ position: 30 }]
    
    status
}

Interface Behavior Definition:

managed implementation in class zbp_tb_travel unique;
strict ( 2 );
with draft;
define behavior for ztb_travel alias tb_travel
lock master total etag lastchangedat
draft table zdtbtrav
authorization master ( instance )
{
  create ( authorization : global );
  update;
  delete;
  field ( readonly ) lastchangedat;
  draft action Activate optimized;
  draft action Discard;
  draft action Edit;
  draft action Resume;
  draft determine action Prepare;
}

Projection Behavior Definition:

projection implementation in class zbp_cb_travel unique;
strict ( 2 );
use draft;

define behavior for zcb_travel alias tb_travel
{
  use create;
  use update;
  use delete;

  use action Activate;
  use action Discard;
  use action Edit;
  use action Resume;
  use action Prepare;
}

Service Definition:

@EndUserText.label: 'sd for table entity travel'
define service Zsd_tb_trav {
  expose zcb_travel as TableEntityTravel;
}

Service Binding:

generate service binding and test,we generate managed rap application, CRUD operations will be handled by framework itself.

Conclusion:
the table entity in RAP provides a simple and effective way to expose database tables directly in RAP-based applications. It helps developers quickly build transactional services with minimal configuration while still benefiting from the RAP framework’s capabilities. By using table entities, developers can accelerate development and maintain consistency within modern SAP application architecture.
ABAP Connectivity ABAP Extensibility SAP BTP ABAP environment ABAP RESTful Application Programming Model

SAP BTP ABAP Environment Customer & Partner Roundtable – April 07, 2026

2026-03-17T09:00:00.021000+01:00

Dear customers, partners, and SAP Community members,

Join us for the next session of our SAP BTP ABAP Environment Customer & Partner Roundtable, taking place on April 07, 2026, from 10:00–11:00 CET.

Our roundtable is a monthly virtual meeting where we share the latest updates from the product team and showcase live demos from experts. It is a great opportunity to stay up to date with the latest capabilities of the SAP BTP ABAP Environment, ask questions, and engage with the community.

Join the session

📅Date: April 07, 2026
⏰Time: 10:00–11:00 CET

Agenda

🔹App as an Entity – Aron Leibfried

🔹Direct App Launch – Aparna Narayanaswamy

🔹Infrastructure Topics (Smaller Runtime & Costs, Multi-Availability Zones) – Christian Lutter

🔹Product Updates – Frank Jentsch

The roundtable is a monthly series taking place on the first Tuesday of every month (10:00–11:00 CET).

👉 Download the .ics calendar file for the full 2026 series and import it directly into your calendar.
Each calendar entry already includes the Microsoft Teams meeting link.

Microsoft Teams meeting link (valid for the entire 2026 series): Microsoft Teams meeting link

All agendas, slides, recordings, and updates from past and current sessions are published centrally via the
SAP Community – SAP BTP ABAP Environment Customer & Partner Roundtable.

We’re looking forward to seeing you there!

SAP BTP ABAP Environment Team

Week 4 : Use Joule Predictive Code Completion to Implement Determination

2026-03-23T05:30:00.019000+01:00

Congratulations to everyone who came along with us till the 4th week of the ABAP Developer Challenge. So far we have seen :

How to create a OData UI Service from Scratch using Joule Chat
How to use Joule - Explain feature to understand a block of code.
How to use Joule - RAP Predict Business Logic to create logic for specific tasks.

Let us wrap up with another interesting feature of Joule's ABAP AI Capability - The Joule Predictive Code Completion.

Quick Links

Please use this separate thread to ask your questions and discuss issues.

Sample Scenario

We had asked you to create a field of type 'Date' during the RAP application creation.

Now let us use Determination function to calculate the number of years since the value in Date field. You can implement it while creating a new record using the app.

Task1: Create a determination and implement the corresponding method.

Define a determination in the BDEF of the CDS view.Define Determination
Now you can notice a small icon to the left of the determination definition. Click on it to create the implementation method for adding determination logic in the local handler class of the behavior pool of your entity. Save and activate the changes.Implement DeterminationFor additional information on Determinations and its syntax and use you can refer the BDEF ‘/DMO/R_Travel_D’. Alternatively you can also refer https://github.com/SAP-samples/abap-platform-rap100/blob/main/exercises/ex04

Task2: Enhance determination with Joule Code Prediction Capability

Use Joule's Predictive Code Completion feature to complete your code by providing simple prompts for each step in the logic.

Here please note that we should use the Toggle option to disable / enable Joule Code Prediction Capability by pressing button in the toolbar.

Hint: Disable the Joule Code Prediction Capability if you want to give prompts for new steps / once finished to stop Automatic Code Prediction.

Note:- The logic and examples are mentioned just for your reference and to make the purpose of the challenge easy to understand. Please feel free to use your own logic and dataset.

To know how to use Predictive Code Completion follow this tutorial

Please note that the challenge will remain open for another week for anyone who is running late.

Before we close for this year we would like to thank everyone who participated. We hope all of you enjoyed the challenge. Let us continue to explore how SAP Joule for developers, ABAP AI capabilities can support us with our day-to-day tasks when working with ABAP code, to increase our efficiency and to lower total cost of development.

Happy Jouling!!!

Custom Business Configurations (F4579): Define default grouping and sorting

2026-03-27T13:50:03.260000+01:00

Introduction

The Custom Business Configurations (CUBCO) app serves as an entry point to the Business Configuration Maintenance Object (SMBC) provided by custom applications or partners.

This blog explains how to define the default grouping and sorting for the tables of the business configuration object.
The basic procedure is already explained here, but we apply it directly to the result of the ADT wizard.

This blog is relevant for

Further reading:

Related blog posts
Learn how you can use ABAP technology to develop innovative applications and business solutions across SAP’s portfolio on SAP Learning Site.

Example scenario

Company codes are defined in the configuration table ZDEMO_CC. In the CUBCO app, the rows are to be grouped and sorted by country.

@EndUserText.label : 'Company Code'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #C
@AbapCatalog.dataMaintenance : #ALLOWED
define table zdemo_cc {
  key client            : abap.clnt not null;
  key company_code      : abap.numc(4) not null;
  country               : land1;
  last_changed_at       : abp_lastchange_tstmpl;
  local_last_changed_at : abp_locinst_lastchange_tstmpl;
}

Define presentation variant

First you use the ADT wizard to generate a Business Configuration Maintenance Object for this table.

In the generated CDS view ZI_COMPANYCODE_S of the Singleton entity, you change the facet type from #LINEITEM_REFERENCE to #PRESENTATIONVARIANT_REFERENCE and add the targetQualifier attribute:

  .facet: [ {
    id: 'ZI_CompanyCode', 
    purpose: #STANDARD, 
    type: #PRESENTATIONVARIANT_REFERENCE, 
    targetQualifier: 'myVariant',
    label: 'Company Codes', 
    position: 1 , 
    targetElement: '_CompanyCode'
  } ]
  .lineItem: [ {
    position: 1 
  } ]
  key 1 as SingletonID,

In the metadata extension ZI_COMPANYCODE of the company code entity, add the following presentation variant:

.presentationVariant: [
  {
    qualifier: 'myVariant',
    sortOrder: [
      {
        by: 'Country',
        direction: #ASC
      }
    ],
    groupBy: [ 'Country' ],
    visualizations: [{type: #AS_LINEITEM}]
  }
]
annotate view ZI_CompanyCode with

Finally, open the generated SMBC object ZCOMPANYCODE in ADT and open the table settings section. Change the table type attribute from Grid Table to Responsive Table because grouping is not supported for grid tables. If you only need the default sorting, you can continue to use the grid table.

Our 2026 Roadmap for Joule for Developers ABAP AI capabilities

2026-03-28T20:13:48.908000+01:00

Sapphire 2026 is approaching quickly and as usual it will bring lots of new announcements. So now is the right point in time to recap what has been announced already until Q2/2026 and prepare for the ABAP AI sessions.

The ABAP Platform AI (covering both SAP BTP ABAP Environment and SAP S/4HANA) transitions from a set of independent AI skills to full-scale Agentic AI. The roadmap focuses heavily on increasing developer productivity via agents in Joule for Developers ABAP (J4D ABAP) and the modernization of ABAP development tools.

The key benefits for customers and partners of the roadmap until Q2/2026 are:

ABAP development tools with AI Agents in VS Code with ABAP MCP Server.
ABAP AI for lower releases of SAP S/4HANA Cloud Private Edition (i.e. 2021, 2022, 2023 and 2025).
Simplified customer on-boarding of ABAP AI via SAP for Me and Central Business Configuration.
Faster innovation with Side-by-Side consumption of SAP and 3rd party Agentic IDEs and LLMs
(e.g. Microsoft, Amazon, IBM, OpenAI, Anthropic, Google, Mistral…)

The biggest shift in 2026 will be the move toward Agentic AI, where the existing ABAP AI skills doesn't just explain, complete or generate code (e.g. RAP, CDS, Tests) independently but acts as an autonomous collaborator. This includes built-in ABAP MCP (Model Context Protocol) server. The introduction of VS Code as IDE can only be a start as the depth and breath of Eclipse which we achieved in so many years cannot be reached with one or two steps in VS Code. It'll be a journey which starts with first providing End-to-end UI services development with agents.

The new ABAP AI side-by-side architecture is designed to provide a scalable and future‑proof foundation for ABAP AI capabilities across heterogeneous SAP landscapes. It enables customers to consume ABAP AI services side‑by‑side, independent of the underlying S/4HANA release, ensuring access even for lower‑release Private Edition systems.

A core benefit of the architecture is also its simplified enablement model through SAP for Me and Central Business Configuration, reducing on-boarding effort and ensuring consistent lifecycle management across environments.
In addition, the architecture allows us to accelerate innovation speed by allowing to leverage SAP‑provided ABAP AI models alongside leading third‑party LLMs (e.g., Microsoft, Amazon, IBM, OpenAI, Anthropic, Google, Mistral) more independently from releases. This flexibility ensures rapid adoption of new capabilities without dependency on individual release cycles.

If you missed the highlights we delivered in Q1/2026 have a look into what Olga Dolinskaja shared about ABAP AI ATC finding explain and custom code explain and proposals. Although this will be a focus also for our future roadmap we will also not stop investing into AI app generators like the Embedded Analytics model generator.

Here you can learn more:

More high-level insights about Joule for Developers/ABAP AI and ABAP platform can be found here . Here you find more on ABAP- 1,

Optional Task: Use Joule CDS Unit Test Generation

2026-03-30T06:30:00.020000+02:00

Thank you to everyone who participated in the ABAP Developer Challenge over the past four weeks and successfully completed all four tasks focused on ABAP AI capabilities. We truly appreciate the enthusiasm and engagement shown throughout the challenge. As a follow-up, we are excited to introduce an additional bonus task.

In Week 2, you enhanced a CDS data definition by implementing simple logic. Building on that work, your next step is to create an ABAP test class to validate the logic within the CDS data definition. For this task, you will utilize another feature of Joule’s ABAP AI capabilities — CDS Test Generation.

Task:

Select the CDS data definition that you enhanced in Week 2.
Generate an ABAP test class using Joule’s CDS Test Generation feature.
Execute the test class and ensure that all generated test cases run successfully.

Please refer to the link below for detailed guidance on how to use this ABAP AI capability.

https://help.sap.com/docs/abap-cloud/abap-development-tools-user-guide/use-cds-test-class-generator?locale=en-US

Smaller ABAP Runtime Size Now Available in SAP BTP ABAP Environment

2026-03-31T14:40:48.302000+02:00

Starting March 31, 2026, SAP BTP ABAP environment introduces a new runtime sizing option: 0.5 ABAP Compute Units (ACU) which is 8 GB of runtime memory.

With the introduction of 0.5 ACU, customers can now operate ABAP systems at 50% lower ABAP runtime cost compared to the previous minimum size of 1 ACU making it significantly more cost-efficient to run development, test, and sandbox systems.

This enhancement allows SAP BTP ABAP environment to run on smaller runtime units, lowering the entry barrier for development and test systems.

What is an ABAP Compute Unit (ACU)?

ABAP Compute Units (ACUs) define the runtime capacity of an SAP BTP ABAP environment system. One ACU corresponds to 16 GB of memory allocated to the ABAP runtime. The total runtime size determines how much capacity is available across all ABAP application servers. For more information, see the documentation on ABAP Compute Units.

What’s New?

With this update SAP BTP ABAP environment now supports 0.5 ABAP Compute Units (ACU) as the new minimum system configuration.

It allows to run smaller systems, enabling more granular runtime sizing compared to previous configurations. It creates an additional option to better match the actual workloads, particularly for smaller environments.

What are the Key Benefits?

50% lower ABAP runtime cost compared to the previous minimum size (1 ACU)
Improved resource utilization for smaller or variable workloads
Lower entry barrier for new and existing customers

For a detailed breakdown of cost components, see my previous blog post on ABAP environment cost calculation.

How to Adjust Existing Systems?

Adjusting the ABAP runtime size (ACUs) is handled via manual scaling and does not lead to a system downtime . You can use the SAP BTP Cockpit to update the service instance, for example, from 1 ACU to 0,5 ACU, see the documentation on Updating an ABAP System.

What Needs to be Considered?

For systems with a runtime size of 0.5 ACU, only one application server is used. This setup is suited for development and test, but not recommended for productive use, as it may increase the likelihood of short outages.

Overview about typical use cases and recommend systems sizes

Use Case	Size	Total Runtime Memory	Application Servers
Development, test, sandbox systems for smaller projects	0.5 ACU (new)	8 GB	1 á 8 GB
Development, test, sandbox systems for bigger projects; Productive systems for up to 1,000 active users per day	1 ACU	16 GB	2 á 8 GB
Productive systems with higher concurrency or up to 100 tenants	2 ACU	32 GB	4 á 8 GB
Productive systems with bigger max session size	4 ACU	64 GB	2 á 32 GB
Productive systems with higher load in multitenant SaaS solution	4 ACU	64 GB	8 á 8 GB

Further References

For more information about sizing options and configuration parameters in SAP BTP ABAP environment, see the documentation on Creating an ABAP System.

Joule for Developers ABAP AI Sapphire and ASUG 2026 Sessions

2026-04-04T17:52:59.936000+02:00

In case you do not have planned your Sapphire Orlando and ASUG agenda here are my recommendations if you want to learn about the latest innovations from ABAP Platform and Joule for developers (J4D) ABAP AI capabilities:

1. Introduction to ABAP Cloud supported by generative AI | BTP1429: Get an overview on ABAP Cloud and recent innovations, get insights on Clean Core and see how generative AI boosts your adoption of ABAP Cloud conducted by Alexander Rother (VP, Head of ABAP Platform Product Management).

2. Build smarter: Agentic ABAP development tools for Visual Studio Code | BTP2573: Simona Marincei (Head of AI - SAP ABAP Platform) will show how ABAP agents orchestrate in VS Code via the ABAP MCP-server tasks, speed up coding, and boost productivity across orchestrators from various partners.

3. Agentic ABAP with SAP Joule for Developers: Build faster, migrate smarter | JOU1428: Simona Marincei (Head of AI - SAP ABAP Platform) and Nora Klemp (Senior Product Specialist) will explain how agentic ABAP accelerates SAP S/4HANA migrations and streamline ABAP Cloud development across modern and legacy environments.

4. Customer Influence and feedback: The product road map for ABAP Cloud | BTP1603: Learn from Alexander Rother (VP, Head of ABAP Platform Product Management) how to give feedback to the ABAP product roadmap with the Customer Influence site which allows submitting, tracking, and prioritizing ideas.

5. Modernize classic extensions for clean core in SAP Cloud ERP Private | BTP1426: Volker Drees (Product Expert, ABAP Cloud, SAP SE) will explain clean core extensibility practice in SAP S/4HANA Cloud Private Edition. Learn how to govern clean core development using the ABAP test cockpit and how to use the ABAP Cloud development model and clean core extensibility principles to modernize your custom on-stack extensions.

The full Sapphire Orlando and ASUG 2026 (11.05.2026 - 13.05.2026) agenda can be found here...

...and here is the agenda for Sapphire Madrid (19.05.2026 - 21.05.26).

Here you can learn more:

More high-level insights about Joule for Developers/ABAP AI and ABAP platform can be found here . Here you find more on ABAP- 1,

New Multi-Availability Zone Option for SAP BTP ABAP Environment

2026-04-06T15:08:26.149000+02:00

Starting March 20, 2026, SAP BTP ABAP environment introduces the multi-availability zone (multi-AZ) option for ABAP environment instances, further strengthening system resilience.

When enabled, the ABAP runtime components of an SAP BTP ABAP environment instance are distributed across multiple availability zones within a region. In parallel, the SAP HANA Cloud database is configured in a high-availability setup with a primary and a secondary instance in different availability zones, using synchronous replication. This ensures that, in case of infrastructure failures, workloads can continue running with minimal disruption.

Compared to the default single availability zone setup, the multi-AZ option provides:

Distribution of ABAP application servers across availability zones
Higher prioritization during recovery scenarios
Automatic failover to a secondary database instance
Improved resilience in case of availability zone outages

It is important to note that the multi-availability zone option does not affect ABAP runtime costs (ACUs). However, persistence layer costs increase, as the SAP HANA Cloud database is deployed with an additional secondary instance (HCUs).

The option is configured at SAP BTP ABAP environment instance level and is particularly relevant for scenarios with higher availability and resilience requirements.

For more details, see Resilience of an ABAP Environment System.

How I Connected Claude AI to My SAP ABAP System Using MCP — A Complete Windows Guide

2026-04-07T12:35:07.976000+02:00

Introduction

The SAP developer community has been buzzing about connecting Claude AI directly to live SAP ABAP systems using MCP (Model Context Protocol) — reading code, modifying objects, creating transports, and activating changes, all from a natural language chat interface.

I tried it myself on Windows, and it works. This blog walks you through exactly how to set it up.

What is MCP?

MCP (Model Context Protocol) is an open standard that lets AI models like Claude connect to external tools and data sources. Think of it as a plugin system for AI — instead of just answering questions from training data, Claude can actually call tools that interact with real systems.

For SAP developers, this means Claude can:

Read your actual ABAP code directly from your system
Write and modify objects
Run syntax checks
Create transport requests
Activate objects

All without you copy-pasting anything.

The Architecture

Claude Desktop / Claude Code CLI         ↕ MCP Protocol  ┌──────────────────────────┐  │   mcp-abap-adt           │  ← Read-only (13 tools)  │   mcp-abap-abap-adt-api  │  ← Full CRUD (30 tools)  └──────────────────────────┘         ↕ ADT REST API    Your SAP ABAP System

Both MCP servers were built by Mario Andreschak and communicate with SAP via the same ADT (ABAP Development Tools) API that Eclipse uses under the hood.

Prerequisites

Before starting, you need:

Windows 10 or 11 (64-bit)
An SAP ABAP system with /sap/bc/adt active in SICF
A user with SAP_ADT_DEVELOPER role (or equivalent)
A Claude Pro/Max/Team subscription at claude.ai
Internet connection

Step 1 — Install Node.js

Node.js is the runtime required by Claude Code CLI and the MCP servers.

Go to https://nodejs.org and download the LTS version
Install with all defaults
Verify in Command Prompt:

node -v    → v24.x.xnpm -v     → 11.x.x

Step 2 — Install Git for Windows

Git provides the bash shell Claude Code requires on Windows.

Go to https://git-scm.com/downloads/win and download the installer
During setup, on the PATH screen select: "Git from the command line and also from 3rd-party software"
Complete with all other defaults

Step 3 — Install Claude Code CLI

cmd

npm install -g @anthropic-ai/claude-codeclaude --version

Then log in:

cmd

claude

Select option 1 (Claude subscription), log in via browser, return to terminal.

Step 4 — Install mcp-abap-adt (Read-Only MCP Server)

This server gives Claude read access to your SAP system with 13 tools including GetProgram, GetClass, GetFunction, GetTable, SearchObject, and more.

cmd

mkdir C:\Toolscd C:\Toolsgit clone https://github.com/mario-andreschak/mcp-abap-adtcd mcp-abap-adtnpm installnpm run build

Create a .env file in the folder:

SAP_URL=https://your-sap-system.com:44300SAP_USERNAME=YOUR_USERNAMESAP_PASSWORD=YOUR_PASSWORDSAP_CLIENT=300TLS_REJECT_UNAUTHORIZED=0

cmd

claude mcp add mcp-abap-adt node C:/Tools/mcp-abap-adt/dist/index.jsclaude mcp list

You should see: mcp-abap-adt: ✓ Connected

Step 5 — Install mcp-abap-abap-adt-api (Full CRUD Server)

This is the powerful one — 30 tools including read, write, syntax check, activate, lock/unlock, and transport management.

cmd

cd C:\Toolsgit clone https://github.com/mario-andreschak/mcp-abap-abap-adt-api.gitcd mcp-abap-abap-adt-apinpm installnpm run build

Create .env (note: slightly different variable names):

SAP_URL=https://your-sap-system.com:44300SAP_USER=YOUR_USERNAMESAP_PASSWORD=YOUR_PASSWORDSAP_CLIENT=300SAP_LANGUAGE=ENNODE_TLS_REJECT_UNAUTHORIZED=0

cmd

claude mcp add mcp-abap-adt-api node C:/Tools/mcp-abap-abap-adt-api/dist/index.js

Step 6 — Setup Claude Desktop (GUI Interface)

Claude Desktop is where it really comes alive — a beautiful chat UI like the LinkedIn video.

Download from https://claude.ai/download
Install and log in
Go to ☰ → Settings → Developer → Edit Config
Replace the content with:

json

{
  "mcpServers": {
    "mcp-abap-adt": {
      "command": "C:\\Program Files\\nodejs\\node.exe",
      "args": ["C:\\Tools\\mcp-abap-adt\\dist\\index.js"],
      "env": {
        "SAP_URL": "https://your-sap-system.com:44300",
        "SAP_USERNAME": "YOUR_USERNAME",
        "SAP_PASSWORD": "YOUR_PASSWORD",
        "SAP_CLIENT": "300",
        "TLS_REJECT_UNAUTHORIZED": "0"
      }
    },
    "mcp-abap-adt-api": {
      "command": "C:\\Program Files\\nodejs\\node.exe",
      "args": ["C:\\Tools\\mcp-abap-abap-adt-api\\dist\\index.js"],
      "env": {
        "SAP_URL": "https://your-sap-system.com:44300",
        "SAP_USER": "YOUR_USERNAME",
        "SAP_PASSWORD": "YOUR_PASSWORD",
        "SAP_CLIENT": "300",
        "SAP_LANGUAGE": "EN",
        "NODE_TLS_REJECT_UNAUTHORIZED": "0"
      }
    }
  }
}

⚠️ Windows-specific tip: You MUST use the full path C:\\Program Files\\nodejs\\node.exe — using just "node" does not work in Claude Desktop on Windows. Also note double backslashes \\ in all paths.

Kill Claude in Task Manager and reopen
Go back to Settings → Developer — you should see both servers listed as running ✅

Step 7 — Add Free Official SAP MCP Servers

Bonus: Claude Desktop has a built-in directory of official SAP MCP servers. Click "Connect your tools to Claude" at the bottom of the chat, search for "SAP", and add:

SAPUI5 MCP Server — for UI5 development
SAP CAP MCP Server — for CAP projects
SAP Fiori MCP Server — for Fiori Elements apps

Also add these free hosted servers to Claude Code CLI (no installation needed):

cmd

claude mcp add --transport http abap-docs https://mcp-abap.marianzeis.de/mcpclaude mcp add --transport http sap-docs https://mcp-sap-docs.marianzeis.de/mcp

These give Claude access to the full ABAP keyword documentation across 8 SAP releases, ABAP cheat sheets, CAP docs, UI5 docs, and SAP Community posts.

Testing It

Open Claude Desktop, create a New Chat, and type:

Get the source code of program SAPMV45A

Watch Claude automatically call your SAP system, retrieve the source code, and explain it — all in seconds.

For write operations (test on $TMP objects only!):

Find a simple Z program in $TMP, add a comment at the top saying "Modified by Claude", save and activate it

For complex workflows like the LinkedIn video:

Connect to my SAP system. Copy class ZCL_SOURCE from package ZPKG_A into ZPKG_B, rename it to ZCL_TARGET, change the carrier_id in the SELECT for /DMO/CONNECTION, create a transport and activate.

Security Notes

Never commit .env files to Git
Change your SAP password if shared in screenshots
Use dedicated service accounts with minimum required authorizations
Only test write operations in $TMP before moving to real packages
The TLS_REJECT_UNAUTHORIZED=0 flag disables SSL validation — use only in dev environments
Check your company's AI policy before sending code to external APIs

My Experience

What surprised me most is how Claude handles the entire workflow autonomously. It doesn't just write code — it searches for the object, reads the source, understands the structure, reads class includes, creates the transport, locks the object, writes the code, runs a syntax check, activates, and unlocks. All from one natural language request.

Important Hint

It can make ABAP-specific mistakes (like forgetting RAP locking fields, or using reserved DDIC words). Always review AI-generated code before activating in production. But as a development accelerator and code reviewer, it's genuinely powerful.

References

GitHub: mcp-abap-adt — Mario Andreschak
GitHub: mcp-abap-abap-adt-api — Mario Andreschak
GitHub: sap-skills — 35 Claude Code plugins for SAP
Blog: SAP Docs MCP Server — Marian Zeis
Blog: Claude Code via MCP — SAP Community
Blog: Installing and Extending an ABAP MCP Server — SAP Community

I hope this helps other ABAP developers get started. If you run into issues or have questions, feel free to comment below. Happy coding!

Custom Business Configurations (F4579): Collaborative draft

2026-04-08T10:55:35.536000+02:00

Introduction

The Custom Business Configurations (CUBCO) app serves as an entry point to the Business Configuration Maintenance Object (SMBC) provided by custom applications or partners.

When you use the ADT wizard to generate a Business Configuration Maintenance Object, the singleton pattern is used when generating the draft enabled RAP BO. One characteristic of this pattern is that all child entities are locked together, so it is not possible for multiple users to work with the same configuration at the same time.

This blog describes how to avoid this restriction by using collaborative draft.

This blog is relevant for

Further reading:

Related blog posts
Learn how you can use ABAP technology to develop innovative applications and business solutions across SAP’s portfolio on SAP Learning Site.

Example scenario

In the configuration table ZDEMO_CC, the company codes are stored.

@EndUserText.label : 'Company Code'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #C
@AbapCatalog.dataMaintenance : #ALLOWED
define table zdemo_cc {
  key client            : abap.clnt not null;
  key company_code      : abap.numc(4) not null;
  country               : land1;
  last_changed_at       : abp_lastchange_tstmpl;
  local_last_changed_at : abp_locinst_lastchange_tstmpl;
}

Enable collaborative draft

In the generated behavior definition, add "collaborative" to the draft annotation:

managed with additional save implementation in class ZBP_I_COMPANYCODE_S unique;
strict;
with collaborative draft;

Add the draft query annotation and the share action to the singleton entity definition:

define behavior for ZI_CompanyCode_S alias CompanyCodeAll
draft table ZDEMO_CC_D_S query ZR_DEMO_CC_CD
[...]
{
  draft action Share;
  [...]
}

Right-click the singleton draft table and choose New Data Definition to create the CDS view for the draft query:

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Draft Query View'
define view entity ZR_DEMO_CC_CD
  as select from zdemo_cc_d_s
{
  key singletonid                   as Singletonid,
      lastchangedatmax              as Lastchangedatmax,
      transportrequestid            as Transportrequestid,
      draftentitycreationdatetime   as Draftentitycreationdatetime,
      draftentitylastchangedatetime as Draftentitylastchangedatetime,
      draftadministrativedatauuid   as Draftadministrativedatauuid,
      draftentityoperationcode      as Draftentityoperationcode,
      hasactiveentity               as Hasactiveentity,
      draftfieldchanges             as Draftfieldchanges
}

You need to enhance the authorization of the involved users. In SAP BTP ABAP environment and SAP S/4HANA Public Cloud Edition you assign business catalog SAP_CORE_BC_RAP_DRAFT_PC to the user, in SAP S/4HANA Private Cloud Edition authorization object S_DRAFT.

Collaboration

User TB is creating a new company code 400 while at the same time user PW is editing company code 100. All changes are recorded on the same transport request.

Since the collaborative draft is enabled for the singleton root entity, the save and discard draft action are applied to all object changes. In this example, users PW and TB process two different company codes, which are logically different objects. Technically, however, they process the same singleton root entity. In practice, this means that discarding the draft or saving must be aligned between the users involved, as the save action persists the changes in all company codes.
For completely independent editing of individual objects, you must develop a RAP BO without a singleton pattern.

How to translate KTD documents for SAP BTP ABAP Environment?

2026-04-13T16:44:46.715000+02:00

Introduction

When you create a KTD document in SAP BTP ABAP Environment you will find out that there is no support for the translation of these documents.

In this blog post I will describe a workaround that can be used until a standard solution will be provided by SAP.

Workaround

I managed to translate a KTD document “manually.”

I logged in with German and created a KTD document.
Then I exported the KTD document into a Git repository.
Then I created a new entry in the XML for the language key “E” , chose a new UUID as the key, and entered the new text Base64 encoded (!).
Finally I imported the content of the Github repository again, thereby creating a translated version of the KTD document.

<?xml version="1.0" encoding="utf-8"?>
<abapGit version="v1.0.0" serializer="LCL_OBJECT_SKTD" serializer_version="v1.0.0">
 <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
  <asx:values>
   <KTD_OBJECT>
    <NAME>ZZ10R_CART</NAME>
    <TYPE>GENERAL_TEXT</TYPE>
    <SOURCE_CONTENT_TYPE>02</SOURCE_CONTENT_TYPE>
    <REF_OBJ_TYPE>DDLS</REF_OBJ_TYPE>
    <REF_OBJ_NAME>ZZ10R_CART</REF_OBJ_NAME>
    <ABAP_LANGUAGE_VERSION>X</ABAP_LANGUAGE_VERSION>
    <CONTENT>
     <item>
      <NAME>ZZ10R_CART</NAME>
      <LANGU>D</LANGU>
      <COMPONENT_UUID>1rDFSNW0H9Cq1O2Gk1jBBg==</COMPONENT_UUID>
      <SOURCE_CONTENT>RG9rdSBpbiBEZXV0c2NoCgphbmQgbm93IGFkZCBzb21ldGhpbmcgbG9nZ2VkIG9uIGluIEVuZ2xp
c2g=</SOURCE_CONTENT>
     </item>
     <item>
      <NAME>ZZ10R_CART</NAME>
      <LANGU>E</LANGU>
      <COMPONENT_UUID>9u8rknFsH+Cq1DFMgPUzaA==</COMPONENT_UUID>
      <SOURCE_CONTENT>IyBub3cgb3JpZ25hbCBlbmdsaXNo</SOURCE_CONTENT>
     </item>
    </CONTENT>
   </KTD_OBJECT>
  </asx:values>
 </asx:abap>
</abapGit>

As a result, I see different texts when I am logged in with English or German.

Known issues

• If you edit a KTD document with ADT while being logged in in another language, you will “see” the version created in the other language. There is no error message.
• In such a case, you can even edit the KTD document and the changes are visible for both login languages.
• Only if, as described above, you export the KTD document via the “Github” detour and create a version in another language, will you have two texts.

Custom Business Configurations (F4579): Implementing an editable tree view (hierarchy)

2026-04-14T07:48:36.986000+02:00

Introduction

The Custom Business Configurations (CUBCO) app serves as an entry point to the Business Configuration Maintenance Object (SMBC) provided by custom applications or partners.
This blog explains how to expose the hierarchical structure of a CDS hierarchy as an editable tree view in the CUBCO app.
For this purpose the SMBC object now supports tree table as table type.

For more details on hierarchies and more detailed examples and explanations, see the links above. The purpose of this blog is to demonstrate the tree view capability of the CUBCO app using a simple example.

This blog is relevant for

SAP S/4HANA Cloud Private Edition (2025, SAP Note 3687833, SAP UI5 1.136.12)
SAP BTP ABAP environment (2605)

Further reading:

Related blog posts
Learn how you can use ABAP technology to develop innovative applications and business solutions across SAP’s portfolio on SAP Learning Site.

Example scenario

In the configuration table ZDEMO_CC, the company codes are stored in a parent-child relationship to organize the corporate structure in a recursive hierarchy.

@EndUserText.label : 'Company Code'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #C
@AbapCatalog.dataMaintenance : #ALLOWED
define table zdemo_cc {
  key client            : abap.clnt not null;
  key company_code      : abap.numc(4) not null;
  country               : land1;
  parent_company        : abap.numc(4);
  last_changed_at       : abp_lastchange_tstmpl;
  local_last_changed_at : abp_locinst_lastchange_tstmpl;
}

Implement editable tree view

First we use the ADT wizard to generate a Business Configuration Maintenance Object for this table. In the wizard, select the option "Create Projection Layer". Apart from this, leave settings as they are and complete the wizard.

Add recursive associations

Add associations _ParentCompany and _Company to generated CDS view ZI_COMPANYCODE. Save and activate.

@EndUserText.label: 'Company Code'
@AccessControl.authorizationCheck: #MANDATORY
define view entity ZI_CompanyCode
  as select from zdemo_cc
  association         to parent ZI_CompanyCode_S as _CompanyCodeAll on $projection.SingletonID = _CompanyCodeAll.SingletonID
  association of many to one ZI_CompanyCode      as _ParentCompany  on $projection.ParentCompany = _ParentCompany.CompanyCode
  association of many to many ZI_CompanyCode     as _Company        on $projection.CompanyCode = _Company.ParentCompany

{
  key company_code          as CompanyCode,
      @Semantics.address.country: true
      country               as Country,
      parent_company        as ParentCompany,
      @Semantics.systemDateTime.lastChangedAt: true
      last_changed_at       as LastChangedAt,
      @Semantics.systemDateTime.localInstanceLastChangedAt: true
      local_last_changed_at as LocalLastChangedAt,
      1                     as SingletonID,
      _CompanyCodeAll,
      _ParentCompany,
      _Company
}

Create CDS hierarchy

Create a new CDS Data Definition ZI_COMPANYCODEHN. Save and activate.

@AccessControl.authorizationCheck: #NOT_REQUIRED
define hierarchy ZI_COMPANYCODEHN
  with parameters
    P_SingletonID : abap.int1
  as parent child hierarchy(
    source ZI_CompanyCode
    child to parent association _ParentCompany
    directory _CompanyCodeAll filter by
      SingletonID = $parameters.P_SingletonID
    start where
      ParentCompany is initial
    siblings order by
      CompanyCode ascending
  )
{
  key CompanyCode,
      ParentCompany,
      SingletonID
}

Add recursive hierarchy to CDS definition

Add the recursive hierarchy and the redirections to the generated projection CDS view ZC_COMPANYCODE

@EndUserText.label: 'Maintain Company Code'
@AccessControl.authorizationCheck: #MANDATORY
@Metadata.allowExtensions: true
@OData.hierarchy.recursiveHierarchy:[{ entity.name: 'ZI_COMPANYCODEHN' }]
define view entity ZC_CompanyCode
  as projection on ZI_CompanyCode
{
  key CompanyCode,
      Country,
      ParentCompany,
      LastChangedAt,
      @Consumption.hidden: true
      LocalLastChangedAt,
      @Consumption.hidden: true
      SingletonID,
      _CompanyCodeAll : redirected to parent ZC_CompanyCode_S,
      _ParentCompany  : redirected to ZC_CompanyCode,
      _Company        : redirected to ZC_CompanyCode
}

Adjust behavior definition

Add the following to the definition of entity CompanyCode in the generated behavior definition ZI_COMPANYCODE_S. Save and activate.

  association _ParentCompany
  {
    with draft;
    link action linkCompany;
    unlink action unlinkCompany;
  }

  association _Company { with draft; }

  instance hierarchy ZI_COMPANYCODEHN
  {
    ascending association _ParentCompany;
    descending association _Company { with cascading delete; }
  }

Extend the behavior projection ZC_COMPANYCODE_S accordingly. Save and activate.

define behavior for ZC_CompanyCode alias CompanyCode
use etag
{
  use update;
  use delete;

  use association _CompanyCodeAll { with draft; }
  use association _ParentCompany
  {
    with draft;
    link action linkManager;
    unlink action unlinkManager;
  }
  use association _Company { with draft; }

}

Set table type

Open the generated SMBC object in ADT. Expand the Table Settings section, select the row for entity CompanyCode and click Edit.
Change Table Type to Tree Table and Table Creation Mode to New Page . Save and activate.

Result

You can maintain your company structure while using the hierarchy features of SAP Fiori elements, such as: Collapse/expand tree, cut and paste nodes, or drag and drop nodes.

Further considerations

You can set the ParentCompany field as read-only. The user can still change the parent company, for example, using drag and drop functionality. However, you cannot modify the ParentCompany field with ABAP EML, only with ABAP SQL.
You can remove the ParentCompany field from the tree table by removing the corresponding UI.lineItem from the metadata extension. It should be sufficient to display the field on the object page as the parent is specified by the visible hierarchy structure.
If the ParentCompany field is enabled for editing, you can provide a value help and implement a validation for create and update to prevent an inconsistent hierarchy. However, a validation does not prevent the update of the draft version. When you reload the app, the entity with an invalid parent disappears. Deletion is configured as cascading, so no additional validation is required for the deletion process.
Instead, consider using a precheck to prevent inconsistent hierarchy changes.

Custom Business Configurations (F4579): Enable associated entities as a read-only navigation target

2026-04-14T10:59:47.811000+02:00

Introduction

The Custom Business Configurations (CUBCO) app serves as an entry point to the Business Configuration Maintenance Object (SMBC) provided by custom applications or partners.

Business software is a tightly integrated network. Application data, configuration data and system data form a giant relational network.
This blog explains how to enable associated entities as a read-only navigation target in the CUBCO app. This can be used, for example, to integrate a where-used list into the configuration app to visualize part of the relational network.

This blog is relevant for

SAP BTP ABAP environment (2605)
SAP S/4HANA Cloud Private Edition (2025, SAP Note 3694141, SAP UI5 1.136.12)

Further reading:

Related blog posts
Learn how you can use ABAP technology to develop innovative applications and business solutions across SAP’s portfolio on SAP Learning Site.

Example scenario

In this simplified scenario, there is one configuration table for company codes and one configuration table for plants. Each plant is assigned to a company code. Our goal is to display on the object page of a company code all plants to which this company code is assigned. For both tables we use the ADT wizard to generate a Business Configuration Maintenance Object.

@EndUserText.label : 'Company Code'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #C
@AbapCatalog.dataMaintenance : #ALLOWED
define table zdemo_cc {
  key client            : abap.clnt not null;
  key company_code      : zdemo_cc_id not null;
  last_changed_at       : abp_lastchange_tstmpl;
  local_last_changed_at : abp_locinst_lastchange_tstmpl;
}

@EndUserText.label : 'Plant'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #C
@AbapCatalog.dataMaintenance : #ALLOWED
define table zdemo_plant {
  key client            : abap.clnt not null;
  key plant_id          : abap.numc(3) not null;
  @AbapCatalog.foreignKey.keyType : #KEY
  @AbapCatalog.foreignKey.screenCheck : true
  company_code          : zdemo_cc_id
    with foreign key zdemo_cc
      where client = zdemo_plant.client
        and company_code = zdemo_plant.company_code;
  country               : land1;
  last_changed_at       : abp_lastchange_tstmpl;
  local_last_changed_at : abp_locinst_lastchange_tstmpl;
}

Create read-only navigation target

Create a new projection view entity for entity plant without a behavior definition so the associated entities cannot be edited. Do not define associations to other editable RAP BOs to keep draft, transport, and concurrency handling separate and correct.

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Plant'
@Metadata.ignorePropagatedAnnotations: true
define view entity ZC_PLANT
  as select from ZI_Plant
{
      .identification: [ {
        position: 1
      } ]
      .lineItem: [ {
        position: 1
      } ]
      .facet: [ {
        id: 'Plant',
        purpose: #STANDARD,
        type: #IDENTIFICATION_REFERENCE,
        label: 'Plant',
        position: 1
      } ]
  key PlantId,
      CompanyCode,
      .identification: [ {
      position: 2
      } ]
      .lineItem: [ {
        position: 2
      } ]
      Country
}

Access Control:

@EndUserText.label: 'Mapping Role for ZC_Plant'
@MappingRole: true
define role ZC_PLANT {
  grant
    select
      on
        ZC_PLANT
          where
            inheriting conditions from entity ZI_Plant;           
}

Add the association to the company code entity:

@EndUserText.label: 'Company Code'
@AccessControl.authorizationCheck: #MANDATORY
@Metadata.allowExtensions: true
define view entity ZI_CompanyCode
  as select from zdemo_cc
  association to parent ZI_CompanyCode_S as _CompanyCodeAll on $projection.SingletonID = _CompanyCodeAll.SingletonID
  association of many to many ZC_PLANT as _Plant on $projection.CompanyCode = _Plant.CompanyCode
{
  key company_code as CompanyCode,
  @Semantics.systemDateTime.lastChangedAt: true
  last_changed_at as LastChangedAt,
  @Semantics.systemDateTime.localInstanceLastChangedAt: true
  @Consumption.hidden: true
  local_last_changed_at as LocalLastChangedAt,
  @Consumption.hidden: true
  1 as SingletonID,
  _CompanyCodeAll,
  _Plant
}

Add a new facet to the metadata extension of company code:

@Metadata.layer: #CUSTOMER
@UI: {
  headerInfo: {
    typeName: 'CompanyCode', 
    typeNamePlural: 'CompanyCodes', 
    title: {
      type: #STANDARD, 
      label: 'Company Code', 
      value: 'CompanyCode'
    }
  }
}
annotate view ZI_CompanyCode with
{
  .identification: [ {
    position: 1 
  } ]
  .lineItem: [ {
    position: 1 
  } ]
  .facet: [ {
    id: 'CompanyCode', 
    purpose: #STANDARD, 
    type: #IDENTIFICATION_REFERENCE, 
    label: 'Company Code', 
    position: 1 
  },
  {
    id: 'Plant', 
    type: #LINEITEM_REFERENCE, 
    label: 'Plant', 
    position: 2 , 
    targetElement: '_Plant'
  } ]
  CompanyCode;
}

Add the plant entity to the service definition of company code:

@ObjectModel.leadingEntity.name: 'ZI_CompanyCode_S'
define service ZUI_COMPANYCODE {
  expose ZI_CompanyCode_S as CompanyCodeAll;
  expose ZI_CompanyCode   as CompanyCode;
  expose ZC_PLANT         as Plant;
}

To enable the user to navigate from the object page of a company code to the object page of a plant, add a row for the plant entity in the "Table Settings" section of the BC maintenance object of the company code.

The company code object page now displays all plants that are assigned to this company code. While the user can edit the company code, the list of plants is not editable.

Intent navigation

The next step to improve the application is to annotate the Plant field with an intent navigation to the Custom Business Configurations app. This allows the user to navigate from the company code object page to the maintenance app of a specific plant.

Currently, this requires the creation of a custom navigation target as it is not possible to use a constant in the semanticObjectBinding annotation.

If you think this type of intent navigation is important to your application, you can vote and comment on this improvement request: https://influence.sap.com/sap/ino/#/idea/338756/?section=sectionDetails