SAP Community - ABAP RESTful Application Programming Model

Derived Events- How to Trigger Custom Event from an SAP Standard Event

2024-12-04T11:42:10.468000+01:00

In my previous blog post, we saw how one can Add Custom Context Attributes for SAP Released Event Types. From release 2308, we can go one step further and create a new custom RAP event from an SAP standard event. This event type is called Derived Event and is immensely popular among our customers.
For those who are new in the topic, please follow the blog series introduced in SAP Community ABAP Connectivity page under Enterprise Event Enablement feature content to learn how to produce and consume RAP business events and get more details in regard to it.

Under SAP Business Accelerator Hub, you can find all available Event Objects. However, only those events developed as an extendable cloud object can be maintained. To find them out, in SAP Business Accelerator Hub - On Stack Extensibility in Business Object Interface area, look your topic of interest, let us say ‘Sales Order’

Here, in General Information Section, you will find the name of the Extensible Interface BO:

Find the extensible RAP BO

For developer extensibility, you need to extend the underlying RAP BO R_SalesOrderTP to trigger a custom event when the SAP-defined event is raised.

The new custom events that are added there, will be published and thus consumable through the published interface. This is the same approach like when adding additional determinations or validations to an extensible RAP business object.

The underlying RAP BO will have typically the same name only starting with an “R_” instead of “I_” as the interface listed in the Business Accelerator Hub. So “R_SalesOrderTP” instead of “I_SalesOrderTP”.

Unfortunately the SAP Business Accelerator Hub does only show the interface I_SalesOrderTP because it focuses on Key User Extensibility so far. As mentioned above, we however need to extend the underlying R_SalesOrderTP object. To find the extensible R_-object we describe in the following several options:

To find the suitable Behavior Definition, click on ‘Browse’ option and enter search string similar to the interface name, i.e. *salesordertp*, then from the matching item, choose the Behavior Definition.

Alternatively, if you simply give the interface name in the Behavior Definition section, the system shows an error message and suggest the name of the suitable Behavior Definition.

In ADT, you can also open the ABAP Development Object and look for the SAP Object type, in our case ‘SALESORDER.’ Then in the ‘Relation Explorer’ you can find all the related objects to this object type.

Yet another alternative would be to open the interface and use CTRL+ mouse click over the interface name in the source code and navigate to the Base Behavior.

Define a Derived Event

To start with, create the Released Objects view on the repository of your system in your ADT Project as it is explained in my previous blog post.
In Project Explorer, extend your S/4 HANA cloud system, then under ‘Released Objects, EXTENDED_IN_CLOUD_DEVELOPMENT’ section, choose ‘Core Data Services, Behavior Definitions’, open the underlying RAP BO R_SalesOrderTP of the interface you found in the previous section in which the events are defined.
As you can see, this RAP BO is extensible and contains three kinds of events. Besides, the event referenced by the derived event needs to be exposed in the C0 and C1 released RAP BO interface, also the CDS view entity which serves as the data source for the payload of the derived event needs to be C1 released. More can be found SAP Help Portal, on Derived Business Events.

To extend this RAP BO, on the left-hand side, right click on the name R_SalesOrderTP and choose ‘New Behavior Extension’ option. Choose your package and give a name and description for this behavior extension.
You have to enter the name of the interface I_SALESORDERTP in the field BO Interface. The name of the Behavior definition R_SalesOrderTP will be added automatically.

Click on ‘Next’, choose your transport and click on ‘Finish’. Your behaviour extension is created. Since our extension concerns a minimal change in the payload, we do not need to do much coding like adding a class as such. So, simply replace the generated code with the following lines:

extension using interface i_salesordertp;
extend behavior for salesorder
{
managed event zzSGBEvntCreated on created parameter ZR_CUSTOMSALESORDER;
}

Our aim is to extend the SAP event ‘Created’. The keyword for defining the Derived Event is ‘managed’ as a Derived Event is a managed event. Then, we define this new event by giving a name for it. This event name must be started with either 'zz' or 'yy'. Then you need to provide a view entity as a parameter in which the Derived Event will be defined and contains the payload you want. It would be better to define this CDS view in advance, but you can add it here as well.

Technically speaking, the Derived Event is a new event, the so called ‘old’ standard event stays as it was defined originally. In another word, although we are speaking of an extension, with Derived Event we are just cloning that original event in a sense that we DO NOT change the payload of the original one, all changes are done in the new Derived Event payload. In this case, whenever an SAP event is generated, a Derived Event will be triggered automatically.

It is essential to consider that the CDS view which defines the Derived Event payload must have the same key fields as the root view in the BDEF. Besides, there should not be any associations defined in this view entity. Here, we select the fields from the I-view. However, you can technically use any view which has the same keys.

As an example, we would like to have the following fields in the payload whenever the total net amount is more than a specific number. So, we define the view as

define view entity ZR_CUSTOMSALESORDER
  as select from I_SalesOrder
{
  key SalesOrder,
      TransactionCurrency,
      @Semantics.amount.currencyCode:TransactionCurrency'
      TotalNetAmount
} where TotalNetAmount > 9999

Using where phrase, you can set a condition acting like a filter. For example, this event will be triggered whenever the Total Net Amount is equal or more than 10000. In this case, the query on the CDS view is executed and if no data is returned due to the WHERE-condition, no event is triggered. Note that in case of a deletion, there is no record left in the table and no derived event can be raised. Hence, be careful when creating derived events on deletions.

Until now, we create a new event which works like any other standard events. This means, to use this event we need to create the event binding and then configure the channel binding.

Create the Event Binding

Now we design our custom event, and we like to expose it to the consumer world. Following the standard procedure, the next step is mapping this event to the external event infrastructure by creating an event binding. This concept is already explained in Creating RAP Business Events blog post. The event binding belongs to the design time, here you define how should your event type look like i.e. with which topic name you want to expose it. Add the event binding exactly like it explains for a RAP event. After filling out the ‘General Information’ section, click on ‘Add’ option and provide with the entity name and the event name. Here, the entity name is the name of the extensible interface, and the entity event name is the name you already choose for your Derived Event.

Now save and activate the event binding. As we are finishing with the design time, we need to continue with the configuration time to be able to consume this event.

Derived Event Configuration

As a next step and similar to an standard event configuration, we need to create a channel and configure the channel binding. In the consumer system, create a communication arrangement as it explains in SAP help page on Creating Communication Arrangement. It is also discussed in creating RAP Business Events blog post.
By creating the communication arrangement, a channel will be created respectively. You can also use any existing active channel if you want. Now, we need to add the event topic to the outbound channel. This is done by the outbound configuration. After selecting your channel in ‘Maintain Event Channel Binding’ application, click on ‘create’ and find the topic which is generated during the event binding creation.

Click on ‘Create’, the topic will be added to the outbound topic bindings of the channel:

As said, whenever an standard event is triggered, a Derived Event will also be triggered accordingly. In our case, this means after creating a new sales order.

Then, open ‘Enterprise Event Enablement-Event Monitor’ application, choose your channel and check the event payload, as it can be seen, the fields we were interested in, are added to the payload:

Summary

In this blog post I explained how one can create a RAP custom event based on an SAP standard event type. This new event is raised with the corresponding SAP released event. We also see that by means of a ‘Where’ condition, we can set a limitation for triggered custom events, i.e. if the SELECT does not return any data, the derived event will not be triggered/send.

In the next post, I would like to show you how you can do source filtering of events and defining filterable properties. I will also introduce dynamic topics and explain how one can use them for routing and filtering in SAP Integration Suite, Advanced Event Mesh (AEM). So, please stay connected!

S/4 HANA Cloudification Guide for Developer: Navigating to Released APIs from Classic Objects

2024-12-05T15:57:16.495000+01:00

Introduction

This blog aims to provide a simple guide for discovering newly released APIs that replace traditional SAP objects, including tables, function modules, class objects, and more.

Whether your organization is implementing Clean Core mindset in S4/HANA On-remise or going through cloud migration(SAP RISE Private Cloud/Public Cloud), one of the first steps towards cloudification is to assess the existing custom solutions are clean core compatible.

The 3-tier extensibility model is a classification that provides rough idea of how much risk of system upgrade will disrupt your custom solution and how protected and stable it is. In the prerequisite of Tier 1, which by definition has the smallest risk of getting affected by upgrade disruption, states the enforced usage of released APIs. Using released objects is a must and a first step towards clean core way of building custom solutions in your SAP system.

The challenge with deprecated objects

Before this clean core concept or 3-tier extension model were introduced, the standard way to extend SAP ERP core is using now so-called classic extensibility, which corresponds to the 3rd-tier in the 3tier-extensibility model. Organizations operating with SAP before this new concept are most likely full of classic extensibility solution. If their system is rated with today's clean core standard, the result will probably say it's not cloud ready/compatible. Number of SAP objects used in the classic solution are now labeled as deprecated in the new standard, resulting in renovating all the custom solution that uses the deprecated objects. To adapt to the new standard, it is crucial to map the deprecated objects to the new released APIs to ensure the functionality and the performance of the custom solutions.

