SAP Community - ABAP Cloud

SAP’s Most Popular Certification Gets a Major Upgrade

2026-03-06T15:55:26.136000+01:00

March is officially the month of ABAP. SAP’s most popular certification for back-end developers, the Back-End Developer ABAP Cloud, is getting a major upgrade. At the same time, the SAP Community developer challenge for ABAP is going live, making this the perfect moment to sharpen your skills and validate your expertise.

A Reimagined Certification Experience

The ABAP Cloud certification exam has been redesigned. Moving beyond traditional question-based formats, the new exam introduces a performance-based, open-book experience.

Learners now work directly in authentic SAP systems, navigating AI-supported, real-world scenarios that reflect actual project work. The focus is no longer on memorization; it’s about demonstrating practical skills that matter on the job.

What does it mean for you?

If you’ve been preparing for certification through the SAP Learning site, you’re already familiar with hands-on exercises and scenario-based tasks embedded in the learning journeys. The new exam format simply extends that approach.

From the moment you begin your certification, the experience feels familiar because it mirrors how you’ve been learning all along.

Every practical exam, whether system-based or scenario-driven reflects the reality of SAP projects:

Timeboxed tasks performed in live SAP systems
Realistic customer and project scenarios
AI-supported simulations
Open-book access to resources such as SAP Help Portal, SAP Learning, SAP Community, and SAP Joule for Consultants (where applicable)
A clear emphasis on proving your ability to do the work

This shift represents something bigger: trust. Trust in learners who invest in building real skills and trust from employers who rely on SAP-certified professionals to deliver value from day one.

How to get certified as Backend Developer for ABAP Cloud

Earning your certification is a structured journey. Whether you are new to ABAP or looking to formalize years of experience, the following resources will help you build a strong foundation and deepen your expertise.

Recommended Courses to Build and Deepen Your Skills

Start with the fundamentals and progressively expand your knowledge:

Course: Learning Basic ABAP Programming
Course: Deepening Your ABAP Programming Knowledge
Course: Building Data Models with the ABAP Dictionary and ABAP Core Data Services
Course: Practicing Clean Core Extensibility for SAP S/4HANA Cloud
SAP Certification: Backend Developer - ABAP Cloud

Together, these courses prepare you not just to pass the exam but to succeed in real-world ABAP Cloud development. Learn more about the exam details in this community blog by @JenniferHauck.

Connect Live with SAP Experts and Strengthen Your Exam Readiness

Learning doesn’t have to be a solo experience. If you’re looking for direct interaction, practical tips, and expert guidance, join the upcoming live sessions available through your SAP Learning Hub subscription:

These sessions offer the opportunity to clarify questions, reinforce key concepts, and gain confidence before taking the exam.

Join the ABAP Developer Community to Learn, Share, and Grow

Certification is just one milestone in your journey. Continuous learning happens through collaboration.
Visit the ABAP developer forum here on the SAP Community to:

Read expert blogs
Ask technical questions
Share your own insights
Connect with developers worldwide

Being part of the community ensures you stay current and continue growing long after certification.

Experience Hands-On Learning at SAP CodeJam Events Near You

If you prefer immersive, in-person learning, don’t miss the upcoming SAP CodeJam events. These sessions are designed to provide practical, guided experience with real SAP technologies in a collaborative environment.

Upcoming sessions include:

April 7: ABAP AI: Capabilities in SAP Joule for Developers CodeJam (São Paulo, Brazil)
April 8: ABAP AI: Capabilities in SAP Joule for Developers CodeJam (Londrina, Brazil)
April 23: ABAP Cloud and the RESTful Application Programming Model (Warsaw, Poland)

These events are an excellent opportunity to deepen your understanding, expand your network, and gain hands-on practice. Be sure to explore the full event calendar regularly, as new sessions are added on an ongoing basis.

Continue Your Learning with On-Demand Developer Content

Can’t attend live? Explore past Devtoberfest sessions, Tech Bytes, SAP CodeTalks, and more on the official SAP Developers YouTube channel

On-demand content allows you to learn at your own pace while staying connected to the latest innovations in ABAP and SAP development.

March is the perfect time to invest in your ABAP Cloud journey. With a certification experience designed to reflect real project work, you’re not just passing an exam, you’re demonstrating that you’re ready to build, extend, and innovate in the SAP ecosystem.

Week 2 : Use Joule Chat to create ABAP RAP Application and explore the Explain feature

2026-03-09T05:30:00.054000+01:00

Last week we had completed the system set up and also created a package with your community ID. We had also gone through the help document on SAP Joule for Developers, ABAP AI Capabilities.

Now let us dive into the world of ABAP AI by creating an application where Joule will guide you during each step.

Quick Links

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

Task 1: Create a ABAP RAP application using 'OData UI Service from Scratch’ wizard

It can be any application of your choice preferably non enterprise related to keep the challenge simple and more interesting. One field should be an amount field and another one a date field so that we can leverage J4D(Joule for Developers) to add some logic in the subsequent weeks. You should have 3 more fields which will be used to try out some of the J4D features.

Note: It is recommended to create all the fields while creating the app itself to avoid any manual coding later.

Example:- You can create a book store application consisting of fields ID, Title, Author, Price, Published Date, Stock, Discounted Price, BookAge. Here the last 3 fields can be used to try out the Joule for Developers (J4D) features. You are free to choose any dataset and logic combinations.

Right click on the package ZAC_<your community ID> created and select ‘Generate ABAP Repository Objects’Generate ABAP Repository Objects’
In the below popup that appears choose ‘Odata UI Service from Scratch’ and click on ‘Next’ two times.Odata UI Service from Scratch
Click ‘Next’ again.Click Next
In the next screen make sure you get the Joule Help to the right of Wizard popup. Here in the section ‘Ask Joule to update the fields’ can provide your prompts to create the application you like by specifying the fields and other details. Hit enter. Note: It is better to create all objects ending with your <community ID> to avoid any naming conflicts. Try to specify this in the prompt.Joule option in WizardNote: Make sure to select the option - ‘Transactional with Draft’ highlighted in the above screenshot is selected to enable ‘Create’ option in the application getting created. For single entity sometimes it is set as ‘Without Draft’.
Joule will now propose the Entity and Fields based on your prompt. Please note that we still should verify whether the suggestions are accurate for our requirements. Here you can notice that sometimes Joule suggests to change the Service Configuration to ‘Transactional Without Draft’, we can handle this in next step.Joule Field Proposal
Once you are satisfied click on ‘Accept’ and you can see that the ‘Artifact Suffix’ if specified and the ‘Project Name’ gets added as shown in the below screenshot. Here remember to change the Service Configuration to ‘Transactional with Draft’ and click ‘Next’.Joule Accept Proposal
Joule lists the artifacts that will be created. Verify them again and click on ‘Next’ and then ‘Finish’ on the next screen.
Refresh the package and check all the artifacts have been created. Publish the Service Binding and preview the application.
The application will open and should have a ‘Create’ button. Here you can either create a data generator class and add some simple logic to fill data / Use the ‘Create’ option in the app to create some sample records. ( Please create 4-5 entries in any case ). You can also adjust the metadata if you like.Application Created

For more information: https://help.sap.com/docs/abap-cloud/abap-development-tools-user-guide/use-odata-ui-service-from-scratch-wizard?locale=en-US

Task 2: Add a simple logic in the CDS data definition

Add some simple logic in the CDS data definition for example to provide 2% discount on actual Price and fill another field say ‘DiscountedPrice’ with the discounted value for all records in the database.
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.
Now that one of the fields was enhanced, you may need to recreate the draft table ending with _D### before launching the application again. If you do not face any issue you can skip this step.
To do that, go to the Project Explorer and open the behavior definition click on the icon as shown on the picture to follow the quick fix. Save and activate the draft table.
Recreate Draft Table

Task 3: Use Joule->Explain capability to understand code

Use ‘Explain’ capability of Joule to get detailed explanation of the code added.

Hint: Please add few lines of code like a simple CASE statement in CDS data definition to test Explain feature.

You may also watch this video to know more about how to use Joule->Explain feature.

We will be back next week with another feature of Joule AI Capability. Stay Tuned!!

Data Integration in ABAP Cloud: Data Consumption using External Entities

2026-03-09T10:28:13.544000+01:00

In the previous post, we discussed data exposure using SQL services. In this post, we shift the focus to the data consumption scenario.

Imagine an ABAP Cloud system that needs to access data located elsewhere, perhaps in an SAP HANA Cloud database, or even in another ABAP system. With SQL Services, an ABAP system can itself act as a database. To support such outbound data access in a clean and cloud-compliant way, ABAP Cloud introduces a new CDS modelling artifact: CDS External Entities.

What Are CDS External Entities?

CDS External Entities enable outbound SQL access from an ABAP Cloud system. This means you can:

Access data from a remote database
Load and process remote data in ABAP
Combine remote data with local data

In ABAP Cloud, classic secondary database connections are not available. CDS External Entities are their more powerful and cloud-ready replacement.

Conceptually, a CDS External Entity is comparable to an SAP HANA virtual table; it represents a local view of a remote table or view. The remote object and its fields may have different names, which can be mapped explicitly.

CDS External Entities can be consumed in two different ways:

- Dynamic Access

In the SAP BTP ABAP environment, a CDS External Entity can be used directly in ABAP SQL. You write a SELECT statement that accesses data from a remote database, loads it, and processes it in ABAP.

- Static Access

Starting with release 2508, CDS view entities and classic CDS views can be built on top of external entities. This allows you to integrate remote data seamlessly into your CDS view modelling and treat it like local data. This feature will be used in my next blog post of the series.

Logical External Schema

Alongside CDS External Entities, there is a second important artifact: the Logical External Schema which is based on SAP HANA Smart Data Access (SDA). The key features are as follows:

It represents a remote system at design time.
It is mapped to a concrete remote source at configuration time.
It contains connection-related information (host, port, user, etc.).

From a runtime perspective, the ABAP system sends the query to its own HANA database, which then federates the query to the remote system using SDA.

How External Entities Work at Runtime

External entities allow remote data access using a new ABAP SQL syntax:

SELECT FROM <external_entity>

PROVIDED BY <logical_external_schema>

INTO TABLE @DATA(result).

In this flow:

The ABAP application sends the SQL query to the local HANA database.
HANA performs query federation using Smart Data Access.
Data is retrieved from the remote database.
Results are returned to the ABAP application server.

The <logical_external_schema> is a design-time artifact that points to the remote system and is bound to an actual remote source during configuration.

Example Scenario

Let us build an example based on the travel scenario in which

SAP HANA Cloud acts as the remote database.
The ABAP system consumes data via Dynamic CDS External Entities.

It is crucial that

The external entity has the same name and field structure as the remote HANA table.
Field names and types must match exactly (HANA is case-sensitive).

Besides, to enable the access, an outbound service and a communication scenario are required.

Design Time Steps

1. Define a Dynamic CDS External Entity

