SAP Community - ABAP Cloud

Dependency Inversion in ABAP : Practical Guide

2024-11-18T12:12:01.010000+01:00

Introduction: Applying Design Principles in ABAP

In ABAP development, many of us don't always focus on design principles and patterns, especially since our work often revolves around customizing existing solutions or integrating systems rather than building software from scratch. However, understanding and applying these principles can still greatly improve the quality, maintainability, and scalability of our code.

In this blog, I want to share a practical example of how we can apply the Dependency Inversion principle, a key concept in the SOLID design patterns, in our everyday ABAP tasks.

What is Dependency Inversion?

Dependency Inversion suggests that the high-level modules (which contain the core logic of the application) should not rely directly on low-level modules (which handle specific tasks or data). Instead, both should depend on abstractions.

Example Scenario: Checking the Budget

Let’s imagine that we are working on a system where we need to check the budget for a Purchase Order (PO). Here’s how the process might unfold in a typical setup without considering Dependency Inversion:

Step 1: Create a PO class that has a method Check_PO_Budget().
Step 2: Create a BudgetService class that interacts with the PO class.
Step 3: In the BudgetService class, you instantiate a PO object and call the po_obj->Check_PO_Budget() method.

The Problem with the Initial Approach

In the example above, the BudgetService class directly depends on the PO class to check the budget. the low and high levels are tightly coupled. The BudgetService class cannot function without initiating a PO object. Another thing f you need to add new functionality, such as checking the budget for a Sales Order (SO) instead of a PO, you have to modify the BudgetService class itself .

Applying Dependency Inversion to Solve the Problem

To solve these issues, we need to decouple the high-level module (BudgetService) from the low-level module (PO). both the high and low-level modules should depend on an interface ( Abstraction layer) that defines the behavior they require, rather than depending directly on each other.

Step-by-Step Approach:

Create an Interface: Define an interface that includes the method for checking the budget.

INTERFACE zi_budge_services PUBLIC .
  METHODS :
    Check_budget RETURNING VALUE(r_out1) type string.
ENDINTERFACE.

Implement the Interface in the PO Class

CLASS zcl_po DEFINITION
    PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES zi_budge_services.
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS zcl_po IMPLEMENTATION.
  METHOD zi_budge_services~check_budget.
    r_out1 = 'Check budget for PO!' .
  ENDMETHOD.
ENDCLASS.

Create the High-Level Class: The BudgetService class will depend on the interface rather than the concrete PO class.

Note that : in the instructor we a type of the Interface so that we can inject any object or class that implements the interface and use its own functionality of checking the budget . this is a technique used to apply the Dependency Inversion called dependency injection ( Constructor Injection ).

CLASS zcl_access_budget_service DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

  methods constructor
      IMPORTING !budget_service type REF TO zi_budge_services .

  methods : run_budget_services RETURNING VALUE(r_output) type string .

  PROTECTED SECTION.
  PRIVATE SECTION.
      data : budget_service type REF TO zi_budge_services .
ENDCLASS.


CLASS zcl_access_budget_service IMPLEMENTATION.
  METHOD constructor.
    me->budget_service = budget_service .
  ENDMETHOD.

  METHOD run_budget_services.
       data(o1) = budget_service->check_budget(  ) .
       r_output = o1 .
  ENDMETHOD.

ENDCLASS.

Test the logic:

CLASS ztest_di DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES if_oo_adt_classrun .
  PROTECTED SECTION.
  PRIVATE SECTION.

ENDCLASS.

CLASS ztest_di IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.

     DATA(lo_po) = NEW zcl_po(  ) .
     data(lo_budget1) =  new zcl_access_budget_service( lo_po ) .
     data(output)     = lo_budget1->run_budget_services( ) .

  ENDMETHOD.
ENDCLASS.

Introducing New Functionalities Without Modifying High-Level Modules : The high level BudgetService remains untouched. We will add a new budget checker (SO) then just Inject it into the BudgetService .

CLASS zcl_so DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES zi_budge_services.
  PROTECTED SECTION.
  PRIVATE SECTION.

ENDCLASS.

CLASS zcl_so IMPLEMENTATION.
  METHOD zi_budge_services~check_budget.
     r_out1 = 'Check budget for SO!' .
  ENDMETHOD.
ENDCLASS.

Nothing to be changed in the BudgetService main Class and only we Inject the SO Object in the testing class like below

    DATA(lo_so) = NEW zcl_so(  ) .

    data(lo_budget1) =  new zcl_access_budget_service( lo_so ) .
    data(output)     = lo_budget1->run_budget_services( ) .

Conclusion

In the blog I tried to highlight the benefits of Dependency Inversion with Dependency Injection as below :

Decoupling: The high-level BudgetService class is now independent of the low-level PO and SO classes. This makes it easier to change or replace them without affecting the core logic.
Flexibility: New types of budget checkers (like PO_V2 or SO) can be introduced with minimal impact on the existing system.
Easier Maintenance: Changes in the low-level classes (e.g., the PO class) do not require changes in the high-level module (e.g., the BudgetService class), reducing the risk of introducing bugs.

This is my first time to work with this pattern and I wanted to share what I have learned , So feel free to try it out in your projects and let me know your thoughts.

SAP BTP ABAP Environment - Release 2411

2024-11-19T09:50:32.702000+01:00

SAP BTP ABAP Environment - Release 2411

As follow-up to our previous release 2408, this blog post provides an update concerning our most recent release 2411, which is available for customers and partners since November 16th. This particular release features highlights such as ABAP Cloud in SAP Build, a new approach to build Application Jobs, and the region-less subscription of the Landscape Portal.

The complete list of all new features can be found on the What´s New for SAP BTP ABAP Environment page.

ABAP Development Tools (ADT)

Creating an ABAP Cloud Project in the Context of the SAP BTP ABAP environment, a service key is no longer needed when creating an ABAP Cloud Project. You now enter the ABAP Service instance URL (details)
Triggering Where-Used List for Usages of CDS Annotation to enable the investigation in which ABAP CDS an annotation is used
Displaying Field Characteristics for RAP Types in the Element Information Popup, The Element Information popup (F2) for RAP types shows additional field characteristics information such as mandatory:create, mandatory:execute or readonly (details)
Multi-Dimensional Analysis App Generator, you can now use the multi-dimensional analysis app generator wizard to create all ABAP development objects that are needed to build, expose, and deploy a multi-dimensional analysis Fiori app (details)
Support of SAP Fiori launchpad app descriptor items in ABAP Development Tools for Eclipse, these items describe how an application is started and consist of a target mapping and one or more tiles, for more information see SAP Fiori Applications in the ABAP Environment and Working with Launchpad App Descriptor Items
Rerunning Unit Tests with Coverage in the ABAP Coverage view (details)
Clearing Coverage results, you can now clear your coverage results in the ABAP Coverage view (details)
ABAP Test Cockpit: ATC Check "Usage of Released APIs" can be run on Key User and ABAP Cloud objects

Reuse Services

New Class Interface for Application Job Catalog Entries and Templates, with the new attribute-based class interface it is now possible to change the parameters, sections, and groups of a catalog entry (details)
Business Rule Framework (BRF plus) is enhanced with a code generation service and an API introduced to facilitate the consumption of business rules within ABAP Cloud (details)
XCO XSLX: You can now style the cells of an Excel worksheet. You can also modify existing documents (details)
XCO CDS: You can now generate CDS external entities and logical external schemas, and you can now add comments and arithmetic expressions to CDS views (details)

UI Services and SAP Fiori Launchpad

Creating Launchpad App Descriptor Items (details)

Integration

With Business Event Logging, you can capture and log business events locally within the ABAP environment
App Display Business Event Logs. It provides an overview of logged business events for different objects and event types. You can explore the details of the event with this app
App Display Business Events by Objects: It groups business events by instances of objects and object components
App Display Changes to Objects: You can see the changes for your objects on a field level as recorded in business event logging

Security

ABAP environment tenants are now equipped with a signed default client certificate, which is automatically rotated and can be used for customer managed integration scenarios
The communication scenario SAP_COM_0915 provides access to APIs to read the Read Access Logs from the system, the API can for instance be leveraged by a Security Incident and Event Management (SIEM) system
TLS 1.3, we now support Transport Layer Security 1.3 for outbound HTTP, WebSocket RFC, and SMTP protocols
The system exposes APIs to retrieve customer-managed security settings in a read-only manner

Custom Code Migration App

Include ADT links in SAP S/4HANA Readiness Check Export, the export of ATC results for the SAP S/4HANA Readiness Check now includes HTTP(S) links, which enables you to navigate to the source code of example code in ADT for Eclipse. This new functionality is available in the Custom Code Migration app only (details)
New option to start analysis after project creation, you can now choose whether you would like to start the custom code analysis run automatically at project creation or whether you would like to schedule it manually after project creation (details)
Changes in Scope Calculation Automation, you now need to initiate scope calculation manually after project creation, the scope calculation no longer starts automatically at project creation (details)

Cloud ATC

Change Validity Date for ATC Exemptions in the Approve ATC Exemptions App (details)
Replication of ATC Exemptions from on-premise towards SAP BTP, Customers need to use transaction SATC_EXPORT_XMPT to download the exemptions from an on-premise ATC system (details)

Technical Monitoring

Enhanced app HANA Table Analysis: With the new Column Loads and Column Unloads screens in the HANA Table Analysis app, you can check how many columns of the tables in your HANA database have been loaded to or unloaded from the main storage (details)
New app HANA Memory Analysis: With the new app, you can get an overview of the memory consumption of the HANA memory components over time. This helps you to identify bottlenecks in your HANA memory (details)

Lifecycle Management

When cloning a software component, you can now optionally use the newly added parameters to request cloning a Bring Your Own Git (BYOG) repository (details)

abapGit

Support of object deletions, it can now be exported from and imported to the ABAP environment with abapGit (details)

Landscape Portal

Extended Access, you can now access and subscribe to the Landscape Portal for SAP BTP ABAP Environment from every region that is available for the ABAP environment. In regions without SAP Continuous Integration and Delivery service, some applications in the Landscape Portal are limited or not available (details)
Deinstalling Products, the new Undeploy Product app in the Landscape Portal enables you to permanently deinstall existing products (details)

ABAP Object Oriented Programming (OOP): Builder pattern Cloud Ready Version.

2024-11-25T08:07:28.766000+01:00

Builder Pattern Cloud Ready Implementation

All code can be found in my GitHub repository: https://github.com/IlyaPrusakou/ABAPBuilderPattern

In this repository you can find implementation of Builder Pattern in ABAP. The main point is the realization of pattern made on special version of ABAP language - ABAP for Cloud Development. So that there is 100% cloud compatibility.

Just copy and use it.

1. Introduction.

The Builder pattern is one of the classic creational design pattern. The main idea of the one is to separate process of creation of Product class (Product, Car, Car Schema and etc.) A logic for creation of Product class is handled into Builder class.

Below you can find Pattern Schemas and Implementation Details, you can skip theoretical notes and go to these sections.

2. Theoretical notes.

2.1. Types of the Builder pattern

There are 3 types of builder pattern I've differentiated. Each of them can be found correspondingly in GitHub files: src/zpru_bld1, src/zpru_bld2, src/zpru_bld3.

2.1.1. Simple Builder:

2.1.2. Builder with Director

2.1.3. Builder with Director and Interfaces

2.2. Semantical structure of pattern

All classes and interfaces can play roles of:

Director
Builder
Product.

Regarding of Product role I would like to underline distinction of at least two type of specialization:

2.2.1. Factual specialization

Factual specialization means that all instances of product has the same class or interface, but they differ by data preserved into. The example:

As you can see there are two instances of class Car, but they are varied with qualified field model, which can be read-only field, set inside constructor.

2.2.2. Type specialization

As you can guessed that type of specialization is based on usage of not only the same class with different values of qualified fields, but also different classes or interfaces. Moreover, there is room for amplification of interfaces raised. The same example:

Regarding Builder role I would elucidate method Build. The method creates an instance of Product and set all data, preserved in Builder instance, into product instance. We can set up builder once with setters methods. All the data will be plugged in Product instance. Each invocation of Build creates new instance of Product with data from Builder. The Builder is a source of data, along with that Product is a recipient of data. Moreover, there is space for implementation of specialization of product. For instance, Builder can have multiple Build methods (buildProductA, buildProductB and etc.), returning different instance setup or different class types.

Director role is just additional stage of Product creation. When Builder is a distinct layer for creation of Products, but Director is a layer to create or setup of Builders. Hence the question of specialization rises again there. For example, we can make multiple methods (setupBuilderA, setupBuilderB and etc.) for setup of different Builders.

3. Pattern Schemas.

3.1. Simple Builder

3.2. Builder with Director.

3.3. Builder With Director and Interfaces

4. Implementation Details

4.1. Simple Builders

Car class has private constructor an establish friendship with Car Builder class.
Car class has only getters methods to receive data from.
Car class has constructor taking all data to setup it as class attributes.
Builder contains only setter methods to setup builder data as class attributes.
Builder has build method, returning instance of Car class.
Builder's build method passes all data from Builder instance into constructor of Car class.

4.2. Simple Builders Usage pattern.

    " Create mercedes builder
    " pass mandatory fields
    DATA(lo_mercedes_builder) = NEW zpru_cl_bld1_car_builder( iv_id    = '1'
                                                              iv_brand = 'MERCEDES'
                                                              iv_model = 'C 180 T-Model' ).
    " pass optional fields into builder
    lo_mercedes_builder->set_price('100000' )->set_multimedia( 'AVANTGARDE' )->set_equipment( 'Memory Package' )->set_assistance_system('Driving Assistance Package Plus' ).

    " construct final object of mercedes
    DATA(lo_mercedes_c_180) = lo_mercedes_builder->build( ).

4.3. Builder with Director

1 - 6 points for Simple Builder are true
Director class has specialized methods to setup different Builders, e.g. buildMercedes, buildPorcshe and etc.
Director's specialized methods has importing parameter of type of Builder class(Builder Interface) to inject Builder instance
Director's methods provide distinguished setup for different Builders' instances.

4.4. Builder with Director Usage pattern

    DATA(lo_director) = NEW zpru_cl_bld2_car_director( ).
    DATA(lo_mercedes_builder) = NEW zpru_cl_bld2_car_builder( iv_brand = 'MERCEDES'
                                                              iv_model = 'C 180 T-Model' ).
    lo_director->build_mercedes( io_builder = lo_mercedes_builder ).

    lo_mercedes_builder->set_color( 'BLUE' ).
    lo_mercedes_builder->set_id( '1' ).
    DATA(lo_mercedes_c180_1_blue) = lo_mercedes_builder->build( ).

4.5. Builder With Director and Interfaces

Basically, 1 - 6 points for Simple Builder are true.
Create common interface for all Product class(Car class and Car Schema class).
Create product specialized interfaces for Car entity and Car Schema entity.
Create common interface for Builder classes(Car Builder class and Car Schema class).
Create Builder specialized interfaces for Car Builder entity and Car Schema Builder entity.
Rework friendship inside Car and Car Schema classes, make it points onto Builder common interface.
Use type of product specialized interface as returning type of Builder's build methods.
Use type of builder specialized interface as importing type of Director's build methods.