(This is, of course, not customer's fault as back then the solutions were probably implemented with the newest technology, insight and standard of that time.)

With this in mind, let's look at what's the easiest way to find released APIs for each classic ABAP objects.

1. Classic objects ➡️ Released objects

Database Tables

The easiest way is to use Fiori App: View Browser(F2170). Check out ➡️ Finding released CDS views for classic SAP tables for detailed steps to find released CDS views for classic SAP tables.

The second easiest way is to use SAP Cloudification Repository, which is also covered in the blog above (however not all objects are listed).

Function Modules / Class

Open the function module in question with ABAP Development Tool(ADT). Open Properties->API State and the successor object is specified.

Example below checks for function module BAPI_PO_CHANGE and class object CL_SD_DOCUMENT_FLOW_RT.

Alternatively, you can use SAP Cloudification Repository(however not all objects are listed).

Business Add-Ins (BAdIs) Definitions

Open the BAdI Definition in question with ABAP Development Tool(ADT). When opening the object, the enhancement spot that uses the BAdI Definition should open and all the BAdI Definitions will be listed. Right click on the BAdI Definition in question -> API State -> Display Use System-Internally.

Example below checks for BAdI Definition MEOUT_BAPI_CUST.

Release state is shown as well as the successor objects if you click Next.

Function Interfaces, Authorization Object, Data Types..etc.

Successor for rest of objects can be found in ADT same way as function module and class objects.

2. Exploring released APIs

In ABAP Development Tool(ADT)

ADT offers tree views to list all the objects depending on the object release status. You can also customize the tree as you see fit by adding Application Component, Packages and Software Component as an extra layer. It does not only show the released objects but also deprecated objects as well as deprecated objects with successors.

Check out ➡️ Exploring released APIs in ABAP Development Tool for step-by-step guide.

Trees that show Released Objects, Deprecated Objects and Deprecated Objects with Successors

In SAP Accelerator Hub

SAP Accelerator Hub is an alternative to find API's for those that don't have developer access and want to explore APIs from business context. It contains not just APIs for tier1/tier2 cloud development, but also out-of-box template for business processes, integration scenarios, events based solutions and everything you need for extension your SAP ERP system. Choose your product(S/4 Public/Private Edition, BTP, etc) and start exploring.

Filter the package and explore released APIs with your desired business area.

Appendix

Released APIs

APIs marked as released are indication that they are technically stable and is the only option available in tier 1 extension to communicate with SAP backend. SAP categorizes the released objects in 5 ways depending on the types and the intension of the extension. In this blog, we focus on the cloudification of SAP objects used for custom development hence will only touch on C1 Contract (Use System-Internally).

Extend (C0)
Use System-Internally (C1)
Use as Remote API (C2)
Manage Configuration Content (C3)
Use in ABAP-Managed Database Procedures (C4)

C1 Contract (Use System-Internally)

Released in C1 contracts indicate that the object is stable enough to be used in Key-User Extension(Custom fields and Custom Logic apps) and Developer Extensibility(custom solution developed solely by ABAP Development for Cloud language scope). The release state is managed separately for each usage and can be found in ABAP Development Tool.

One Tool to Track Them All

2024-12-06T15:21:19.467000+01:00

We launched our process-tracking tool, Process Observer, over a decade ago. Since then, a lot has changed. Now, our goal is Cloud First, and we want our customers to RISE to the cloud and GROW in the cloud.

SAP acquired and integrated Signavio a while ago and our biggest question was - what is the future of Process Observer in the cloud and how does it play together with SAP Signavio Process Intelligence? The answer — A new kid on the block, "BUSINESS EVENT LOGGING (BEL)."

BEL uses a much leaner and more performant approach compared to Process Observer. It also requires less configuration on your part while still giving you the freedom to enhance and integrate your processes. At the same time, it allows you to easily integrate with SAP Signavio Process Intelligence.

Fig. 1: Event Log Viewer App in Business Event Logging

Overview and Benefits

So, what is Business Event Logging?

It collects the event data locally and you can use integration to extract the data into SAP Signavio Process Intelligence.
It is based on Business Events, but it is also planned to support other sources like Change Documents.
It provides field change information.
It is available now in SAP S/4HANA CE, SAP S/4HANA OP/PC and SAP ABAP Platform Cloud.

How can BEL be useful for you?

You can activate logging of events just by selecting the relevant Object Types. You can create process views (“cases”) in SAP Signavio Process Intelligence and analyze your processes there.
You can use the data viewer apps to review logged data in multiple aspects.
You can manage the data retention in the business event log with SAP ILM.
You can extend processes or log your own processes by creating your own Business Events.

The Foundation

Business events are object-centric events created in the RAP framework. They are assigned with an event binding and are C2-released by SAP. You can find these events documented in the SAP Business Accelerator Hub, Follow the path: Explore / <your product> / Events.

Fig. 2: Business Events in the BEL Accelerator Hub

The RAP framework is an extensible framework: you can create your own objects, create events with binding, extend SAP delivered objects with your events, or just extend an SAP-delivered event.

Business events can also contain change information. For more information, you can explore event definitions in the SAP Business Accelerator Hub. This change information is now visible in the BEL log.

If you require additional standard events delivered by SAP, or change information, you can raise a request via the Customer Influence Portal. .

Beyond these Business Events, there are internal events such as RAP events, SAP-delivered C1- events, and Change Documents for other BEL data sources. We plan to support them in the future and will keep you updated.

Release support

You might be wondering when you could start using this. The great news is that if you’re in the cloud you can start right away!

SAP S/4HANA Public Cloud & SAP BTP, ABAP Environment:

For the SAP S/4HANA Cloud Public Edition 2408 or later and for SAP BTP, ABAP Environment 2411 or later, we support:

Logging of all released business events for all object types as listed in the SAP Accelerator Hub for the product.
Logging of customer events. For more information, see the instructions in the product documentation.

You can find the detailed documentation for Business Event Logging for these products here:

SAP S/4HANA Cloud Public Edition (latest): User documentation

SAP BTP, ABAP Environment (latest): User documentation

SAP S/4HANA Private Cloud & On-Premise:

The support in the SAP S/4HANA Private Cloud Edition and On-Premise Edition depends on the release.

Functionalities provided with PC/OP 2021 FPS2:

Only logging of Order-to-Cash related events provided by SAP (based on Business Event Handling).
Customer extensibility is not supported by Business Event Handling.

Functionalities provided with PC/OP 2022 FPS1:

Only logging of Order-to-Cash related events provided by SAP (based on RAP)
Customer events are supported with FPS 2 of OP 2022

Functionalities provided with PC/OP 2023 FPS2:

Logging of all Business Events provided by SAP is supported (as documented in the SAP Business Accelerator Hub).

Functionalities provided with S/4HANA Private Cloud / On Premise 2023 (latest):

You can view the list of functionalities in the User documentation.

We will cover the integration of the component and the customer extensibility in separate articles:

Using Customer-Defined Events in Business Event Logging

Building a RAP Application: From Custom Actions to Sending Emails – A Step-by-Step Guide

2024-12-08T23:37:14.397000+01:00

If you've started exploring SAP RAP, you may have noticed that classes like CL_BCS, which are typically used for sending emails in SAP, cannot be directly used in RAP. The main reason is that RAP does not allow the use of "COMMIT" which is required by these classes.

In this blog, I aim to address this limitation while also exploring how to create a custom action and build a simple RAP project.

The blog will be structured around the following key topics:

Creation of Interface and Consumption CDS Views
Creation of Metadata
Creation of the Service
Creation of Behavior
Creation of Class and Action
Email Sending Process

To ensure clarity, we will proceed with an example scenario throughout the blog. Our scenario involves listing invoices and some details from the VBAK table, and sending the selected data via email as part of the email sending process.

Creation of Interface and Consumption CDS Views

Interface CDS is used to abstract raw data into a reusable and meaningful structure, serving as the foundational data model. Consumption CDS, on the other hand, processes this data to make it user-friendly and tailored for specific use cases, such as reporting, Fiori UI, or analytical solutions.

Even though we might not need it for this project, it is generally good practice to follow this structure. Let's start by creating the Interface CDS view.

For the sake of example, I have added a few fields. You can expand it according to your scenario. Additionally, ensure that the entity is marked as "root," as this will be our top-level entity. [Figure-1]

Figure-1

During the creation of the Consumption CDS, we used the "Audat" filter to narrow down our dataset and also to leverage the Consumption logic. [Figure-2]

Figure-2

Creation of Metadata

In SAP RAP (Restful ABAP Programming Model), metadata extensions are used to enhance the metadata of existing CDS views or entities without modifying the original CDS definition. This is especially useful for tailoring application behavior or UI representations in a decoupled and non-intrusive manner.

We create metadata from our Consumption CDS.[Figure-3]

Figure-3

After creating the metadata extensions, we add annotations.[Figure-4]

Figure-4

Creation of the Service

Now, we create a service definition from our Consumption CDS.
You can follow Figures 5 and 6 for reference.

Figure-5

Figure-6

After the service is created, we must not forget to expose our Consumption CDS views.[Figure-7]

Figure-7

Now, we need to create a service binding. For this, we will use the service definition we previously created.[Figure-8]

Figure-8

Make sure to select "OData V2 - UI" as the Binding Type.
When the service is first created, it will not be published. To publish it, click the button I have highlighted.[Figure-9]

Figure-9

In the published service, you can view the entity sets and associations that you have added.[Figure-10]

Figure-10

If you want to test the service, simply double-click on the entity. This allows you to test your service easily.[Figure-11]

Figure-11

Creation of Behavior

Behavior definitions for the business object entities in a given composition model are established for the root CDS view, outlining the behavior for all included entities.

Therefore, we create Behavior definitions for both the Interface and Consumption CDS views.

Let's start with the Interface CDS.[Figure-12]

Figure-12

After creating the Behavior, we add an alias.
Since we will not perform create, update, or delete operations, we can disable these actions. [Figure-13]

The class "zbp_i_vbak_example" will be created in later steps.

Figure-13

Now, we need to create a Behavior for our Consumption CDS.[Figure-14 & 15]

Figure-14

Figure-15

We have successfully created the Behavior within the Consumption CDS. Now, we can move on to the next step.

Creation of Class and Action

To make the action we are going to create functional, we need a class.
To create the class, go to the Behavior, right-click, and select "Quick Fix".[Figure-16]

Figure-16

Here, we select "Create" to create our class.[Figure-17]

Figure-17

The class creation process is now complete.
Make sure to note that all the code we have written is under "Local Types".[Figure-18]

Figure-18

To create an action, we first need an abstract CDS. This CDS will define the input parameters for the action.
For this, we create a new Data Definition.
Here, we will define the input parameter for the email address.[Figure-19]

Figure-19

Next, we go to the Interface ZI_** named behavior and define our action. We will provide the Abstract CDS as the parameter. [Figure-20]

Figure-20

Then, by clicking the Quick Fix button, we ensure the class method for the action is defined.[Figure-21]

Figure-21

Next, we go to the ZC_*-named behavior and define the action there as well.[Figure-22]

Figure-22

Finally, to make the button visible on the screen, we go to the Metadata Extension and add the relevant line.[Figure-23]

Figure-23

: { lineItem: [ 
      { type: #FOR_ACTION, dataAction: 'SendMail', label: 'Send Mail' } ]}

Once we execute the service again, you will be able to see the button added.[Figure-24]

Figure-24

Email Sending Process

As we mentioned earlier, we cannot use classes like CL_BCS that include a "commit" in RAP for email sending. Therefore, we will use the CL_BCS_MAIL_MESSAGE class to send emails.

For this, we go to the class where we defined the Send_mail method.
The selected row and email information will be contained in the "keys" variable. We will read the table and send the email. I have not included many details in the email content, but you can add more as needed.[Figure-25]

Figure-25

 METHOD SendMail.
    DATA:lv_mail TYPE bcs_msg_sender.
    DATA(ls_keys) = VALUE #( keys[ 1 ] OPTIONAL ).
    lv_mail = ls_keys-%param-Mail.
    DATA(mail) = cl_bcs_mail_message=>create_instance( ).
    mail->set_sender( 'Sender@mail.com' ).
    mail->add_recipient( lv_mail ).


    mail->set_subject( 'Test' ).

    mail->set_main( cl_bcs_mail_textpart=>create_instance(
        iv_content      = '<h2>Hi</h2><p>Hi you can see the details of invoice number ' && ls_keys-Vbeln &&' below. </p>'
        iv_content_type = 'text/html' ) ).

    mail->send( IMPORTING et_status = DATA(lt_status) ).

  ENDMETHOD.

Now, we run a preview of the service. We select an invoice, click the Send Mail button, and enter the email address.[Figure-26]

Figure-26

To check the email, we will use the "SOST" transaction code.
As shown in the figure, the email has been successfully sent.[Figure-27]

Figure-27

I hope it has been a useful blog.
Regards.

How to Call RAP Actions with Table Types from a List Report

2024-12-24T22:09:03.542000+01:00

Introduction

In this blog, we’ll explore how to define an action in the ABAP RESTful Application Programming Model (RAP) that accepts a table-type parameter and returns a single result. Additionally, we’ll walk through how to integrate this action into a List Report.

The motivation for exploring this approach came from a requirement to generate a PDF report based on the data from multiple selected rows. While the standard actions in a List Report allow for returning a single result using "invocationGrouping": #CHANGE_SET, we, as developers, cannot easily handle such results within custom logic. This led to the idea of creating a custom action.

For this blog, we’ll demonstrate the implementation using a simpler scenario, focusing on how to realize this functionality step by step.

Scenario Overview

We will create a simple application focused on calculating inventory values for products. In a List Report, users can select one or more products from the list and trigger the action via a button. The total value will then be displayed in a popup dialog.

Development Environment

Backend: BTP ABAP Environment (trial)
Frontend: SAP Business Application Studio

Development Steps

Backend
- Table Definition
- Defining an Action to Handle Deep Parameters
- Implement Behavior Logic
Frontend
- Creating a Fiori Elements Application
- Implementing the Custom Action

Backend

1. Table Definition

Define a simple table containing product information.

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

  key client      : abap.clnt not null;
  key id          : sysuuid_x16 not null;
  product_id      : abap.char(20);
  price           : abap.int2;
  stock           : abap.int2;
  created_by      : abp_creation_user;
  created_at      : abp_creation_tstmpl;
  last_changed_by : abp_locinst_lastchange_user;
  last_changed_at : abp_locinst_lastchange_tstmpl;
}

After creating the table, generate a RAP BO and an OData service using the "Generate ABAP Repository Objects" wizard.

2. Defining an Action to Handle Deep Parameters

An action calcStockAmountDeep has been added to the auto-generated behavior definition. This action receives a deep parameter, ZA_PRODUCT_ROOT.

static action calcStockAmountDeep deep parameter ZA_PRODUCT_ROOT result [1] ZA_AMOUNT;

Initially, I was going to use the deep table parameter because my requirement was to pass a single level table entity. However, as posted in this Q&A, this statement does not seem to be supported yet, so I used the deep parameter instead.

To define an action parameter that takes a deep structure as input, the following objects will be created:

Root Abstract Entity

This entity contains a table of products. A "dummy" is defined because at least one property must be present in the root entity.

@EndUserText.label: 'Deep Parameter Root'
define root abstract entity ZA_PRODUCT_ROOT
{
    dummy: abap.char(1); 
    _product : composition [0..*] of ZA_PRODUCT_TABLE;
}

Child Abstract Entity

This entity contains the key fields of the product entity. An "isActiveEntity" field is added, because the service is draft-enabled. This is necessary if you want to handle both active entities and draft entities in the event handler.

@EndUserText.label: 'Deep Parameter for Products'
define abstract entity ZA_PRODUCT_TABLE
{
  productUuId : sysuuid_x16;
  isActiveEntity: abap_boolean;
  
  _root: association to parent ZA_PRODUCT_ROOT;
}

Abstract Behavior Definition

An abstract behavior definition is required to use the abstract entity as a deep parameter for an action.

abstract;
strict ( 2 );
with hierarchy;
define behavior for ZA_PRODUCT_ROOT alias Root
{
    association _product;
}

define behavior for ZA_PRODUCT_TABLE alias Product
{
}

3. Implement Behavior Logic

First, define the following type in the private section of the behavior handler class. This type will be used to extract the product keys from the parameters passed to the action.

    TYPES: BEGIN OF ty_key,
             id       TYPE sysuuid_x16,
             is_draft TYPE abp_behv_flag,
           END OF ty_key.

Next, implement the calcStockAmountDeep method as follows.

  METHOD calcStockAmountDeep.
    DATA amount TYPE i.
    DATA lt_productuuid TYPE STANDARD TABLE OF ty_key.

    "get product keys
    LOOP AT keys INTO DATA(key).
      LOOP AT key-%param-_product INTO DATA(product).
        APPEND VALUE #( id = product-productUuId
                        is_draft = SWITCH #( product-isActiveEntity
                                              WHEN abap_true THEN if_abap_behv=>mk-off
                                                             ELSE if_abap_behv=>mk-on ) ) TO lt_productuuid.
      ENDLOOP.
    ENDLOOP.

    READ ENTITIES OF zr_yasu_stock IN LOCAL MODE
      ENTITY Stock
      FIELDS ( Price Stock )
      WITH VALUE #( FOR data IN lt_productuuid (
          %tky = VALUE #( id = data-id
                          %is_draft = data-is_draft ) ) )
      RESULT DATA(stock_t).

    " calculate stock amount
    LOOP AT stock_t INTO DATA(stock).
      amount = amount + stock-Price * stock-Stock.
    ENDLOOP.

    " return result
    result = VALUE #( FOR key1 IN keys (
                       %cid = key1-%cid
                       %param =  VALUE #( amount = amount )
                     ) ).

  ENDMETHOD.