@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'external entity for travel'
define external entity ZI_EE_TRAVEL_000 external name TRAVEL
{
  key TravelID      : abap.numc(8)                external name "TravelID";
      AgencyID      : abap.numc(6)                external name AgencyID;
      CustomerID    : abap.numc(6)                external name CustomerID;
      @Semantics.amount.currencyCode: 'CurrencyCode'
      BookingFee    : abap.curr(16,2)             external name BookingFee;
      @Semantics.amount.currencyCode: 'CurrencyCode'
      TotalPrice    : abap.curr(16,2)             external name TotalPrice;
      CurrencyCode  : abap.cuky                   external name CurrencyCode;
      BeginDate     : abap.dats                   external name BeginDate;
      EndDate       : abap.dats                   external name EndDate;
      Description   : abap.sstring(1024)          external name Description;
      OverallStatus : abap.char(1)                external name OverallStatus;
      CreatedBy     : abp_creation_user           external name CreatedBy;
      CreatedAt     : abp_creation_tstmpl         external name CreatedAt;
      LastChangedBy : abp_locinst_lastchange_user external name LastChangedBy;
}
with federated data 
provided at runtime;

This entity models the structure of the remote table or view.

2. Define a Logical External Schema

This acts as a placeholder for the remote database and is referenced by the external entity.

3. Create Outbound Service and Communication Scenario

Create an SQL type outbound service for the logical external schema
Create a communication scenario and assign the outbound service to it. Then save and publish the scenario locally.

This enables administrators to configure access to the remote system

4. Consume the External Entity in ABAP SQL

Create a class and write ABAP SQL code

Select * from my external entity provided by my remote into table my local table

CLASS zcl_travel_consume_000 DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun .
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS zcl_travel_consume_000 IMPLEMENTATION.
METHOD if_oo_adt_classrun~main.
     data: travel type table of zi_ee_travel_000.

    select * from zi_ee_travel_000 provided by z_travel_remote_db_000 into table @Travel.

    out->write( travel ).
    endmethod.

ENDCLASS.

In summary, what happens at runtime is as follows

The ABAP system sends the query to its HANA database
HANA SDA forwards the query to the remote database
Data is fetched and returned to the ABAP application
The local internal table is filled with remote data

Now we need to establish the connection between our development system and the SAP HANA Cloud database.

Configuration Time Steps

1. Create Communication Arrangement

In the SAP Fiori Launchpad:

Create a communication arrangement for the communication scenario you published in design time.

2. Maintain a communication system for the remote database

Activate Remote SQL-Access
Choose HANA ODBC as the SDA adapter
Provide host, port, driver, and additional connection settings
(These details are typically provided by the system administrator)

save the communication system.

3. Maintain Remote Schema Information

In the communication arrangement:

Specify the schema name of the remote HANA database
Save the configuration and check whether the connection is successful

4. Prepare the Remote HANA Database

In Visual Studio Code and using SAP HANA Database Explorer:

Create a table that matches the CDS External Entity exactly
Ensure field names, types, and sizes match as well

Remember that SAP HANA is case-sensitive.

What Happens Behind the Scenes

When you execute the ABAP SQL statement:

The ABAP SQL layer resolves the external entity and logical external schema
HANA automatically:

Creates a remote source
Creates the required virtual table

Query federation is handled transparently

In this sense, CDS External Entities act as a smart abstraction that automatically manages HANA remote sources and virtual tables via ABAP design-time objects.

Press F9, and the data is returned as expected.

In the next blog post I would like to build a RAP application in the cloud, based on data I read from an on-premises system. So, stay tuned!

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.

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 !!!

Oops we did it again! A brand new top-level ABAP keyword in ABAP CE 2602.

2026-03-16T12:43:47.550000+01:00

Introduction

New ABAP commands arise only once in most people's lifetimes. But after the ABAP command WITH in AS ABAP 7.51, we have now introduced the new ABAP command MERGE.
The fact that both keywords concern databases is no coincidence. Leveraging the full power of the HANA database is one of ABAP's highest priorities.
Note that we use "command" as a synonym for top-level keywords in this article.

Introducing a new ABAP top-level keyword in the 21st century

What is the problem with introducing a new ABAP keyword? Macros. Consider the following coding:

DEFINE merge.
  WRITE : / &1.
END-OF-DEFINITION. 
 
MERGE 'hello'.

After introducing MERGE as a new keyword, this code would have syntax errors. This is why, for example, RAP avoided introducing any new top-level keyword with EML. MODIFY, READ, COMMIT all existed well before RAP.
But the developers of ABAP SQL are not afraid, as they have already shown in the past. With MERGE, they introduced the concept of a weak ABAP keyword! Macros take precedence. Here is what happens when you use a macro named MERGE in 2602:

So despite a number of warnings, nothing bad happens. You cannot use the new ABAP command MERGE in this program, though. There is and will be no escape mechanism.

Of course, macros are not available in ABAP Cloud and this is only relevant for customers when MERGE makes it into the next On Premise release.

What does MERGE do?

MERGE is a standard SQL database command. It exists on the HANA database and most other commercial databases. Practically it is a more powerful version of UPDATE, DELETE, INSERT and MODIFY all in one command.

As MERGE is an SQL standard keyword and ABAP is a superset of SQL by tradition, we also opted to keep the command name and thus introduce a new ABAP command.

Conceptually, MERGE is a very easy operation to understand. Here is the flow:

Here, "when no join partner found" means that the joined table (e.g., internal table) contains a set not contained in the database table. The other direction is not covered yet (see below).

A practical example

In this section, we give a very easy example of the MERGE command. Say you have a database table of users, and from time to time, you update it from an Excel spreadsheet stored in an internal table.

A simple merge command would look like follows:

MERGE INTO users
  USING @Excel AS excel
  ON users~userid = excel~userid
  WHEN MATCHED AND users~managed_by_excel = @abap_true THEN UPDATE SET user_data = excel~user_data
  WHEN NOT MATCHED THEN INSERT ALL.

This command is really self-explanatory. When you want to change the fields inserted into the database, you can also specify them as expressions in the VALUES ( .... ) clause. The usage of DELETE is fairly similar.

Some databases (for example SQL Server) have an additional clause WHEN NOT MATCHED BY SOURCE, which is triggered when an entry is found in the joined table (e.g. excel) but not in the target table (e.g. users). This is neither present in ABAP nor on the HANA database yet.
Thus, conceptually, the join equals a RIGHT OUTER JOIN.

Summary

This article introduces the new ABAP command MERGE, a powerful tool for data manipulation. Due to its ability to join an internal or database table (or a global temporary table for that matter) it can be a very powerful tool in the hands of an ABAP developer.

You may find additional information in the SAP help article here.

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

How to create a RAP application using a parameterized CDS view

2026-03-17T10:38:18.358000+01:00

Hello everyone, recently I came across a somewhat unusual requirement where I needed to use a parameter in a RAP application. As we know, this isn’t natively supported with Fiori Elements, so I had to look for a way to make it work. After some research and a few tests, I ended up with a solution that I consider quite innovative: using a Fiori Freestyle approach.

The best part is that it requires only a minimal amount of code, something that any ABAP developer can implement without much effort, and it becomes extremely useful whenever you need to work with parameters that are not directly linked to the data exposed by the CDS view.

The idea behind this solution is simple:

Since projection views in RAP do not support CDS parameters directly, we expose a parameterized interface CDS view through a service definition and service binding.

Then, using a Fiori Freestyle application with a Smart Table, we dynamically inject the parameter into the table binding path before the data request is sent to the backend.

This allows the RAP service to consume the parameterized CDS view without requiring complex workarounds.

Let’s go through the required steps:

1) Since it’s not possible to add WITH PARAMETERS to a projection view, we need to create an interface CDS view and use it as our “projection.”

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: '<your cds description>'
@Metadata.ignorePropagatedAnnotations: false
@Metadata.allowExtensions: true

define view entity <your_parameterized_interface_cds>
  with parameters
    p_date : abap.char(8)

as select from <your_source_cds_or_table>
(
  p_date : $parameters.p_date
)
{
    key <your_key_field>,
        <your_field_1>,
        <your_field_2>,
        <your_field_3>
}

2) Create our service definition normally

3) Create Service Binding ( Odata V2 )

4) Now we have to create the freestyle app with the fiori generator application

5) Now just connect to the S4 and select the service binding created earlier

At this point, you can see the project structure in the Explorer panel on the left. We’ll focus only on the view and controller folders.

First, we need to create our Smart Table in the view folder. Inside the SmartFilterBar, we must set the entitySet from our service binding. After that, we add a customControl in my case, I used a DatePicker, but you can use any control that fits your requirement. I also attached an onDateChange event to the DatePicker so we can capture and manipulate the selected date whenever it changes.

Within the Smart Table, we also need to define the same entitySet. Another very important point here is the beforeRebindTable event. This is the hook that allows us to pass the parameter to the CDS view. It will trigger the onBeforeRebindTable method in the controller, where we can dynamically inject the parameter into the binding before the data is requested.

<mvc:View
    xmlns:table="sap.ui.table"
    xmlns="sap.ui.comp.smartfilterbar"
    xmlns:f="sap.f"
    xmlns:m="sap.m"
    xmlns:mvc="sap.ui.core.mvc"
    xmlns:smartTable="sap.ui.comp.smarttable"
    controllerName="<your.app.namespace>.controller.Main"
    height="100%">

<f:DynamicPage
    id="dynamicPage"
    fitContent="true"
    title="{i18n>appTitle}">

<f:header>
<f:DynamicPageHeader>

<SmartFilterBar
    id="smartFilterBar"
    entitySet="<your_entity_set>">

    <controlConfiguration>

        <ControlConfiguration
            key="<your_parameter_field>"
            visibleInAdvancedArea="true"
            label="<your_filter_label>"
            mandatory="true">

            <customControl>

                <m:DatePicker
                    id="datePicker"
                    displayFormat="dd/MM/yyyy"
                    valueFormat="yyyyMMdd"
                    placeholder="dd/mm/yyyy"
                    width="100%"
                    required="true"
                    change="onDateChange"/>

            </customControl>

        </ControlConfiguration>

    </controlConfiguration>

</SmartFilterBar>

</f:DynamicPageHeader>
</f:header>

<f:content>

<smartTable:SmartTable
    id="smartTable"
    beforeRebindTable="onBeforeRebindTable"
    showRowCount="true"
    enableAutoBinding="false"
    entitySet="<your_entity_set>"
    smartFilterId="smartFilterBar"
    useVariantManagement="true"
    tableType="Table"
    initiallyVisibleFields="<your_fields>"
    enableAutoColumnWidth="true"
    showTablePersonalisation="true">

    <smartTable:customToolbar>

        <m:OverflowToolbar design="Transparent">
            <m:ToolbarSpacer/>
        </m:OverflowToolbar>

    </smartTable:customToolbar>

</smartTable:SmartTable>

</f:content>

</f:DynamicPage>

</mvc:View>

7) In this step, we implement the logic inside the onBeforeRebindTable method, which is responsible for dynamically passing the parameter to the CDS view before the Smart Table triggers the data request.

First, the code retrieves the value entered in the DatePicker using byId. This value will be used as the parameter for the CDS. A local variable (sDate) is initialized to store the selected date.