4.6. Builder With Director and Interfaces Usage pattern.

    DATA lo_mercedes_builder_car TYPE REF TO zpru_if_bld3_builder_car.
    DATA lo_mercedes_builder_schema TYPE REF TO zpru_if_bld3_builder_schema.
    DATA lo_director TYPE REF TO zpru_cl_bld3_car_director.

    lo_director = NEW zpru_cl_bld3_car_director( ).
    lo_mercedes_builder_car = NEW zpru_cl_bld3_car_builder( iv_brand = 'MERCEDES'
                                                            iv_model = 'C 180 T-Model' ).
    lo_director->build_mercedes_car( io_builder = lo_mercedes_builder_car ).

    lo_mercedes_builder_car->zpru_if_bld3_builder~set_id( '1' ).
    DATA(lo_mercedes_c180_car) = lo_mercedes_builder_car->build( ).

    lo_mercedes_builder_schema = NEW zpru_cl_bld3_schema_builder( iv_brand = 'MERCEDES'
                                                                  iv_model = 'C 180 T-Model' ).

    lo_director->build_mercedes_schema( io_builder = lo_mercedes_builder_schema ).
    lo_mercedes_builder_schema->zpru_if_bld3_builder~set_id( '2' ).
    DATA(lo_mercedes_c180_schema) = lo_mercedes_builder_schema->build( ).

“ABAP AI is our Shared Treasure” - ABAP AI is on its way.

2024-11-25T08:44:38.882000+01:00

It’s time to talk about the announced ABAP AI capabilities, planned to be delivered with the 2502 release and beyond. ABAP AI is important to all SAP business software developers. It is our shared treasure that we hold in our hands. Let’s take a moment to elaborate a little while on this statement.

ABAP AI is powerful

The new Joule copilot integrated into ABAP Development Tools for Eclipse, offers a full-fledged copilot experience and by that revolutionizes the way ABAP developers work. It provides AI support during the development process, significantly accelerating the creation and testing of custom ABAP applications. These groundbreaking developments have already been revealed and demonstrated at SAP TechEd 2024.

Imagine someone sitting next to you and guiding you, to write very good ABAP code. Not too bad, you might say. Now imagine that person complementing you and even starting to write code or to do unit tests for you. You can even discuss with this person and have them explain code you don’t understand.

Let's take a closer look at some of Joule's ABAP developer capabilities.

Joule for ABAP Code Prediction (Ghost Texting)

This feature helps you code. As you start typing your code, Ghost Text uses AI to propose the next lines of code. The difference between classic code completion already available in der development tools and this new feature is that ABAP AI actually understands the context and makes intelligent suggestions that are aligned with your coding objective. This is made possible by GenAI and SAPs trained ABAP model, which is designed to understand and predict ABAP coding patterns. This allows you to spend even more time solving complex problems and innovating.

ABAP AI Unit Agent

The ABAP AI Unit Agent is designed to assist you generate unit tests for an ABAP class. This ensures that your code is thoroughly tested. Traditionally, you would have to write unit tests manually, which is time-consuming and likely to be error-prone. With the ABAP AI Unit Agent, you can automate this process: You run the unit test for the ABAP class and check the code coverage option. The ABAP Unit Test analyzes the code coverage and identifies the methods that are not adequately covered. The ABAP AI Unit Agent adds to this the generation of unit tests.

ABAP and Core Data Services Code Explain

This feature makes ABAP, including ABAP Core Data Services (CDS), easier for developers to understand. When you select an ABAP class, CDS view, function module, a method or a code snippet, ABAP & CDS Explain analyzes the code and generates a human-readable explanation. This explanation includes a high-level overview of what the code does, as well as detailed explanations of each component. It is designed to understand ABAP coding patterns and conventions, so that it can provide accurate and useful explanations. By providing clear explanations of complex function modules, it helps developers improve their understanding of ABAP coding patterns, and best practices.

ABAP AI is attractive
SAPs ABAP AI SDK, powered by Intelligent Scenario Lifecycle Management (ISLM ), serves as an "AI toolbox" for ABAP developers. It allows you to incorporate AI capabilities to your custom ABAP applications. The ABAP AI SDK integrates seamlessly with the SAP BTP GenAI Hub, enabling you to leverage Large Language Models (LLMs) and infuse AI capabilities into your custom applications. This SDK is also used internally for all ABAP-based AI solutions.

With the ABAP AI SDK, you can easily access and use the models and features provided by the Hub by calling released ABAP classes and interfaces directly in your application code. The ABAP AI SDK takes care of the rest, executing prompts and handling the complexities of integrating AI capabilities into ABAP. This seamless integration significantly simplifies the process of incorporating AI into business applications. If that is not attractive, what is?

ABAP AI is a treasure

Even more powerful than the ABAP AI developer use cases mentioned above is the ABAP custom code migration use case. Our shared goal is to help our customers and partners to transform their custom code and move into SAP’s cloud universe.

ABAP AI for Custom Code Migration will be a game changer in achieving this goal.

We will help you transform your custom code by accelerating the transformation of custom code. Whether it's the mandatory transformation of ABAP code when migrating from ECC to SAP S/4HANA or the subsequent transformation of ABAP code to ABAP Cloud and a Clean Core.

ABAP AI support is provided for the migration of from the classic business suite to SAP S/4HANA and to ABAP Cloud and a Clean Core. This will include explanations of the mandatory simplification items to be considered during your SAP S/4HANA transformation, as well as code suggestions for refactoring your classic ABAP code towards ABAP Cloud. The corresponding AI features will be integrated in the Custom Code Migration App as well as in ABAP Development Tools for Eclipse.

Let us summarize: ABAP AI is powerful. ABAP AI is attractive. ABAP AI is a treasure.

Have a look at the ABAP AI roadmap for more information:
https://help.sap.com/docs/abap-cross-product/roadmap-info/genai

Best Practices for SAP BTP ABAP Environment

2024-12-18T11:38:59.199000+01:00

Best Practices: SAP BTP ABAP Environment

Introduction:

This blog post summarizes the best practices for getting started with the SAP BTP ABAP environment (aka Steampunk). Further articles and blog posts are linked in the appropriate places so that more information is available there if required.

The SAP BTP ABAP environment was developed to create cloud-enabled business applications, services and extensions. It offers the ABAP cloud development model that uses SAP HANA Cloud, SAP Fiori and a cloud-optimized ABAP language with standard APIs. Developers can use a toolset for tight integration with Git-enabled lifecycle management.

The use of SAP BTP ABAP environment offers 3 key benefits:

It enables a side-by-side extension option for the custom extension of SAP S/4HANA
The cloud transformation can be accelerated by using reusable ABAP assets to create innovative solutions for the cloud
Keep the core clean, the on-premise custom code is kept on another decoupled platform, where you can profit from independent and regular release cycles

The following graphic shows the four different areas of use of the SAP BTP ABAP environment. Individual adaptations for each interest group are possible for each part so that the best possible benefit is achieved.

SAP BTP ABAP Environment Positioning

Development

You can simply connect the ABAP Cloud system to Eclipse so that you can use the ABAP Development Tools (ADT) provided there to develop the ABAP Cloud apps. Build your own OData services using the ABAP RESTful application programming model (RAP) optimized for SAP HANA Cloud. You can also analyze ABAP code with advanced static custom code analysis tools like ABAP Test Cockpit, see also the blog Usage of ABAP Test Cockpit for developments in SAP BTP ABAP Environment. By the way, the security checks by SAP CVA (Code Vulnerability Analyzer) can be used in SAP BTP ABAP environment without any additional licensing fee.

Central ABAP Test Cockpit for Management of Private Cloud and on-premise Systems

Using central ABAP Test Cockpit (ATC ) in SAP BTP ABAP Environment you can perform remote static code analysis with the latest checks for developments in your private cloud and on-premise systems. Also in this scenario the security SAP CVA checks can be used without any additional licensing fee.

See the blog post Usage of ATC in the cloud for on premise developments for more details. The Custom Code Migration app in SAP BTP ABAP environment can be used to analyze your custom code during conversion to SAP S/4HANA, migration to SAP BTP ABAP environment or during clean core journey.

Administration and Integration

Administrative tasks such as user management and security setup can be performed via the role-based SAP Fiori Launchpad. Create extension projects between ABAP Cloud and other SAP Build tools, and easily integrate with existing on-premises systems and any SAP S/4HANA systems. You can also use third-party services that are based on HTTP.

The central aspect of the SAP BTP ABAP environment is the broad range of data centers globally provided. You can choose from a total number of more than 20 data centers, a list of all of them can be found in the SAP Discovery Center. The number and therefore the variety will continue to increase, and further locations are planned and will soon be available. All other upcoming features can be found in the roadmap and the what's new page for the SAP BTP ABAP environment in the SAP Help Portal. In addition, there is already a blog post in which the upgrade window for next year's releases is listed and you can find information regarding the Cloud System Notification Subscriptions (CSNS).

The Landscape Portal is part of the SAP BTP ABAP environment offering and acts as a central tool to perform system administration (for example system hibernation), manage lifecycle operations, and facilitate the configuration and deployment of multitenant SaaS solutions.

Choosing Your Starting Point: The Free Tier Option

It is important to note at the initial stage that it is not necessary to create all the systems at once, but only those that are needed at the time. On the one hand, this ensures clarity and, on the other, saves unnecessary costs.

We recommend using the Free Tier option for your first contact with this system. This allows you to try out everything free of charge and then decide whether you want to continue using it. This offer can be used for a maximum of 90 days.

Setting Up Your System: Step-by-Step Guide

The next step is the creation of a software component as a delivery unit for your project, this is possible via the SAP Fiori Launchpad. The free tier system can be converted into a standard plan development system, so that all projects and created files can be transferred. It is of course also possible to create a development system directly. The SAP BTP Cockpit is generally used for the system creation.

With the ABAP Development Tools (ADT) for Eclipse, all items can be developed as usual and released using the transport requests.

Once development is complete, a test system can be created via the SAP BTP Cockpit. The software components can then be pulled into the test system in the SAP Fiori Launchpad.

Best Practices for System Management

A subaccount to create a system is required. We recommend creating a separate subaccount for each system. This ensures maximum flexibility, for example with the trust settings. But there are also scenarios to create multiple systems in one subaccount in order to share the same trust settings. All information about Cloud Foundry and the required accounts and spaces can be found in the SAP Help Portal.

When creating the subaccount, you can also specify the region in which the system will be located. There are three different hyperscalers to choose from, which are represented in more than 20 data centers worldwide.

And each system must be assigned to a Cloud Foundry Space. Here too, it is recommended to use a Cloud Foundry Space for only one system to create a better overview.

Optimizing Costs: Sizing and Hibernation Tips

All systems should initially be created with the minimum size, one ACU (ABAP Compute Unit) and 2 HCUs (HANA Compute Unit). This usually provides sufficient coverage, as one ACU can serve around 1,000 active business users per day. These are the only two metrics that are relevant for this. The size can of course be easily changed and adapted at a later stage vie the SAP BTP Cockpit. An overview of the prices can be found in the SAP Discovery Center, where the ACUs and HCUs are also explained in more detail.

If the system has more than just the minimum size available, it is possible to use the elastic scaling. The resources are adjusted and automatically scaled based on the required workload. To be able to use this functionality, the BTPEA Commercial Model is required.

The default setting when creating a system is a development system, but if you want to create a test or productive system, you must uncheck this box. To distinguish between the different systems, you can assign them a descriptive ID in the “ABAP System ID” field.

The system hibernation function can be used to save further costs. This function is suitable for stopping development systems outside working hours, for example at weekends, starting test systems only when they are needed or starting the productive system only when it goes live. It can simply be started up via the Landscape Portal.

A detailed cost analysis for customers can be found in this blog post.

Recommended System Landscapes: Finding the Right Fit

The various landscapes are only briefly explained here, detailed descriptions can be found in the documentation. When setting up the systems, we recommend that you only start with the system that is currently required. It is not necessary to set up the entire system landscape directly. It is sufficient if only the development system is set up first and then the test or production system as soon as the need is met. On the one hand, this provides a better overview at the beginning and on the other hand, costs can be reduced.

3-System Landscape

This landscape consists of a development system, a quality assurance system and the production system. This allows the tests of new developments to be tested directly in parallel and ensures that the application is also executable in non-development systems.

5 System Landscape

In this scenario, the code lines for development and corrections can be handled separately. The correction system and the test system are on the same level as the production system. This means that the respective corrections can be tested before they are imported into the production system. To develop larger releases and code parts, there is an actual development system. There is also the corresponding test system. Urgent corrections can be implemented directly and have no influence on the normal development cycle.

Note: At this point you can use the system hibernation function, because if it is not necessary to enter corrections frequently, the correction system and the associated test system can be shut down and thus also save costs. If there is a need for these systems, they can simply be started up again. A detailed explanation of the system hibernation can be found in this blog post.

This learning journey can give you an overview of how to create an ABAP environment on the SAP BTP or you can attend our monthly Customer and Partner Roundtable. Among other topics, new product features are presented in this meeting, live demos are shown by experts or you have the opportunity to ask questions live. To register for the roundtable, please follow the SAP Community for SAP BTP ABAP Environment, where the next date will be announced in a blog post and registration details will be provided. If you have missed a roundtable or would like to look at past ones again, you can find them on GitHub, where the respective slides are also available.

Hopefully this blog post has given you a clear introduction to the SAP BTP ABAP environment.

How to call RFC FM using Service Consumption Model in ABAP Cloud

2024-12-18T12:02:46.438000+01:00

Please follow the below step by step instructions.

**Download RFC Metadata**:

- Open transaction ACO_PROXY on your ERP ex: S4HANA-on premise system.

Click on Create(F8) and save the metadata file locally.

**Create Service Consumption Model**:

- In ADT, create a service consumption model.

- Select RFC as the service type and upload the previously downloaded metadata file.

- Follow the wizard to finalize creation.

**Set Up Outbound Service and Communication Scenario**:

- Create an outbound service with the type RFC.

- Create a communication scenario.

- And in the outbound service tab, add the outbound service which is just created.

And Publish the communication scenario.

**Administrator Configuration**:

- Configure the communication system:

- Set up the communication arrangement:

**Call RFC Module in ADT Class Runner**:

- Create a new ABAP class implementing IF_OO_ADT_CLASSRUN.

- Copy the code from Service Consumption Model.

- Save and run the class to test the RFC call.

Thanks,

Jaman

CDS : How to define analytical query using two structures

2024-12-20T14:44:22.867000+01:00

This blog is about how to use two structures in CDS analytical query as in BW query.

The structure forms the foundational layout of the axes (rows or columns) in a data table, determining how information is organized and presented.
Structural components of key figure structures are always based on the key figure selections (basic key figures, restricted key figures, and calculated key figures). Characteristic structural components cannot contain key figure selections.

The arrangement of the structure affects the order and quantity of key figures or characteristics displayed in the rows and columns of a query or report.

Example: BW Query with Characteristic structure and Key Figure structure

In Analytical query, elements can be assigned to characteristics structure using @AnalyticsDetails.query.onCharacteristicStructure: true. Element with measures get automatically assigned to measure structure.

Formulas can be defined for both characteristic structure and measure structure. The operands of a formula must be elements of the same structure to which the formula belongs. Operands of the other structure are not allowed.

If an analytical query has two structures (a measure and a characteristic structure), then the query result is a grid. Each cell in this grid is defined by an element of the measure structure and one of the characteristic structures. Restrictions are combined with AND. If both elements are formulas, the formula of the measure structure is calculated by default. Also, other properties like scaling, decimals are taken from the element of the measure structure by default. If this should be different, @AnalyticsDetails.query.collisionHandling annotation is used.

collisionHandling:

{ formula : String( 20) enum { DEFAULT; THIS; CONCURRENT; };

decimals : String( 20) enum { DEFAULT; THIS; CONCURRENT; };

scaling : String( 20) enum { DEFAULT; THIS; CONCURRENT; };

semanticObject : String( 20) enum { DEFAULT; THIS; CONCURRENT; };

};

Example:

@AccessControl.authorizationCheck: #NOT_ALLOWED
@EndUserText.label: 'CDS Query with 2 Structures'
@ObjectModel.modelingPattern: #ANALYTICAL_QUERY
@ObjectModel.supportedCapabilities: [ #ANALYTICAL_QUERY ]

define transient view entity ZLR_2STRUCT_CELL_REF_SIMPLE
provider contract analytical_query
as projection on ZOQ_FLIGHT
{

//----Elements of Key Figure structure
@AnalyticsDetails.query.axis: #ROWS
@EndUserText.label: 'Max Capacity Economy'
seatsmax,

@AnalyticsDetails.query.axis: #ROWS
@EndUserText.label: 'Occupied Economy'
seatsocc,


@AnalyticsDetails.query.axis: #ROWS
@Aggregation.default: #FORMULA
@EndUserText.label: 'Percentage'
@AnalyticsDetails.query.decimals: 5
seatsocc / seatsmax * 100 as percentage,


//---Elements of Characteristics Structure

@AnalyticsDetails.query.axis: #COLUMNS
@EndUserText.label: 'Calender Year 2019'
@AnalyticsDetails.query.onCharacteristicStructure: true
case when flyear = '2019' then 1 else null end as year2019,

@AnalyticsDetails.query.axis: #COLUMNS
@EndUserText.label: 'Calender Year 2020'
@AnalyticsDetails.query.onCharacteristicStructure: true
case when flyear = '2020' then 1 else null end as year2020,

@AnalyticsDetails.query.axis: #COLUMNS
@Aggregation.default: #FORMULA
@EndUserText.label: 'Diffenece 2019-2020'
@AnalyticsDetails.query.onCharacteristicStructure: true
@AnalyticsDetails.query.decimals: 2
@AnalyticsDetails.query.collisionHandling: {decimals: #THIS}
 $projection.year2019 -  $projection.year2020 as difference

}

Output:

To display structure element in a hierarchy, AnalyticsDetials.query.elementHierarchy.parent and @AnalyticsDetails.query.elementHierarchy.initiallyCollapsed annotations are used in CDS.

Example:

@AccessControl.authorizationCheck: #NOT_ALLOWED
@EndUserText.label: 'CDS Query with 2 Structures'
@ObjectModel.modelingPattern: #ANALYTICAL_QUERY
@ObjectModel.supportedCapabilities: [ #ANALYTICAL_QUERY ]

define transient view entity ZLR_2STRUCT_CELL_REF_HIER
provider contract analytical_query
as projection on ZOQ_FLIGHT
{

//----Elements of Key Figure structure
@AnalyticsDetails.query.axis: #ROWS
@EndUserText.label: 'Max Capacity Economy'
seatsmax,

@AnalyticsDetails.query.axis: #ROWS
@EndUserText.label: 'Occupied Economy'
seatsocc,


@AnalyticsDetails.query.axis: #ROWS
@Aggregation.default: #FORMULA
@EndUserText.label: 'Percentage'
@AnalyticsDetails.query.decimals: 5
seatsocc / seatsmax * 100 as percentage,


//---Elements of Characteristics Structure

@AnalyticsDetails.query.axis: #COLUMNS
@EndUserText.label: 'Calender Year 2019'
@AnalyticsDetails.query.onCharacteristicStructure: true
  @AnalyticsDetails.query.elementHierarchy.parent: 'difference'
case when flyear = '2019' then 1 else null end as year2019,

@AnalyticsDetails.query.axis: #COLUMNS
@EndUserText.label: 'Calender Year 2020'
@AnalyticsDetails.query.onCharacteristicStructure: true
  @AnalyticsDetails.query.elementHierarchy.parent: 'difference'
case when flyear = '2020' then 1 else null end as year2020,

@AnalyticsDetails.query.axis: #COLUMNS
@Aggregation.default: #FORMULA
@EndUserText.label: 'Diffenece 2019-2020'
@AnalyticsDetails.query.onCharacteristicStructure: true
@AnalyticsDetails.query.decimals: 2
@AnalyticsDetails.query.collisionHandling: {decimals: #THIS}
@AnalyticsDetails.query.elementHierarchy.initiallyCollapsed: true  
$projection.year2019 -  $projection.year2020 as difference

}

Output:

After Expanding Hierarchy

Reference:

Working with Structures

Transforming Classic ABAP to ABAP Cloud: From Background Jobs to Application Jobs

2024-12-30T22:17:50.580000+01:00

Introduction: The Journey from Classic to Cloud

In the S/4HANA world, we hear about Clean Core all the time. Most of us also understand why Clean Core is such a great approach. And when we talk about S/4HANA Cloud, the Core is clean by definition.

However, I can imagine how inconvenient and counterintuitive resolving a general development task can be for a developer experienced in standard ABAP when working in the Cloud or Clean Core environment.

So, what am I sharing? In this blog, my intention is not to reiterate the principles of Clean Core, nor is it to provide detailed documentation of ABAP Cloud. Instead, I aim to show you an example of what happens when you need to solve a classic task in a new, cloud-ready way.

Classic ABAP: The Good, the Bad, and the Background Jobs

Any experienced ABAP developer knows what background jobs are. We use them all the time, especially when we want to run tasks periodically and automatically in the system.

When we need our custom code to execute periodically, we create a report with the required logic and schedule it as a background job step. You can refer to this blog to refresh your memory on how this is done.

There’s no doubt that even as we step into the Cloud and leave many obsolete methods behind, we still need such essential functionality. But wait - reports are not available in the Cloud!

Real life scenarios:

Imagine this: you are a seasoned SAP developer with several trusty ABAP reports for background usage that have worked perfectly for years. One day, you move to the Cloud, and you can’t take those reports with you!

Another case: you’re implementing all your developments in a Clean Core way from the beginning. You receive a requirement to code several processes and have them run autonomously in the system (e.g., a periodic data update). You know exactly how to solve it: create a report, schedule it in SM36 - but these tools are no longer available. You need a new way.

The Cloud Awakens: Modernising with ABAP Cloud

Good news! A new, cloud-ready method exists, and it comes in the beautiful class-based form we love in modern ABAP development.

How to do it, in a nutshell:

Terminology Update: Instead of “Background Job,” you’ll now deal with an “Application Job.” The transition from SAP GUI to Fiori means the Application Jobs app is now your tool for scheduling. Learn more here.
Code the Business Logic: Instead of creating a report, you’ll create a class. To make the class compatible with Application Jobs, add two interfaces: IF_APJ_DT_EXEC_OBJECT and IF_APJ_RT_EXEC_OBJECT. For SAP BTP ABAP Environment, different interfaces apply (see links below).
Register Your Class: Register your class for Application Jobs by creating a Job Catalog Entry.
Create a Job Template: To create a "variant" of your Job Catalog with prefilled fields, create a Job Template. All these steps are done in Eclipse ADT.

Once you’re finished, use the Application Jobs Fiori app to schedule a job based on the Job Template.

Profit:

Old school reports	->	Modern class-based implementation
SAP GUI: SE38, SM36, SM37	->	Eclipse native configurations & Application Jobs Fiori app
Classic development	->	Clean Core-compliant development with all its advantages
S/4HANA On Premise	->	Any S/4HANA or BTP ABAP Environment

Let's see a real-life example.

Real-World Example: A Customer's Case

The problem.

One of my customers relied on a standard Analytical Query built on a complex stack of CDS views and AMDP procedures. The data selection speed was insufficient.

The solution.

We decided to persist the analytical data daily for quick access. On top of this persisted data, we created a new analytical view for high-performance data selection. To automate this process, we needed a periodic job.

Additional conditions.

The project strategy required Clean Core implementation.

Let’s see how this was achieved.

The How-To: Step-by-Step Guide

1. Class with business logic

Create an ABAP class for your application job:

Define parameters for the Application Job (e.g., using class constants)

See how this parameters will look like in the Fiori App:

We now need to define what happens, when the Application Job framework calls our class:

2. Job Catalog

We need to create an entry and specify the class for job execution - all in Eclipse ADT:

3. Job Template

Finally, we create a variant for our job. We can add values for some of the parameters:

Now we are all set from the development point of view. We can launch the Application Jobs app and create a job.

P.S.

That’s it! The Application Jobs app includes additional features (e.g., job status monitoring) not covered in this blog. Refer to the official documentation for more.

For SAP BTP ABAP Environment, updated versions of class interfaces exist. At the time of writing, S/4HANA still uses the older versions.

This blog isn’t a comprehensive guide to all “Standard ABAP → ABAP Cloud” transformations but demonstrates how familiar concepts can be adapted for the Cloud.

I hope I’ve shown that there’s no rocket science here!

So, what’s next? Use this blog as a quick guide for ABAP Application Jobs or as inspiration for ABAP Cloud. Stay tuned for more on tackling challenges in the Classic ABAP → ABAP Cloud journey!

SAP Developer News, January 2nd, 2025

2025-01-02T21:10:00.075000+01:00

Podcast: https://podcast.opensap.info/sap-developers/2025/01/02/sap-developer-news-january-2nd-2025/

DESCRIPTION

A look back at the year 2024 in the SAP Developer Ecosystem with insights from each of the Developer Advocates.

Year in review: Antonio

What’s new in SAP Integration Suite: https://help.sap.com/whats-new/5793247a5d5741beb0decc5b7dee1160?Environment=Cloud+Foundry&Valid_as_Of=2024-01-01:2024-12-31&locale=en-US

Year in review: Kevin

CAP-LLM-Codejam: https://github.com/SAP-samples/codejam-cap-llm

CHAPTER TITLES

0:00 Intro
0:10 Year in review: Antoni
2:28 Year in review: Josh
4:27 Year in review: Sheena
5:51 Year in review: Michelle
7:36 Year in review: Ajay
9:01 Year in review: Kevin
10:08 Year in review: Rich
11:46 Year in review: Daniel

Transcription

[Intro] This is the SAP Developer News for January 2, 2025. Happy New Year!

[Antonio] Hello, SAP Developers! 2024 was a very exciting year in the integration space. Proof of that is that there have been a total of 282 updates in SAP Integration Suite this year alone. There are two new capabilities, the Dataspace and EventMesh capabilities. The integration architecture guide was recently updated. Edge Integration Cell is now supported in more platforms. for example GKE and Red Hat OpenShift. API Business Hub is now known as the developer hub. In cloud integration, we now have design guidelines checks in iFloos. The pipeline lab concept was introduced and it has significantly evolved. Lots of new adapters available for SAP cloud integration and the migration tooling is now pattern -based instead of template base. In the event-driven space, EventMesh is now part of the SAP integration suite. The SAP Event Broker is now known as SAP Cloud Application Event Hub and we can configure their connectivity with cloud integration. We can now leverage the SAP Application Interface framework to send events to advance event mesh and many more updates.

Personally, I had the opportunity to meet many SAP developers, customers and partners at different in-person events, be it as part of our CodeJams, networking events, SAP Inside Tracks, or Take It On Tour. Definitely the highlight for me there was the CodeJam road show we did with Josh in Latin America. Seuro, organized another in 2025. Virtually, interacting with many via the SAP community. I hosted a Code Challenge focusing on cloud events. I did a few live streams, but not as many as I would like. Also, being part of SAP TechEd Virtual, and also, organizing the Devtoberfest 2024 integration track. Last, presentedly, not least, I got to work on a unique project, which was publishing an SAP Press eBite, focusing on developing event -driven integrations with SAPBTP, published on the 14th of November. What can I say? It was an eventful year, but I'm already looking forward to 2025 and sharing some of the new cool projects we're working on. Ciao.

[Josh] Hey everybody. It's Mr. Bluebeard, Josh Bentley, and I wanted to reach out to you at the end of this holiday season to say, I am not traveling right now. I did a lot of traveling this year, and I was super appreciative of it. And that's really the highlight of what I wanted to say while I'm actually making my bathroom a proper color, blue. So see what's going on there? And we're going to tile the bottom. So it's going to look nice when it's done. That's what I'm doing at the end of the year. Taking a few days off, relaxing, recharging, and reflecting. So the 3Rs, Recharging, Reflecting. I just made that up. I basically am going to sit here and paint, and when I get a little frustrated to have a project's going, I'm going to remember how lucky I am to get to be a developer advocate for SAP, talk about thing like SAP build, and when I'm not building tile or building something in my house, I'm building apps. And I got to do that with Antonio in Latin America, my first time down there. So we got to go to great four different Code Jam locations. We did eight co-GEMs down there and a few stomptish. And then I got to go to Europe, of course, to do tech ed. And then we did Tech Ed on tour in Florida and then jump down to Australia. Also my first time down there. So amazing time getting to be a part of this SAP community. And what's really cool is that I don't care really where the geography is, where it is in the northern hemisphere, the southern, eastern, west. It doesn't matter because it's all about the people. It's about you guys. I got pain on my fingers. It's about you guys, the SAP community. And it doesn't matter where we are, as long as we're together and we're interacting and I can talk to you about code. You can talk to me about code or just what's going on in your life. It's really nice to be a part of this community. So I'm now going to spend the next four hours naming each and every one of you. I've met this. No, just kidding. This is a short two-minute video. I'm going to get back to working here in the house and take off a lot of days the rest of the year. I hope you all have a great holiday season. And I can't wait to see you next year. Bye.

[Sheena] Hello everyone. As 2024 comes to a close, I want to celebrate some of the major milestones I achieved this year. My journey as a developer advocate in 2024 was very exciting. I kicked off the year with an ABAP Cloud CodeJam in Mumbai, followed by several code jams across India alongside my colleague, Shilpa. This year brought me closer to the community through several events like SAP Insight Track, the Abab Developer Challenge, the SAP TechByte series and Devtoberfest. In SAPPTICPi series, we have covered all that you need to know about ABAP data services. In September, September, I had the privilege of organizing the ABAP track for one of the most awaited events, Devtoberfest. It featured many great sessions led by the experts and the response from the community was truly overwhelming. Then in October, I traveled to the beautiful city of Heidelberg, Germany, to participate in my first SAP TechEd virtual event. I got the opportunity. to present a developer keynote session together with my amazing colleagues, Shilpa, Rich and Ritali. It was also a fantastic experience to meet my colleagues from around the globe. I hope your 2024 was equally exciting and let us look forward for even more exciting activities in 2025. Till then, wish you all a Merry Christmas and Happy New Year.

[Michelle] 24 was such a great year as I got to do so many incredible things. and meet incredible people while doing it. I got to go to my childhood dream country of Australia, not just once, but twice, to present and meet all the folks attending the mastering SAP event in April and at the SAUGX conference after TechEd. Everyone there was so friendly and excited about SAP that I would gladly fly the 22 hours it takes to get there every opportunity. I was even able to turn one of those into a two-week vacation to explore beautiful Australia and I got to snorkel at the Great Barrier Reef, which was awesome. I also got to hang out with the amazingly talented and knowledgeable Devtoberfest 2023 winners at the ASUG Tech Connect event in Florida and at Disney World. It was all part of their reward for reaching Nirvana in Devtoberfest last year, and I'm grateful to be such a big part of it. It was so fun to be able to sit down and get to know these folks over a few days and chat all about SAP technologies. It was also fun to go on a roller coaster at Disney, which was not a work perk I ever expected to have. Finally, I being able to have. terrified of heights, was able to jump out of a plane because one of my insanely brave go -workers does it as a hobby. I got to ask him a million questions about it, including if they could push me out of the plane, which didn't end up being a problem because I had the tallest instructor as my tandem buddy, so my feet weren't even touching the plane when we got out.

[Ajay] This year, as an SAP developer advocate was wonderful for me, and these are just a few of the highlights. I got to travel the world, present, and meet wonderful members of our community. I know next year is going to have even more in -person events and I can't wait to meet everyone there and present on topics I'm so passionate about. Happy Holidays, Happy New Year, and as always, happy coding. Hello everyone, Season's greetings. As we approach the new year, let's reflect on the past year. I had the privilege of meeting many of our SAP developer community members during 10 in-person code jam sessions across Kolkata, Kohamvatur, Hyderabad and Bengaluru. I am very grateful to ask for CodeJam hosts for making this in-person event possible. We look forward to reaching more regions and developers next year. I had a person of meeting some of you at SAP Inside Track events where I also presented a session on SAP Cloud Application Programming Model. Later in September and October, we were focused on organizing SAP Devtoberfest event and virtual SAP TechEd. A big thank you to all our Devtoberfest presenters and participants for making it a resounding success. Many of you personally expressed your appreciation for the format and accessibility of Devtoberfest sessions. We hope to make it even better next year. Finally, I got to meet SAP community members and developers at SAUG-X TechEd on tour in Melbourne. It was pleasure to connect with so many of you at Developer Garage, hands-on sessions and mini stamp dish in Australia. Wishing you all, Merry Christmas and a very happy end to the year. and looking forward to seeing you soon next year.

[Kevin] We're in the last months of the year, which to me is always a beautiful time of quietness, learning and reflection. I'm trying to take the time to look back on the year. My son turned one and he learned to speak and I visited my dad in Grandmont, California. But there were a lot of great moments at work as well. For me, what stood out the most was Devtoberfest in Recap. Both events gave me the chance to connect and interact with our development community, the most and I also saw all my colleagues again. I had a great discussion with smart developers and even found some new friends. With SAP's AI portfolio growing rapidly, I've decided to create a brand new CodeJam covering the AI service development with CAP and SAP Charter to the AI Hub, which to me is not only interesting, but also gives you a great opportunity to learn this great new technology. I'm excited to see what the new year brings and I hope I'll see you on one of my co-jams. I wish you all so quiet times, time with family and friends, time to reflect and be mindful. See you all in 2025.

[Rich] Hey folks, Rich I'm in here and I have my best little boy, Sully, and my best little girl, Sage, here with me as well. And of course, my beautiful wife, Shauna behind the camera. Thanks, baby. I just wanted to take a couple minutes and reflect on 2024 and share some of the highlights. from the year. The developer advocates team had a really great year, and we really do appreciate your support, so thank you for that. Some highlights for me. We, of course, did the Code Jam Roadshow through Europe with Thomas, starting, or stopping through Romania, Germany, France, and Spain. It was a really great trip, and we had a chance to talk with so many of you face -to-face was really great. After that, my focus was really on tech-ed planning and supporting Devtoberfest, which was a really great. was an entire team effort. Our team worked closely with internal colleagues to build out a fantastic Devtoberfest agenda and the response from all of you was huge. So thank you for that. And of course, the whole team dropped into Heidelberg to host the TechEd virtual, which was awesome. I had so much fun with everyone involved. The developer keynote deconstructed was dialed in as usual. The Tech Ed on tour stops around the world. The last couple months of the year have been, I was a whirlwind. And I think a lot of us are a little relieved that it's over. So we're resting up and getting ready to do it all again next year, all for you, our developer community. So with that, I leave you with Happy Holidays, Happy New Year, and I'll see you in 2025.

[Daniel] I'm here in Kanandawa along the lake in upstate New York, where it's quite called, I must say. And I just want to look back at 2020. and say it was an amazing year. I got to be all over the world doing code jams at beating all kinds of interesting people and helping you learn SAP build. And I'm looking forward to an amazing 2025 with a dozen more code jams, tech cad, Devtoberfest, and more. And I want to wish all of you an amazing 2025 full of peace and happiness where all your dreams come true. And I finally want to especially thank my colleagues by fellow developers. Advocates who really, really helped me in all kinds of ways. And I want to wish them, I want to wish my fellow developer advocates, a wonderful 2025. We're full of success and excitement and I don't know what to say now. And in 2025, I want to wish all of my developer advocate colleagues who've done so much for me, an amazing year. And I hope we get to work together even. more. Take care.

ETag In RAP

2025-01-10T14:24:58.475000+01:00

This blog post provides a beginner-friendly introduction to the concept of ETags in RAP (RESTful ABAP Programming).

Introduction

This is one of the concurrency control approaches

ETag is used to manage data concurrency, preventing multiple users from overwriting the same record simultaneously, similar to the functionality of lock objects.

Concurrency: Accessing/Updating a resource at the same time by different users. It causes confusion among the users and inconsistency in the excepted output.

If you use Etag, so multiple user can only read the data but they can't update the data, because the server first check the Etag value.

Scenario for Etag in RAP

Consider a scenario where two users access the same record, and User 1 saves their changes first, the ETag mechanism ensures User 2 cannot overwrite those changes without being aware of the update. This prevents data inconsistencies. In this blog, we'll explore implementing ETag functionality in RAP using a timestamp field.

Procedure:

1. Created one database table ‘ZVS_DT_TRAVEL’.

The table zvs_dt_travel holds information related to travel records. It includes key fields like travel_id, and non-key fields such as agency_id, begin_date, end_date, last_changed_by, and last_changed_at. The field last_changed_at is particularly important because it tracks the last timestamp when the record was modified. This timestamp will be used to generate the ETag value.

@EndUserText.label : 'Table for travel'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #RESTRICTED
define table zvs_dt_travel {

  key client      : abap.clnt not null;
  key travel_id   : /dmo/travel_id not null;
  agency_id       : /dmo/agency_id;
  begin_date      : /dmo/begin_date;
  end_date        : /dmo/end_date;
  last_changed_by : abp_locinst_lastchange_user;
  last_changed_at : abp_locinst_lastchange_tstmpl;

}

This table holds travel records:

2. Now create one interface view ‘ZVS_I_TRAVEL1’ on top of DB table: -

The CDS interface view zvs_i_travel1 selects the relevant fields from the zvs_dt_travel table, including last_changed_at. This field (last_changed_at) will be used for generating the ETag value, as indicated by the @Semantics.systemDateTime.localInstanceLastChangedAt annotation. This annotation ensures that last_changed_at is recognized as the field that tracks the last modification time.

Code of interface view:

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'interface view for travel'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.usageType:{
    serviceQuality: #X,
    sizeCategory: #S,
    dataClass: #MIXED
}
define root view entity zvs_i_travel1 as select from zvs_dt_travel
{
    key travel_id as TravelId,
    agency_id as AgencyId,
    begin_date as BeginDate,
    end_date as EndDate,
    last_changed_by as LastChangedBy,
    @Semantics.systemDateTime.localInstanceLastChangedAt: true //annotation marks LastChangedAt as the timestamp for enabling ETag checks.
    last_changed_at as LastChangedAt
}

ETag Generation: The last_changed_at field will act as the ETag value. The ETag is a unique identifier for the version of the record. Whenever the last_changed_at value changes (which happens when a record is updated), the ETag value will also change.

3. Now create on consumption view ‘ZVS_C_TRAVEL1’ on top of interface view:

The consumption view zvs_c_travel1 projects the data from the interface view zvs_i_travel1. This view is intended to expose the data for transactional operations, such as create, update, and delete. The consumption view allows clients to interact with the data, but the actual persistence and behavior are managed through the behavior definition.

Code of Projection view:

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Consumption view for travel'
@Metadata.ignorePropagatedAnnotations: true
@Metadata.allowExtensions: true
define root view entity zvs_c_travel1 
provider contract transactional_query 
as projection on zvs_i_travel1
{
    key TravelId,
    AgencyId,
    BeginDate,
    EndDate,
    LastChangedBy,
    LastChangedAt
}

4. Now create a behavior definition on top of interface view:

In the behavior definition for zvs_i_travel1, the LastChangedAt field is specified as the ETag for concurrency control. It is marked as the etag master LastChangedAt, ensuring that the value of LastChangedAt will be used for update validation.

Update Scenario: When a client sends an UPDATE request, it must include the If-Match header containing the LastChangedAt timestamp (the ETag value). The system will check this value against the current LastChangedAt value stored in the database. If the values match, the update will proceed. If the values don't match (meaning the record has been updated by another user), the system will return a 412 Precondition Failed error, preventing the overwrite.

Code of Behavior Definition of Interface:

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

define behavior for zvs_i_travel1 //alias <alias_name>
persistent table zvs_dt_travel
lock master
authorization master ( instance )
etag master LastChangedAt       //ensures concurrency control using the LastChangedAt field for ETag verification
{
  create;
  update;
  delete;
  field ( readonly ) TravelId;

  mapping for zvs_dt_travel{
  TravelId = travel_id;
  AgencyId = agency_id;
  BeginDate = begin_date;
  EndDate = end_date;
  LastChangedBy = last_changed_by;
  LastChangedAt = last_changed_at;
  }

}

5. Now create a behavior definition on top of consumption view:

In the behavior definition for the consumption view (zvs_c_travel1), you must specify that ETag should be used. This tells RAP that the consumption view will work with ETags when performing operations like create, update, or delete.

ETag Use: This line ensures that ETag will be used during the create, update, and delete operations. It tells RAP that when a record is updated, the ETag value (i.e., LastChangedAt) should be checked to prevent overwriting concurrent changes.

Code of Behavior Definition of Projection:

projection;
strict ( 2 );

define behavior for zvs_c_travel1 alias travel
use etag     //ensures ETag validation during create, update, and delete operations
{
  use create;
  use update;
  use delete;
}

ETag Mechanism in Updating Data:

When the client wants to update the travel record, it sends a PATCH request to the system with the If-Match header containing the ETag value (i.e., the LastChangedAt value). The system will compare the If-Match value with the current LastChangedAt value in the database.

If the If-Match value matches the current LastChangedAt, the update is allowed, and the LastChangedAt is updated to the current timestamp.

If the If-Match value doesn't match the current LastChangedAt (i.e., the record has been modified by another user in the meantime), the update is rejected, and the system returns a 412 Precondition Failed error.

Now from the Frontend, two different users are accessing the same data at the same time:

User 1:

User 2:

Now user 1 will change the End Date:

Here we can see that User 1 updated the data successfully.

But here User 2, still viewing the old version (Jan 8, 2025)

Now User 2 will change End Date to Aug 5, 2025:

So if user 2 click on save button, so he will get one error: -

(Your changes could not be saved. A more recent version is available. To make changes to the latest version, please refresh the data).

User 2 cannot overwrite User 1's updated record without refreshing to see the latest changes.

if User 1 updates a record and saves it, User 2, still viewing the old version, cannot overwrite the updated record without refreshing the data. The ETag, generated using a timestamp, ensures only the latest version can be updated, avoiding data inconsistencies.

If User 2 refreshes the data, they will be able to see the updated version and then update the data.

After refreshing:

Now, if User 2 tries to update the data, they can update it:

Conclusion:

ETag in RAP ensures data consistency by using a unique value, like a timestamp, to track changes. It prevents users from accidentally overwriting each other's updates.

SAP Developer News, January 16th, 2025

2025-01-16T21:10:00.023000+01:00

Podcast: https://podcast.opensap.info/sap-developers/2025/01/16/sap-developer-news-january-16th-2025/

DESCRIPTION

Upload Files from Build Apps to DMS, DOX and Other Services

Video #1: Set Up SAP Build Apps to Work with DMS – https://youtu.be/lhBB2mM9Nho
Video #2: Call DMS from SAP Build Apps – https://youtu.be/SJt_BzctwbI
Video #3: Upload a File from Build Apps to DMS – https://youtu.be/gIW_tHOaNuY
Free DMS projects: https://github.com/sap-tutorials/sap-build-apps/tree/main/projects/dms
Document Management Service Playlist: https://www.youtube.com/playlist?list=PL6RpkC85SLQCsKSvIOqMzFKW30B4TKXh-
Ming Kho’s blog post on Build Apps and DMS: https://community.sap.com/t5/technology-blogs-by-sap/sap-build-apps-upload-files-to-sap-document-management-service-dms/ba-p/13963628
Ming Kho’s blog post on Build Apps and DOX: https://community.sap.com/t5/technology-blogs-by-sap/sap-build-apps-upload-files-to-sap-document-information-extraction-dox/ba-p/13964007

CAP December 2024 Release

Release notes https://cap.cloud.sap/docs/releases/dec24

Joule ABAP Developer Capabilities Early Adopter Program

https://influence.sap.com/sap/ino/#/campaign/3822

How to implement "readonly : update" for draft instances

https://community.sap.com/t5/technology-blogs-by-sap/how-to-implement-quot-readonly-update-quot-for-draft-instances/ba-p/13981904

SAP Fiori Innovation Day & UI5 Road Map 2025

SAP Fiori Innovation Day Silicon Valley: https://events.sap.com/noam/sap-fiori-innovation-day-silicon-valley/en/home
UI5 Road Map Explorer: https://roadmaps.sap.com/board?PRODUCT=73554900100800001361&range=CURRENT-LAST#Q1%202025

CHAPTER TITLES

0:00 Intro
0:10 Upload Files from Build Apps to DMS, DOX and Other Services
1:51 CAP December 2024 Releas
5:06 Joule ABAP Developer Capabilities Early Adopter Program
6:02 How to implement "readonly : update" for draft instances
6:58 SAP Fiori Innovation Day & UI5 Road Map 2025

Transcription

[Intro] This is the SAP Developer News for January 16th, 2025.

[Daniel] SAP Build Apps has just released a new flow function that lets you upload documents to the BTP Document Management Service, the document information extraction service, or any service that requires a binary upload. Minko, a developer at SAP Build Apps, created the HTTP Destination and request flow function, which takes a multi-part request body and lets you specify a destination, both of which enable you to upload to the services. He has written two blogs, one on using it with DMS and one on using it with DMS, but I want to point out that I've just released three short videos on how to use this flow function with build apps and DMS, and I want to point out that I've just released three short videos on how to use this flow I've released an entire application that lets you navigate through a DMS repo. So it will list all the documents in the root or any folder in the DMS repo, let you upload documents, let you create folders, and let you delete folders and documents. All you need to do is attach your destination to your DMS repo. And I want to point out that we also have a playlist dedicated just to the document management service. It has videos on setting up DMS, unrelated to SAP Build, as well as how to use it with process automation, and build apps. Links to all of that content are in the description.

[DJ] While most of us were taking some time off over the holiday period recently, the CAP team has kept on working and put out another regular monthly release. December 24 of this. As usual, there are plenty of highlights, some of which I want to bring to your attention here. There are so many I've actually got a list and a read through. Got some notes. And this also sees CAP Node.js at 8.6 and CAP Java at 3.6. Okay, so what have we got? There are changes and improvements in the CDS language and compiler area, specifically For example, a completely rewritten CQN specification using TypeScript declaration files, which in turn brings about improved documentation and also some Intellisense operations that are also improved. There's a new beta feature where foreign key elements of managed associations can be explicitly annotated. Moving to the Node.js flavor of CAPs specifically, there are new compiler related life cycle events. They're also in beta. There are some enhancements to CDS Env. These enhancements relate to source formats and profile-specific endv files. And CDSQL has some enhancements. And these enhancements bring about a more robust operation in general and also some new functions for CQN object construction. In the OData arena, there are also some additions and improvements relating to the OData containment feature, and also a move to allow query option-based provision of function parameters, which some of you, I'm sure, will enjoy. In the Java flavor of CAP, there are some important changes in the area of NPM build plugin support, and also the new Calaisi plugin for the document management service is now open source. Last but not least, in the tools area, there are many enhancements to the CDS REPL. Some of you may have seen these enhancements sort of take shape over the course of the first six episodes of the art and science of CAP, a live stream series that we ran recently with the one and only Daniel Hutzl. So I'll put a link to that also in the description to this item, as well as the link to this December 2024. for Capphire release notes, but also for TypeScript developers out there, you can now just use CDS watch to start the server and it will automatically detect a TypeScript project and under the hood it will run CDSTSX for you. There's also more, even more, in this December 2024 release, but I'll leave it to you to go and check out the release notes in Capphire. Until then, see you online.

[Rich] Hey friends, Rich Heilman here. I just wanted to stop in a bit and let you know about the Joule ABAP Developer Capabilities Early Adopter Program for Customers and Partners. That's right, do you want to check out the Bleeding Edge technology helping ABAP developers become more efficient developers? If so, then go to the Influence. site and register for the early adopters program. Registration started on January 15th and will end on February 15th the same day we plan to release to customers. So again, if you are ready to get your hands dirty with AI and using Joule within ADT to help you with ABAP development, then please sign up for this excellent opportunity to try it out, give us some feedback, and make the product better for all. Thanks to ABAP developers, and we'll see you. See you soon. Bye for now.

[Sheena] You might have noticed that when a field is defined as Read Only for updates in a Draft-enabled application, it cannot be edited after an initial value is provided. Andre Fischer in his latest blog post explains how to achieve the editing of such fields in Draft using the dynamic feature control option. For this, just replace the statement read-only update with features instance in your behavior definition. Then in your behavior implementation method, verify whether an active instance of the entity already exists. If yes, the field will be made read only, however, if no active instance exists, the field will remain editable. Please note that this is applicable only when an object is being created as a draft and has not yet been persisted. Check out the details and sample code in the blog post link provided in the description.

[Nico] Hi everyone and welcome to the SAP Developer News. We have some updates in the Fiori and U5 area that we want to put your attention to. First of all, the SAP Fiori Innovation Day happens on February 5th in Silicon Valley. Definitely check it out if you're in the area. AI is going to be a hot topic, there's going to be a partner session, hands -on sessions and an outlook from the Fiori team on what's to come in the future. Check out the link to register in the future. the description of this video. And also related to Fiori, more UI5. The 2025 Roadmap is out now. Go check it out. If you're interested in UI5, there's some interesting items on there, and go follow. All right, check it out. Hope you see you soon. Bye.

Change API State of your ABAP Cloud Development Objects in Bulk Mode

2025-01-17T15:45:04.919000+01:00

When developing software components, it's often beneficial to reuse existing development objects in other parts of your project or in entirely different projects. To enable this reusability, you need to release these objects with "visibility use" in Cloud Development.

While you can achieve this manually through your Eclipse IDE, the process can be quite time-consuming, especially when dealing with a large number of objects. Each object needs to be individually released, which can quickly become a tedious and inefficient task.

To streamline this process and increase productivity, we can leverage the power of the XCO library. This library provides tools and functionalities that allow you to release objects programmatically, saving you valuable time and effort.

In this blog post, we will look at a sample working code that can help you release:

Domains
Data Elements
Tables
Classes

"----------------------------------------------------------------------------
" Purpose: This program sets API State to Released
" Note: Developer should first set the TR Number Correctly
" Currently Supported For:
"  1. Domains
"  2. Data Elements
"  3. DDIC Tables
"  4. Classes
" Also supports display only mode, which only shows the current state (RELEASED or NOT RELEASED)
"----------------------------------------------------------------------------
CLASS zcl_set_api_state DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

  PRIVATE SECTION.
    TYPES: BEGIN OF details_struc,
             name      TYPE string,
             api_state TYPE string,
           END OF details_struc.

    CLASS-DATA details_tab TYPE TABLE OF details_struc WITH EMPTY KEY.

    TYPES: BEGIN OF obj_type_switch,
             doma TYPE abap_boolean,
             dtel TYPE abap_boolean,
             tabl TYPE abap_boolean,
             clas TYPE abap_boolean,
           END OF obj_type_switch.

    CLASS-DATA selection_switch TYPE obj_type_switch.

ENDCLASS.


CLASS zcl_set_api_state IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.
    DATA package      TYPE sxco_package.
    DATA tr           TYPE sxco_transport
    DATA display_only TYPE abap_boolean.

    " TODO: Set value for package and transport request
    "package = <Provide the package name of objects>
    "tr = <Provide the TR number>
    DATA(lo_transport) = xco_cp_cts=>transport->for( tr ).

    " TODO: If you only want to only display set to TRUE, if you want to release set this to FALSE
    display_only = abap_true.

    " TODO: What type of objects you want to select?
    " If you want to select all, set all elements of the structure selection_switch to TRUE
    " Else selectively pick and choose
    selection_switch-clas = abap_true.
    selection_switch-doma = abap_false.
    selection_switch-dtel = abap_false.
    selection_switch-tabl = abap_false.

    DATA(package_handle) = xco_cp_abap_repository=>package->for( package ).

    DATA(lo_api_state_rel) = xco_cp_ars=>api_state->released( VALUE #( ( xco_cp_ars=>visibility->sap_cloud_platform ) ) ).

    IF     selection_switch-doma = abap_false AND selection_switch-dtel = abap_false
       AND selection_switch-tabl = abap_false AND selection_switch-clas = abap_false.
      out->write( 'No object types selected' ).
      RETURN.
    ENDIF.

    IF selection_switch-doma = abap_true.
      " Getting all domains contained in the package
      DATA(all_domains) = xco_cp_abap_repository=>objects->doma->all->in( package_handle )->get( ).

      LOOP AT all_domains ASSIGNING FIELD-SYMBOL(<fs_doma>).
        APPEND VALUE #( name      = <fs_doma>->name
                        api_state = <fs_doma>->get_api_state( )->get_release_state( )->value )
               TO details_tab.
      ENDLOOP.

      SORT details_tab BY name.

      out->write( |\nThe package { package } includes the following { lines( details_tab ) } domains:| ).
      out->write( details_tab ).

      IF display_only <> abap_true.
        " Releasing ....
        out->write( 'Releasing ....' ).
        LOOP AT all_domains ASSIGNING FIELD-SYMBOL(<fs_doma1>).
          IF <fs_doma1>->get_api_state( )->get_release_state( )->value = 'RELEASED'.
            out->write( |\nThe Domain: { <fs_doma1>->name } Already released| ).
            CONTINUE.
          ENDIF.
          TRY.
              DATA(lo_doma) = xco_cp_abap_repository=>object->doma->for( <fs_doma1>->name ).
              lo_doma->set_api_state( io_change_scenario = lo_transport
                                      io_api_state       = lo_api_state_rel ).
            CATCH cx_root INTO DATA(lo_exp).
              out->write( 'Error occurred during releasing of API State' ).
              out->write( lo_exp->get_text( ) ).
              RETURN.
          ENDTRY.
        ENDLOOP.
        out->write( 'API State of Domains Set to Released ...' ).
      ENDIF.

    ENDIF.

    IF selection_switch-dtel = abap_true.
      " Getting all data elements contained in the package
      DATA(all_dtel) = xco_cp_abap_repository=>objects->dtel->all->in( package_handle )->get( ).

      CLEAR details_tab.
      LOOP AT all_dtel ASSIGNING FIELD-SYMBOL(<fs_dtel>).
        APPEND VALUE #( name      = <fs_dtel>->name
                        api_state = <fs_dtel>->get_api_state( )->get_release_state( )->value )
               TO details_tab.
      ENDLOOP.

      SORT details_tab BY name.

      out->write( |\nThe package { package } includes the following { lines( details_tab ) } data elements:| ).
      out->write( details_tab ).

      IF display_only <> abap_true.
        " Releasing ....
        out->write( 'Releasing ....' ).
        LOOP AT all_dtel ASSIGNING FIELD-SYMBOL(<fs_dtel1>).
          IF <fs_dtel1>->get_api_state( )->get_release_state( )->value = 'RELEASED'.
            out->write( |\nThe Data element: { <fs_dtel1>->name } Already released| ).
            CONTINUE.
          ENDIF.
          TRY.
              DATA(lo_dtel) = xco_cp_abap_repository=>object->dtel->for( <fs_dtel1>->name ).
              lo_dtel->set_api_state( io_change_scenario = lo_transport
                                      io_api_state       = lo_api_state_rel ).
            CATCH cx_root INTO lo_exp.
              out->write( 'Error occurred during releasing of API State' ).
              out->write( lo_exp->get_text( ) ).
              RETURN.
          ENDTRY.
        ENDLOOP.
        out->write( 'API State of Data Elements Set to Released ...' ).
      ENDIF.
    ENDIF.

    IF selection_switch-tabl = abap_true.
      " Getting all database tables contained in the package
      DATA(all_tabl) = xco_cp_abap_repository=>objects->tabl->all->in( package_handle )->get( ).

      CLEAR details_tab.
      LOOP AT all_tabl ASSIGNING FIELD-SYMBOL(<fs_tabl>).

        DATA(db_table) = CONV sxco_dbt_object_name( <fs_tabl>->name ).
        DATA(db_handler) = xco_cp_abap_dictionary=>database_table( db_table ).
        DATA(db_exists) = db_handler->exists( ).

        IF db_exists IS NOT INITIAL.
          DATA(db_rel_state) = db_handler->get_api_state( )->get_release_state( )->value.
        ELSE.
          db_rel_state = 'Could not be determined'.
        ENDIF.

        APPEND VALUE #( name      = <fs_tabl>->name
                        api_state = db_rel_state )
               TO details_tab.
      ENDLOOP.

      SORT details_tab BY name.

      out->write( |\nThe package { package } includes the following { lines( details_tab ) } Tables:| ).
      out->write( details_tab ).

      IF display_only <> abap_true.
        " Releasing ....
        out->write( 'Releasing ....' ).
        LOOP AT all_tabl ASSIGNING FIELD-SYMBOL(<fs_tabl1>).
          TRY.

              db_table = CONV sxco_dbt_object_name( <fs_tabl1>->name ).
              db_handler = xco_cp_abap_dictionary=>database_table( db_table ).
              db_exists = db_handler->exists( ).

              IF db_exists IS NOT INITIAL.

                db_handler->set_api_state( io_api_state       = lo_api_state_rel
                                           io_change_scenario = lo_transport ).
              ELSE.
                out->write( |\nHandler doesn't exist for DB Table: { <fs_tabl1>->name }| ).
              ENDIF.

            CATCH cx_root INTO lo_exp.
              out->write( 'Error occurred during releasing of API State' ).
              out->write( lo_exp->get_text( ) ).
              RETURN.
          ENDTRY.
        ENDLOOP.
        out->write( 'API State of Database tables Set to Released ...' ).
      ENDIF.
    ENDIF.

    IF selection_switch-clas = abap_true.
      " Getting all repository objects contained in the package
      DATA(all_clas) = xco_cp_abap_repository=>objects->clas->all->in( package_handle )->get( ).

      CLEAR details_tab.
      LOOP AT all_clas ASSIGNING FIELD-SYMBOL(<fs_clas>).
        APPEND VALUE #( name      = <fs_clas>->name
                        api_state = <fs_clas>->get_api_state( )->get_release_state( )->value )
               TO details_tab.
      ENDLOOP.

      SORT details_tab BY name.

      out->write( |\nThe package { package } includes the following { lines( details_tab ) } classes:| ).
      out->write( details_tab ).

      IF display_only <> abap_true.
        " Releasing ....
        out->write( 'Releasing ....' ).
        LOOP AT all_clas ASSIGNING FIELD-SYMBOL(<fs_clas1>).
          IF <fs_clas1>->get_api_state( )->get_release_state( )->value = 'RELEASED'.
            out->write( |\nThe Class: { <fs_clas1>->name } Already released| ).
            CONTINUE.
          ENDIF.
          TRY.
              DATA(lo_clas) = xco_cp_abap_repository=>object->clas->for( <fs_clas1>->name ).
              lo_clas->set_api_state( io_change_scenario = lo_transport
                                      io_api_state       = lo_api_state_rel ).
            CATCH cx_root INTO lo_exp.
              out->write( |Error occurred during releasing of API State, Class Name: { <fs_clas1>->name }| ).
              out->write( lo_exp->get_text( ) ).
              CONTINUE.
          ENDTRY.
        ENDLOOP.
        out->write( 'API State of Classes Set to Released ...' ).
      ENDIF.
    ENDIF.
  ENDMETHOD.
ENDCLASS.

The program needs a few variables to be set, which are indicated by TODO comments placed in the beginning of the program. If the display_only flag is set to true then only the current API state of the object is displayed. You can also control for which types of object you want to set the API State, by using the selection_switch variable.

Currently the program is designed to select all the Classes/Domains/Data Elements/Tables of a package. However you can easily introduce filters to restrict this.

A sample output is shown below:

Hope this makes the job of ABAP Cloud Developers a bit more easy !!

If you have other ideas on how we can efficiently manage this task do share in the comments!

Enable OData Streams in RAP

2025-01-20T06:28:13.387000+01:00

Problem statement:
How to enable OData Streams such as excel, pdf, Images and other large objects using standard RAP Based application development without using UI5 tooling?

Solution:

With the latest SAP BTP ABAP Environment 2208 release the RAP framework now supports OData streams. It is now possible to enable your RAP application to maintain and handle Large Objects(LOBs).This feature provides end users an option to upload external files of different file formats such as PDF, XLSX , binary file format and other types hence allowing media handling.

I am on of the presenter for this topic at ABAP Conference and int the below youtube recording. This topic covers content related to how to enable large objects using RAP (ABAP RESTful Programming Model ). Upload functionality using custom actions, download functionality using custom actions, how to use XCO library to read and write XLSX content and some useful links which can be explored about OData Streams in RAP.

ABAP Conference recording: Enable OData Streams in RAP

Slides: https://abapconf.org/abapconf2024/#/agenda

Check for topic "Enable OData Streams in RAP" where you can find the link to download slides in pdf document.

Use cases covered:

Working with Large Objects
Upload Functionality using Custom Action
Download Functionality using Custom Action
Use XCO library to read and write XLSX Content

Code based GitHub URL's:

1. Upload and Download Functionality application : https://github.com/rvrrpk/OdataStreamsRAP

2. Download History Application : https://github.com/rvrrpk/DownloadHistory

Unlock Your Future: Prove Your ABAP Cloud Readiness Today!

2025-01-20T13:34:03.019000+01:00

In the fast-evolving tech landscape, staying ahead means embracing the future. And in the world of ABAP development, that future is ABAP Cloud.

What is ABAP Cloud?

ABAP Cloud is the cutting-edge evolution in ABAP development. It's your gateway to creating cloud-ready business applications, services, and extensions that stand the test of time. Imagine harnessing the power of Core Data Services (CDS) for seamless data modelling, the ABAP RESTful Application Programming Model (RAP) for streamlined service development, and a cloud-optimized ABAP language that makes your business logic soar.

This all-encompassing programming model caters to both the SAP Business Technology Platform and SAP S/4HANA, working harmoniously across public cloud, private cloud, and on-premise environments. It's not just the next step—it's the future.

Get Certified and Stand Out

Ready to showcase your ABAP Cloud expertise? The SAP Certified Associate - Back-End Developer - ABAP Cloud certification is your ticket to proving your prowess. But how do you prepare for this transformative exam?

Explore Your Training Options

Whether you're a fan of interactive classroom experiences or prefer the flexibility of e-learning, SAP has you covered.

If you appreciate the benefits of classroom training, you can prepare for the certification with the classroom training courses S4D400 (Basic ABAP Programming), S4D401 (Intermediate ABAP Programming) and S4D430 (Data Modelling in ABAP Dictionary and ABAP Core Data Services) - as shown in the curriculum map below. Building on S4D430, the free e-learning Practicing Clean Core Extensibility for SAP S/4HANA Cloud covers the remaining content required for the exam.

In-Depth Knowledge: Even though the 5-day classroom training course S4D437 (Building Transactional Apps with the ABAP RESTful Application Programming Model) - also shown in the curriculum map - isn't included in the exam, it's a goldmine for those serious about mastering the ABAP RESTful Application Programming Model. We highly recommend it!

E-Learning Flexibility: For those who prefer learning at their own pace, there are excellent alternatives. Instead of attending the classroom training courses S4D400, S4D401 and S4D430, you can alternatively work through the free e-learning Acquiring Core ABAP Skills. It covers the entirety of the three classroom training courses, allowing you to study whenever and wherever you want.

Mix and Match Your Learning Path

Flexibility is key. Combine classroom and e-learning approaches to fit your schedule and learning style. For example, attend S4D400 in person, then switch to the e-learning Acquiring Core ABAP Skills to cover the content of S4D401 and S4D430 — it's entirely your call. The e-learning content is carefully designed to mirror classroom training, so you won't miss a beat.

Your Path, Your Future

Chart your own course to ABAP Cloud certification. Take control of your learning journey, prove your skills, and unlock unparalleled opportunities in the tech world.

Ready to embark on this exciting journey? Your future in ABAP Cloud awaits!

This article has been created by Christoph Knecht

Customer & Partner Roundtable for SAP BTP ABAP Environment #20

2025-01-24T11:01:14.541000+01:00

👉 The call for contributions for one of the upcoming roundtables is open!

If you want to show a demo or share a use case scenario for SAP BTP ABAP Environment send us an email and we will get back to you.

Introduction

As SAP BTP ABAP environment (aka Steampunk) and ABAP Cloud became more popular inside and outside of SAP, there is a high demand for rolling out the latest product news and updates, asking questions, and showing demos.

💡 You can find the slides presented, recordings, and further references from the previous roundtables in this GitHub repository.

Meeting Information

When:

February 13th, 10:00 - 11:00 AM CET – Zoom Meeting (please register in advance)

Who:

All interested customers, partners, and stakeholders are invited to join this roundtable
BTP ABAP team:
- Frank Jentsch (Product Lead for SAP BTP ABAP Environment)
- Uenal Akkaya & Thomas Alexander Ritter (ABAP Cloud Dev Tools)
- Iwona Hahn, Burcu Karlidag, Ronny Pahlke, Nora Klemp (BTP ABAP Product Management)

Preliminary Agenda:

Product update for SAP BTP ABAP Environment
ABAP IDE Actions including live demo
Q&A

Looking forward to meeting you!

Check out our SAP Business Technology ABAP Environment page in SAP Community for product updates and upcoming events.

Custom Value Help Creation For a Particular Field In SAP RAP.

2025-01-24T16:38:12.930000+01:00

Introduction

In SAP RAP (Restful ABAP Programming), a custom entity refers to a user-defined data model that represents business data specific to your needs. It’s typically created using Core Data Services (CDS) views and exposed as an OData service for consumption in applications like Fiori.

Custom entities in RAP empower developers to create tailored data models that fit unique business scenarios while easily integrating with SAP's cloud and UI platforms.

The custom entity provides a structure and implements the logic via an ABAP class. The entity itself does not contain any data but must always be called by the SADL framework first. This is why custom entities are mainly used in RAP applications.

In this blog we will make Value help for Status field In our RAP Project.

Final Output :-

Implementation

In the first step, we begin by creating the Core Data Service and the ABAP class.

1. Class

Since the class in the annotation is also checked when the custom entity is created, we implement the empty class first.

To do this, we create the class and use the interface IF_RAP_QUERY_PROVIDER, which expects the custom entity.

CLASS zcl_status_query DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES if_rap_query_provider .
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.


CLASS zcl_status_query IMPLEMENTATION.

  METHOD if_rap_query_provider~select.
* write logic here


  ENDMETHOD.
ENDCLASS.

2. Core Data Service

In the next step, we create the Core Data Service using the context menu. We use the CDS template "defineCustomEntityWithParameters" as a template:-

Now Add This annotation at CDS

@ObjectModel.query.implementedBy: 'ABAP:ZCL_STATUS_QUERY'

Now We will create two fields:

First we create a status field with appropriate data type. In this we will enter the description of the status field.
The next field is the short description of the status. ( ex: N = New ).

Since we are using built-in data types, we also set the label and tooltip for the user so that the texts appear in the UI.

@EndUserText.label: 'Value Help cds for status data element'
@ObjectModel.query.implementedBy: 'ABAP:ZCL_STATUS_QUERY'
define custom entity ZCDi_status_VH
{
    @EndUserText.label: 'Status'
    @EndUserText.quickInfo: 'Currently available status'
    key status : abap.char(10);
    
    @EndUserText.label: 'Status(Short)'
    @EndUserText.quickInfo: 'Short Name for the status'
    Status_short : abap.char(1);
     
}

We have now created the basic elements that we need for the search help. In this section we implement the necessary logic to see data in the UI.

To do this, we bind the search help to the field in the projection view.

   @Consumption.valueHelpDefinition: [{ entity: { name: 'ZCDI_STATUS_VH', element: 'status' } }]
      Status,

Since value help must also be released externally, you should include the view in your service definition.

(NOTE: Expose only if you did association with the custom CDS. In this case we will do ) .

@EndUserText.label: 'Employee table service defination'
define service Zsd_empheader {
  expose zcdp_Empheader;
  expose zcdp_address;
  expose zcdp_items;
  expose ZCDi_status_VH;
}

3. Extending the previously defined class

Let's now extend the query class with the logic we need to be able to use the value help easily. To do this, we need an internal table with the data type of the custom entity. We fill this with the appropriate data

    DATA: lt_create TYPE STANDARD TABLE OF  zcdi_status_vh WITH EMPTY KEY.

    lt_create = VALUE #( ( status = 'New'         Status_short = 'N' )
                          ( status = 'Completed'  Status_short = 'C' )
                           ( status = 'Invalid'   Status_short = 'I' )
                            ( status = 'Pending'  Status_short = 'P' )
     ).


    IF io_request->is_data_requested( ).
      io_response->set_data( lt_create ).
    ENDIF.

    IF io_request->is_total_numb_of_rec_requested( ).
      io_response->set_total_number_of_records( lines( lt_create ) ).
    ENDIF.

    io_request->get_sort_elements( ).
    io_request->get_paging( ).

To return the data, we still have to call the appropriate REPSONSE methods. Here it is important to only call the methods if the framework requests it, otherwise an error will occur. Therefore, we first ask whether the fields have been requested and then call the method. It is also important that the two methods must always be implemented and should not, for example, be in a TRY/CATCH, where they may not be called if an error occurs.

    IF io_request->is_data_requested( ).
      io_response->set_data( lt_create ).
    ENDIF.

    IF io_request->is_total_numb_of_rec_requested( ).
      io_response->set_total_number_of_records( lines( lt_create ) ).
    ENDIF.

In addition to this method, we also must call the GET_PAGING method, for which we receive a similar error. The call to the methods must be implemented within the method call.

    io_request->get_sort_elements( ).
    io_request->get_paging( ).

Now we have to associate our custom CDS with the root CDS where status field is present and expose the custom status entity.

association  to ZCDi_status_VH   as _status       on  $projection.Status = _status.status.

*expose it
_status,

status -> Field in the custom entity.
Status -> field in the root CDS.

Result :-

On Clicking value help , value help window will appear.

On clicking to the required status, it will populate In the field.

CREATE_DEEP_ENTITY using RAP ( Unmanaged )

2025-01-24T16:44:09.141000+01:00

Hello Experts,

In this blog, We will learn how to create a simple RAP OData API and use it to achieve a Deep entity set creation operation which is requested in lot of projects and Custom services especially in complex integration scenarios .

In this example, we will be using a custom cds view entities based on standard tables for header and items, unmanaged behavior definition, service definition and binding .

Step 1 : Parent CDS :

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Production order Cds view'
@Metadata.ignorePropagatedAnnotations: true
define root view entity z7pi_production_order 
    as select from aufk as _order
    composition [1..*] of z7pi_serial_number as _serial
{
    
    key aufnr as Production_order,
    auart,
    
    _serial
}

Step 2 : Child CDS :

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'serial Number Cds view'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.usageType:{
    serviceQuality: #X,
    sizeCategory: #S,
    dataClass: #MIXED
}
define view entity z7pi_serial_number 
    as select from objk
    association [0..1] to ser05 on objk.obknr = ser05.obknr
    association [0..1] to ser06 on objk.obknr = ser06.obknr
    
    association to parent z7pi_production_order as _order
        on $projection.Production_order = _order.Production_order
{
    key ser05.ppaufart as Production_order,
    key objk.sernr     as serial,
    key ser06.exidv  as hu,
    
    _order
    
}

Step 3 : Unmanaged Behavior Definition :

unmanaged implementation in class z7pbp_7pi_production_order unique;
strict ( 2 );

define behavior for z7pi_production_order alias _order
//late numbering
lock master
authorization master ( instance )
//etag master <field_name>
{
  field ( features : instance ) auart ;
  create;
  update;
  delete;
  association _serial { create; }
}

define behavior for z7pi_serial_number alias _serial
//late numbering
lock dependent by _order
authorization dependent by _order
//etag master <field_name>
{
  update;
  delete;
  field ( readonly  ) Production_order;
  association _order;
}

Step 4 : using quick fix create the implementation Class

Step 5 : comment or remove the create and cba_association create methods

we remove both methods and create a new method using the events from the removed ones

CLASS lhc__order DEFINITION INHERITING FROM cl_abap_behavior_handler.
  PRIVATE SECTION.

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

*    METHODS create FOR MODIFY
*      IMPORTING entities FOR CREATE _order.

    METHODS deep_create FOR MODIFY
      IMPORTING
        order  FOR CREATE _order
        serial FOR CREATE _order\_serial.

    METHODS update FOR MODIFY
      IMPORTING entities FOR UPDATE _order.

    METHODS delete FOR MODIFY
      IMPORTING keys FOR DELETE _order.

    METHODS read FOR READ
      IMPORTING keys FOR READ _order RESULT result.

    METHODS lock FOR LOCK
      IMPORTING keys FOR LOCK _order.

    METHODS rba_serial FOR READ
      IMPORTING keys_rba FOR READ _order\_serial FULL result_requested RESULT result LINK association_links.
    METHODS get_instance_features FOR INSTANCE FEATURES
      IMPORTING keys REQUEST requested_features FOR _order RESULT result.

*    METHODS cba_serial FOR MODIFY
*      IMPORTING entities_cba FOR CREATE _order\_serial.

ENDCLASS.

then in the implementation of the new method we should be able to access both the header and child entities

METHOD deep_create.

    DATA(lv_import) = order.
    DATA(lv_import_sr) = serial.
    LOOP AT lv_import_sr ASSIGNING FIELD-SYMBOL(<sr>) .
          LOOP AT <sr>-%target ASSIGNING FIELD-SYMBOL(<tr>).

            wa_order_ser = VALUE #(
                         %key-production_order =   lv_ord_no
                         %key-serial           =   <tr>-serial
                         production_order      =   lv_ord_no
          ).

            wa_report_ser = VALUE #(
                          %key-production_order =   lv_ord_no
                          %key-serial           =   <tr>-serial
                          production_order      =   lv_ord_no
            ).

            wa_fail_ser = VALUE #(
                        %key-production_order =   lv_ord_no
                        %key-serial           =   <tr>-serial
                        production_order      =   lv_ord_no
             ).


            SELECT SINGLE obknr
              FROM objk
              WHERE sernr EQ @<tr>-serial
                AND taser EQ 'SER05'
               INTO (obj_list).
            

          ENDLOOP.


        ENDLOOP.
  ENDMETHOD.