With the backend implementation complete, we will test the action by calling it from Postman. Before invoking the action, use a GET method to retrieve the CSRF token, and include it in the headers when making the action call. You can confirm that the total stock value is returned successfully.

Frontend

1. Creating a Fiori Elements Application

In SAP Business Application Studio, select the OData service created in the previous step and use the List Report template to create the application. Since we want to implement the logic using TypeScript, select the "Enable TypeScript" option in the "Project Attributes" during the project setup process.

2. Implementing the Custom Action

From the Page Map, add an action to the table's toolbar by selecting "Add Custom Action".

In the "New Custom Action" dialog, define the action as follows. (Although not visible in the screenshot, the Handler Method was set to getTotalDeep.)

Implement the action in ext/controller/GetTotalDeep.ts as follows.

import ExtensionAPI from 'sap/fe/core/ExtensionAPI';
import Context from 'sap/ui/model/odata/v4/Context';
import ListReportExtensionAPI from 'sap/fe/templates/ListReport/ExtensionAPI';
import ODataContextBinding from 'sap/ui/model/odata/v4/ODataContextBinding';
import MessageBox from 'sap/m/MessageBox';
import NumberFormat from 'sap/ui/core/format/NumberFormat';

interface Error {
	message: string
	error: { 
		code: string
		details: Error[] 
	}
}

interface Result {
    amount: string
}

const namespace = "com.sap.gateway.srvd.zui_yasu_stock_o4.v0001."

/**
 * Generated event handler.
 *
 *  this reference to the 'this' that the event handler is bound to.
 *  pageContext the context of the page on which the event was fired
 */
export function getTotalDeep(this: ExtensionAPI, pageContext: Context) {
    //get selected contexts
    const ListReportExtensionAPI = this as ListReportExtensionAPI;
    const contexts = ListReportExtensionAPI.getSelectedContexts();
    const products = contexts.map(context => {
        return {
            productUuId: context.getProperty("Id"),
            isActiveEntity: context.getProperty("IsActiveEntity")
        }
    })

    //invoke the action
    const model = ListReportExtensionAPI.getModel();
    const operation = model?.bindContext("/Stock/" + namespace + "calcStockAmountDeep(...)") as ODataContextBinding;
    operation.setParameter("dummy", "X");
    operation.setParameter("_product", products);
    
    const fnSuccess = () => {
        //show total
        const result = operation.getBoundContext().getObject() as Result;
        const amount = result.amount;
        const numberFormat = NumberFormat.getIntegerInstance({
            groupingEnabled: true
        });
        var formattedAmount = numberFormat.format(amount);
        MessageBox.show(`${formattedAmount} JPY`, {
            title: "Stock Amount"
        });
    }

    const fnError = (error:Error) => {
        MessageBox.error(error.message);
    }

    operation.invoke().then(fnSuccess, fnError);

}

Conclusion

In this blog, we explored how to implement a custom action in RAP that processes deep parameters and integrate it with a Fiori Elements List Report. We demonstrated the end-to-end process, from backend implementation to frontend integration.

Note that in a List Report, clicking "Select All" only selects the rows currently visible on the screen (refer to SAP Note 2428401). As a result, the approach introduced here is best suited for use cases where a few rows from the displayed data are selected, rather than scenarios involving bulk selection of large datasets.

My ABAP in Eclipse wish list for 2025 enhancements / new features

2024-12-27T22:30:05.686000+01:00

"Run in Projekt" Funktion.
- We often develop in client 100 but run / test in client 120. So it would be great if we could set a "run in client" in which Unit Tests / Run / F9 etc are executed. So connect 120 as the "run in" client to development client 100.
Allow Comments in RAP Service Definition files.
Create Methods using method chains:
- currently ZCL_Factory=>get_instance( )->createNewMethodWithWizzard() is not supported
Move multiple ABAP Classes / Objects into a new package ( currently is only one possible )
Allow method call as parameters for functions modules instead of only variables. #ABAPCore
Auto Refresh test client on debug start. We are adding new lines in client 100. Than we run test in client 120, but the code is not refreshed, we have to refresh the code in the debugger manually to see the cursor on the correct lines.
Debugger, compare two structures in a comfortable view. Example old and new data.
~~Allow method (getter) call in where clause~~ #ABAPCore
Works in 1909: select single * from wbhk where tkonn = @( item->get_tkonn( ) ) into @data(test).
Refactoring: add push-down method (additionally to pull-up method ; or is is called pull-down) - with selection of subclass.
Show CDS abapdoc comments (/**...*/) in Element View (just like abapdoc in classes) [including @link might work automatically]
Markdown in abapdoc (or other structuring features - <ul><li></li> is very cumbersome; but also headings, bold, external links, etc.)
Fix abapdoc export, improve and add other elements e.g. ddic, CDS Views ; add adt links; initial page, navigation
Method signature (shift-Enter) provide functional signature
- data(matnr) = get_matnr( vbeln = vbeln posnr = posnr ) instead of
- get_matnr( exporting vbeln = vbeln posnr = posnr returning matnr = matnr )
Add to constructor quickfix:
when clicking on an attribute of a class, have an "add to constructor", which would cause adding importing parameter and assignment of this parameter to my attribute. Something like that:
DATA: my_attribute.
METHOD constructor.
my_attribute = i_my_attribute.
ENDMETHOD. Thanks to Michał B.

looking forward for your comments.

Former post of feature Requests :

https://community.sap.com/t5/application-development-blog-posts/adt-feature-requests-after-2-years-of-use-in-project/ba-p/13375168

Switching from ALV GUI to List Report Fiori RESTful Abap Programming is now easy

2025-01-03T15:44:27.909000+01:00

List report read-only

In this topic will create a simple Fiori List Report without object page. It's recommended to use odata v4 but here we will create both v2 and v4

CDS Model

The CDS model is driven by the VDM(Virtual data model) which follow consistent modeling and naming rules.

View entity Basics/Composites

Create new data definition language in ADT(need eclipse 😀 )

DDIC view based are obsoletes, so we only use view entity.

We don't use table directly beceause it's not clean core, instead we use release CDS, you can see this if they are flagged with "#PUBLIC_LOCAL_API" or release C1 contract in API State.

Now fill your new CDS :

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'CDS basic purchase orders'
define view entity ZI_MyPurchaseOrders
  as select from I_PurchaseOrderAPI01
{
  key PurchaseOrder,
      PurchaseOrderType,
      PurchaseOrderSubtype,
      PurchasingDocumentOrigin,
      CreatedByUser,
      CreationDate,
      PurchaseOrderDate,
      CashDiscount1Percent,
      CashDiscount1Days,
      @Semantics.amount.currencyCode: 'DocumentCurrency'
      DownPaymentAmount,
      DocumentCurrency

}

Compile your CDS, and if you want you can add documentation :

Now you can fill your own documentation

And if you refresh your CDS you can open your documentation or if you press F2 on your object you can see documentation with definition

Now we will create our root view entity but you can also create other CDS levels between the two.

The root view entity is the last level before projection view. We'll go into more detail in the object section on page

You can use the code below

@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'CDS root purchase orders'
define root view entity ZR_MyPurchaseOrders
  as select from ZI_MyPurchaseOrders
{
  key PurchaseOrder,
      PurchaseOrderType,
      PurchaseOrderSubtype,
      PurchasingDocumentOrigin,
      CreatedByUser,
      CreationDate,
      PurchaseOrderDate,
      CashDiscount1Percent,
      CashDiscount1Days,
      DownPaymentAmount,
      DocumentCurrency
}

Compile

View entity Projection View

Now you need to create the top level view. Only the fields you have in this view can be displayed.

@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'CDS Projection view Purchase Orders'
define root view entity ZC_MYPURCHASEORDERS
  provider contract transactional_query
  as projection on ZR_MyPurchaseOrders
{
  key PurchaseOrder,
      PurchaseOrderType,
      PurchaseOrderSubtype,
      PurchasingDocumentOrigin,
      CreatedByUser,
      CreationDate,
      PurchaseOrderDate,
      CashDiscount1Percent,
      CashDiscount1Days,
      DownPaymentAmount,
      DocumentCurrency
}

As you're pointing to a root cds view, you need to specify the root instruction in the projection view too.

Also you need to provide a contract, for our example it's "transactional_query", you can bypass this but it's not recommended.

Compile

Metadata Extension

The metadata extension is used to arrange elements on the UI application with annotations. You can have multiple levels of metadata extension.

Add fields position in table

By default, no fields will be displayed. To achieve this, we're going to add annotations at the CDS level (where they can also be added in the frontend application).

So firstly you need to add this annotation in your projection view

@Metadata.allowExtensions: true

Then to add a field in first position you'll use this annotation