Next, a validation is performed to ensure that the date field is filled in. Since this parameter is mandatory for the query, if no value is provided the DatePicker is set to the Error state and a validation message is displayed. At the same time, the table binding is stopped using:

oBindingParams.preventTableBind = true;

This prevents the Smart Table from calling the backend without the required parameter, avoiding unnecessary requests and possible errors.

If the date is correctly filled in, any previous error state is cleared by setting the ValueState back to None.

Finally, the most important part happens: the table binding path is updated dynamically. Here we pass the selected date to the parameterized CDS by changing the binding path of the Smart Table:

setTableBindingPath("/<EntitySet>(p_date='${sDate}')/Set")

This is what allows the RAP application to consume a CDS with parameters, because the parameter is injected at runtime just before the data is requested from the backend.

onBeforeRebindTable: function (oEvent) {

    let oDatePicker = this.byId("datePicker");
    let sDate = "";

    if (oDatePicker) {
        sDate = oDatePicker.getValue();
    }

    if (!sDate) {

        if (oDatePicker) {
            oDatePicker.setValueState("Error");
            oDatePicker.setValueStateText("Please inform the date.");
        }

        let oBindingParams = oEvent.getParameter("bindingParams");

        if (oBindingParams) {
            oBindingParams.preventTableBind = true;
        }

        return;
    }

    if (oDatePicker) {
        oDatePicker.setValueState("None");
    }

    this.getView()
        .byId("smartTable")
        .setTableBindingPath("/<your_entity_set>(p_date='" + sDate + "')/Set");

}

And Vooooalá!

Conclusion

Although RAP and Fiori Elements provide powerful tools for building enterprise applications, there are still scenarios where certain features are not directly supported, such as consuming parameterized CDS views in projection layers.

By combining RAP services with a lightweight Fiori Freestyle approach, we can overcome this limitation in a simple and flexible way. Using events like beforeRebindTable and dynamically modifying the binding path allows parameters to be passed to the CDS view at runtime.

This approach requires only a small amount of additional UI code and can be implemented quickly by ABAP developers who are already familiar with RAP and Fiori.

I hope this solution helps others facing similar challenges when working with parameterized CDS views in RAP applications.

RAP Unmanaged Draft: Early Numbering and Associations for Unique IDs

2026-03-19T15:23:41.063000+01:00

INTRODUCTION

In RAP, Implementing numbering mechanisms during these operations is essential to ensure unique identifiers for newly created entities.
This blog is exposure the best for numbering during Creation and Creation by Association, in Unmanaged Scenario with Draft. How to handle number creation with Draft Scenario's.

Some Information about Numbering
Basically, Numbering is the concept to process assigning unique values to the key fields of business entities during Create and Create By Association Operations.

Unmanaged Early Numbering:

Developers need to implement custom code logic to create and assign keys values during the creation and create by association operation.
%is_draft – It is a component of the transactional key (%tky) in RAP.
- It tells the framework whether to operate on the draft table or the active persistent table for a given operation.
- %is_draft = mk-on reads from draft table
- %is_draft = mk-off reads from active table

Problem Statement

A sales clerk begins creating a Sales Order in Fiori. The order header is saved as a draft, but items need to be added immediately under that draft. To ensure consistency, the system must generate a unique Sales Order ID right away and assign incremental item numbers without waiting for activation.

Importance:

Early numbering guarantees unique identification across drafts and active records.
Associations ensure header–item linkage is preserved.
Draft handling allows users to save incomplete transactions safely and activate later without losing data integrity.

Behavior Definition of Root Entity

early numbering → enables key generation during root creation.

unmanaged implementation in class zbp_i_vd_head unique;
strict ( 2 );
with draft;

define behavior for ZI_VD_HEAD alias Header
draft table zdft_vd_head
lock master
total etag CreatedOn
authorization master ( instance )
early numbering // Early numbering declaration in root entity
{
  create;
  update;
  delete;
  association _item { create; }
  field ( readonly : update ) CustNo;

  draft action Edit;
  draft action Activate optimized;
  draft action Resume;
  draft action Discard;
  draft determine action Prepare;
}
mapping for zvd_t_hsale {
  CustNo     = cust_no;
  SalesOrder = sales_order;
  CreatedOn  = created_on;
  EntryTime  = entry_time;
  Name       = name;
  DocCat     = doc_cat;
}

Behavior Definition of Item Entity

early numbering → enables key generation during item creation.

define behavior for ZI_VD_ITEM alias Item
draft table zdft_vd_item
lock dependent by _head
authorization dependent by _head
early numbering // Early numbering declaration in item entity
{
  update;
  delete;
  field ( readonly ) CustNo;
  association _head;

  mapping for zvd_t_isale {
    CustNo     = cust_no;
    SalesOrder = sales_order;
    DocItem    = doc_item;
    MatNumber  = mat_number;
    MatGroup   = mat_group;
    CreatedOn  = created_on;
  }
}

Behavior Pool Implementation

This method ensures that every new entity gets a unique identifier (CustNo) during creation if it wasn’t already provided.

UUID Generation:

cl_system_uuid=>create_uuid_x16_static( ) generates a globally unique key.
This avoids collisions and guarantees uniqueness across drafts and active records.

Mapped Root:

%cid → correlates client-side temporary IDs with backend entities.
%key → holds the generated or existing key.
%is_draft → ensures draft state is preserved.
CustNo → the actual business key stored in the entity.

METHOD earlynumbering_create.
   LOOP AT entities INTO DATA(entity).
      DATA(lv_custno) = entity-custno.
      IF lv_custno IS INITIAL.
        TRY.
            lv_custno = cl_system_uuid=>create_uuid_x16_static( ).
          CATCH cx_uuid_error.
            "handle exception
        ENDTRY.
      ENDIF.
      APPEND VALUE #(
          %cid      = entity-%cid
          %key      = VALUE #( custno = lv_custno )
          %is_draft = entity-%is_draft
          custno    = lv_custno
      ) TO mapped-header.
    ENDLOOP.
ENDMETHOD.

Mapped Item:

This method handles early numbering when creating items via association (CREATE-BY-ASSOCIATION).

First, it retrieves the maximum cust_no from the database table zvd_t_isale for the current entity.

%cid → client-side correlation ID.
%key → generated key with CustNo.
%is_draft → preserves draft state.
CustNo → ensures linkage to the root entity.

METHOD earlynumbering_cba_item.
  LOOP AT entities INTO DATA(entity).
      " Get current max Customer Number from DB
      SELECT MAX( cust_no )
        INTO (lv_max)
        FROM zvd_t_isale
        WHERE cust_no = -%key-custno.

      LOOP AT entity-%target INTO DATA(t_item).
        APPEND VALUE #(
            %cid      = t_item-%cid
            %key      = VALUE #(
                            custno = entity-%key-custno )
            %is_draft = t_item-%is_draft
            custno    = entity-%key-custno
        ) TO mapped-item.
      ENDLOOP.
    ENDLOOP.
ENDMETHOD.

Item inherits lock and authorization from the header.
Early numbering ensures item keys are generated consistently.
Association links items back to the header BO.

Persistence Methods

Create Method

METHOD create.
  LOOP AT entities INTO DATA(entity).
    DATA(header) = CORRESPONDING zvd_t_hsale( entity MAPPING FROM ENTITY ).

    header-created_on = sy-datum.
    header-entry_time = sy-datum.
    header-name       = sy-uname.

    APPEND header TO gt_hsale.
  ENDLOOP.
ENDMETHOD.

Create-By-Association Method

METHOD cba.
  LOOP AT entities_cba INTO DATA(entity_cba).
    LOOP AT entity_cba-%target INTO DATA(target_item).
      DATA(item) = CORRESPONDING zvd_t_isale( target_item MAPPING FROM ENTITY ).

      item-cust_no   = entity_cba-%key-CustNo.
      item-created_on = sy-datum.

      APPEND item TO gt_isale.
    ENDLOOP.
  ENDLOOP.
ENDMETHOD.

Result

Conclusion

By combining Draft Handling, Associations, and Early Numbering, RAP unmanaged scenarios can support complex business objects like Sales Orders, Purchase Orders. This approach ensures flexibility, control, and consistency in transactional applications.

Thank You...

Link Handlers cannot be registered as the application is signed - Eclipse MAC

2026-03-19T16:11:34.391000+01:00

What Are Link Handlers?

When you click an adt:// link somewhere — SAP GUI, a wiki, a colleague's message — macOS needs to figure out which app should open it. That mapping is handled by link handlers.

In Eclipse, you find them under Preferences → General → Link Handlers. Two entries matter for ABAP developers:

adt – How adt:// links open ABAP objects (classes, programs, etc.) in your Eclipse workspace.
eclipse+command – Lets URLs trigger Eclipse commands, like opening a specific view.

Both should show a checked box and "This application" in the Handler column. If you only have one Eclipse on your Mac, you might never notice a problem. But with two installations (say one for ABAP, one for Java), wrong link routing gets annoying fast.

The Problem

You open Link Handlers and see this at the top:

⛔Link Handlers cannot be registered as the application is signed.

Checkboxes grayed out. Handler column says "Other application." Sometimes you also get this when clicking around the page:

Cannot invoke "org.eclipse.urischeme.ISchemeInformation.schemeIsHandledByOther()"
because "schemeInfo.information" is null

You click an adt:// link and either the wrong Eclipse opens, or nothing happens.

Why This Happens on macOS

macOS maps URL schemes to apps using the Info.plist inside each app bundle (/Applications/Eclipse.app/Contents/Info.plist). A key called CFBundleURLTypes lists which schemes the app claims. macOS reads it and stores the mapping in its Launch Services database. On top of that, plugins like ADT can also register schemes at runtime.

Here's where it breaks. Eclipse ships code-signed. The signature covers the entire bundle, including Info.plist. When Eclipse tries to modify the plist at runtime to register a scheme, macOS blocks it because that would invalidate the signature. The Link Handlers page sees the restriction and grays everything out.

The Fix

Two parts to this: first, make sure your Info.plist has the right URL scheme entries, then fix the code signature that's blocking everything.

⚠️Close Eclipse before you start.

Step 1: Check your Info.plist for CFBundleURLTypes

Open the plist:

sudo nano /Applications/Eclipse.app/Contents/Info.plist

Look for a CFBundleURLTypes key. The default Eclipse plist usually already has eclipse+command and eclipse+mpc, but not adt. You need all three in a single CFBundleURLTypes array. If the key already exists, add the adt entry into the existing array. If it's missing entirely, add this block just before the closing </dict> at the end of the file:

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLName</key>
        <string>Eclipse Command</string>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>eclipse+command</string>
        </array>
    </dict>
    <dict>
        <key>CFBundleURLName</key>
        <string>Eclipse Marketplace</string>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>eclipse+mpc</string>
        </array>
    </dict>
    <dict>
        <key>CFBundleURLName</key>
        <string>ADT Link Handler</string>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>adt</string>
        </array>
    </dict>
</array>

Save and exit (Ctrl+O, then Ctrl+X).