Finally we create the service binding and service definition

@EndUserText.label: 'Blocking zrep order type serials'
define service Z7PAPI_ZREP_BLOCK {
  expose z7pi_production_order as prd_ord;
  expose z7pi_serial_number as serial;
}

then we move to testing

as shown you can access your header and child entities however you see fit

Defining a Basic CDS View

2025-01-25T10:58:50.521000+01:00

Defining a basic Core Data Services (CDS) view in SAP involves creating a data model on the database layer rather than the application layer. This offers significant advantages in terms of performance, data access, and reusability. Here's a breakdown of how to define a basic CDS view:

1. Development Environment:

You'll typically use the ABAP Development Tools (ADT) in Eclipse to create CDS views. This provides a modern and integrated development environment.

2. CDS View Syntax:

The basic syntax for defining a CDS view is as follows:

SQL

@AbapCatalog.sqlViewName: 'SQL_VIEW_NAME'
@AbapCatalog.compiler.compareFilter: true
@AccessControl.authorizationCheck: #CHECK
define view VIEW_NAME
  as select from DATABASE_TABLE or VIEW
{
  element1 as alias1,
  element2 as alias2,
  ...
  elementN as aliasN
};

Let's break down each part:

@AbapCatalog.sqlViewName: 'SQL_VIEW_NAME': This annotation is mandatory. It defines the name of the corresponding SQL view that will be created in the database. This is the name you'll use when accessing the view from standard SQL.
@AbapCatalog.compiler.compareFilter: true: This annotation is recommended. It ensures that filter conditions are pushed down to the database level for better performance.
@AccessControl.authorizationCheck: #CHECK: This annotation is crucial for security. It enforces authorization checks based on the defined authorization objects.
define view VIEW_NAME: This keyword starts the definition of the CDS view, followed by the name you want to give to the CDS entity. This is the name used within ABAP programs.
as select from DATABASE_TABLE or VIEW: This specifies the data source for the view. You can select from database tables, database views, or other CDS views.
{ element1 as alias1, ... }: This is the element list. It defines the fields you want to include in the view. You can rename fields using aliases (as alias).