"""Metadata extension """
@UI.lineItem: [{ position: 10 },{ importance: #HIGH }]

Increment from 10 to 10 to make reworking easier if you've got a position wrong.

Add selection fields(filters) position in table

"""Metadata extension """
@UI.selectionField: [{ position: 10 }]

Add value helps

To add value helps your have two options, one with relationship with foreign key and the second with cds view

We focus only on the second option. To do this, we'll need a cds view of type value help, which we'll call up and which will return all the values in the database.

@Consumption.valueHelpDefinition: [{ entity : {name: '/DMO/I_AGENCY_STDVH', element: 'AgencyID'  } }]

Create and fill your metadata extension

Now that we have the three default annotations for a correct list report, we can get started.

Then you can choose to annotate entity or view.

Choose view for example

Now the aim is to add annotations for every field you want

@Metadata.layer: #CUSTOMER
@UI: {
    headerInfo: {
        typeName: 'Purchase Order',
        typeNamePlural: 'Purchase Orders'
    },
    presentationVariant: [{
        sortOrder: [{
            by: 'PurchaseOrder',
            direction: #DESC
        }],
        visualizations: [{
            type: #AS_LINEITEM
        }]
    }]
}
@Search.searchable: true
annotate view ZC_MYPURCHASEORDERS with
{
@UI.lineItem: [{ position: 10 },{ importance: #HIGH }]
@UI.selectionField: [{ position: 10 }]
@Search.defaultSearchElement: true
@Search.fuzzinessThreshold: 0.8
PurchaseOrder;
@UI.lineItem: [{ position: 20 },{ importance: #HIGH }]
@UI.selectionField: [{ position: 20 }]
@Search.defaultSearchElement: true
@Search.fuzzinessThreshold: 0.8
@Consumption.valueHelpDefinition: [{ entity : {name: 'I_PurchasingDocumentType', element: 'PurchasingDocumentType'  } }]
PurchaseOrderType;
@UI.lineItem: [{ position: 30 }]
@UI.selectionField: [{ position: 30 }]
@Search.defaultSearchElement: true
@Search.fuzzinessThreshold: 0.8
PurchaseOrderSubtype;
@UI.lineItem: [{ position: 40 }]
@UI.selectionField: [{ position: 40 }]
@Search.defaultSearchElement: true
@Search.fuzzinessThreshold: 0.8
PurchasingDocumentOrigin;
@UI.lineItem: [{ position: 50 }]
@UI.selectionField: [{ position: 50 }]
CreatedByUser;
@UI.lineItem: [{ position: 60 }]
@UI.selectionField: [{ position: 60 }]
CreationDate;
@UI.lineItem: [{ position: 70 }]
@UI.selectionField: [{ position: 70 }]
PurchaseOrderDate;
@UI.lineItem: [{ position: 80 }]
@UI.selectionField: [{ position: 80 }]
CashDiscount1Percent;
@UI.lineItem: [{ position: 90 }]
@UI.selectionField: [{ position: 90 }]
CashDiscount1Days;
@UI.lineItem: [{ position: 100 }]
@UI.selectionField: [{ position: 100 }]
DownPaymentAmount;
@UI.lineItem: [{ position: 110 }]
@UI.selectionField: [{ position: 110 }]
DocumentCurrency;
}

Business Services

Now we will define entities and create odata service

Service Definition

Create new Service Definition

Insert the code below

@EndUserText.label: 'Service definition for ZC_MYPURCHASEORDERS'
define service ZUI_MYPURCHORDERS {
  expose ZC_MYPURCHASEORDERS as PurchaseOrders;
}

Don't forget to alias your entities

Service Binding

Now we'll create our odata service. Here's how to create an odata v2 and v4 service.

You need to activate your service binding (ctrl+f3)

Now you have two way to activate your odata service, use the publish button BUT it's only for testing because the input will be local and cannot be put into a package, or use the t-code /IWFND/V4_ADMIN to transport it in package.

I advise you to check that there are no errors with the publish option in service binding, as you can sometimes get errors with conversion routines (which are not allowed in view entities with 3 exceptions). Once ok, you can unpublish it and then republish it with the transaction for productive use.

Now your odata V4 is ready to use.

For V2 it's the same logic but for productivity you need to activate with t-code /IWFND/MAINT_SERVICE

Access control (DCL)

If you want to add authorization objects in this application, you can add access control. For example if you want restrict purchase order type with PFCG object. Once you've created your odata service, you'll need to add the authorization objects used in access control in su24.

Make sure you have enabled authorization control on the root view

@AccessControl.authorizationCheck: #CHECK

Create DCL(Access Control) for root view entity :

Then insert the code below

@EndUserText.label: 'Access control for ZR_MYPURCHASEORDERS'
@MappingRole: true
define role ZR_MYPURCHASEORDERS {
    grant 
        select
            on
                ZR_MYPURCHASEORDERS
                    where ( PurchaseOrderType ) = aspect pfcg_auth ( M_BEST_BSA,BSART,actvt = '03' );
                        
}

And of course, if you want to use your own specific authorization object, that's also possible.

Now create another DCL(Access Control) for projection view. This DCL will only inherit the DCL of the root view.

Make sure you have enabled authorization control on the projection view

@AccessControl.authorizationCheck: #CHECK

Insert the below code

@EndUserText.label: 'Access control for ZC_MYPURCHASEORDERS'
@MappingRole: true
define role ZC_MYPURCHASEORDERS {
    grant
        select
            on
                ZC_MYPURCHASEORDERS
                    where
                        inheriting conditions from entity ZR_MyPurchaseOrders;
                        
}

Now you just need to add yours authorizations objects in your odata service with t-code SU24, and create role in PFCG and assign to you or users.

Fiori Element

Open Business Application Studio or VScode(with configured Fiori tools extension).

Launch "Fiori open application generator" with command palette(ctrl+shift+p)

Select Fiori Element List report and select your system, odata service,project name, options

Now your app is ready to test.

You'll notice that by default it has added a navigation in manifest.json to an object page that we haven't coded in the CDS views. We'll set this aside.

    },
        "PurchaseOrdersObjectPage": {
          "type": "Component",
          "id": "PurchaseOrdersObjectPage",
          "name": "sap.fe.templates.ObjectPage",
          "options": {
            "settings": {
              "editableHeaderContent": false,
              "contextPath": "/PurchaseOrders"
            }
          }
        }

Test your app with command

npm run start

You can also test your value help in purchase order type

And congrats, you've got a simple List Report application that respects the new development standards.

Of course, this display is very simplistic as we've added very few features, so feel free to dig deeper. You can also extend your application to add a custom filter or a new column. And if the design of the lists reports doesn't suit your needs you can always go for FPM and even freestyle(but no longer recommended 😀 )

Technical Catalog

If you want to deploy for an Private Cloud/On-Premise system in the Fiori Launchpad, you need to create at least a technical catalog. To do this create your catalog in t-code /UI2/FLPAM an fill your Fiori application technical data(no longer use launchpad designer please)

Next steps

The next step is to deploy your application on your SAP system. To do this, you'll need to run the deployment configuration (npm run deploy-config). Also you may need to fill in the object page and we'll look at that in a second part. And why not show how to add an action with behavior definition(BDEF).

How to implement "readonly : update" for draft instances

2025-01-09T17:40:28.603000+01:00

Introduction

Via the customer influence channel the requirement was raised to "allow to modify a field for a draft entity that is not already created in persistency table, the record only exists in draft table." when the field has been configured as readonly : update in the behavior definition.

Since this does not work out of the box, I will show how such a behavior, a field which is read-only after the first draft has been saved can be achieved in RAP using the SAP standard.

Problem description

When a field is being defined as readonly for update

  field ( readonly : update ) AgencyId;

and if this application is draft-enabled it turns out, that the field cannot be edited after having provided an intial value in the first dialogue of your application.

Solution ( implementation )

You can test this code with sample RAP business object that is being created using the following tutorial:

Build an SAP Fiori elements App Using the ABAP RESTful Application Programming Model (RAP) – Beginner [RAP100] | SAP Tutorials

The desired behavior can be achieved by using dynamic feature control. Instead of using the statement readonly : update you can use the following syntax in your behavior defintion.

 field ( features : instance ) AgencyId;

And in your behavior implementation in the get_instance_features() method you have to implement code that checks if an active instance of the travel entity is available.

If yes, the field will be made readonly. If not, and this is only the case when the object is being created as a draft but has not been persisted yet, the field will still be editable.

  METHOD get_instance_features.

    DATA result_line LIKE LINE OF result.

    " read relevant travel instance data
    READ ENTITIES OF zrap100_r_traveltp_rou IN LOCAL MODE
      ENTITY Travel
        FIELDS ( AgencyId )
        WITH CORRESPONDING #( keys )
      RESULT DATA(travels)
      FAILED failed.

    LOOP AT travels INTO DATA(travel).

      SELECT SINGLE * FROM zrap100_r_traveltp_rou
                      WHERE TravelId = -TravelId
                      INTO (travel_cds_line).

      result_line-%tky = travel-%tky.

      IF travel_cds_line IS NOT INITIAL.
        result_line-%features-%field-AgencyId =  if_abap_behv=>fc-f-read_only .
      ELSE.
        result_line-%features-%field-AgencyId = if_abap_behv=>fc-f-unrestricted.
      ENDIF.

      APPEND result_line TO result.

    ENDLOOP.
  ENDMETHOD.

Result

The app now behaves as follows:

We create a new travel instance.
1. We enter a value for the field AgencyId
2. and press the "Back" button

We can now see the newly created instance in our drafts
1. We select the editing status "Own Draft"
2. We select the newly created entity

When we now edit the entity again we see that the field AgencyId can still be edited
1. We press Create to persist the data.

The newly created item shows up and we press Edit again

Finally we can see that the field AgencyId has become readonly because an active instance exists.

New SAP Discovery Center Mission: Mastering SAP S/4HANA Extension with SAP Build

2025-01-10T12:27:25.847000+01:00

From the very beginning, SAP Build has been introduced as a unified low-code platform, enabling developers of all skill levels to create, extend, and automate business applications with drag-and-drop simplicity. Later, its capabilities were expanded with the integration of Java and JavaScript development, enhanced by AI features. And now the latest enhancements of SAP Build include ABAP development capabilities, advanced generative AI features, and deeper integration with SAP S/4HANA and other business applications.

SAP Build simplifies extension development and accelerates ERP modernization by seamlessly connecting all SAP development tools — ABAP, Java, JavaScript, and low-code — to enable effortless collaboration across diverse skill sets.

Start the new mission Mastering SAP S/4HANA Extension with SAP Build to try out the power of the Fusion Development experience provided by SAP Build.

Who is the mission made for?

No matter if you are a professional developer or a citizen developer with small development experience, this mission will guide you to the process of developing your extension application within a few hours.

What is it about?

The tutorial scenario is based on the following story:

Suzan, a medical technician at SBA Medical Clinic, noticed a small issue with one of the medical devices during her routine equipment checks. To address it quickly, she used the Service Hub Client mobile app to report the problem directly from her smartphone. The app, powered by SAP's Cloud Application Programming Model (CAP), immediately logged the incident in a central system, ensuring all service details were captured in one place.

Alex, the service manager at Health Tech Devices, received the report through the Service Hub Admin interface. He quickly reviewed the issue, prioritized it, and assigned a technician to fix the problem. Using the ABAP RESTful Application Programming model (RAP) power in background, Alex is able to assign the nearest processor of the issue, seeing all available technicians on the map within a selected range.

What will I do?

The final solution consists of several services and applications driven by SAP BTP.

You will start development by creating and deploying a CAP application using SAP Build Code. This application will be the heart of the project, processing data for equipment maintenance issues. All the steps will be done using the power of artificial intelligence provided by Joule. You will design a data model, expose it with the services, implement some custom logic and deploy to the Cloud Foundry environment, including SAP HANA artifacts.

You will then create another background service using SAP BTP ABAP environment. This will provide the data for the available incident processors. The data includes some processor information and geo-location. The main data of a processor is assumed to come from an SAP S/4HANA Cloud system (Business Partner data). For simplicity, this data is uploaded only once. In real production scenarios, there should be a more comprehensive integration. To reproduce this scenario, you don't need an access to a real SAP S/4HANA Cloud system as you will use the SAP Business Accelerator Hub Sandbox. In addition, you will create a service using the ABAP RESTful Application Programming model to search for the processors within a given distance range using the power of the SAP HANA database geo-engine.

To access the data from your front-end applications, you will create SAP BTP destinations.

When all background services are available you will use SAP Build Apps to create 2 cross-platform applications. You will use all the power of SAP Build Apps hidden behind the drag-and-drop simplicity, including advanced components, complex (but still intuitive) formulas, REST-based integration for non-standard data requests, and so on.

How can I start?

Try out the mission in SAP Discovery Center for free. The content of the mission is tested on a regular basis and will be kept up to date by integrating the latest services and features.

Even though this mission involves numerous services and applications, you can complete all the steps from start to finish using the SAP BTP Trial Account.

You are interested in more end-to-end missions? Pick up one of them from SAP Discovery Center.

We are excited to hear your feedback about this mission. Please feel free share your thoughts in the comment section below or reach out to us via Discovery Center support tool.

Enabling Multiline Editing Capabalities in RAP

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

Introduction

To enable multi-inline editing also for default root view entities, RAP offers the solution to model a technical root entity with just one instance, from which you can navigate to its object page. This singleton pattern provides a single entrance point to all master data instances.

Multi-inline-edit capabilities are always necessary if you want the end user of a UI app to be able to edit, add, and delete all instances directly on a Fiori UI list report without navigating to the object page of one instance. It is always relevant for customizing and maintaining complete table data. Multi-inline capabilities on the UI represent the same feature scope as transaction SM30 in SAP GUI.

Following Steps to enable Multiline Editing with Singleton instance

Step 1: Create Custom Table.

Step 2: Create Interface view on top of table (Child Entity)

Step 3: Create root view entity With Reference to standard view

step 4: Create Consumption view on top of root view and add Metadata.

step 5: Create Consumption view on top of child view and add Metadata.

step 6: create behavior definition on top of base root view (mapping)

make left out join from root view entity to the child table to get all the fields.

step 7: create behavior definition for root consumption view

make application as draft enable

step 8: create draft table for root table

step 9: create draft table for child table.

step 10: Create Service Definition for root consumption view

step 11: Create Service Binding

Preview application

Step 1: Create Custom Table.

@EndUserText.label : 'Emplyoyee Data' 
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE 
@AbapCatalog.tableCategory : #TRANSPARENT 
@AbapCatalog.deliveryClass : #A 
@AbapCatalog.dataMaintenance : #RESTRICTED 
define table zemp_a { 
key employee_id : abap.char(10) not null; 
first_name : abap.char(50); 
last_name : abap.char(50); 
department : abap.char(20); 
joining_date : abap.dats; 
is_active : abap.char(1); 
changed_by : abap.char(12); 
local_last_changed_at : abp_locinst_lastchange_tstmpl; 
changed_at : abp_lastchange_tstmpl;

Step 2: Create Interface view on top of table (Child Entity)

@AbapCatalog.viewEnhancementCategory: [#NONE] 
@AccessControl.authorizationCheck: #NOT_REQUIRED 
@EndUserText.label: 'Employee Interface' 
//@Metadata.ignorePropagatedAnnotations: true 
@ObjectModel.usageType:{ 
serviceQuality: #X, 
sizeCategory: #S, 
dataClass: #MIXED 
} 
define view entity ZI_EMP_AR as select from zemp_a 
association to parent ZI_SINGLETONE_AR as _Semp  
on $projection.EmpSingleton = _Semp.EmpSingleton 
{ 
@EndUserText.label : 'Employee ID' 
key employee_id as EmployeeId, 
1 as EmpSingleton, 
@EndUserText.label: 'First Name' 
first_name as FirstName, 
@EndUserText.label: 'Last Name' 
last_name as LastName, 
@EndUserText.label: 'Department' 
department as Department, 
@EndUserText.label: 'Joining Date' 
joining_date as JoiningDate, 
@EndUserText.label: 'Status' 
is_active as IsActive, 
@Semantics.user.lastChangedBy: true 
changed_by as ChangedBy, 
// ETag Field 
@Semantics.systemDateTime.localInstanceLastChangedAt: true 
local_last_changed_at as LocalLastChangedAt, 
// Total ETag Field 
@Semantics.systemDateTime.lastChangedAt: true 
changed_at as ChangedAt, 
_Semp  
}

Step 3: Create root view entity (Singleton) With Reference to standard view.

make left outer join in the root view entity to access all fields from the employee table .

@AccessControl.authorizationCheck: #NOT_REQUIRED 
@EndUserText.label: 'Employee Singletone Interface' 
@Metadata.ignorePropagatedAnnotations: true 
define root view entity ZI_SINGLETONE_AR as select from I_Language 
left outer join zemp_a as zemp on 1 = 1 // to get all the field from the table 
composition[ 0..* ] of ZI_EMP_AR as _EMP 
{ 
key 1 as EmpSingleton, 
max(zemp.changed_at) as maxChangedAt, //Done for total etag  
_EMP 
} 
where I_Language.Language = $session.system_language

step 4: Create Consumption view on top of root view.

@AccessControl.authorizationCheck: #NOT_REQUIRED 
@EndUserText.label: 'Consumption view for Singletone Employee' 
@Metadata.ignorePropagatedAnnotations: true 
@UI.headerInfo: { 
typeName: 'Manage Employee', 
typeNamePlural: 'Employee Singleton', 
title: { 
type: #STANDARD, 
value: 'EmpSingleton', 
targetElement: '_EMP' 
} } 
define root view entity ZC_SINGLETONE 
provider contract transactional_query 
as projection on ZI_SINGLETONE_AR 
{ 
@UI.facet: [{ 
purpose: #STANDARD, 
parentId: '', 
position: 10, 
label: 'Employee Multil inline Edit', 
type: #LINEITEM_REFERENCE, 
targetElement: '_EMP' 
}] 
@UI.lineItem: [{ position: 10 }] 
key EmpSingleton, 
maxChangedAt, //done for total etag field 
/* Associations */ 
_EMP : redirected to composition child ZC_EMP_AR

step 5: Create Consumption view on top of child view.

@AccessControl.authorizationCheck: #NOT_REQUIRED 
@EndUserText.label: 'Consumption view for Employees' 
//@Metadata.ignorePropagatedAnnotations: true 
@UI: { headerInfo: { 
typeName: 'Employee', 
typeNamePlural: 'Employees', 
title: { 
type: #STANDARD, 
label: 'Employee', 
value: 'EmployeeId' 
} } 
} 
define view entity ZC_EMP_AR 
as projection on ZI_EMP_AR 
{ 
@UI.facet: [{ 
type:#IDENTIFICATION_REFERENCE 
}] 
@UI:{ lineItem: [{ position: 10 }], identification: [{ position: 10 }] } 
key EmployeeId, 
// @ui:{ lineItem: [{ position: 20 }], identification: [{ position: 20 }] } 
EmpSingleton, 
@UI:{ lineItem: [{ position: 30 }], identification: [{ position: 30 }] } 
FirstName, 
@UI:{ lineItem: [{ position: 40 }], identification: [{ position: 40 }] } 
LastName, 
@UI:{ lineItem: [{ position: 50 }], identification: [{ position: 50 }] } 
Department, 
@UI:{ lineItem: [{ position: 60 }], identification: [{ position: 60 }] } 
JoiningDate, 
@UI:{ lineItem: [{ position: 70 }], identification: [{ position: 70 }] } 
IsActive, 
// @ui:{ lineItem: [{ position: 80 }], identification: [{ position: 80 }] } 
// ChangedBy, 
// LocalLastChangedAt, 
// ChangedAt, 
_Semp : redirected to parent ZC_SINGLETONE 
}

step 6: create behavior definition on top of base root view (mapping)

managed implementation in class zbp_i_singletone_ar unique; 

strict ( 2 ); 

with draft; 

 

define behavior for ZI_SINGLETONE_AR //alias <alias_name> 

with unmanaged save // when we dont want save data to table then defin with unmanaged save 

draft table ZDT_SINGLETONE 

 

//persistent table t002 

lock master 

total etag maxChangedAt 

authorization master ( instance ) 

//etag master <field_name> 

##draft_op_not_required //to hide the warnings, create uptade, delete 

{ 

// dont want modify the data for root entity 

// create; 

// update; 

// delete; 

field ( readonly ) EmpSingleton; 

association _EMP { create; with draft; } 

draft action Edit; 

draft action Activate optimized; 

draft action Discard; 

draft action Resume; 

draft determine action Prepare; 

 

} 

 

define behavior for ZI_EMP_AR //alias <alias_name> 

persistent table zemp_a 

draft table ZDT_EMP_AR 

lock dependent by _Semp 

authorization dependent by _Semp 

etag master LocalLastChangedAt 

{ 

update; 

delete; 

field ( mandatory : create, readonly :update ) EmployeeId; 

field ( readonly ) EmpSingleton, ChangedAt, ChangedBy; 

field ( mandatory ) FirstName; 

association _Semp; 

mapping for zemp_a 

{ 

EmployeeId = employee_id; 

FirstName = first_name; 

LastName = last_name; 

Department = department; 

JoiningDate = joining_date; 

IsActive = is_active; 

ChangedBy = changed_by; 

ChangedAt = changed_at; 

LocalLastChangedAt = local_last_changed_at; 

} 

}

step 07: create behavior definition for root consumption view

make application as draft enable .

rojection; 
strict ( 2 ); 
use draft;
define behavior for ZC_SINGLETONE //alias <alias_name> 

{ 
use action Edit; 

use action Activate; 
use action Discard; 
use action Prepare; 
use action Resume; 
use association _EMP { create; with draft; }
} 

define behavior for ZC_EMP_AR //alias <alias_name> 
//use etag 
{ 
use update; 
use delete; 
use association _Semp { with draft; } 
}

step 08: create draft table for root table.

@EndUserText.label : 'Draft table for entity ZI_SINGLETONE_AR' 

@AbapCatalog.enhancement.category : #EXTENSIBLE_ANY 

@AbapCatalog.tableCategory : #TRANSPARENT 

@AbapCatalog.deliveryClass : #A 

@AbapCatalog.dataMaintenance : #RESTRICTED 
define table zdt_singletone { 
key empsingleton : abap.int1 not null; 
maxchangedat : abap.dec(21,7); 

"%admin" : include sych_bdl_draft_admin_inc;

step 09: create draft table for child table.

@EndUserText.label : 'Draft table for entity ZI_EMP_AR' 

@AbapCatalog.enhancement.category : #EXTENSIBLE_ANY 

@AbapCatalog.tableCategory : #TRANSPARENT 

@AbapCatalog.deliveryClass : #A 

@AbapCatalog.dataMaintenance : #RESTRICTED 

define table zdt_emp_ar { 

key employeeid : abap.char(10) not null; 

empsingleton : abap.int1; 

firstname : abap.char(50); 

lastname : abap.char(50); 

department : abap.char(20); 

joiningdate : abap.dats; 

isactive : abap.char(1); 

changedby : abap.char(12); 

locallastchangedat : abp_locinst_lastchange_tstmpl; 

changedat : abp_lastchange_tstmpl; 

"%admin" : include sych_bdl_draft_admin_inc; 

}

step 11: Create Service Definition for root consumption view

@EndUserText.label: 'Employee Data Maintainance' 

define service ZSR_ENPLOYEE_DATA { 

expose ZC_SINGLETONE; 

expose ZC_EMP_AR; 

}

step 11: Create Service Binding

Preview application

Click Singleton Data

Click on Edit (Here you can edit multiple data and save it to the database table.)

Conclusion

Enabling multiline editing in RAP requires careful configuration of both the backend (CDS Views and Business Logic). Proper data types, UI components, and backend handling must be in place to ensure seamless interaction with multiline text fields.

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.

How to Select All Rows and Execute Custom Actions on a List Report-like Screen

2025-01-14T22:03:36.413000+01:00

Introduction

In the previous blog, we explored how to call RAP actions with table types from a List Report. While this approach works effectively for scenarios involving a few selected rows, the "Select All" functionality only selects the rows currently visible on the screen. This constraint makes it unsuitable for use cases requiring bulk selection of large datasets.

To address this limitation, this blog focuses on how to implement "Select All"-like functionality on a List Report-like screen to execute custom actions. By leveraging the Flexible Programming Model and creating a Custom Page, we can achieve bulk selection and execute actions on all rows, whether visible or not.

Implementation Approach

To achieve "Select All"-like functionality and execute actions on all rows, the following approach is used:

Retrieve Filter Conditions: Instead of selected rows, the filter conditions from the filter bar are passed to the action, allowing it to operate on all matching rows, even if they are not visible.
Customize the Filter Bar: The filter bar displays only fields relevant to the action, and the "Adapt Filter" button is hidden to prevent users from adding additional fields to the filter bar.

This application is not intended to be a generic List Report but is specifically for scenarios requiring bulk actions on all rows.

Note: This approach was implemented as part of a proof of concept (PoC) and has not been used in any productive applications.

Scenario Overview

In this blog, we will create an application similar to the one in the previous example, focusing on calculating stock values. The application allows users to specify a Plant (single value) and Location (multiple values) in the filter bar. When the "Get Total Stock Value" action is executed, the total stock value is calculated and displayed in a popup dialog.

Development Environment

Backend: BTP ABAP Environment (trial)
Frontend: SAP Business Application Studio

Development Steps

Backend
- Table Definition
- Defining an Action to Handle Deep Parameters
- Implementing Behavior Logic
Frontend
- Creating a Custom Page Application
- Adjusting Filter Fields
- Implementing the View
- Implementing the Controller

Backend

The backend implementation for this application is similar to the one described in the previous blog. As such, the explanation has been omitted here, and only the code is provided for reference.

1. Table Definition

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

  key client      : abap.clnt not null;
  key id          : sysuuid_x16 not null;
  product_id      : abap.char(20);
  plant           : abap.char(4);
  location        : abap.char(4);
  price           : abap.int2;
  stock           : abap.int2;
  created_by      : abp_creation_user;
  created_at      : abp_creation_tstmpl;
  last_changed_by : abp_locinst_lastchange_user;
  last_changed_at : abp_locinst_lastchange_tstmpl;

}

2. Defining an Action to Handle Deep Parameters

2.1. Behavior Definition

static action calcStockAmountAll deep parameter ZA_PLANT result [1] ZA_AMOUNT;

2.2. Root Abstract Entity

@EndUserText.label: 'Plant'
define root abstract entity ZA_PLANT
{
    plant : abap.char(4);
    _location : composition [0..*] of ZA_LOCATION; 
}

2.3. Child Abstract Entity

@EndUserText.label: 'Location'
define abstract entity ZA_LOCATION
{
    location : abap.char(4);
    _plant : association to parent ZA_PLANT;
    
}

2.4. Abstract Behavior Definition

abstract;
strict ( 2 );
with hierarchy;

define behavior for ZA_PLANT alias Plant
{
  association _location;
}

define behavior for ZA_LOCATION alias Location
{
}

3. Implement Behavior Logic

  METHOD calcStockAmountAll.
    DATA plant TYPE zr_yasu_stock-Plant.
    DATA r_location TYPE RANGE OF zr_yasu_stock-location.
    DATA amount TYPE i.

    "get plant and storage locations
    LOOP AT keys INTO DATA(key).
      plant = key-%param-plant.
      r_location = VALUE #( FOR loc IN key-%param-_location (
                           sign = 'I'
                           option = 'EQ'
                           low = loc-location ) ).
      EXIT. "get the first record of the keys
    ENDLOOP.

    "select from cds view (not including draft data)
    SELECT price,
           stock
      FROM zr_yasu_stock
      WHERE plant = 
      AND location IN @r_location
      INTO TABLE (stock_t).

    " calculate stock amount
    LOOP AT stock_t INTO DATA(stock).
      amount = amount + stock-Price * stock-Stock.
    ENDLOOP.

    " return result
    result = VALUE #( FOR key1 IN keys (
                       %cid = key1-%cid
                       %param =  VALUE #( amount = amount )
                     ) ).
  ENDMETHOD.

Frontend

1. Creating a Custom Page Application

In SAP Business Application Studio, select the OData service created in the previous step and use the "Custom Page" template to create the application.

Since we want to implement the logic using TypeScript, select the "Enable TypeScript" option in the "Project Attributes" during the project setup process.

The structure of the generated project is as follows:

2. Adjusting Filter Fields

Set the filter fields in the Page Map so that only Plant and Location are displayed in the filter bar.

3. Implementing the View

Implement the ext/main/Main.view.xml file as follows. Similar to the List Report, it displays a filter bar, a table, and variant management.

<mvc:View xmlns:core="sap.ui.core" xmlns:mvc="sap.ui.core.mvc" xmlns="sap.m" xmlns:macros="sap.fe.macros"
    xmlns:f="sap.f" xmlns:macrosTable="sap.fe.macros.table" xmlns:v="sap.ui.fl.variants"
    xmlns:html="http://www.w3.org/1999/xhtml" controllerName="miyasuta.selectallaction.ext.main.Main">
    <f:DynamicPage id="FilterBarDefault" class="sapUiResponsiveContentPadding">
		<f:title>
			<f:DynamicPageTitle id="_IDGenDynamicPageTitle1">
				<f:heading>
					<v:VariantManagement id="vm" for="FilterBar" showSetAsDefault="true" headerLevel="H2" />
				</f:heading>
				<f:snappedContent>
					<Text id="_IDGenText" text="{fbConditions>/filtersTextInfo}" />
				</f:snappedContent>
			</f:DynamicPageTitle>
		</f:title>
		<f:header>
			<f:DynamicPageHeader id="_IDGenDynamicPageHeader1" pinnable="true">
				<VBox id="_IDGenVBox1">
					<macros:FilterBar
						metaPath="/Stock/@com.sap.vocabularies.UI.v1.SelectionFields"
						id="FilterBar"
						filterChanged=".onFiltersChanged"
					/>
				</VBox>
			</f:DynamicPageHeader>
		</f:header>
        <f:content>
			<macros:Table metaPath="@com.sap.vocabularies.UI.v1.LineItem" readOnly="true" id="LineItemTable" filterBar="FilterBar">
                <macros:actions>
                    <macrosTable:Action id="_IDGenAction1"
                        key="getTotalStockValue"
                        text="Get Total Stock Value"
                        press=".onGetTotalStockValue"
                        requiresSelection="false"
                    />
                </macros:actions>
            </macros:Table>
		</f:content>
    </f:DynamicPage>
</mvc:View>

4. Implementing the Controller

The complete code is available here.

4.1. Hiding the "Adapt Filter" Button

To hide the "Adapt Filter" button, set the visible property of the button to false in the onBeforeRendring method. While this approach may not be officially recommended, I found it in the following Q&A:

CAP: Disable visibility of Adapt Filters button in List Page

    public  onBeforeRendering(): void {        
        //disable the adapt filter button
        const adaptFilter = this.getView()?.byId("miyasuta.selectallaction::StockMain--FilterBar-content-btnAdapt") as Button;
		adaptFilter.setVisible(false);
    }

The button's ID can be identified using tools like the UI5 Inspector.

4.2. Calling the Action

First, retrieve the selected values from the filter bar. If the required fields are not specified, return an error.
Next, set the retrieved values as parameters and call the action. Finally, display the result in a popup dialog.

    public onGetTotalStockValue(): void {
        //get filter conditions
        const { plant, locations } = this.extractFilterConditions();

        // validate required parameters
        if (!plant) {
            MessageBox.error("Select a plant in the filter");
            return;
        }

        // invoke action
        const model = this.getModel();
        const operation = model?.bindContext("/Stock/" + namespace + "calcStockAmountAll(...)") as ODataContextBinding;
        operation.setParameter("plant", plant);
        operation.setParameter("_location", locations);

        const fnSuccess = () => {
            // show total
            const result = operation.getBoundContext().getObject() as Result;
            const amount = result.amount;
            const numberFormat = NumberFormat.getIntegerInstance({
                groupingEnabled: true
            });
            const formattedAmount = numberFormat.format(amount);
            MessageBox.show(`${formattedAmount} JPY`, {
                title: "Stock Amount"
            });
        };

        const fnError = (error: Error) => {
            MessageBox.error(error.message);
        };

        operation.invoke().then(fnSuccess, fnError);
    }

This is the part of the code that extracts filter conditions from the filter bar, processes them, and returns the extracted plant and location(s).

    private extractFilterConditions(): { plant: string | undefined; locations: Location[] } {
        //get filter conditions
        const allFilters = this.getAllFilters();

        let plantRef = { plant: undefined as string | undefined };
        let locations: Array<Location> = [];

        allFilters.forEach(filter => {
            if (filter.getPath()) {
                this.processFilter(filter, plantRef, locations);
            } else {
                filter.getFilters()?.forEach(innerFilter => this.processFilter(innerFilter, plantRef, locations));
            }
        });

        return { plant: plantRef.plant, locations };
    }

    private getAllFilters(): Filter[] {
        const filterBar = this.getView()?.byId("FilterBar") as FilterBar;

        // Get the filters from the FilterBar; the structure of filters[0]
        // can either be an object (if a single filter value is set)
        // or an array (if multiple filter values are set).
        const filters = (filterBar.getFilters() as FilterObject).filters[0];

        // If filters[0] contains an array of filters, return it directly
        if (Array.isArray(filters?.getFilters())) {
            return filters.getFilters() as Filter[];

        // If filters[0] is an object, wrap it in an array and return
        } else if (filters) {
            return [filters];
        }
        // If no filters are set, return an empty array
        return [];
    }
    
    private processFilter(filter: Filter, plantRef: { plant: string | undefined }, locations: Location[]): void {
        if (filter.getPath() === "Plant") {
            plantRef.plant = filter.getValue1();
        } else if (filter.getPath() === "Location") {
            locations.push({ location: filter.getValue1() });
        }
    }

Conclusion

This blog addressed the challenge of being unable to select all rows and execute an action in a List Report. To overcome this, values specified in the filter bar were passed as parameters to the action, achieving functionality similar to "Select All."

While I considered implementing a similar approach by extending the List Report, I found it to be less feasible for two reasons: the difficulty of retrieving values from the filter bar, and the fact that using the internal controls of the filter bar itself is not appropriate. This made the approach an unsuitable solution.

The Flexible Programming Model is well-suited for creating applications with a List Report-like appearance while enabling more flexible extensions.

If you have solved a similar challenge using a different approach, I would appreciate it if you could share your solution in the comments section.

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.

Fiori Apps in Minutes using RAP framework/generator

2025-01-17T15:25:36.977000+01:00

This blog-tutorial will guide you through the process of creating a RAP application using ABAP repository objects generator.

Prerequisites:

SAP system access with eclipse installed. (You can use SAP BTP trial account as well)

Process:

Create the required database table
Right click on Package --> New --> Other ABAP Repository Object

Search for database table and click on Next

Provide name & description for the table and click on Next

Create TR or select an existing one and click on Finish

Add required fields to the table and activate it (you can also create a data element for user_id or can use any existing one)
Generate objects for UI
Right click on table name in project explorer and click on 'Generate ABAP Repository Objects'

Select OData UI Service and click on Next

Select Package and click on Next

Provide names for all the artifacts/objects to be generated and click on Next

Click on Next
Select TR and finish

You can see all the generated objects in the project explorer
Publish service
Open Service binding and click on Publish

This option to publish an OData V4 service through eclipse might not work in an on-premises system, for that I will write another blog soon.

Your basic RAP based Fiori application is ready for preview
Preview Service
Select entity set and click on Preview

As this is a managed app, so few standard features like Create, Edit & Delete are handled by system.

Try creating a new entry using Create button and the same will be visible on report page

This can be checked on table level as well

I will try to enhance this RAP application in future and include the same in my future blogs.

RAP Messages

2025-01-17T15:28:43.512000+01:00

Introduction :

In the Restful ABAP Programming Model (RAP), messages play a crucial role in validations as they provide meaningful feedback to the user regarding errors, warnings, or informational prompts. These messages help ensure data integrity and guide users during transactional or CRUD (Create, Read, Update, Delete) operations. And REPORTED and FAILURE structures are used to handle messages effectively during validations and other operations. They provide mechanisms to return meaningful feedback to the user.

The Reported structure is used to collect and return messages to the caller. These messages can be of various types, such as errors, warnings, or informational messages.

The Failure structure we have to fill what is cause of that particular failure .

There are different type of messages in rap such as state messages and transition messages

State message: As state messages are semantically related to the state of business object

It belong to particular state of business object instance.

State messages always save in database along with the particular message.

State messages are very useful the draft scenario because in the draft we are saving not only the consistent and we are saving the inconsistent data in the draft table .

Transition messages: Since transition messages are semantically related to the current request rather than the state of a business object, they are returned using the REPORTED structure of the corresponding EML statement. And transition messages will be available during the transition from one state to another state it will displayed when displayed once. if user will close it will disappear and it will not save in backend.

In transition messages it is not important to pass %TKY.

Key Components of Messages:

%TKY: it is important to pass the %TKY in state messages because it will tell this particular messages belong to this behavior

%element : it will specify from which field the error will raise. We need specify both %element and %TKY it will specify from which field and entity the error raised.

%path : in this we are specifying error will be from root entity are from child entity

%op-%create

%op-%action-action1 : this error came due to create operation or action .

By this user will get to know error will came due to create operation.

%STATE_AREA: When this component of type String is populated, the framework treats the message as a state-related message.

%other: The %OTHER to handle messages that are not related to a specific entity. The %OTHER component is populated with an instance of the message-wrapper class for unbound messages that are not tied to any business object entity.

%MSG: Contains an instance of the message-wrapper class.

Let see practical of both state and transition messages

Scenarios for messages:

State messages :

Scenario for state: When a user attempts to enter or update a subject name in the Fees details, the system should validate that this subject name exists in the exam Details. If the subject name does not exist, an error message should be displayed, preventing the operation.

Behavior definition:

Validation method code:

METHOD Check_Subject. 

READ ENTITIES OF zdp_i_cds_stu IN LOCAL MODE 
ENTITY Student 
by \_fees 
ALL FIELDS 
WITH CORRESPONDING #( keys ) 
RESULT DATA(lt_fees). 

read ENTITIES OF zdp_i_cds_stu in LOCAL MODE 
ENTITY student 
by \_exam 
from CORRESPONDING #( lt_fees ) 
link data(student_exam_subject). 

data(ls_fees) = lt_fees[ 1 ]. 

select SINGLE from zdp_dt_exam fields subject_name WHERE stuid = _fees-Stuid INTo (ls_subject). 

if ls_subject ne ls_fees-SubjectName. 
APPEND VALUE #( %tky = ls_fees-%tky ) to failed-zdp_i_fees_m. 
APPEND VALUE #( 
              %tky = ls_fees-%tky 
              %state_area = 'VALIDATE SUBJECT NAME' 
              %element-subjectname = if_abap_behv=>mk-on 
              %path = value #( Student-%tky = student_exam_subject[ key id 
                               source-%tky = ls_fees-%tky ]-target-%tky ) 
              %msg = me->new_message( 
               id = 'ZDP_MESSAGE_CLASS' 
               number = '011' 
               severity = ms-error 
               v1 = ls_fees-SubjectName 
               * v2 = 
               * v3 = 
               * v4 = 
) ) TO reported-zdp_i_fees_m. 
ENDIF. 
ENDMETHOD.

This my output screen. in that we can see three entities data will be displayed such as student, exam and fees details.

In exam details I pass the subject.

In fees details if I didn’t pass same subject name then error will raise.

Output: the system generates a message specifying the entity and field with the issue.

in this error we can see that messages is coming from fees details entity and Field name.

Transition messages : are of three type instance bound ,Entity bound ,Unbound Transition .

Instance bound : in instance bound along with the message you are passing messages belong to which instance.

Scenario for transition: In exam details If user didn't provide the marks at that time message will trigger.

Behavior definition:

Code:

METHOD marks_validation. 

READ ENTITIES OF zdp_i_cds_stu 
ENTITY Student BY \_Exam 
FIELDS ( Marks ) WITH CORRESPONDING #( keys ) 
RESULT DATA(lt_marks). 

DATA(ls_marks) = lt_marks[ 1 ]. 
DATA(lv_marks) = ls_marks-Marks. 

IF ls_marks-Marks IS INITIAL. 
APPEND VALUE #( %tky = ls_marks-%tky 
         %msg = new_message_with_text( severity = 
         if_abap_behv_message=>severity-error 
         text = 'Please Enter Marks for STUID ' && ' ' && ls_marks-Stuid ) ) TO reported-student. 