Important: Make sure there's only one CFBundleURLTypes key in the entire file. If you're adding the adt entry to an existing array, don't create a second CFBundleURLTypes block — duplicate keys in a plist don't merge. macOS only reads one of them, and you'll get unpredictable results. I made this mistake editing in nano and it caused the schemeInfo.information is null error.

Step 2: Remove the existing code signature

sudo codesign --remove-signature /Applications/Eclipse.app

Don't try to open Eclipse after this. macOS won't launch an unsigned app. Move straight to Step 3.

Step 3: Re-sign with an ad-hoc signature

sudo codesign --force --deep --sign - /Applications/Eclipse.app

The - means ad-hoc — no developer certificate needed. --deep signs all the nested binaries inside the bundle too.

Step 4: Re-register with Launch Services

/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -R -f /Applications/Eclipse.app

Tells macOS to re-read the app bundle and update its URL scheme mappings.

Step 5: Open Eclipse and check

Go to Preferences → General → Link Handlers. Both adt and eclipse+command should now show checked and marked "This application".

All terminal commands together

# Close Eclipse first, then:
sudo codesign --remove-signature /Applications/Eclipse.app
sudo codesign --force --deep --sign - /Applications/Eclipse.app
/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -R -f /Applications/Eclipse.app
# Open Eclipse → Preferences → Link Handlers

What I Tried That Didn't Work

Sharing these so you don't waste time on the same dead ends.

Re-signing without removing first. Tried just running codesign --force --deep --sign - on its own. Didn't help. The old signature's restrictions stuck around somehow. You have to remove first, then sign fresh.

Duplicate CFBundleURLTypes keys in the plist. This one cost me the most time. When editing in nano, I accidentally added a second CFBundleURLTypes block instead of adding entries into the existing one. Plist files don't merge duplicate keys — macOS only reads one of them. The result was the schemeInfo.information is null error, and eclipse+command stayed stuck on "Other application." If you see that error, open the plist and check for duplicate keys.

Running lsregister by itself. Doesn't do anything useful if the signature is still blocking registration. Necessary as a final step, but not enough on its own.

Environment

Tested on Eclipse 2025-03 (4.39) with ADT on macOS. Should work the same on any recent Eclipse version where you see the signed-application warning.

Object Release State in Cloudification Repository Viewer for Clean Core Extensibility

2026-03-20T08:14:22.285000+01:00

Introduction

The updated Clean Core Extensibility whitepaper was introduced in August 2025 by SAP as an evolution of the 3-Tier Extensibility concept. This updated the 3-Tier Extensibility to a more detailed assessment of classic ABAP extensions based on the clean core level concept, allowing you as SAP customers and partners stepwise transformation to clean core at your own pace .

While using external APIs in your ABAP custom code, one of the first things to check as per the updated level concept is the release state of that API in the Cloudification Repository Viewer. The release state tells you how stable the object is, what contractual guarantee SAP provides for it, and how your ATC checks will treat any usage of it. Getting this right is important because it directly affects your clean core compliance and your upgrade readiness.

SAP categorizes all objects in the Cloudification Repository Viewer into five distinct states. Each state carries a specific meaning for your custom code, and knowing the difference will help you make better decisions when selecting or replacing APIs.

The Five Release States in the Cloudification Repository Viewer

Here is what each state means in practice and what you should do when you encounter it.

Released

A Released API is one that SAP has formally published with a stability contract. Backward compatibility is guaranteed across upgrades, so you can build on these objects with confidence. Released APIs correspond to clean core Level A.

Level A objects are 100% Cloud compliant, 100% Clean core, can be achieved On-Stack, Side-by-Side or Hybrid.

If you are starting new development, Released APIs are your first choice. They represent the safest and most future-proof option available to you.

Deprecated

A Deprecated API was once Released but SAP is now phasing it out. It still functions today, but it has a planned end of life. SAP recommends that you do not start any new development on it.

If your existing code already uses a Deprecated object, that code is treated as clean core Level B and flagged as Priority 3 in ATC checks. Make sure to identify the successor API in the Cloudification Repository or the SAP Business Accelerator Hub and plan your migration. The sooner you move away from a Deprecated API, the less remediation work you will face when the object reaches its end-of-life date.

Classic API

Classic APIs are well-known, time-tested objects such as BAPIs and RFC-enabled function modules that SAP product experts nominated before a formal release process existed. They do not carry a formal stability contract, but they are upgrade stable and widely used across the SAP ecosystem.

Classic APIs correspond to clean core Level B and are flagged as Priority 3 in ATC checks. Keep in mind that while these objects are stable in practice, they do not carry the same forward-compatibility guarantee as Released APIs. Use them when no Released alternative is available and check the Cloudification Repository Viewer for the availability of the Released APIs as successors to Classic APIs.

Not to be Released

An API marked as Not to be Released is one that SAP has explicitly decided is not intended for external use. Any exemption for using such an object must include a migration plan toward a Released API.

These objects correspond to clean core Level C depending on the context and are flagged as Priority 2 in ATC checks. If you encounter this state, treat it as a signal to find a supported alternative as quickly as possible.

No API

An object classified as No API has no API contract whatsoever. Objects classified as noAPI must not be used, creates maximum technical debt.

This state is flagged as Priority 1 in ATC checks and must be addressed at the highest priority. If you find a noAPI object in your custom code, replacing it with a Released API must be your immediate next step.

Why Some APIs Are Listed as Both Released and Classic or Not to be Released and Classic

You may come across a scenario in the Cloudification Repository Viewer where the same API appears under both the Classic API and Released API categories or Not to be Released and Classic. This is a valid situation and worth understanding, because it can cause some confusion at first glance.

Take the CDS view I_EARMARKEDFUNDSDOCUMENTITEM as an example. If you check this object in the Cloudification Repository Viewer for the 2022 SP0 release of SAP Cloud ERP Private, it is listed only as a Classic API. When you switch to the 2025 FPS01 release, it appears as both Classic API and Released API.

What this tells you is that I_EARMARKEDFUNDSDOCUMENTITEM was formally Released in the 2025 FPS0 release of SAP Cloud ERP Private.

Both statuses are equally valid for this object. It carries the historical stability of a Classic API and now also has a formal stability contract as a Released API. In this case, the clean core status will be Level A as Released API will take the precedence and ATC check will not give any message.

Similarly, take the Class CL_HTTP_UTILITY as an example. If you check this object in the Cloudification Repository Viewer for the 2022 SP0 release of SAP Cloud ERP Private, it is listed only as a Classic API. When you switch to the 2025 FPS0 release, it appears as both Classic API and Not to be Released, with a successor.

Both statuses are equally valid for this object. It carries the historical stability of a Classic API and now also has a formal stability contract as a Not to be Released, with a successor.

In this case, the clean core status will be Level B as Classic API will take the precedence and ATC check will give a Priority 3 message. You are recommended to move to the successor API in this case.

This is why it is recommended to check the Cloudification Repository Viewer against the specific release you are working with.

Conclusion

The Cloudification Repository Viewer continues to grow with each release as SAP adds more objects and updates their states. Use it as your starting point before selecting any API in your custom code. Checking the release state upfront will save you significant remediation work during upgrade cycles and help you stay clean core compliant from day one.

We will continue to share updates on clean core extensibility as the tooling and API landscape evolves. In the meantime, refer to the Cloudification Repository Viewer and the SAP Business Accelerator Hub for the latest state of the objects relevant to your development.

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!!!

RAP: Factory Action to copy Billing Header and its Item(s) using Create by association

2026-03-25T10:31:08.744000+01:00

In this blog, I am going to explain how we can use create by association with factory action in SAP RAP environment for complex use case like copying duplicate billing header with its associated child entities.

Let's understand what action in RAP is, and what is factory action first.

If you want to perform any operation other than those four basic operations (CRUD), we can use action keyword in RAP. It helps us to do custom action like approve billing doc or change any field value like status.

We have three types of actions in RAP:

Instance Action: we need to select a record to perform action.
Static Actions: that are not tied to a specific instance.
Factory Actions: used for creating the copy of already existing instance. We will see this more in details.

Create by Association: In scenario where we cannot create child entity as it is depend on header, we need to use create by association. Used to create deep entity.

So, let's start with the steps to generate our basic application. Please have a look.

1. My header table look like this: 👇

@EndUserText.label : 'Billing Header'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #RESTRICTED
define table ztb_billheader {

  key client         : abap.clnt not null;
  key bill_id        : abap.numc(10) not null;
  bill_type          : abap.char(4);
  bill_date          : abap.dats;
  customer_id        : kunnr;
  @Semantics.amount.currencyCode : 'ztb_billheader.currency'
  net_amount         : abap.curr(15,2);
  currency           : waers;
  sales_org          : vkorg;
  createdby          : syuname;
  createdat          : timestamp;
  lastchangedby      : syuname;
  lastchangedat      : timestamp;
  locallastchangedat : timestamp;
  status             : abap.char(1);
  statustext         : abap.char(10);

}

I am not using managed numbering here as I want custom Bill Id.

2. My Item table look like this: 👇

@EndUserText.label : 'Billing Item'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #RESTRICTED
define table ztb_billitem {

  key client         : abap.clnt not null;
  key bill_id        : abap.char(10) not null;
  key item_no        : abap.numc(6) not null;
  material_id        : matnr;
  description        : abap.char(40);
  @Semantics.quantity.unitOfMeasure : 'ztb_billitem.uom'
  quantity           : abap.quan(13,3);
  @Semantics.amount.currencyCode : 'ztb_billitem.currency'
  item_amount        : abap.curr(15,2);
  currency           : waers;
  uom                : meins;
  createdby          : syuname;
  createdat          : timestamp;
  lastchangedby      : syuname;
  lastchangedat      : timestamp;
  locallastchangedat : timestamp;

}

3. I have created interface view on top of header table: You can skip that also. It looks like this: 👇

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Interface View for Bill header'
@Metadata.ignorePropagatedAnnotations: true
define view entity ZI_BillHeader as select from ztb_billheader
{
    key bill_id as BillId,
    bill_type as BillType,
    bill_date as BillDate,
    customer_id as CustomerId,
    @Semantics.amount.currencyCode: 'Currency'
    net_amount as NetAmount,
    currency as Currency,
    sales_org as SalesOrg,
    createdby as Createdby,
    createdat as Createdat,
    lastchangedby as Lastchangedby,
    lastchangedat as Lastchangedat,
    locallastchangedat as Locallastchangedat,
    status as status,
    statustext as StatusText
}

4. I have created root view on top of header interface view: 👇

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Root View Bill Header'
@Metadata.ignorePropagatedAnnotations: true
define root view entity ZR_BillHeader as select from ZI_BillHeader
composition[0..*] of ZI_BillItem as _Item
{
    key BillId,
    BillType,
    BillDate,
    CustomerId,
    @Semantics.amount.currencyCode: 'Currency'
    NetAmount,
    Currency,
    SalesOrg,
    Createdby,
    Createdat,
    Lastchangedby,
    Lastchangedat,
    Locallastchangedat,
    status,
    StatusText,
    _Item // Make association public
}