3. Example:

Let's say you have a database table SCARR (Carrier) and you want to create a CDS view that includes the carrier ID and name:

SQL

@AbapCatalog.sqlViewName: 'Z_CARRIER_VIEW'
@AbapCatalog.compiler.compareFilter: true
@AccessControl.authorizationCheck: #CHECK
define view ZCarrierView
  as select from SCARR
{
  carrid as CarrierID,
  carrname as CarrierName
};

In this example:

Z_CARRIER_VIEW is the name of the SQL view.
ZCarrierView is the name of the CDS view.
carrid is renamed to CarrierID.
carrname is renamed to CarrierName.

4. Key Concepts and Enhancements:

Aliases: Using aliases makes your code more readable and can be essential when joining tables with fields that have the same name.
Data Types: The data types of the elements in the view are derived from the underlying database table or view.
Expressions: You can use expressions in the element list to create calculated fields. For example:

SQL

define view ZSalesOrderValue
  as select from VBAK
{
  vbeln as SalesOrder,
  netwr as NetValue,
  waerk as Currency,
  netwr * 1.19 as GrossValue // Calculated field
};

Joins: You can join multiple tables or views in the FROM clause.

SQL

define view ZCustomerOrders
  as select from KNA1 as Customer
    inner join VBAK as SalesOrder
      on Customer.kunnr = SalesOrder.kunnr
{
  Customer.kunnr as CustomerID,
  Customer.name1 as CustomerName,
  SalesOrder.vbeln as SalesOrderNumber
};