ENDIF. 
ENDMETHOD.

Output:

Entity bound :

Entity bound messages are typically displayed in global authorization and global feature control scenarios. In such cases, the instance itself is not available. Therefore, before creating the instance, we check whether the user has the required access.

Scenario: If the user's result_status is failed and is changed to pass by clicking the action button, the system will display a success message after the successful update using an entity-bound message.

Behavior definition:

Code :

METHOD change_exam_result_enabler. 

MODIFY ENTITIES OF zdp_i_cds_stu IN LOCAL MODE 
ENTITY Student 
UPDATE FIELDS ( result_status ) WITH VALUE #( FOR key IN keys ( %tky = key-%tky result_status = 'P' ) ). 
result = VALUE #( FOR key IN keys ( %tky = key-%tky 
%param = CORRESPONDING #( key ) ) ) . 

APPEND VALUE #( %msg = new_message_with_text( 
severity = if_abap_behv_message=>severity-success 
text = 'Successfully changed Result_status' ) ) 
TO reported-student. 

ENDMETHOD.

Output:

After successfully update

Conclusion:

As state messages are semantically related to the state of business object while transition messages are semantically related to the current request rather than the state of a business object. Both complement each other to enhance user experience and ensure clarity in the RAP model.

File Handling In RAP ( Unmanaged )