5. I have created interface view on top of item table: 👇

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Interface View for Bill Item'
@Metadata.ignorePropagatedAnnotations: true

define view entity ZI_BillItem 
as select from ztb_billitem
association to parent ZR_BillHeader as _header on $projection.BillId = _header.BillId
{
    key bill_id as BillId,
    key item_no as ItemNo,
    material_id as MaterialId,
    description as Description,
    @Semantics.quantity.unitOfMeasure: 'Uom'
    quantity as Quantity,
    @Semantics.amount.currencyCode: 'Currency'
    item_amount as ItemAmount,
    currency as Currency,
    uom as Uom,
    createdby as Createdby,
    createdat as Createdat,
    lastchangedby as Lastchangedby,
    lastchangedat as Lastchangedat,
    locallastchangedat as Locallastchangedat,
    _header
}

6. Created projection view on top of root view: 👇

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Projection View Bill Header'
@Metadata.ignorePropagatedAnnotations: true
@Metadata.allowExtensions: true
define root view entity ZP_BillHeader
  provider contract transactional_query
  as projection on ZR_BillHeader
{
  key BillId,
      BillType,
      BillDate,
      CustomerId,
      @Semantics.amount.currencyCode: 'Currency'
      NetAmount,
      Currency,
      SalesOrg,
      Createdby,
      Createdat,
      Lastchangedby,
      Lastchangedat,
      Locallastchangedat,
      @ObjectModel.text.element: ['StatusText']
      status,
      StatusText,
      /* Associations */
      _Item : redirected to composition child ZP_BillItem
}

7. Similarly created projection view for item entity: 👇

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Projection View Bill Item'
@Metadata.ignorePropagatedAnnotations: true
@Metadata.allowExtensions: true
define view entity ZP_BillItem
  as projection on ZI_BillItem
{
  key BillId,
  key ItemNo,
      MaterialId,
      Description,
      @Semantics.quantity.unitOfMeasure: 'Uom'
      Quantity,
      @Semantics.amount.currencyCode: 'Currency'
      ItemAmount,
      Currency,
      Uom,
      Createdby,
      Createdat,
      Lastchangedby,
      Lastchangedat,
      Locallastchangedat,
      /* Associations */
      _header : redirected to parent ZP_BillHeader
}

8. My metadata looks like this: 👇 (Please make sure I haven't given labels for each field, so in UI for few field it will missing. My core agenda is to elaborate factory action)

Header:

@Metadata.layer: #CORE
@UI.headerInfo:{
typeName: 'Billing Document',
typeNamePlural: 'Billing Documents',
title: { type: #STANDARD, label: 'Biiling Document', value: 'BillId' }}
annotate entity ZP_BillHeader with
{
@UI.facet: [{ //id: 'BillDocHeader',
  label: 'Billing header',
  position: 10,
  purpose: #STANDARD,
  type: #IDENTIFICATION_REFERENCE
   },
   { //id: 'BillDocItem',
   label: 'Bill Item',
   position: 20,
   purpose: #STANDARD,
   type: #LINEITEM_REFERENCE,
   targetElement: '_Item'
   }]

@UI.lineItem: [{ position:10 },
   { position: 10,
   type: #FOR_ACTION,
  dataAction: 'ApproveBill',
  label: 'Approve Bill' },
     { position: 20,
   type: #FOR_ACTION,
  dataAction: 'CopyBilldoc',
  label: 'Copy Bill' }]
@UI.selectionField: [{position: 1  }]
@UI.identification: [{ position: 1  }]
  BillId;
@UI.lineItem: [{ position:20 }]
@UI.identification: [{ position: 2  }]
  BillType;
@UI.lineItem: [{ position:30 }]
  BillDate;
@UI.lineItem: [{ position:40 }]
@UI.identification: [{ position: 3  }]
  CustomerId;
@UI.lineItem: [{ position:50 }]
@UI.identification: [{ position: 4  }]
  NetAmount;
@UI.lineItem: [{ position:60 }]
@UI.identification: [{ position: 5 }]
  Currency;
@UI.lineItem: [{ position:70 }]
@UI.identification: [{ position: 6  }]
  SalesOrg;
@UI.lineItem: [{ position:80 }]
@UI.identification: [{ position: 7  }]
@UI.textArrangement: #TEXT_ONLY
  status;

}

Item:

@Metadata.layer: #CORE
annotate entity ZP_BillItem with
{
  @ui.facet: [ {
    id:       'BillDocItem',
    purpose:  #STANDARD,
    type:     #IDENTIFICATION_REFERENCE,
    label:    'Billing Doc Item',
    position: 10
  }]
@UI.lineItem: [{ position:10 }]
@UI.identification: [{ position: 1 }]
BillId;
@UI.lineItem: [{ position:20 }]
@UI.identification: [{ position: 1 }]
  ItemNo;
@UI.lineItem: [{ position:30 }]
@UI.identification: [{ position: 1 }]
  MaterialId;
@UI.lineItem: [{ position:40 }]
  Description;
@UI.lineItem: [{ position:50 }]
  Quantity;
@UI.lineItem: [{ position:70 }]
  ItemAmount;
@UI.lineItem: [{ position:80 }]
  Currency;
@UI.lineItem: [{ position:60 }]
  Uom;
@UI.lineItem: [{ position:90 }]
  Createdby;
@UI.lineItem: [{ position:100 }]
  Createdat;
@UI.lineItem: [{ position:110 }]

  /* Associations */
  _header;

}

Now we have basic structure ready !!! Main steps for our topic start from here.

9. Create behavior definition on top of root entity. Just right click on the root view entity and select new behavior definition as shown below 👇

Once behavior definition is generated, use quick fix to implement behavior class.

10. Now add below syntax in behavior definition:

  factory action CopyBilldoc [1];

The whole behavior definition looks like this:

managed implementation in class zbp_r_billheader unique;
strict ( 2 );

with draft;
define behavior for ZR_BillHeader //alias <alias_name>
persistent table ztb_billheader
draft table ztb_billhdr_drf
lock master total etag Lastchangedat
authorization master ( instance, global )
etag master Locallastchangedat
{
  create;
  update;
  delete;
  draft action Edit;
  draft action Resume;
  draft determine action Prepare;
  draft action Activate optimized;
  draft action Discard;
  field ( readonly : update, mandatory : create ) BillId;


  action ( features : instance ) ApproveBill result [1] $self;
  factory action CopyBilldoc [1];
  side effects
  {
    action CopyBilldoc affects $self;
  }
  association _Item { create; with draft; }

  mapping for ztb_billheader
    {
      BillId             = bill_id;
      BillType           = bill_type;
      BillDate           = bill_date;
      CustomerId         = customer_id;
      NetAmount          = net_amount;
      Currency           = currency;
      SalesOrg           = sales_org;
      CreatedBy          = createdby;
      CreateDat          = createdat;
      LastChangedBy      = lastchangedby;
      LastChangeDat      = lastchangedat;
      LocalLastChangeDat = locallastchangedat;
      status             = status;
      StatusText         = statustext;
    }
}

define behavior for ZI_BillItem //alias <alias_name>
persistent table ztb_billitem
draft table ztb_billitem_drf
lock dependent by _header
authorization dependent by _header
//etag master <field_name>
{
  update;
  delete;
  field ( readonly : update, mandatory : create ) BillId, ItemNo;
  association _header { with draft; }

  mapping for ztb_billitem
    {
      BillId             = bill_id;
      ItemNo             = item_no;
      MaterialId         = material_id;
      Description        = description;
      Quantity           = quantity;
      ItemAmount         = item_amount;
      Currency           = currency;
      Uom                = uom;
      CreatedBy          = createdby;
      CreateDat          = createdat;
      LastChangedBy      = lastchangedby;
      LastChangeDat      = lastchangedat;
      LocalLastChangeDat = locallastchangedat;
    }
}

Here, I have added extra things like draft, custom action and side effects. But for now, just focus on the line number 24.

11. Activate and use quick fix to generate this method in behavior class.

12. Use below code inside the generated factory action method. 👇

METHOD CopyBilldoc.

    " Declaration of internal tables.

    DATA: lt_bill     TYPE TABLE FOR CREATE ZR_BillHeader\\ZR_BillHeader,
          lt_billitem TYPE TABLE FOR CREATE ZR_BillHeader\_item.

    DATA: lv_billId TYPE c LENGTH 10.
   " Reading highest existing bill id and incrementing it by 1 to use as new bill id
    SELECT BillId FROM ZR_BillHeader ORDER BY BillId DESCENDING
        INTO _billid UP TO 1 ROWS.
    ENDSELECT.

    lv_billId = lv_billId + 1.

   " Read by association 

    READ ENTITIES OF ZR_BillHeader  IN LOCAL MODE
    ENTITY ZR_BillHeader
    ALL FIELDS WITH CORRESPONDING #( keys )
    RESULT DATA(lt_data1)
    ENTITY ZR_BillHeader BY \_item
    ALL FIELDS WITH CORRESPONDING #( keys )
    RESULT DATA(lt_data2)
    FAILED failed.
   
   " Appending to create a new structure
    LOOP AT lt_data1 ASSIGNING FIELD-SYMBOL(<ls_data1>).

      APPEND VALUE #( %cid = keys[ KEY entity %key = <ls_data1>-%key ]-%cid

                      "%is_draft = keys[ KEY entity %key = <ls_data1>-%key ]-%param-%is_draft

                      %data = CORRESPONDING #( <ls_data1> EXCEPT BillId )

                      ) TO lt_bill ASSIGNING FIELD-SYMBOL(<new_bill_doc>).

      <new_bill_doc>-BillId = CONV #( lv_billId ).
      <new_bill_doc>-BillDate = cl_abap_context_info=>get_system_date(  ).

      LOOP AT lt_data2 INTO DATA(ls_data2).
        APPEND VALUE #(
        %cid_ref = <new_bill_doc>-%cid
        "BillId = <new_bill_doc>-BillId
        %target = VALUE #( ( %cid = <new_bill_doc>-%cid
        BillId = <new_bill_doc>-BillId
        MaterialId = ls_data2-MaterialId
        ItemNo = ls_data2-ItemNo ) )
         ) TO lt_billitem ASSIGNING FIELD-SYMBOL(<new_bill_item>).

      ENDLOOP.

    ENDLOOP.

    "Create BO instance by copy.

    MODIFY ENTITIES OF ZR_BillHeader IN LOCAL MODE
    ENTITY ZR_BillHeader
    CREATE FIELDS ( BillId BillDate BillType Currency CustomerId NetAmount SalesOrg )
    WITH VALUE #( (
    %cid = <new_bill_doc>-%cid
    BillId = <new_bill_doc>-BillId
    BillDate = <new_bill_doc>-BillDate
    Currency = <new_bill_doc>-Currency
    CustomerId = <new_bill_doc>-CustomerId
    NetAmount = <new_bill_doc>-NetAmount
    SalesOrg = <new_bill_doc>-SalesOrg ) )
    CREATE BY \_item FIELDS ( ItemNo MaterialId )
    WITH VALUE #( (
    %cid_ref = <new_bill_doc>-%cid
    %target = VALUE #( FOR i IN lt_billitem
        FOR j IN i-%target (
    %cid = j-ItemNo
    ItemNo = j-ItemNo
    MaterialId = j-MaterialId
) ) ) )
    MAPPED DATA(mapped_create).

    " Set values to front end.

    mapped-ZR_BillHeader = mapped_create-ZR_BillHeader.


  ENDMETHOD.