WHERE Clause: You can use a WHERE clause to filter the data.

SQL

define view ZActiveCustomers
  as select from KNA1
{
  kunnr as CustomerID,
  name1 as CustomerName
} where kunnr like '1000%'; // Filter customers starting with 1000

Associations: You can define associations between CDS views to navigate related data. This is a more advanced topic but very powerful for building complex data models.

5. Activation and Usage:

After defining the CDS view in ADT, you need to activate it. This creates the corresponding SQL view in the database. You can then use the CDS view in ABAP programs using Open SQL statements:

ABAP

SELECT *
  FROM ZCarrierView
  INTO TABLE @DATA(lt_carriers).

You can also access the underlying SQL view directly using native SQL if needed.

Benefits of CDS Views:

Performance: Data processing is pushed down to the database level, which is much faster than processing data in the application server.
Simplified Data Access: CDS views provide a simplified and consistent way to access data.
Reusability: CDS views can be reused in multiple applications.
Extensibility: You can extend standard SAP data models using CDS views without modifying the original objects.

By understanding these basic concepts, you can start building efficient and powerful data models using CDS views in your SAP development.

https://www.linkedin.com/posts/mickaelquesnot_gusap-s4-hanadefining-a-basic-cds-viewdocx-activity-7288156015299108864-KdWM?utm_source=share&utm_medium=member_desktop