2025-01-17T15:28:55.820000+01:00

File uploads let you add file handling functionality to your applications inside the framework of SAP's Rapid Application Programming (RAP) methodology. This gives customers the ability to upload a variety of file formats, including photos, Excel spreadsheets, PDFs, and more.

SAP's Rapid Application Programming (RAP) architecture allows you to integrate file handling functionality into your applications through file uploads. Users can now upload a variety of file kinds, including PDFs, Excel spreadsheets, photos, and more.

OData streams are now supported by the RAP framework thanks to the most recent release of SAP BTP ABAP 2208. You may now make your RAP application capable of handling and maintaining Large Objects (LOBs).This feature enables media handling by giving end users the ability to upload external files in a variety of file formats, including PDF, XLSX, binary, and others.

In this Blog we will explore how to upload and handle Large Object such as PDF or Binary files without the need to extend the RAP application in BAS.

Large objects are modelled by means of the following fields:

Attachment

Mime type

Filename

The field Attachment contains the LOB itself in a RAWSTRING format and is technically bound to the field Mime type and Filename using semantics annotation.

Mime type represents the content type of the attachment uploaded and the values for the fields Mime type and Filename are derived from the field Attachment by the RAP framework based on the maintained CDS annotations. No attachment can exist without its mime type and vice versa.