The whole my behavior class looks like this: 👇

CLASS lhc_ZR_BillHeader DEFINITION INHERITING FROM cl_abap_behavior_handler.
  PRIVATE SECTION.

    METHODS get_instance_authorizations FOR INSTANCE AUTHORIZATION
      IMPORTING keys REQUEST requested_authorizations FOR ZR_BillHeader RESULT result.

    METHODS get_global_authorizations FOR GLOBAL AUTHORIZATION
      IMPORTING REQUEST requested_authorizations FOR ZR_BillHeader RESULT result.
    METHODS ApproveBill FOR MODIFY
      IMPORTING keys FOR ACTION ZR_BillHeader~ApproveBill RESULT result.
    METHODS get_instance_features FOR INSTANCE FEATURES
      IMPORTING keys REQUEST requested_features FOR ZR_BillHeader RESULT result.
    METHODS copybilldoc FOR MODIFY
      IMPORTING keys FOR ACTION zr_billheader~copybilldoc.

ENDCLASS.

CLASS lhc_ZR_BillHeader IMPLEMENTATION.

  METHOD get_instance_authorizations.
  ENDMETHOD.

  METHOD get_global_authorizations.
  ENDMETHOD.

  METHOD ApproveBill.
    MODIFY ENTITIES OF ZR_BillHeader IN LOCAL MODE
               ENTITY ZR_BillHeader
                  UPDATE FROM VALUE #( FOR key IN keys
                  ( %tky = key-%tky
                    status = 'A' " Approved
                    StatusText = 'Approved'
                    %control-status = if_abap_behv=>mk-on
                    %control-StatusText = if_abap_behv=>mk-on ) )
                  FAILED failed
                  REPORTED reported.

    "Read changed data for action result
    READ ENTITIES OF ZR_BillHeader IN LOCAL MODE
      ENTITY ZR_BillHeader
      ALL FIELDS WITH
      CORRESPONDING #( keys )
      RESULT DATA(billheaders).

    result = VALUE #( FOR billheader IN billheaders
             ( %tky   = billheader-%tky
               %param = billheader ) ).

  ENDMETHOD.

  METHOD get_instance_features.
    READ ENTITIES OF ZR_BillHeader IN LOCAL MODE
  ENTITY ZR_BillHeader
     FIELDS (  BillId status )
     WITH CORRESPONDING #( keys )
   RESULT DATA(BillHeaders)
   FAILED failed.

    result =
      VALUE #( FOR BillHeader IN BillHeaders
        ( %key = BillHeader-%key
          %features-%action-ApproveBill = COND #( WHEN BillHeader-status = 'A'
                                                        THEN if_abap_behv=>fc-o-disabled
                                                        ELSE if_abap_behv=>fc-o-enabled )
         ) ).
  ENDMETHOD.

  METHOD CopyBilldoc.

    " Copy records assigned to internal table.

    DATA: lt_bill     TYPE TABLE FOR CREATE ZR_BillHeader\\ZR_BillHeader,
          lt_billitem TYPE TABLE FOR CREATE ZR_BillHeader\_item.

    DATA: lv_billId TYPE c LENGTH 10.

    SELECT BillId FROM ZR_BillHeader ORDER BY BillId DESCENDING
        INTO _billid UP TO 1 ROWS.
    ENDSELECT.

    lv_billId = lv_billId + 1.


    READ ENTITIES OF ZR_BillHeader  IN LOCAL MODE
    ENTITY ZR_BillHeader
    ALL FIELDS WITH CORRESPONDING #( keys )
    RESULT DATA(lt_data1)
    ENTITY ZR_BillHeader BY \_item
    ALL FIELDS WITH CORRESPONDING #( keys )
    RESULT DATA(lt_data2)
    FAILED failed.

    LOOP AT lt_data1 ASSIGNING FIELD-SYMBOL(<ls_data1>).

      APPEND VALUE #( %cid = keys[ KEY entity %key = <ls_data1>-%key ]-%cid

                      "%is_draft = keys[ KEY entity %key = <ls_data1>-%key ]-%param-%is_draft

                      %data = CORRESPONDING #( <ls_data1> EXCEPT BillId )

                      ) TO lt_bill ASSIGNING FIELD-SYMBOL(<new_bill_doc>).

      <new_bill_doc>-BillId = CONV #( lv_billId ).
      <new_bill_doc>-BillDate = cl_abap_context_info=>get_system_date(  ).

      LOOP AT lt_data2 INTO DATA(ls_data2).
        APPEND VALUE #(
        %cid_ref = <new_bill_doc>-%cid
        "BillId = <new_bill_doc>-BillId
        %target = VALUE #( ( %cid = <new_bill_doc>-%cid
        BillId = <new_bill_doc>-BillId
        MaterialId = ls_data2-MaterialId
        ItemNo = ls_data2-ItemNo ) )
         ) TO lt_billitem ASSIGNING FIELD-SYMBOL(<new_bill_item>).

      ENDLOOP.

    ENDLOOP.

    "Create BO instance by copy.

    MODIFY ENTITIES OF ZR_BillHeader IN LOCAL MODE
    ENTITY ZR_BillHeader
    CREATE FIELDS ( BillId BillDate BillType Currency CustomerId NetAmount SalesOrg )
    WITH VALUE #( (
    %cid = <new_bill_doc>-%cid
    BillId = <new_bill_doc>-BillId
    BillDate = <new_bill_doc>-BillDate
    Currency = <new_bill_doc>-Currency
    CustomerId = <new_bill_doc>-CustomerId
    NetAmount = <new_bill_doc>-NetAmount
    SalesOrg = <new_bill_doc>-SalesOrg ) )
    CREATE BY \_item FIELDS ( ItemNo MaterialId )
    WITH VALUE #( (
    %cid_ref = <new_bill_doc>-%cid
    %target = VALUE #( FOR i IN lt_billitem
        FOR j IN i-%target (
    %cid = j-ItemNo
    ItemNo = j-ItemNo
    MaterialId = j-MaterialId
) ) ) )
    MAPPED DATA(mapped_create).

    " Set values to front end.

    mapped-ZR_BillHeader = mapped_create-ZR_BillHeader.


  ENDMETHOD.

ENDCLASS.

13. Create behavior projection on top of root projection view. It will look like this 👇

projection;
strict ( 2 );

use draft;
define behavior for ZP_BillHeader //alias <alias_name>
{
  use create;
  use update;
  use delete;
  use action Edit;
  use action Activate;
  use action Discard;
  use action Resume;
  use action Prepare;
  use action ApproveBill;
  use action CopyBilldoc;
  use association _Item { create; with draft;}
}

define behavior for ZP_BillItem //alias <alias_name>
{
  use update;
  use delete;

  use association _header { with draft; }
}

14. Now create the service definition and expose both header and item projection:

@EndUserText.label: 'Service Definition for Billing Doc'
define service ZSD_BillingDocument {
  expose ZP_BillHeader as BillingHeader;
  expose ZP_BillItem   as BillingItem;
}

15. On top of service definition, create a service binding. I have use Odata V4 as I am using draft functionality.

16. Finally, it's a result time. Have a first look of our application. 👇

17. Now select any record and click on copyBill. I am selecting second record.

18. Once I clicked on copyBill, We can see a new BillId is generated with same line items as of source record.

Conclusion: So, we have come to the end of our blog. We have seen how we can implement an use case related to factory action. I want to summarise important steps again required to implement factory action:

Declare factory action in behavior definition and activate it.
Use quick fix to generate the method in implementation class.
Use Read by association to read both header and child entity.
Append the new structure.
Create new duplicate BO entry by using create by association.

Thank You for reading my blog. Do comment if you have any doubt or if you know any better way to do this. Good Bye 👋

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 developer productivity via Joule and the modernization of ABAP development tools. The key benefits for customers and partners of the roadmap until Q2/2026 are:

ABAP development tools 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.

Dynamic Watermark in SAP S/4HANA Public Cloud Output Management: A Step-by-Step Guide

2026-04-01T09:29:57.553000+02:00

Recently, I got one of those requirements that sounds incredibly simple on paper but turns into an interesting technical puzzle once you work on S4HPC.

The business wanted a conditional watermark on their Purchase Order Output Form. If the PO is still navigating the approval workflow, it needs to display a massive "DRAFT" watermark across all pages. Once fully approved and released, that watermark needs to disappear completely.

The idea is straightforward: add custom logic to make the watermark conditional at both, form template level and the data source level. But as anyone who works with SAP Output Management knows, getting the Master Form and Content Form to talk to each other isn't always plug-and-play.

Here is how I did it.

Step 1: The Data Source Dilemma

Since the watermark needs to appear on all pages, the logical place to put it is the master form template.

First, I checked the standard PO form data source FDP_EF_PURCHASE_ORDER_SRV to see if I could simply grab the PurchasingProcessingStatus and ReleaseIsNotCompleted fields of I_PurchaseOrderAPI01 view to build my condition. Unsurprisingly, they weren't there.

My next thought was to extend the standard data source via the Custom Fields app. However, FDP_EF_PURCHASE_ORDER_SRV cannot be extended.

After some digging, I came across SAP Note 3525721, which states that custom fields can be used for the PO output data source with the use BAdI MMPUR_PO_OUTPUT_HEADER_EXT.

Step 2: Adding the Custom Field via BAdI

First, I went to the Custom Fields app (Business Context: Procurement: Purchasing Document) and created a new Text(1) or Indicator field called YY1_PO_WF_APPROVED_PDH. I made sure to enable its usage for the respective Form Templates.

Next, I implemented the BAdI MMPUR_PO_OUTPUT_HEADER_EXT to determine the workflow status. Here is the BAdI logic:

SELECT SINGLE FROM i_purchaseorderapi01 WITH PRIVILEGED ACCESS
  FIELDS 
  WHERE purchaseorder = @purchaseorder
    AND releaseisnotcompleted = @ABAP_false
    AND purchasingprocessingstatus = '05'
  INTO (po_approved).
IF sy-subrc = 0.
  purdoc_extension-yy1_po_wf_approved_pdh = 'X'.
ENDIF.

After downloading the Content Form XML/XDP again, the newly added custom field was sitting right there in the Data View palette.

Step 3: Form Layout Setup

Now, let’s jump into Adobe LiveCycle Designer to actually build the layout.

I added the DRAFT image inside a subform (named formWatermark) on both of the Master Pages: mst1 (the first page) and mst2 (subsequent pages).

Note: Make sure your formWatermark subform is set to Positioned (not Flowed) in the Object palette, and right-click to select Send to Back. This ensures it acts as a true background watermark and doesn't push your main content areas down.

Here is where we hit the major roadblock: How do we access the master page watermark subform from the content form? Or conversely, how do we access the content form data from the master page?