From Syntax to Semantics: A Classification of Core Data Services (CDS)

2025-02-06T19:31:06.611000+01:00

Introduction
Topology Layers
Logical Layer
CDS Object Tree
CDS and SQL
CDS System Function
CDS Scalar Function and CDS Table Function
CDS System Entities
Linguo-Technical Layer
Mapping CDS Language to CDS Source Code and CDS Object
Syntactic Layer
CDS by Keyword
Keyword Semantic
Business Layer
VDM Type
CDS Purpose
CDS by Stability Contract
CDS by Lifecycle
CDS by Modelling Pattern

1 Introduction

Recently, I read the ABAP keyword documentation to get an overview of the CDS framework from a high-level perspective. I came across numerous terms, each defined in the keyword dictionary. For example, terms like CDS Objects, DDL, and CDS Entity were mentioned, among others.

This prompted me to organize and systematize these terms to better understand their roles and why the documentation authors chose to highlight them.

As a result, I came up with the idea of creating a CDS classification. Of course, this topology is not exhaustive.

This article turned out to be quite a long read, and I hope, dear reader, that you won’t mind. Maybe you’ll find a moment to go through this classification while sipping your latte on a winter evening. Otherwise, feel free to use the table of contents above to navigate quickly through the article.

I’ve only gathered high-level information here, so I encourage you to dive deeper if you're interested.

If you prefer the article is available on my GitHub: https://github.com/IlyaPrusakou/CDSClassification.git

2 Topology Layers

The CDS typology begins by dividing the CDS framework into four layers:

1 Logical
2 Linguo-technical
3 Syntactic
4 Business

The first three layers are derived from the keyword documentation, while the fourth—Business—is based on my experience and active googling.

3 Logical Layer

At the foundation of the Logical level is the term CDS object. I would define a CDS object as a programmatic entity that encapsulates all runtime properties of a CDS view. We refer to a CDS as an object when it is used as a type in ABAP code, as part of an Open SQL selection, or in similar contexts.

4 CDS Object Tree

I would represent CDS objects as the following tree:

1 CDS objects

1.1 CDS annotations

1.2 CDS metadata extensions

1.3 CDS entities
1.3.1 CDS view entities
1.3.2 CDS projections view
1.3.2.1 CDS Transactional query
1.3.2.2 CDS Analytical projection view
1.3.2.3 CDS Transactional interface
1.3.3 CDS Table functions
1.3.4 CDS Hierarchies
1.3.5 CDS Custom Entities
1.3.6 CDS Abstract Entities
1.3.7 CDS DDIC-based views
1.3.8 CDS External Entities
1.3.9 ABAP CDS Aspect

1.4 CDS Tunning Objects
1.4.1 CDS Entity Buffers

1.5 CDS User Defined Types
1.5.1 CDS Simple Types
1.5.2 CDS Enumeration Types

1.6 CDS Functions
1.6.1 CDS Scalar Functions
1.6.1.1 CDS SQL-based Scalar Functions
1.6.1.2 CDS Analytical Scalar Functions
1.6.2 CDS Built-in Functions

1.7 CDS Roles

5 CDS and SQL

Also, it's worth to mention It is also worth mentioning the classification of CDS Entities into two categories:

CDS SQL Entities – This includes all entities except CDS non-SQL entities.
CDS Non-SQL Entities – These are specialized entities such as Abstract Entities, Custom Entities, and CDS Analytical Projection Views.

6 CDS System Function

Another important aspect to clarify is the semantic overlap between CDS user-defined functions and CDS system functions. The overarching term for both is CDS Scalar Function, which can be further classified as follows:

CDS Scalar Function
1.1 Analytical Scalar Function - Classified as a System Function
1.2 SQL-Based Scalar Function
1.2.1 Delivered by SAP - Classified as a System Function
1.2.2 User-Defined Scalar Function

7 CDS Scalar Function and CDS Table Function

I would also like to emphasize the dichotomy between CDS Table Functions and CDS Scalar Functions. While CDS Table Functions are classified as a type of CDS Entity, CDS Scalar Functions fall under the category of CDS Functions.

8 CDS System Entities

Lastly, it’s worth noting that SAP provides special CDS System Entities, which are predefined entities. However, for the sake of clarity and consistency, I propose classifying them under CDS Entities, specifically as entities delivered by SAP.

9 Linguo-Technical Layer

At the core of the Technical level lies the term CDS source code. Why is this significant? The answer is that CDS source code is used by developers to define all the properties of a CDS object. Additionally, it serves for transporting CDS objects between systems and generating the corresponding runtime artifacts.

10 Mapping CDS Language to CDS Source Code and CDS Object

In summary, I propose distinguishing CDS objects as runtime artifacts and CDS source code as design-time artifacts. The classification can be outlined as follows:

Source Code Type	Source Code Subtype	CDS Object
CDS Source Code	CDS Source Code	CDS Object
Data Definition Language (DDL)		CDS Entity (e.g., CDS View Entity, CDS Custom Entity, etc.)
	DDL Annotation (DDLA)	CDS Annotation
	DDL Metadata Extension (DDLX)	CDS Metadata Extension
Data Control Language (DCL)		CDS Roles
Type Definition Language (TDL)		CDS User-Defined Types
Function Definition Language (FDL)		CDS Function

I deliberately exclude Service Definition Language (SDL), as it pertains to a different topic—the RAP framework. Nevertheless, it’s worth noting the close relationship between Service Definitions and the CDS framework.

Additionally, it’s important to highlight that the languages used for annotations and metadata extensions (DDLA and DDLX) are sub-dialects of the broader DDL.

11 Syntactic Layer

In the Syntactic Layer, I am going to propose a classification of CDS entities based on their primary defining keyword. This approach organizes CDS artifacts according to the central syntax element that dictates their structure and functionality. By focusing on the main keyword, we can establish a clear and systematic understanding of the various CDS types.

12 CDS by Keyword

1. Syntax of ABAP CDS

1.1 DEFINE ANNOTATION
1.2 ANNOTATE VIEW
1.3 ANNOTATE ENTITY

1.4 DEFINE VIEW ENTITY

1.5 DEFINE VIEW ENTITY AS PROJECTION ON
Provide Contract: Transactional Query

1.6 DEFINE VIEW ENTITY AS PROJECTION ON
Provide Contract: Transactional Interface

1.7 DEFINE TRANSIENT VIEW ENTITY AS PROJECTION ON
Provide Contract: Analytical Query

1.8 DEFINE VIEW
1.9 DEFINE TABLE FUNCTION
1.10 DEFINE HIERARCHY
1.11 DEFINE CUSTOM ENTITY
1.12 DEFINE ABSTRACT ENTITY
1.13 DEFINE EXTERNAL ENTITY
1.14 DEFINE VIEW ENTITY BUFFER

1.15 DEFINE ROLE
1.16 DEFINE ACCESS POLICY

1.17 DEFINE TYPE
1.18 DEFINE TYPE ENUM

1.19 DEFINE SCALAR FUNCTION

1.20 DEFINE ASPECT

2 Extension Syntax

2.1 EXTEND VIEW ENTITY
2.2 EXTEND CUSTOM ENTITY
2.3 EXTEND ABSTRACT ENTITY
2.4 EXTEND VIEW

13 Keyword Semantic

To express the semantics of the CDS main keyword, I have adopted a notation similar to Backus-Naur Form (BNF), which is commonly used to describe the syntax of programming languages. In this approach, the CDS main keyword is constructed using the following components:

<keyword> ::= <cds_action> <cds_type>
<cds_action> ::= define | extend | annotate

<cds_type> ::= view | <entity> | <view_entity> | role | table_function | aspect | hierarchy | <type> | scalar_function | view_entity_buffer

<entity> ::= [custom | abstract | external] entity

<view_entity>  ::= [transient] view entity [as projection] [<contract>]

<contract> ::= provide contract transactional {query | interface} | analytical query

<type> ::= type | type enum

14 Business Layer

The Business Layer represents the practical application of CDS as a modeling pillar, enabling the creation of business entities based on the technical foundation provided by the CDS framework. One of the key guides within this layer is the Virtual Data Model (VDM), which standardizes the design and structure of CDS-based entities to align with business requirements.

VDM acts like a blueprint, similar to how Lego bricks can be assembled to build a castle. In this analogy, the Lego bricks represent the CDS framework components, while the final model—be it a Remote API, Value Help, or another business construct—symbolizes the resulting business entity. This approach ensures consistency, reusability, and alignment with SAP's overall architecture principles.

15 VDM Type

The division of the Business Layer relies on the values of the VDM.viewType annotation. This annotation is a key component used by SAP for the internal structuring and interpretation of CDS views. It defines the purpose and role of each CDS view within the overall VDM architecture. Below are the specific types of VDM views:

1 Basic CDS View

Represents the foundational layer of the VDM. Typically maps to a single database table to provide raw data. Used as a building block for higher-level CDS views.

2 Composite CDS View

Combines multiple Basic CDS Views or other Composite Views. Provides aggregated, enriched, or contextualized data. Acts as a middle layer in the VDM hierarchy.

3 Consumption CDS View

Designed for use in user interfaces, analytics, or APIs. Focuses on data presentation and consumption by external applications. Often leverages SAP Fiori or analytical tools.

4 Extension CDS View

Used to extend existing CDS views without modifying the original definition. Enables custom fields or logic to be added to standard SAP-delivered views.

5 Derivation Function

Facilitates the calculation of derived fields or values within a CDS view. They are often used for derivation values for CDS parameters.

6 Transactional

Supports transactional use cases. Often used for modelling business objects(e.g. RAP objects) and associated with data modification or interactions in SAP’s transactional scenarios.

16 CDS Purpose

CDS Purpose Classification:

1 Views Providing Data Access

These views interact with the underlying database and are used for various data access purposes:

1.1 Interface CDS View

Acts as an interface for data reading, often used as a source in Open SQL or as select source in other CDS views

1.2 Restricted Reuse CDS View

Provides entities with specific restrictions for usage outside of particular application area. Restricted nature means that the CDS should not be used by customers or SAP partners in their developments. Don't confuse with Private CDS.

1.3 Consumption CDS View

Focused on presenting data for analytics or user interfaces (e.g., SAP Fiori). Therefore they contain a plenty of consumption specific metadata.

1.4 Private CDS View

Intended for internal use as constituting part of other non-private CDS. Once it is created, it is used only in one specific place in CDS hierarchy.

1.5 Transactional Processing CDS View

They are used for modelling CDS tree of business objects and enable capability of adding transactional behavior to them.

1.6 Remote API CDS View

Exposes data as part of remote APIs for integration with external consumers. While Consumption CDS are created for specific consumption case providing a set consumption specific metadata, Remote API CDS are consumption and client agnostic reducing any redundant metadata.

1.7 View Extends

Extends an existing CDS view to add additional fields or logic while keeping the original definition intact.

1.8 View Extension Include

Created by key user extensibility supplier to enable this extension option for customers. To better understand this topic, I recommend exploring the Key User Extensibility documentation. Essentially, these views serve as anchors for further extensions views generated via key user apps

1.9 Derivation Function

Performs derived field calculations within the CDS view.

2 Views Without Data Access

These views do not directly access data but serve other modeling purposes:

2.1 Abstract View

Provides an abstract structure used for ABAP typing and RAP action parameter modelling.

17 CDS by Stability Contract

By stability contract:

1 C0 Extend
These entities can be extended, with specific usage contexts:

1.1 Use in Key User Apps
Extension point is designed for extensions via key user tools.

1.2 Use in Cloud Development
Extension point is suitable for extensions in cloud-based development scenarios(in ADT tool).

1.3 Both context
Can be used in both key user apps and cloud development environments.

2 C1 Use System-Internally
These entities are intended for internal system usage:

2.1 Use in Key User Apps
View is visible in objects with language version ABAP for Key Users.

2.2 Use in Cloud Development
View is visible in objects with language version ABAP for Cloud Development.

3 C2 Use as Remote API
These entities are exposed as remote APIs for external consumption.

18 CDS by Lifecycle

By lifecycle status:

1 Released
CDS views that are officially released for productive use. SAP and partner and customers shall utilize them in full grade.

2 Deprecated
CDS views that are marked for future removal. While still available, successor view is provided to substitute of deprecated one. Their usage is discouraged and all interesting actors have to adopt their code to replace with successor view.

3 Decommissioned
CDS views that are no longer available or supported. The code adoption is completed. A particular time, usually defined by product owner, for notification of customers is over. They can be removed from the system at any time.

19 CDS by Modelling Pattern

1 None
Basic CDS views without any specific modeling pattern applied.

2 Auxiliary Views
These views serve auxiliary purposes, such as supporting additional features or providing helper structures:

2.1 Data Structure: These entities are primarily used for parameter modeling in RAP actions or functions and for defining structured variable types in ABAP code. Typically, such CDS entities are not combined with other supported capabilities. Their exlusive purpose is to serve as data structures

2.2 Language Dependent:These CDS entities provide translations or language-dependent texts. They are often based on text tables or table with domain values. Typically, they are linked to text consumer entities through associations.

2.3 Value Help Provider: These CDS entities are used to supply value help for fields, such as dropdown lists or input assistance. They are typically based on database tables or existing CDS entities that contain the relevant value set. Value help providers are linked to consumer entities through associations and annotations, ensuring seamless integration with user interfaces.

2.4 Collective Value Help: It refers to a CDS entity that combines multiple value help sources into a single, unified value help. This is useful when a field requires input assistance from different datasets or when the value help is context-specific.

2.5 Derivation Function: It is a mechanism in SAP CDS views used to calculate or derive values dynamically based on specific business logic or conditions. These functions are often used to populate fields, restrict data, or enhance query results by deriving context-specific values, such as defaulting fiscal periods, calculating derived attributes, or mapping inputs to outputs. The CDS entity can be used as Derivation Function in an Consumption.derivation annotation.

6 Parent-Child Hierarchy Node Provider
Used for hierarchical data structures, enabling navigation between parent and child nodes. The CDS entity defines a parent-child hierarchy. Requests from the entity return hierarchy nodes with additional hierarchy-specific information, for example the size of the subhierarchy starting at a node. The entity can be used in hierarchy-navigation and hierarchy-aggregation functions.

7 Enterprise Search Provider
These view entities are annotated with framework-specific annotations EnterpriseSearch. The annotations define search capabilities and they also trigger the generation of a CDS-based search connector. CDS-based enterprise search provides enhanced search capabilities in SAP Fiori launchpad.

8 RAP Framework
Focused on the SAP RESTful Application Programming model:

8.1 Transactional Interface: A CDS transactional interface is a CDS projection view that is intended to serve as stable public interface for consumption. A CDS transactional interface should be classified by a release contract(don't mixed up with provider contract) and thus serve as released API. They are typically used in the context of the ABAP RESTful Application Programming Model to provide the basis for a RAP BO interface. Technically, BO interface layer consists of a CDS projection view with the provider contract transactional_interface and a Behavior Definition Interface with implementation type interface. A CDS transactional interface is defined using the CDS DDL statement DEFINE VIEW ENTITY AS PROJECTION ON and it must have its provider contract set to TRANSACTIONAL_INTERFACE. A CDS transactional interface is a CDS persistent entity.

8.2 Transactional Query: A CDS projection view that is intended for modeling transactional queries. A transactional query is typically used in the context of the ABAP RESTful Application Programming Model to adapt a CDS data model for service-specific use cases (They are substitution of Consumption views). A transactional query is defined using the CDS DDL statement DEFINE VIEW ENTITY AS PROJECTION ON and it must have the provider contract set to TRANSACTIONAL_QUERY. A CDS transactional query is a CDS persistent entity.

9 Analytical Framework
Designed for analytics and reporting:

9.1 Analytical Query: Analytical queries are views that selects data from your analytical data model, based on specific use-cases requirements. Queries can also define the initial layout that is displayed in the output, and can be used to perform various analytical evaluations and calculations. They expose defined measurement and dimensions

9.2 Analytical Cube: Data cube represents the multidimensional data model. All fields(except key fields) should be defined as dimensions or measures. The cube view is the center of a Star/Snowflake schema referencing dimension views (annotated with Analytics.dataCategory: #DIMENSION). CDS view as cube view has annotation Analytics.dataCategory: #CUBE in the header. A cube is the data source of an analytical query (analytical projection) and must contain at least one measure.

9.3 Analytical Dimension: A dimension view provides extended information for combination of dimension and measure fields in Cube like attributes, texts, hierarchies. The view is annotated with Analytics.dataCategory: #DIMENSION

9.4 Analytical Parent-Child Hierarchy Node: The CDS entity can be used as a parent-child hierarchy in analytics. It is either an analytical dimension, or connected to an analytical dimension. The rows of the entity represent nodes of the hierarchy. Currently only hierarchies defined by annotation Hierarchy.parentChild can be used in analytic models.

9.5 Analytical Document Store: These CDS entities are usually annotated with: ObjectModel.supportedCapabilities: #ANALYTICAL_DOCUMENT_STORE and ObjectModel.modellingPattern: #ANALYTICAL_DOCUMENT_STORE. Also, they have a specific data category: Analytics.dataCategory: #DOCSTORE. Moreover, these CDS entities should be linked with the parent CDS Analytics Cube via the annotation Analytics.document.storageForEntity: ['Name_of_Cube']. And last but not least, the annotation Analytics.document.serviceClassName: '<IF_RSDOC_SERVICE_VIR>' should be placed in the CDS header. A CDS-based Document Store handles Document IDs and their assignment to cells in a query result. The actual documents are handled by the application. To achieve this, the application must implement a class that implements a special interface IF_RSDOC_SERVICE_VIRT, and the name of this class must be assigned to the Document CDS view.

9.6 Analytical Fact: Facts are an optional part of an analytical data model in ABAP analytics. A fact can be used as a data source for a cube. The fact view has annotation Analytics.dataCategory: #FACT in the header

9.7 Analytical KPI:The Analytical KPI CDS is designed to represent Key Performance Indicators (KPIs) within SAP's analytical frameworks. KPIs provide measurable values that help organizations assess the performance of their processes, operations, or objectives.

10 Output Management
Enables data preparation for outputs like forms and emails:

10.1 Output Form Data Provider: Supplies data for forms.

10.2 Output Email Data Provider: Provides data for email templates.

10.3 Output Parameter Determination Data Source: Helps in determining parameters for output processes.

11 Situation Framework
Handles contextual situations and notifications:

11.1 Situation Anchor: Defines the primary anchor business object for a situation.

11.2 Situation Trigger: Specifies the events or triggers for a situation.

11.3 Situation Data Context: Provides the data context for evaluating situations.

12 External Data Provider
Integrates data from external sources into the CDS framework. I suppose that pattern is imposed exactly for CDS External Entities.

It's worth mentioning that for hierarchy modeling, we can also distinguish patterns such as hierarchy source CDS and CDS hierarchy directory. Moreover, CDS hierarchies can be modeled in a time-dependent or permanent manner.

Regarding points 10–11, they remain unfamiliar territory to me. Therefore, I would greatly appreciate it if you, dear reader, could share a detailed guide on them. Thank you in advance!

Calling SOAP Asynchronous Api In RAP ( Public Cloud )

2025-02-11T14:49:07.721000+01:00

Greetings to everyone,

I recently took part in my first public cloud project. I did a lot of research and development in this process. I would like to share with you a case that happened to me and the steps I applied in this case.

Used Api: Journal Entry - Clearing (Asynchronous)

( https://api.sap.com/api/JOURNALENTRYBULKCLEARINGREQUES/overview )

Tutorial on the use of SOAP Services:

https://developers.sap.com/tutorials/abap-environment-soap-web-services..html

Case: Journal Entry - Clearing (Asynchronous) api is called with a button behind a screen made using RAP. In this case, when we start with the approach in the tutorial link above, dump is taken on the screen caused by the modify statement in the automatically generated class.

( https://help.sap.com/docs/abap-cloud/abap-rap/rap-transactional-model-and-sap-luw )

Approach: In this case, we can run the xml of the soap service by embedding it into the body as if we call ODATA service. However, ws-a addressing and generate message id ticks must be checked in order to run Asynchronous Soap services. The aim is to make these ticks behave as if they are checked in postman and to provide the same situation in the code.

In order to run the Asynchronous SOAP service via SOAPUI, the following two ticks must be checked ( https://www.soapui.org/docs/soap-and-wsdl/supported-standards/using-ws-addressing/ )

In order for Postman to correspond to this, we need to put the ws-a addressing link that we view in the wsdl file into the header and then fill in the action and message id parts.

Action: We can get the action link on SoapUI.

WS-A: We can get the link on WSDL.

MessageID: urn:uuid:{{{$randomUUUID}}} should be used to structure that generate random uuid with every time we do a post operation.

We can embed this structure into our transform object when calling the api from our Behavior class. We can use cl_system_uuid=>create_uuid_c36_static( ) method to provide the same format as urn:uuid:{{$randomUUUID}}.

The code of the Behavior Class Method where the Asynchronous Soap API is called:

TRY.
DATA(lo_http_destination) = cl_http_destination_provider=>create_by_url( 'https://host-api.s4hana.cloud.sap/sap/bc/srt/scs_ext/sap/journalentrybulkclearingreques' ).
  CATCH cx_http_dest_provider_error INTO DATA(lo_http_dest_provider_error).
ENDTRY.

  TRY.
        DATA(lo_web_http_client) = cl_web_http_client_manager=>create_by_http_destination( lo_http_destination ) .
      CATCH  cx_web_http_client_error INTO DATA(lo_client_error).
        DATA(lv_client) = lo_client_error->get_text( ).
    ENDTRY.

    DATA(lo_web_http_request) = lo_web_http_client->get_http_request( ).
    lo_web_http_request->set_authorization_basic(  EXPORTING  i_username = Communication User
                                                              i_password = Communication User Password ).


    lo_web_http_request->set_header_fields( VALUE #( (  name = 'Content-Type' value = 'text/xml; charset=UTF-8' )
                                                     (  name = 'SOAPAction'    value = 'http://sap.com/xi/SAPSCORE/SFIN/JournalEntryBulkClearingRequest_In/JournalEntryBulkClearingRequest_InRequest' ) )   ).
TRY.
        DATA(lv_uuid) = cl_system_uuid=>create_uuid_c36_static( ).
      CATCH cx_uuid_error INTO DATA(lx_uuid).
    ENDTRY.
    lv_uuid_s = lv_uuid.


*--->fill the body


  DATA(lv_body) = xco_cp_json=>data->from_abap( ls_body )->apply( VALUE #(  ( xco_cp_json=>transformation->underscore_to_pascal_case ) ) )->to_string( ).

        TRY.
            CALL TRANSFORMATION zfi_ac_api_to
           SOURCE data = ls_body
            RESULT XML lv_body.
          CATCH cx_root INTO DATA(lo_root).
            DATA(lv_mes_tr) = lo_root->get_text( ).
        ENDTRY.


        REPLACE ALL OCCURRENCES OF 'uuid:{UUID}' IN lv_body WITH lv_uuid_s.
        REPLACE ALL OCCURRENCES OF '<?xml version="1.0" encoding="utf-16"?>' IN lv_body WITH ''.
        REPLACE ALL OCCURRENCES OF '&lt;' IN lv_body WITH '<'.
        REPLACE ALL OCCURRENCES OF '&gt;' IN lv_body WITH '>'.

        lo_web_http_request->set_text( lv_body ).
        TRY.
            DATA(lo_web_http_response) = lo_web_http_client->execute( if_web_http_client=>post ).
          CATCH cx_web_http_client_error INTO lo_client_error.
            lv_client = lo_client_error->get_text( ).
        ENDTRY.
        DATA(lv_response)      = lo_web_http_response->get_text( ).
        DATA(ls_response_stat) = lo_web_http_response->get_status( ).

The code of the Transformation Object:

<xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:sap="http://www.sap.com/sapxsl" version="1.0">
  <xsl:strip-space elements="*"/>

  <xsl:output encoding="UTF-8" indent="yes" method="xml"/>

  <xsl:template match="DATA">
    <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:sfin="http://sap.com/xi/SAPSCORE/SFIN">
      <soapenv:Header xmlns:wsa="http://www.w3.org/2005/08/addressing">
        <wsa:Action soapenv:mustUnderstand="1">http://sap.com/xi/SAPSCORE/SFIN/JournalEntryBulkClearingRequest_In/JournalEntryBulkClearingRequest_InRequest</wsa:Action>
        <wsa:MessageID soapenv:mustUnderstand="1">uuid:{UUID}</wsa:MessageID>

      </soapenv:Header>
      <soapenv:Body>
        <sfin:JournalEntryBulkClearingRequest>
          <xsl:element name="MessageHeader">
            <xsl:element name="ID">
              <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/MESSAGE_HEADER/I_D"/>
            </xsl:element>
            <xsl:element name="CreationDateTime">
              <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/MESSAGE_HEADER/CREATION_DATE_TIME"/>
            </xsl:element>
            <TestDataIndicator>
              <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/MESSAGE_HEADER/TEST_DATA_INDICATOR"/>
            </TestDataIndicator>
          </xsl:element>
          <JournalEntryClearingRequest>
            <xsl:element name="MessageHeader">
              <ID>
                <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/JOURNAL_ENTRY_CLEARING_REQUEST/MESSAGE_HEADER/I_D"/>
              </ID>
              <xsl:element name="CreationDateTime">
                <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/JOURNAL_ENTRY_CLEARING_REQUEST/MESSAGE_HEADER/CREATION_DATE_TIME"/>
              </xsl:element>
            </xsl:element>
            
            <JournalEntry>
              <CompanyCode>
                <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/JOURNAL_ENTRY_CLEARING_REQUEST/JOURNAL_ENTRY/COMPANY_CODE"/>
              </CompanyCode>
              <AccountingDocumentType>
                <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/JOURNAL_ENTRY_CLEARING_REQUEST/JOURNAL_ENTRY/ACCOUNTING_DOCUMENT_TYPE"/>
              </AccountingDocumentType>
              <DocumentDate>
                <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/JOURNAL_ENTRY_CLEARING_REQUEST/JOURNAL_ENTRY/DOCUMENT_DATE"/>
              </DocumentDate>
              <PostingDate>
                <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/JOURNAL_ENTRY_CLEARING_REQUEST/JOURNAL_ENTRY/POSTING_DATE"/>
              </PostingDate>
              <CurrencyCode>
                <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/JOURNAL_ENTRY_CLEARING_REQUEST/JOURNAL_ENTRY/CURRENCY_CODE"/>
              </CurrencyCode>
              <DocumentHeaderText>
                <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/JOURNAL_ENTRY_CLEARING_REQUEST/JOURNAL_ENTRY/DOCUMENT_HEADER_TEXT"/>
              </DocumentHeaderText>
              <CreatedByUser>
                <xsl:value-of select="JOURNAL_ENTRY_BULK_CLEARING_RE/JOURNAL_ENTRY_CLEARING_REQUEST/JOURNAL_ENTRY/CREATED_BY_USER"/>
              </CreatedByUser>
              
              <xsl:for-each select="JOURNAL_ENTRY_BULK_CLEARING_RE/JOURNAL_ENTRY_CLEARING_REQUEST/JOURNAL_ENTRY/APARITEMS/item">
                <APARItems>
                  <ReferenceDocumentItem>
                    <xsl:value-of select="REFERENCE_DOCUMENT_ITEM"/>
                  </ReferenceDocumentItem>
                  <CompanyCode>
                    <xsl:value-of select="COMPANY_CODE"/>
                  </CompanyCode>
                  <AccountType>
                    <xsl:value-of select="ACCOUNT_TYPE"/>
                  </AccountType>
                  <APARAccount>
                    <xsl:value-of select="APARACCOUNT"/>
                  </APARAccount>
                  <FiscalYear>
                    <xsl:value-of select="FISCAL_YEAR"/>
                  </FiscalYear>
                  <AccountingDocument>
                    <xsl:value-of select="ACCOUNTING_DOCUMENT"/>
                  </AccountingDocument>
                  <AccountingDocumentItem>
                    <xsl:value-of select="ACCOUNTING_DOCUMENT_ITEM"/>
                  </AccountingDocumentItem>
                  <xsl:value-of select="OTHER_DEDUCTION_AMOUNT_IN_DSP"/>
                </APARItems>

              </xsl:for-each>
            </JournalEntry>
          </JournalEntryClearingRequest>
        </sfin:JournalEntryBulkClearingRequest>
      </soapenv:Body>
    </soapenv:Envelope>
  </xsl:template>
</xsl:transform>

I hope this blog post has been helpful.

Have a great day!

SAP Community - ABAP Cloud

Dependency Inversion in ABAP : Practical Guide

SAP BTP ABAP Environment - Release 2411

SAP BTP ABAP Environment - Release 2411

ABAP Development Tools (ADT)

Reuse Services

UI Services and SAP Fiori Launchpad

Integration

Security

Custom Code Migration App

Cloud ATC

Technical Monitoring

Lifecycle Management

abapGit

Landscape Portal

ABAP Object Oriented Programming (OOP): Builder pattern Cloud Ready Version.

Builder Pattern Cloud Ready Implementation

1. Introduction.

2. Theoretical notes.

2.1. Types of the Builder pattern

2.1.1. Simple Builder:

2.1.2. Builder with Director

2.1.3. Builder with Director and Interfaces

2.2. Semantical structure of pattern

2.2.1. Factual specialization

2.2.2. Type specialization

3. Pattern Schemas.

3.1. Simple Builder

3.2. Builder with Director.

3.3. Builder With Director and Interfaces

4. Implementation Details

4.1. Simple Builders

4.2. Simple Builders Usage pattern.

4.3. Builder with Director

4.4. Builder with Director Usage pattern

4.5. Builder With Director and Interfaces

4.6. Builder With Director and Interfaces Usage pattern.

“ABAP AI is our Shared Treasure” - ABAP AI is on its way.

Best Practices for SAP BTP ABAP Environment

Best Practices: SAP BTP ABAP Environment

How to call RFC FM using Service Consumption Model in ABAP Cloud

CDS : How to define analytical query using two structures

Transforming Classic ABAP to ABAP Cloud: From Background Jobs to Application Jobs

Introduction: The Journey from Classic to Cloud

Classic ABAP: The Good, the Bad, and the Background Jobs

The Cloud Awakens: Modernising with ABAP Cloud

Real-World Example: A Customer's Case

The How-To: Step-by-Step Guide

1. Class with business logic

2. Job Catalog

3. Job Template

P.S.

Links

SAP Developer News, January 2nd, 2025

DESCRIPTION

CHAPTER TITLES

Transcription

ETag In RAP

SAP Developer News, January 16th, 2025

DESCRIPTION

CHAPTER TITLES

Transcription

Change API State of your ABAP Cloud Development Objects in Bulk Mode

Enable OData Streams in RAP

Unlock Your Future: Prove Your ABAP Cloud Readiness Today!

Customer & Partner Roundtable for SAP BTP ABAP Environment #20

👉 The call for contributions for one of the upcoming roundtables is open!

Introduction

Meeting Information

Custom Value Help Creation For a Particular Field In SAP RAP.

CREATE_DEEP_ENTITY using RAP ( Unmanaged )

Defining a Basic CDS View

From Syntax to Semantics: A Classification of Core Data Services (CDS)

Table of Contents

1 Introduction

2 Topology Layers

3 Logical Layer

4 CDS Object Tree

5 CDS and SQL

6 CDS System Function