For example, when a TEXT file is uploaded the Mime type field will be derived and populated with ‘APPLICATION/txt’.

Step 1 : Create the data element of raw string Datatype for the field that stores the file attachment in the Table.

Step 2 : Creating the Database table using below fields.

Step 3 : Create the Interface view on Above Database table.

@Semantics.mimeType: true => Use the above annotations to Handle the field as Mime Type by Internal Framework and to store the attached file which is usually large data.

@Semantics.largeObject : { mime Type: 'mime type', file Name: 'filename', content Disposition Preference: #ATTACHMENT } => In this annotations we have to pass the mime type field name and the field which stores the file name.

Step 4 : Create the Projection View on Interface View.

Step 5 : Create the meta data extension for the created consumption view.

Step 6 : create the behavior definition for Interface View and choose the Implementation type as Unmanaged. For Media handling it is mandatory to create the OData v4 and with Draft functionality.

Draft table for the persistent Table.

Step 7 : Create the Implementation class for the behavior definition for CRUD operation.

CLASS lhc_zr_sm_t_file_hand DEFINITION INHERITING FROM cl_abap_behavior_handler.
  PRIVATE SECTION.

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

    METHODS create FOR MODIFY
      IMPORTING entities FOR CREATE zr_sm_t_file_hand.

    METHODS update FOR MODIFY
      IMPORTING entities FOR UPDATE zr_sm_t_file_hand.

    METHODS delete FOR MODIFY
      IMPORTING keys FOR DELETE zr_sm_t_file_hand.

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

    METHODS lock FOR LOCK
      IMPORTING keys FOR LOCK zr_sm_t_file_hand.

ENDCLASS.

CLASS lhc_zr_sm_t_file_hand IMPLEMENTATION.

  METHOD get_instance_authorizations.
  ENDMETHOD.

  METHOD create.

    zcl_sm_unmanaged_crud=>get_instance(  )->create(
      EXPORTING
        entities = entities
      CHANGING
        mapped   = mapped
        failed   = failed
        reported = reported
    ).

  ENDMETHOD.

  METHOD update.

  zcl_sm_unmanaged_crud=>get_instance(  )->update(
    EXPORTING
      entities = entities
    CHANGING
      mapped   = mapped
      failed   = failed
      reported = reported
  ).

  ENDMETHOD.

  METHOD delete.

    CALL METHOD zcl_sm_unmanaged_crud=>get_instance(  )->delete(
      EXPORTING
        keys     = keys
      CHANGING
        mapped   = mapped
        failed   = failed
        reported = reported
    ).

  ENDMETHOD.

  METHOD read.

    zcl_sm_unmanaged_crud=>get_instance(  )->read(
      EXPORTING
        keys     = keys
      CHANGING
        result   = result
        failed   = failed
        reported = reported
    ).

  ENDMETHOD.

  METHOD lock.
  ENDMETHOD.

ENDCLASS.

CLASS lsc_ZR_SM_T_FILE_HAND DEFINITION INHERITING FROM cl_abap_behavior_saver.
  PROTECTED SECTION.

    METHODS finalize REDEFINITION.

    METHODS check_before_save REDEFINITION.

    METHODS save REDEFINITION.

    METHODS cleanup REDEFINITION.

    METHODS cleanup_finalize REDEFINITION.

ENDCLASS.

CLASS lsc_ZR_SM_T_FILE_HAND IMPLEMENTATION.

  METHOD finalize.
  ENDMETHOD.

  METHOD check_before_save.
  ENDMETHOD.

  METHOD save.

    zcl_sm_unmanaged_crud=>get_instance(  )->save_data(
      CHANGING
        reported = reported
    ).

  ENDMETHOD.

  METHOD cleanup.
  ENDMETHOD.

  METHOD cleanup_finalize.
  ENDMETHOD.

ENDCLASS.

Step 8 : Create the API class for the Implementation class.

CLASS zcl_sm_unmanaged_crud DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    TYPES: tt_std_create     TYPE TABLE FOR CREATE zr_sm_t_file_hand,
           tt_std_update     TYPE TABLE FOR UPDATE zr_sm_t_file_hand,
           tt_mapped_early   TYPE RESPONSE FOR MAPPED EARLY zr_sm_t_file_hand,
           tt_failed_early   TYPE RESPONSE FOR FAILED EARLY zr_sm_t_file_hand,
           tt_reported_early TYPE RESPONSE FOR REPORTED EARLY zr_sm_t_file_hand,
           tt_mapped_late    TYPE RESPONSE FOR MAPPED LATE zr_sm_t_file_hand,
           tt_reported_late  TYPE RESPONSE FOR REPORTED LATE zr_sm_t_file_hand,
           tt_keys_read      TYPE TABLE FOR READ IMPORT zr_sm_t_file_hand,
           tt_keys_delete    TYPE TABLE FOR DELETE zr_sm_t_file_hand,
           tt_read_result    TYPE TABLE FOR READ RESULT zr_sm_t_file_hand.

    CLASS-METHODS get_instance RETURNING VALUE(ret_student) TYPE REF TO zcl_sm_unmanaged_crud.

    METHODS: create IMPORTING entities TYPE tt_std_create
                    CHANGING  mapped   TYPE tt_mapped_early
                              failed   TYPE tt_failed_early
                              reported TYPE tt_reported_early,

             read IMPORTING keys     TYPE tt_keys_read
                  CHANGING  result   TYPE tt_read_result
                            failed   TYPE tt_failed_early
                            reported TYPE tt_reported_early,

             update IMPORTING entities TYPE tt_std_update
                    CHANGING  mapped   TYPE tt_mapped_early
                              failed   TYPE tt_failed_early
                              reported TYPE tt_reported_early,

             delete IMPORTING keys     TYPE tt_keys_delete
                    CHANGING  mapped   TYPE tt_mapped_early
                              failed   TYPE tt_failed_early
                              reported TYPE tt_reported_early,

             save_data CHANGING reported TYPE tt_reported_late.

  PROTECTED SECTION.
  PRIVATE SECTION.
    CLASS-DATA: go_instance TYPE REF TO zcl_sm_unmanaged_crud,
                gt_create   TYPE TABLE OF zsm_t_file_hand,
                gt_update   TYPE TABLE OF zsm_t_file_hand,
                gr_delete   TYPE RANGE OF zr_sm_t_file_hand-DocumentId,
                gs_file     TYPE zsm_t_file_hand.
ENDCLASS.



CLASS zcl_sm_unmanaged_crud IMPLEMENTATION.

  METHOD get_instance.

    ret_student = COND #( WHEN go_instance IS BOUND THEN go_instance
                          ELSE NEW #(  ) ).

  ENDMETHOD.

  METHOD create.

    gt_create = CORRESPONDING #( entities MAPPING FROM ENTITY ).

    LOOP AT entities ASSIGNING FIELD-SYMBOL(<lfs_entities>).

      IF gt_create IS NOT INITIAL.

        gt_create[ 1 ]-client = sy-mandt.
        gt_create[ 1 ]-last_changed_by = sy-uname.
        GET TIME STAMP FIELD DATA(lv_timestamp).
        gt_create[ 1 ]-last_changed_at = lv_timestamp.

        mapped-zr_sm_t_file_hand = VALUE #( ( %cid = <lfs_entities>-%cid
                                              %key = <lfs_entities>-%key
                                              %is_draft = <lfs_entities>-%is_draft ) ).
      ENDIF.


    ENDLOOP.
  ENDMETHOD.

  METHOD save_data.

    IF gt_create IS NOT INITIAL.

      INSERT zsm_t_file_hand FROM TABLE _create.
      CLEAR gt_create[].

    ELSEIF gt_update IS NOT INITIAL.

      UPDATE zsm_t_file_hand FROM TABLE _update.
      CLEAR gt_update[].

    ELSEIF gr_delete IS NOT INITIAL.

      DELETE FROM zsm_t_file_hand WHERE document_id IN _delete.
      CLEAR gr_delete[].

    ENDIF.

  ENDMETHOD.

  METHOD update.

    DATA : lt_update_x TYPE STANDARD TABLE OF zsm_ts_boolean,
           lt_update   TYPE STANDARD TABLE OF zsm_t_file_hand.

    lt_update = CORRESPONDING #( entities MAPPING FROM ENTITY ).
    lt_update_x = CORRESPONDING #( entities MAPPING FROM ENTITY USING CONTROL ).

    IF lt_update IS NOT INITIAL.