This can be achieved from either side using a simple xfa.resolveNode trick. You only need to use one of the following methods/approaches.

Note: For both approaches, ensure your Script Editor dropdowns are set to Language: JavaScript and Run At: Server. In S/4HANA Public Cloud, form rendering happens on the Server.

Method #1: Controlling it from the Master Template Form

To access our custom field value from the Content template form dataset within the Master template form, we need the absolute path of the field from the Content template's data view (e.g., PurchaseOrderNode.YY1_PO_WF_APPROVED_PDH).

We concatenate xfa.datasets.data.Form. with our custom field path. Place this JavaScript logic on the formWatermark subform's initialize event:

var WFStatusNode = xfa.resolveNode("xfa.datasets.data.Form.PurchaseOrderNode.YY1_PO_WF_APPROVED_PDH");

if (WFStatusNode.value === "X") {
    this.presence = "hidden";
} else {
    this.presence = "visible";
}

Method #2: Controlling it from the Content Template Form

Alternatively, we can access the master page watermark subforms directly from within the content template form by prefixing the path with #pageSet[0]..

Place this JavaScript code on the YY1_PO_WF_APPROVED_PDH field's initialize event:

var firstPageWatermarkNode = xfa.resolveNode("#pageSet[0].mst1.formWatermark");
var subsequentPageWatermarkNode = xfa.resolveNode("#pageSet[0].mst2.formWatermark");

if (this.rawValue === "X") {
    firstPageWatermarkNode.presence = "hidden";
    subsequentPageWatermarkNode.presence = "hidden";
} else {
    firstPageWatermarkNode.presence = "visible";
    subsequentPageWatermarkNode.presence = "visible";
}

The Final Result

After choosing your preferred approach, upload the forms (Master and Content) back into the system and test your output.

When the PO is still in approval:

And once the approval is fully completed:

The draft watermark completely vanishes!

It’s a relatively simple requirement that forces you to touch a few different areas of S/4HANA Cloud Extensibility, combining the MMPUR_PO_OUTPUT_HEADER_EXT BAdI with a little Adobe Forms JavaScript gets the job done perfectly.

Have you tackled similar form requirements in Public Cloud recently? Let me know your approach in the comments.

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!

CAP, RAP, or Both: Stop Hiding Behind 'It Depends'

2026-04-09T02:05:37.595000+02:00

I've read every major article on this topic. They all end the same way:

"Both models are complementary. Choose based on your context. Use each for the right scenario."

That is a technically accurate, professionally safe, and completely useless answer.

This article gives you the framework I actually use with clients — including the uncomfortable parts most posts skip: the staffing bias that impact architecture decisions, what to do when your client has thousands of Z-objects, why migrating RAP to CAP is not a refactor, and why CAP is the only model that enforces the Clean Core promise architecturally.

One thing upfront: this is not an anti-ABAP article. ABAP knowledge — deep understanding of business processes, transactional models, and SAP data structures accumulated over years — is one of the most valuable assets in enterprise

What We're Actually Debating

RAP (ABAP RESTful Application Programming Model) is SAP's extension model for the S/4HANA core and ABAP Cloud environments. It's ABAP-native, optimized for extending standard SAP Business Objects with transactional consistency. SAP's answer to "how do I extend S/4HANA without modifying standard code."

CAP (Cloud Application Programming Model) is SAP's framework for building cloud-native services on SAP BTP. Node.js and Java, BTP Cloud Foundry and Kyma, multitenancy, eventing, and OData/GraphQL out of the box. SAP's answer to "how do I build new business capabilities that live outside the S/4HANA core."

Same goal — Clean Core, BTP-native development. Fundamentally different execution contexts.

The Uncomfortable Truth First

Most teams choosing between CAP and RAP are not making a pure architectural decision.

They're making a decision shaped by team composition.

An ABAP-heavy organization will present RAP as the natural choice for almost any BTP extension. The justification will sound architectural: "We need access to S/4HANA data," "We want to leverage existing ABAP logic," "RAP is Clean Core approved." All of those statements can be true and still be a rationalization. The real driver is often simpler: the team knows ABAP, so RAP wins.

This is a systemic pattern worth naming explicitly — because when staffing drives architecture, the decisions look reasonable one at a time and catastrophic in aggregate. The job of a principal architect is to separate these two questions before the decision is made.

When RAP Is Genuinely the Right Answer

1. Extending Standard SAP Business Objects

If you need to extend standard S/4HANA entities — Sales Orders, Purchase Requisitions, Business Partners, Material Documents — RAP is purpose-built for this. Proper lock handling, transactional consistency, draft management, clean integration with standard SAP workflows. Trying to replicate this via CAP calling S/4HANA APIs introduces latency, complexity, and consistency gaps that are difficult to manage at scale. For tight S/4HANA core extensions, RAP's native access is a genuine advantage, not just familiarity.

2. On-Premise + Cloud Parity Requirements

RAP runs on both on-premise ABAP Platform and ABAP Cloud. CAP is cloud-only. Hybrid deployment, phased cloud migration, regulated industries with on-premise constraints — RAP is the only viable option when parity is required.

3. Maximizing Existing ABAP Investment

Complex, well-tested ABAP business logic that needs to be exposed as a service can be wrapped with a Clean Core API facade in RAP without rewriting it. Legitimate — with the caveat covered in the Z section below.

4. Simple, Bounded In-App Extensions

A single-source, single-consumer extension with no external integrations and no scalability concerns does not need the infrastructure overhead of CAP. Don't over-engineer.

When CAP Is the Right Answer — Which Is More Often Than You Think

1. Multi-Source Data Scenarios

The moment your extension needs data from more than one system, CAP is the correct choice. CAP's service layer was designed for data federation. RAP operating across multiple external sources becomes a manual integration exercise.

2. Independent Scalability

Side-by-side BTP extensions with variable load profiles should not be constrained by ABAP runtime characteristics. CAP on BTP Cloud Foundry or Kyma scales horizontally.

3. Talent Pool and Long-Term Maintainability

The global Node.js and Java developer pool is orders of magnitude larger than ABAP Cloud specialists. But the real point is different: the scarce resource in SAP programs is not syntax knowledge — it's SAP business process knowledge. An architecture that requires ABAP Cloud specialists to maintain it creates organizational dependency risk. An ABAP architect who already has the process knowledge and adds CAP to their toolkit is the most valuable person in the room.

4. Multi-Tenant SaaS and Reusable Services

CAP's multitenancy model is production-grade out of the box. RAP was not designed for this.

5. Non-SAP Ecosystem Integration

When your extension lives at the intersection of SAP and non-SAP systems, CAP's polyglot nature is a structural advantage. Building this in RAP means engineering brittle ABAP-to-external-API bridges.

6. Survival of SAP Upgrade Cycles

CAP extensions communicate with S/4HANA via stable, versioned APIs. They have no ABAP lifecycle. This connects directly to the Clean Core argument below.

The Big Z Problem

Most clients don't arrive at this debate with a clean slate. They arrive with 1,000, 2,000, sometimes 5,000 Z-objects accumulated over decades of ECC customization. The first proposal is almost always: "Let's migrate the Zs to RAP."

This is the wrong answer — and it is expensive.

The right question, before any migration decision, is: why does each Z-object exist?

Category 1 — SAP now covers it natively (retire it)
A significant portion of Z-objects from ECC exist because SAP didn't have that functionality in 2005. S/4HANA and BTP may have it natively today. Before migrating anything, check whether SAP standard now covers the need. If it does: retire the Z. Don't migrate what you should delete.

Category 2 — Genuine core business object extension (evaluate RAP)
Some Z-objects encode real business logic tightly coupled to SAP transactional objects — custom validations on Sales Orders, derivations on Financial documents, extensions to MM flows. These are legitimate RAP candidates because the coupling is intentional and the transactional integrity requirement is real.

Category 3 — Side-by-side logic that never belonged in the core (evaluate CAP with bias)
Many Z-objects are reporting utilities, data extraction routines, integration helpers, or workflow logic placed inside the ABAP stack out of convenience, not architecture. These should be evaluated for CAP first — finally living where they should have lived from the beginning. One qualifier: if the logic requires HANA-native pushdown on large datasets (financial close, ATP, margin analysis at scale), or participates in SAP's transactional determination chain, evaluate before rebuilding. The default is still CAP. The exception needs justification.

The Big Z is not a RAP migration backlog. It's a forcing function to finally answer which of your customizations your business actually needs, which SAP now covers natively, and which were architectural accidents waiting to be corrected.

And for the Zs that survive the triage but can't be rewritten this quarter — wrap them. A clean API boundary around legacy logic is not technical debt; it's the first act of modernization. What you cannot afford is leaving Z-code directly exposed. That's how "temporary" becomes permanent.

The CAP First Decision Protocol

CAP First means the burden of proof shifts. The default is CAP. RAP must earn its place by satisfying a specific gate.

The only gate that stops CAP: transactional consistency with a standard SAP Business Object, bounded to S/4HANA data, with no external systems, no multi-tenancy, and no independent scalability requirements.

One honest prerequisite: CAP First is the right posture for organizations that have already invested in BTP platform maturity — an operational subaccount, CI/CD for Node.js or Java, and the operational capability for Cloud Foundry or Kyma workloads. For organizations that haven't built that foundation yet, CAP First is still the right destination — it comes with a deliberate enablement journey first. The posture doesn't change. The timeline does.

Why does the default posture matter? Because the cost of the wrong decision is asymmetric.

The Real Cost of Getting the Model Wrong

A clarification worth making explicitly, because ABAP architects will correctly challenge a weaker version of this argument:

Upgrading S/4HANA with existing RAP extensions is relatively low cost — if your RAP uses only ABAP Cloud Released APIs (C1), which is what Clean Core RAP should do. SAP guarantees stability on released APIs across versions. ABAP teams who make this point are correct.

The cost argument I'm making is different. It's about switching models — what happens when you built in RAP and later discover that CAP was the right choice: multi-source data appeared, scalability became a requirement, the business needs this as a multi-tenant service.

RAP is ABAP. CAP is Node.js or Java. These are not different versions of the same language — different runtimes, different deployment models, different ecosystems entirely. When you migrate a RAP service to CAP:

The CDS data model needs to be rewritten in CAP CDS (similar syntax, different runtime behavior)
All business logic needs to be reimplemented in Node.js or Java — not ported, reimplemented
The deployment pipeline, CI/CD, monitoring, and operational model all change
The ABAP artifacts are retired, not converted

For a medium-complexity service: weeks to months. For a large one: a quarter or more. For a portfolio that grew because nobody pushed back: a program, not a project.

The cost of the wrong default is asymmetric. Not because RAP upgrades are expensive — they're not. But because choosing the wrong model and needing to switch is. CAP First reduces the risk of landing on that side.

One variable that changes this equation: AI. Claude Code connected to SAP ADT via MCP can analyze RAP logic and generate CAP equivalents faster than before — it lowers the code generation cost. It does not replace the authorization model revalidation, the test suite rebuild, or the operational cutover, which is where most of the real effort lives. The fear factor drops. The effort doesn't disappear. That full conversation is a follow-up article.