*
      SELECT * FROM zsm_t_file_hand FOR ALL ENTRIES IN _update
      WHERE document_id = _update-document_id
      INTO TABLE (lt_result_old).

    ENDIF.
    GET TIME STAMP FIELD DATA(lv_timestamp).
    gt_update = VALUE #(

                 FOR x = 1 WHILE x LE lines( lt_update )

                 LET ls_control_flag = VALUE #( lt_update_x[ x ] OPTIONAL )
                     ls_new   = VALUE #( lt_update[ x ] OPTIONAL )
                     ls_old   = VALUE #( lt_result_old[ document_id = ls_new-document_id ] OPTIONAL )

                 IN
                 (
                    client     = sy-mandt
                    document_id = COND #( WHEN ls_control_flag-document_id IS INITIAL
                                          THEN ls_old-document_id )
                    filename = COND #( WHEN ls_control_flag-filename IS NOT INITIAL
                                      THEN ls_new-filename ELSE ls_old-filename )
                   attachment = COND #( WHEN ls_control_flag-attachment IS NOT INITIAL
                                      THEN ls_new-attachment ELSE ls_old-attachment )
                   mimetype = COND #( WHEN ls_control_flag-mimetype IS NOT INITIAL
                                      THEN ls_new-mimetype ELSE ls_old-mimetype )
                   created_at = COND #( WHEN ls_control_flag-created_at IS INITIAL
                                      THEN ls_old-created_at )
                   created_by = COND #( WHEN ls_control_flag-created_by IS INITIAL
                                      THEN ls_old-created_by )
                   last_changed_at = COND #( WHEN ls_control_flag-last_changed_at IS INITIAL
                                      THEN lv_timestamp )
                   last_changed_by = COND #( WHEN ls_control_flag-last_changed_by IS INITIAL
                                      THEN sy-uname )

                  ) ).


  ENDMETHOD.

  METHOD read.

    SELECT * FROM zsm_t_file_hand FOR ALL ENTRIES IN 
    WHERE document_id = -DocumentId
    INTO TABLE (lt_result).

    result = CORRESPONDING #( lt_result MAPPING TO ENTITY ).

  ENDMETHOD.

  METHOD delete.

     DATA: lt_delete TYPE STANDARD TABLE OF zsm_t_file_hand.

           lt_delete = CORRESPONDING #( keys MAPPING FROM ENTITY ).

           gr_delete = VALUE #(

                             FOR ls_delete IN lt_delete
                             sign = 'I' option = 'EQ' ( low = ls_delete-document_id )
                              ).

  ENDMETHOD.

ENDCLASS.

Step 7 : create the behavior definition for the Projection View.

Step 8 : Create the Service definition for the consumption view.

Step 9 : Create the Service Binding for Created Service definition and Choose the Binding type as OData V4 ,activate and publish the service.

Preview the Application and click on create to upload the file.

Click on upload icon near to the attachment field, select the file, file name will be auto filled and fill the Mime type manually.

CDS view - real world analogy

2025-01-17T22:35:58.201000+01:00

To better understand and remember the complex things I always use some real world analogy. In this blog I will provide you my real world analogy for CDS Views.

Definition of ABAP Core Data Services that I found here says that CDS is an infrastructure for defining and consuming semantically rich data models in ABAP. Did you understand something? I am not 😐

From the definition we can extract the main parts:

infrastructure
for defining and consuming
semantically rich data models

🔬 let's look closer

1. CDS is some infrastructure. OK, but we are don't know yet what exact is infrastructure about.

2. This infrastructure is for defining and consuming some data? This is make sense! In the SAP world it's all about the data, right? And CDS helps us to defining and consuming data? But we already can do it with normal tables and table views... Until now it is not clear why we need some extra tool for this.

3. Defining and consuming semantically rich data models. Ah maybe this make sense! CDS help us to work with semantically rich data models. But wait... What does hack mean semantically rich data models? I found such example of semantic definition:

Semantics is the study of meaning in language. It can be applied to entire texts or to single words. For example, "destination" and "last stop" technically mean the same thing, but students of semantics analyze their subtle shades of meaning.

OK, so semantic its a meaning of something. And what about data model?

A data model is an abstract model that organizes elements of data and standardizes how they relate to one another and to the properties of real-world entities. For instance, a data model may specify that the data element representing a car be composed of a number of other elements which, in turn, represent the color and size of the car and define its owner.

Hmm... how can the car data model be semantically rich? To understand this, let’s create an analogy that relates it to the real world.

Real-World Analogy: Car Registration Office 🏢 🚗

A CDS view can be compared to a car registration office that organizes, retrieves, and presents vehicle data for various purposes, such as issuing registration certificates or generating reports. Here's how the analogy works:

Step 1: A Basic Data Model

Raw data about cars and owners is stored in separate database tables. For example cars table might look like this:

Car_ID	Brand	Model	Size	Manufacture_Year	Owner_ID
C001	BMW	X5	Large	2018	O001
C002	Tesla	Model 3	Medium	2022	O002

and owners table might look like this:

Owner_ID	First_Name	Last_Name	Email
O001	Bob	Marlie	bob.marlie@sap.com
O002	James	Bond	james.bond@sap.com

While this tables is useful, it lacks context or relationships between the data. For example:

What does "Size" really mean? Is it a physical dimension or a category (e.g., SUV vs. sedan)?
Who is "Owner"?

This tables is not semantically rich because it doesn’t provide additional meaning or relationships between data elements.

Step 2: Adding Semantic Layers

Using CDS views, we enrich the car data model by:

Adding Descriptive Metadata
- Define "Size" as an enumeration (e.g., small, medium, large) with clear business rules.
- Specify relationships, such as the "Owner" being a reference to the Owners table.
Creating Relationships
- Link the car to additional entities, such as "Owner".
Using Calculated Fields
- Create a derived field, such as Car_Age (based on the car's manufacturing year).

Here’s an enriched view of the same table with CDS:

If you query this CDS view, you’d get:

Car_ID	Manufacturer	Model	Manufacturing_Year	Size_Text	Owner_Name	CarAge
C001	BMW	X5	2018	SUV	Bob	7
C002	Tesla	Model 3	2022	Sedan	James	3

Now when someone (e.g., a car owner, law enforcement officer, or auditor) requests specific information, the staff:

Combines relevant data from multiple files (tables).
Presents only the necessary information in an organized format (view).

How CDS Makes it Easier

CDS views allow you to:

Model these semantic layers once and use them consistently across your ABAP applications.
Make your data reusable with associations (instead of static joins).
Ensure all consumers (apps, reports, services) interpret the data in the same meaningful way.

Aha now its more clear! CDS allow us to add more information about the data to allow us to use this information for search or analyze the data more efficient.

The real world analogy could be a projector (CDS projector 😀) which shines through the database tables and extends/joined/aggregate the data on the projection.

CDS projectorIn the CDS view we can see now the semantic, related to the car size. Large become SUV, owner ID become the person name and CDS also calculate the car age based on the manufacturing year. All this additional data we can use to easily search, filter, and analyze. Nice, is it?

Now let see how it was made with CDS view that adds semantic meaning to the raw data.

@AbapCatalog.sqlViewName: 'ZCDS_CAR_INFO'
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Car Information with Semantics'
define view ZCDS_CarInfo
  as select from Cars
    inner join Owners on Cars.Owner_ID = Owners.Owner_ID
{
  key Cars.Car_ID as CarID,
  Cars.Manufacturer,
  Cars.Model,
  Cars.Manufacturing_Year as ManufacturingYear,
  @ObjectModel.text.element: ['Size_Text']
  Cars.Size,
  case Cars.Size
    when 'Small' then 'Hatchback'
    when 'Medium' then 'Sedan'
    when 'Large' then 'SUV'
    else 'Unknown'
  end as Size_Text,
  Owners.Name as OwnerName,
  cast( year( current_date ) - Cars.Manufacturing_Year as INT ) as CarAge,
}

Now this CDS view can be used across multiple apps, reports, and services. Users and developers can work with meaningful data without worrying about low-level table structures. All consumers interpret data the same way (do you remember Large means SUV).

Thats all from my side about basic understanding of CDS view and the purpose of them. Leave the comment if it was useful for you or not. I will appreciate it 👍

Thank you and enjoy your work!

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

Publishing ODATA v4 service in a customizing client

2025-01-21T19:02:11.234000+01:00

This blog-tutorial will guide you through the process of publishing OData v4 service in a customizing client.

Problem:

Publishing local service endpoint of service binding 'XXXXX' has encountered a problem

This problem usually occurs if you are working in a customizing client and the settings for the client in section "Changes and transports for client specific objects" are set to one of the options

"Automatic recording of changes" or
"No changes allowed"

This can be checked using SCC4 transaction

This blog mainly focuses on publishing v4 service created based on RAP BO using ADT (eclipse) but can also be referred for publishing any v4 service.

Solution:

Activate the service binding post RAP BO creation using ADT (this will create a service group)

Go to /N/IWFND/V4_ADMIN

Click on 'Publish Service Groups'

Select system alias and click on 'Get Service Groups'

Select the group ID corresponding to the OData service and click on 'Publish Service Groups

Update description and click on continue

Select a customizing request or create a new one and continue

Service group has been published

Once published, service group will be visible under service groups on v4 admin

Now, go back to eclipse and refresh (F5) the service binding. Voila! Now, the service has been published, and the entity set and service URL will be visible

Thanks for going through the blog and now you will be able to publish any v4 service. 😀

RAP Draft Actions

2025-01-21T19:39:15.365000+01:00

Draft actions in the ABAP RESTful Application Programming (RAP) model are used to handle temporary versions of business objects before they are saved as active versions.

Here are some key points about draft actions in RAP:
Draft Actions: These include Edit, Activate, Discard, and Resume. They allow data manipulation on the RAP draft table.
Behavior Definition: Draft actions must be specified in the behavior definition of the business object. This ensures that the draft handling is enabled.
Implementation: While RAP provides default implementations for these actions, you can customize them as needed. For example, you might want to control which fields can be edited or how data is validated

Draft Action Edit
The draft action EDIT copies an active instance to the draft database table. Feature and authorization control is available for the EDIT, which you can optionally define to restrict the usage of the action.

Draft Action Activate
The draft action ACTIVATE is the inverse action to EDIT. It invokes the PREPARE and a modify call containing all the changes for the active instance in case of an edit-draft, or a CREATE in case of a new-draft. Once the active instance is successfully created, the draft instance is discarded.

In contrast to the draft action Edit, the Activate does not allow feature or authorization control. Authorization is not available as the Activate only transfers the state of the draft buffer to the active buffer. Authorization is controlled when the active instance is saved to the database.

The draft action activate is also available in an optimized variant which can improve the performance compared to the variant without optimization.

Draft Action Discard
The draft action DISCARD deletes the draft instance from the draft database table. No feature or authorization control can be implemented.

Draft Determine Action Prepare
The draft determine action PREPARE executes the determinations and validations that are specified for it in the behavior definition. The PREPARE enables validating draft data before the transition to active data.

In the behavior definition, you must specify which determinations and validations are called during the prepare action. Only determinations and validations that are defined and implemented for the BO can be used.

Note
For performance reasons, determinations and validations are not executed during the draft determine action Prepare, if these determinations and validations have already been executed during a previous determine action that has been executed on the instance in the same transaction.

This performance optimization is not applied in the following cases:

A modification performed after the first determine action triggers a determination/validation.

A validation in the first determine action reports a failed key.

A determination/validation has been assigned using the addition always.

In order to ensure data consistency, make sure that your determinations and validations follow the respective modelling guidelines described in Determination and Validation Modelling.

Draft Action Resume
The draft action RESUME is executed when a user continues to work on a draft instance whose exclusive lock for the active data has already expired. It recreates the lock for the corresponding instance on the active database table. On a Fiori Elements UI, it is invoked when reopening and changing a draft instance whose exclusive lock is expired.

In case of a new draft, the same feature and authorization control is executed as defined for a CREATE. In case of an edit-draft, the same feature and authorization control is executed like in an Edit.

It is sequence of triggering when edit is done in Draft.

In the Behavior define the draft actions

managed implementation in class ZBP_R_NP_DT_PARTNER unique;
strict ( 2 );
with draft;
define behavior for ZR_NP_DT_PARTNER alias ZrNpDtPartner
persistent table znp_dt_partner
draft table znp_dt_partner_d
etag master LastChangedAt
lock master total etag LastChangedAt
authorization master ( global )

{
  field ( mandatory : create )
  Partner;

  field ( readonly )
  CreatedBy,
  CreatedAt,
  LastChangedBy,
  LastChangedAt;

  field ( readonly : update )
  Partner;


  create;
  update;
  delete;

  validation city on save { field City; create; }
  validation currency on save { field PaymentCurrency; create; update; }
  draft action Activate optimized with additional implementation;
  draft action Discard with additional implementation;
  draft action Edit with additional implementation;
  draft action Resume with additional implementation;
  draft determine action Prepare
  {
    validation City;
    validation currency;
  }

  mapping for znp_dt_partner
    {
      Partner         = partner;
      Name            = name;
      Street          = street;
      City            = city;
      Country         = country;
      PaymentCurrency = payment_currency;
      CreatedBy       = created_by;
      CreatedAt       = created_at;
      LastChangedBy   = last_changed_by;
      LastChangedAt   = last_changed_at;
    }
}

Projection view Behavior Definition.

projection implementation in class ZBP_C_NP_DT_PARTNER unique;
strict ( 2 );
use draft;
define behavior for ZC_NP_DT_PARTNER alias ZcNpDtPartner
use etag

{
  use create;
  use update;
  use delete;

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

In the draft table the field value will be null hence it is not valid.

If we provide the value and save it will be updated to active instance and that record will be discard from the draft.

Once we add the valid value it will saved to active instance and removed from Draft.

Database table.

Draft table.