CAP Enforces the Clean Core Promise. RAP Requires Discipline to Maintain It.

SAP's official definition of Clean Core: don't modify standard code, use the approved extensibility models. RAP is on that list — and a RAP extension using only ABAP Cloud Released APIs (C1) is genuinely Clean Core compliant by SAP's own definition. Let's be precise about this.

But Clean Core has a purpose beyond compliance: the ability to upgrade your SAP core without touching your business logic. Faster upgrades. Lower risk. Smaller impact windows.

Here is the real distinction between RAP and CAP on this point — and it is not about compliance. It is about enforcement.

Both models can satisfy the Clean Core compliance definition when implemented with discipline. The difference is what happens when discipline breaks down. In RAP, a team under delivery pressure can find paths to unreleased ABAP internals — friend class patterns, dynamic calls, legacy function module invocations. The architectural boundary exists as a rule, not a wall. In CAP, you are physically outside the ABAP stack. You cannot access unreleased internals because there is no path to them from a Node.js or Java runtime. The boundary is enforced by the architecture itself.

RAP requires discipline to stay Clean Core. CAP makes it structurally difficult to leave.

This is not a criticism of ABAP developers. It is a recognition that architectural guardrails matter most under pressure — and pressure is the normal operating condition of enterprise SAP programs.

A valid counterpoint here: ABAP Cloud on BTP — the ABAP Environment as a side-by-side deployment — does break the S/4HANA lifecycle dependency. The toolchain enforces Released APIs syntactically via the language version check, so the "discipline" argument partially weakens. But there is a distinction worth making: ABAP Cloud on BTP decouples you from S/4HANA's runtime lifecycle. CAP decouples you from the ABAP architecture itself. If your constraints are about upgrade survival, both work. If your constraints are about talent pool, integration patterns, and long-term architectural independence away from the ABAP stack — only one of them gets you there.

A CAP service communicates with S/4HANA through stable, versioned OData or API endpoints. It does not know what version of S/4HANA is running underneath. It has no ABAP lifecycle. It can be upgraded, redeployed, and scaled completely independently. RAP is the right direction. CAP is the destination. The difference is whether Clean Core survives contact with reality.

This Is Not Anti-ABAP. It's a Call to Deploy ABAP Knowledge Differently.

Deep ABAP expertise — understanding transactional models, business process flows, SAP data structures built over decades — is irreplaceable. The scarce resource in SAP programs is not syntax knowledge. It is SAP business process knowledge. A Node.js developer learns the CAP framework in weeks. They do not learn how SAP processes an intercompany stock transfer in weeks. ABAP architects already have the hard part.

The problem is not ABAP knowledge. The problem is when that knowledge becomes a reason to avoid CAP rather than a foundation for it.

In 2026, with Claude Code connected to SAP ADT via MCP and Joule for Developers embedded in the SAP ecosystem, an experienced ABAP developer can build a production-grade CAP service with AI assistance in a fraction of the time it would have taken two years ago. The language gap has never been smaller to bridge. The "we don't have CAP developers" argument has never been weaker.

And the most mature SAP architectures don't choose one model. They use both deliberately: RAP as the API layer of S/4HANA — the clean, stable interface that exposes core business objects. CAP as the orchestration and composition layer above it — multi-source, scalable, independently deployable. That is not a compromise. That is the target state. ABAP architects who understand both are positioned to design it.

A Challenge for Your Next Architecture Review

Before your team decides on RAP — or commits to a Z-to-RAP migration program — answer four questions publicly in the room:

For Z-objects: Does each Z exist because SAP lacked functionality that it now has natively? If yes: retire it, don't migrate it.
For new extensions: Does this require transactional consistency with a standard SAP Business Object, bounded to S/4HANA data only? If yes: RAP is correct.
For new extensions: Does this require data from outside S/4HANA, independent scalability, or multi-tenant deployment? If yes: CAP is correct.
Before committing to either: Is RAP on the table because of architectural justification — or because of who is in the room?

Question 4 is the one that changes the outcome. And it takes organizational courage to ask it out loud.

The CAP vs. RAP debate is not a technology debate. It's an organizational clarity debate — and more often than not, an organizational courage debate. The teams that get this right are the ones willing to name what's actually driving the decision, separate ABAP expertise from ABAP default, and deploy both models where they genuinely belong.

References

Walter Aguero Machado —SAP Enterprise Architect | SAP BTP SME at Globant | SAP Certified Solution Architect & BTP Administrator | ASUG Speaker

Custom Sorting for Virtual Elements in RAP

2026-04-10T00:06:47.289000+02:00

Introduction

In the ABAP RESTful Application Programming Model (RAP), virtual elements are essential for displaying computed data that doesn't exist in the database—such as deriving a month or year from a timestamp. However, because these elements are calculated at runtime, they lack standard OData capabilities like server-side sorting and filtering. In this article, we will explore how to overcome these limitations by implementing a SADL exit. We’ll walk through how to enable full sorting and calculation capabilities for virtual elements, ensuring a seamless experience for the end user.

What are Virtual Elements in RAP?

In the ABAP RESTful Application Programming Model (RAP), a virtual element is a field defined in a CDS (Core Data Services) projection view that does not have a corresponding column in the underlying database table.

Real-Time Business Scenario: Sales Period Reporting

In many SAP implementations, the business requires reports segmented by Month and Year (e.g., for Monthly Sales Performance). While the underlying database table stores a precise (Created On) date, it does not store the Month or Year as separate columns.

The Problem

If we create a Fiori Elements app and want to show "Sales Month" and "Sales Year" as separate columns:

Simple Virtual Elements can calculate these strings (e.g., "January", "2024").
The Failure: When a user tries to sort the "Sales Month" column, the UI will throw an error or do nothing because the OData service doesn't know how to sort a field that doesn't exist in the database.

The Solution

By using a SADL Exit, we "map" the virtual Month/Year fields back to the physical Sales date field. This allows the database to perform the sort on the actual date, while the user sees the sorted Month or Year on their screen.

Implementation Steps

Step 1: Create a database table

Define the physical storage. This is where the raw data lives before any calculations happen.

@EndUserText.label : 'Sales table'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #RESTRICTED
define table zsales_table {

  key client      : abap.clnt not null;
  key sales_uuid  : sysuuid_x16 not null;
  sales_id        : abap.char(10);
  sales_date      : abap.dats;
  @Semantics.amount.currencyCode : 'zsales_table.currency'
  total_amount    : abap.curr(15,2);
  currency        : abap.cuky;
  last_changed_at : timestampl;

}

Step 2: Create a interface view on top of database table.

This layer projects the database fields into a clean, business-oriented structure.

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Interface view for sales table'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.usageType:{
    serviceQuality: #X,
    sizeCategory: #S,
    dataClass: #MIXED
}
define root view entity zi_sales_table
  as select from zsales_table
{
  key sales_uuid      as SalesUuid,
      sales_id        as SalesId,
      sales_date      as SalesDate,
      @Semantics.amount. currencyCode: 'Currency'
      total_amount    as TotalAmount,
      currency        as Currency,
      last_changed_at as LastChangedAt
}

Step 3: Create a Consumption view

This is where the Virtual Elements are defined. We use annotations to link the UI to the specific ABAP logic for calculation and sorting.

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Projection view for sales table'
@Metadata.ignorePropagatedAnnotations: true

define root view entity ZP_SALESPROJ
  provider contract transactional_query
  as projection on zi_sales_table
{
      .facet: [{ type: #IDENTIFICATION_REFERENCE,
                    position: 10,
                    label: 'Salestable',
                    targetQualifier: 'GENERAL',
                    purpose: #STANDARD }]
                    
      .lineItem: [{ position: 10, label: 'Sales Uuid' }]
  key SalesUuid,

      .lineItem: [{ position: 20, label: 'Sales Id' }]
      .identification: [{ position: 20, label: 'Sales Id' }]
      SalesId,

      .lineItem: [{ position: 30, label: 'Sales order date' }]
      .identification: [{ position: 30, label: 'Sales order date', qualifier: 'GENERAL' }]
      SalesDate,

      .lineItem: [{ position: 40, label: 'Sales order year' }]
      .identification: [{ position: 40, label: 'Sales order year', qualifier: 'GENERAL' }]
      @ObjectModel.virtualElement: true
      @ObjectModel.virtualElementCalculatedBy: 'ABAP:ZCL_SALES_VE_HANDLER'
      @ObjectModel.sort.transformedBy: 'ABAP:ZCL_SALES_VE_HANDLER'
  virtual SalesYear  : abap.char(4),

      .lineItem: [{ position: 50, label: 'Sales order month' }]
      .identification: [{ position: 50, label: 'Sales order month' , qualifier: 'GENERAL' }]
      @ObjectModel.virtualElement: true
      @ObjectModel.virtualElementCalculatedBy: 'ABAP:ZCL_SALES_VE_HANDLER'
      @ObjectModel.sort.transformedBy: 'ABAP:ZCL_SALES_VE_HANDLER'
  virtual SalesMonth : abap.char(2),

      .lineItem: [{ position: 60, label: 'Total amount' }]
      .identification: [{ position: 60, label: 'Total amount' }]
      @Semantics.amount.currencyCode: 'Currency'
      TotalAmount,

      Currency
}

Step 5: The Handler Class Logic

This class implements two critical interfaces: if_sadl_exit_calc_element_read for the calculation and if_sadl_exit_sort_transform to enable sorting.

CLASS zcl_sales_ve_handler DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES if_sadl_exit_calc_element_read.
    INTERFACES if_sadl_exit_sort_transform.
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.



CLASS zcl_sales_ve_handler IMPLEMENTATION.
  METHOD if_sadl_exit_calc_element_read~get_calculation_info.
    IF line_exists( it_requested_calc_elements[ table_line = 'SALESYEAR' ] ) OR
           line_exists( it_requested_calc_elements[ table_line = 'SALESMONTH' ] ).
      APPEND 'SALESDATE' TO et_requested_orig_elements.

    ENDIF.
  ENDMETHOD.

  METHOD if_sadl_exit_calc_element_read~calculate.
    DATA lt_data TYPE TABLE OF zp_salesproj WITH DEFAULT KEY.
    lt_data = CORRESPONDING #( it_original_data ).


    LOOP AT lt_data ASSIGNING FIELD-SYMBOL(<fs_row>).
      <fs_row>-SALESYEAR  = <fs_row>-salesdate(4).
      <fs_row>-SALESMONTH = <fs_row>-salesdate+4(2).
    ENDLOOP.
    ct_calculated_data = CORRESPONDING #( lt_data ).
  ENDMETHOD.

  METHOD if_sadl_exit_sort_transform~map_element.
    CASE iv_element.
      WHEN 'SALESYEAR' OR 'SALESMONTH'.
        " Map the UI sort request to the database field 'SALESDATE'
        APPEND VALUE #( name = 'SALESDATE' ) TO et_sort_elements.
    ENDCASE.
  ENDMETHOD.

ENDCLASS.

Result:

With the handler class implemented, the Sales order month and Sales order year ( Virtual Elements) now behaves like a standard database fields.