SAP Community - ABAP RESTful Application Programming Model

How to search in the new SAP community for the latest content related to an SAP managed tag?

2024-03-13T17:46:57.400000+01:00

The workaround is very simple. I am basically searching for the SAP managed tag as a string by surrounding the tag in question by double quotes, for example:
"ABAP RESTful Application Programming Model".

In addition I choose a sortorder by Date so that the newest posts will show up first.

So the following link will produce a list of the latest posts that have used the SAP managed tag "ABAP RESTful Application Programming Model".

It is also possible to store such a search as an RSS Feed.

https://community.sap.com/t5/forums/searchpage/tab/message?q=%22ABAP%20RESTful%20Application%20Programming%20Model%22&noSynonym=false&sort_by=-topicPostDate&collapse_discussion=true

How to add a new entity to the RAP BO of a customizing table

2024-03-15T14:18:55.104000+01:00

Introduction

You have created a RAP BO based on one or more customizing tables by using the BC Maintenance Object ADT Wizard as described in this tutorial.

You want to extend the RAP BO by adding an additional customizing table to the data model.

The business configuration maintenance object supports RAP BO whose height of the composition tree is less than or equal to 2. For example, root entity A has two child entities B and C. Entity C has a child entity D. D cannot have any further child entities.
Depending on the back-end version, while the ADT wizard can handle multiple tables at the same time, the most complex supported scenarios require a manual enhancement after generation.

This blog is relevant for:

Example RAP BO

You have used the following table ZCB_HEAD with the ADT wizard to generate a maintenance object:

@EndUserText.label : 'Header'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #C
@AbapCatalog.dataMaintenance : #ALLOWED
define table zcb_head {
  key client            : abap.clnt not null;
  key head_key          : zcb_id not null;
  head_content          : abap.char(30);
  last_changed_at       : abp_lastchange_tstmpl;
  local_last_changed_at : abp_locinst_lastchange_tstmpl;
}

The table ZCB_ITEM that you want to add has the following structure and is a child entity of table ZCB_HEAD:

@EndUserText.label : 'Item'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #C
@AbapCatalog.dataMaintenance : #ALLOWED
define table zcb_item {
  key client            : abap.clnt not null;
  @AbapCatalog.foreignKey.keyType : #KEY
  @AbapCatalog.foreignKey.screenCheck : false
  key head_key          : zcb_id not null
    with foreign key zcb_head
      where client = zcb_item.client
        and head_key = zcb_item.head_key;
  key item_key          : abap.numc(3) not null;
  item_content          : abap.char(30);
  local_last_changed_at : abp_locinst_lastchange_tstmpl;
}

Data model & behavior

CDS View

Create a CDS view for table ZCB_ITEM with

an association to parent table ZCB_HEAD
an association to the singleton entity based on a calculated field SingletonID
if you do not have a projection layer, add the annotation @Metadata.allowExtensions: true

@EndUserText.label: 'Header'
@AccessControl.authorizationCheck: #CHECK
@Metadata.allowExtensions: true
define view entity ZI_Item
  as select from zcb_item
  association        to parent ZI_Header as _Header    on $projection.HeadKey = _Header.HeadKey
  association [1..1] to ZI_Header_S      as _HeaderAll on $projection.SingletonID = _HeaderAll.SingletonID
{
  key head_key              as HeadKey,
  key item_key              as ItemKey,
      item_content          as ItemContent,
      @Semantics.systemDateTime.localInstanceLastChangedAt: true
      @Consumption.hidden: true
      local_last_changed_at as LocalLastChangedAt,
      @Consumption.hidden: true
      1                     as SingletonID,
      _Header,
      _HeaderAll
}

Add a composition to ZI_Item in the CDS View of table ZCB_HEAD:

@EndUserText.label: 'Header'
@AccessControl.authorizationCheck: #CHECK
define view entity ZI_Header
  as select from zcb_head
  association to parent ZI_Header_S as _HeaderAll on $projection.SingletonID = _HeaderAll.SingletonID
  composition [0..*] of ZI_Item     as _Item
{
  key head_key              as HeadKey,
      head_content          as HeadContent,
      @Semantics.systemDateTime.lastChangedAt: true
      last_changed_at       as LastChangedAt,
      @Semantics.systemDateTime.localInstanceLastChangedAt: true
      @Consumption.hidden: true
      local_last_changed_at as LocalLastChangedAt,
      @Consumption.hidden: true
      1                     as SingletonID,
      _HeaderAll,
      _Item
}

If you have a projection layer, create a projection CDS view for ZI_Item with redirection to entity ZC_Header and the singleton entity. Save and activate.

@AccessControl.authorizationCheck: #CHECK
@Metadata.allowExtensions: true
@EndUserText.label: 'Maintain Item'
define view entity ZC_Item as projection on ZI_Item
{
  key HeadKey,
  key ItemKey,
  ItemContent,
  @Consumption.hidden: true
  LocalLastChangedAt,
  @Consumption.hidden: true
  SingletonID,
  _Header : redirected to parent ZC_Header,
  _HeaderAll : redirected to ZC_Header_S
}

If you have a projection layer, add a redirection to composition child ZI_Item in the projection CDS view of ZI_Header:

@EndUserText.label: 'Maintain Header'
@AccessControl.authorizationCheck: #CHECK
@Metadata.allowExtensions: true
define view entity ZC_Header
  as projection on ZI_Header
{
  key HeadKey,
      HeadContent,
      LastChangedAt,
      @Consumption.hidden: true
      LocalLastChangedAt,
      @Consumption.hidden: true
      SingletonID,
      _HeaderAll : redirected to parent ZC_Header_S,
      _Item      : redirected to composition child ZC_Item
}

Behavior definition

In the behavior definition ZI_HEADER_S, add the following definition for entity ZI_Item:

define behavior for ZI_Item alias Item
persistent table ZCB_ITEM
draft table ZCB_ITEM_D
etag master LocalLastChangedAt
lock dependent by _HeaderAll
authorization dependent by _HeaderAll

{
  field ( mandatory : create )
   ItemKey;

  field ( readonly )
   SingletonID,
   HeadKey,
   LocalLastChangedAt;

  field ( readonly : update )
   ItemKey;

  field ( notrigger )
   SingletonID,
   LocalLastChangedAt;


  update( features : global );
  delete( features : global );

  mapping for ZCB_ITEM
  {
    HeadKey = HEAD_KEY;
    ItemKey = ITEM_KEY;
    ItemContent = ITEM_CONTENT;
    LocalLastChangedAt = LOCAL_LAST_CHANGED_AT;
  }

  association _HeaderAll { with draft; }
  association _Header { with draft; }

  validation ValidateTransportRequest on save ##NOT_ASSIGNED_TO_DETACT { create; update; delete; }
}

In the entity definition of ZI_Header, add an association to ZI_Item:

association _Item { create ( features : global ); with draft; }

Save the behavior definition. Place the cursor on the draft table ZCB_ITEM_D and use the quick assist (Ctrl+1) to generate the draft table. After activating the draft table, activate the behavior definition.
Place the cursor on ZI_Item underlined by a warning message and use the quick assist to generate the missing method implementations.

If you have a projection layer, adjust the behavior projection:

projection;
strict;
use draft;

define behavior for ZC_Header_S alias HeaderAll

{
  use action Edit;
  use action Activate;
  use action Discard;
  use action Resume;
  use action Prepare;
  use action SelectCustomizingTransptReq;

  use association _Header { create; with draft; }
}

define behavior for ZC_Header alias Header

{
  use update;
  use delete;

  use association _HeaderAll { with draft; }
  use association _Item { create; with draft; }
}

define behavior for ZC_Item alias Item

{
  use update;
  use delete;

  use association _HeaderAll { with draft; }
  use association _Header { with draft; }
}

Behavior implementation

Edit the behavior implementation class.
Add the table entity relation for ZCB_ITEM:

CLASS LHC_RAP_TDAT_CTS IMPLEMENTATION.
  METHOD GET.
    result = mbc_cp_api=>rap_tdat_cts( tdat_name = 'ZHEADER'
                                       table_entity_relations = VALUE #(
                                         ( entity = 'Header' table = 'ZCB_HEAD' )
                                         ( entity = 'Item' table = 'ZCB_ITEM' )
                                       ) ) ##NO_TEXT.
  ENDMETHOD.
ENDCLASS.

Implement the methods of LHC_ZI_ITEM and move the class definition LHC_RAP_TDAT_CTS up:

CLASS lhc_rap_tdat_cts DEFINITION FINAL.
  PUBLIC SECTION.
    CLASS-METHODS:
      get
        RETURNING
          VALUE(result) TYPE REF TO if_mbc_cp_rap_tdat_cts.

ENDCLASS.

CLASS lhc_item DEFINITION INHERITING FROM cl_abap_behavior_handler.

  PRIVATE SECTION.

    METHODS get_global_features FOR GLOBAL FEATURES
      IMPORTING REQUEST requested_features FOR Item RESULT result.

    METHODS ValidateTransportRequest FOR VALIDATE ON SAVE
      IMPORTING keys FOR Item~ValidateTransportRequest.

ENDCLASS.

CLASS lhc_item IMPLEMENTATION.

  METHOD get_global_features.
    DATA edit_flag TYPE abp_behv_flag VALUE if_abap_behv=>fc-o-enabled.
    IF lhc_rap_tdat_cts=>get( )->is_editable( ) = abap_false.
      edit_flag = if_abap_behv=>fc-o-disabled.
    ENDIF.
    result-%update = edit_flag.
    result-%delete = edit_flag.
  ENDMETHOD.

  METHOD ValidateTransportRequest.
    DATA change TYPE REQUEST FOR CHANGE ZI_Header_S.
    SELECT SINGLE TransportRequestID
      FROM zcb_head_d_s
      WHERE SingletonID = 1
      INTO (TransportRequestID).
    lhc_rap_tdat_cts=>get( )->validate_changes(
                                transport_request = TransportRequestID
                                table             = 'ZCB_ITEM'
                                keys              = REF #( keys )
                                reported          = REF #( reported )
                                failed            = REF #( failed )
                                change            = REF #( change-item ) ).
  ENDMETHOD.

ENDCLASS.

If you are using the VALIDATE_ALL_CHANGES method, delete the ValidateTransportRequest method from the LHC_ITEM class and adjust the ValidateTransportRequest method of the LHC_ZI_HEADER class:

VALIDATETRANSPORTREQUEST FOR VALIDATE ON SAVE
        IMPORTING
          KEYS_HEADER FOR Header~ValidateTransportRequest
          KEYS_ITEM FOR Item~ValidateTransportRequest.
[...]
  METHOD VALIDATETRANSPORTREQUEST.
    DATA change TYPE REQUEST FOR CHANGE ZI_Header_S.
    IF keys_Header IS NOT INITIAL.
      DATA(is_draft) = keys_Header[ 1 ]-%IS_DRAFT.
    ELSEIF keys_Item IS NOT INITIAL.
      is_draft = keys_Item[ 1 ]-%IS_DRAFT.
    ELSE.
      RETURN.
    ENDIF.
    READ ENTITY IN LOCAL MODE ZI_Header_S
    FROM VALUE #( ( %IS_DRAFT = is_draft
                    SingletonID = 1
                    %CONTROL-TransportRequestID = if_abap_behv=>mk-on ) )
    RESULT FINAL(transport_from_singleton).
    IF lines( transport_from_singleton ) = 1.
      DATA(transport_request) = transport_from_singleton[ 1 ]-TransportRequestID.
    ENDIF.
    lhc_rap_tdat_cts=>get( )->validate_all_changes(
                                transport_request     = transport_request
                                table_validation_keys = VALUE #(
                                                          ( table = 'ZCB_HEAD' keys = REF #( keys_Header ) )
                                                          ( table = 'ZCB_ITEM' keys = REF #( keys_Item ) )
                                                               )
                                reported              = REF #( reported )
                                failed                = REF #( failed )
                                change                = REF #( change ) ).
  ENDMETHOD.

Add the %ASSOC-_Item statement to the GET_GLOBAL_FEATURES method of LHC_ZI_HEADER:

  METHOD get_global_features.
    DATA edit_flag TYPE abp_behv_flag VALUE if_abap_behv=>fc-o-enabled.
    IF lhc_rap_tdat_cts=>get( )->is_editable( ) = abap_false.
      edit_flag = if_abap_behv=>fc-o-disabled.
    ENDIF.
    result-%update = edit_flag.
    result-%delete = edit_flag.
    result-%ASSOC-_Item = edit_flag.
  ENDMETHOD.

Metadata extension

Create a metadata extension for ZI_Item or ZC_Item when using a projection layer:

@Metadata.layer: #CUSTOMER
@UI: {
  headerInfo: {
    typeName: 'Item', 
    typeNamePlural: 'Items', 
    title: {
      type: #STANDARD, 
      label: 'Item', 
      value: 'ItemKey'
    }
  }
}
annotate entity ZC_Item with
{
  @UI.identification: [ {
    position: 1 , 
    label: 'ItemKey'
  } ]
  @UI.lineItem: [ {
    position: 1 , 
    label: 'ItemKey'
  } ]
  @UI.facet: [ {
    id: 'ZI_Item', 
    purpose: #STANDARD, 
    type: #IDENTIFICATION_REFERENCE, 
    label: 'Item', 
    position: 1 
  } ]
  ItemKey;
  
  @UI.identification: [ {
    position: 2 , 
    label: 'ItemContent'
  } ]
  @UI.lineItem: [ {
    position: 2 , 
    label: 'ItemContent'
  } ]
  ItemContent;
}

Add a facet to _Item in the metadata extension of ZI_Header or ZC_Header when using a projection layer:

[...]
annotate entity ZC_Header with
{
  @UI.identification: [ {
    position: 1 
  } ]
  @UI.lineItem: [ {
    position: 1 
  } ]
  @UI.facet: [ {
    id: 'ZI_Header', 
    purpose: #STANDARD, 
    type: #IDENTIFICATION_REFERENCE, 
    label: 'Header', 
    position: 1 
  }, 
  {
    id: 'ZI_Item', 
    type: #LINEITEM_REFERENCE, 
    label: 'Item', 
    position: 2 , 
    targetElement: '_Item'
  } ]
  HeadKey;
[...]

Access Control

Create an access control object for ZI_Item:

@MappingRole: true
define role ZI_Item {
  grant select on ZI_Item
  where INHERITING CONDITIONS FROM ENTITY ZI_Header;
}

If you are using a projection layer, create an access control object for ZC_Item:

@MappingRole: true
define role ZC_Item {
  grant select on ZC_Item
  where INHERITING CONDITIONS FROM ENTITY ZI_Item;
}

Transport Object

Add table ZCB_ITEM to the transport object definition ZHEADER:

  "tableItems": [
    {
      "tableName": "ZCB_HEAD",
      "isPrimaryTable": true
    },
    {
      "tableName": "ZCB_ITEM"
    }
  ]

If you are using SAP S/4HANA On Premises 2023, use transaction SOBJ instead of ADT to adjust the transport object definition.

Business Service

Add entity ZC_Item to the service definition:

define service ZUI_HEADER {
  expose ZC_Header_S as HeaderAll;
  expose ZC_Header   as Header;
  expose ZC_Item     as Item;
}

Maintenance Object

No adjustments are necessary. You have the option to define specific table settings for the new entity, for example, to change the table creation mode.

You can now restart the Custom Business Configurations app to review the changes.

How to enable an OData V4 service for anonymous access?

2024-03-19T21:57:57.546000+01:00

Introduction

This requirement stems from a customer that asked how to publish an OData V4 service in an SAP S/4HANA on premise system such that it could be used on a public web site without the need to provide any authentication.

With OData V2 this requirement can be achieved more easily since here every service has it's own SICF node where it would be possible to store credentials just for this service.

In OData V4 we have only one SICF node, namely /sap/opu/odata4/.

This is obviously a problem since there is no service specific node available in SICF.

Solution

The problem can be solved using the following approach.

Create a role that only contains the S_START authorization for the one single OData V4 service we want to publish ,
help.sap.com/doc/saphelp_nw75/7.5.5/de-DE/c6/dd838722ce4b8d9cc4a0741d93d864/frameset.htm
Create a technical user that has only the authorization to access the single OData V4 service we want to make accessible.
Create an alias in SICF for the node /sap/opu/odata4/
Store the credentials of the aforementioned user in the alias
Test the service

Result

As we can see accessing the service zrap630ui_shop_o4_05a via the alias zodatav4_2 works.

https://10.79.21.221:44301/sap/opu/zodatav4/sap/zrap630ui_shop_o4_05a/srvd/sap/zrap630ui_shop_o4_05a/0001/?sap-client=100

Whereas accessing a second OData V4 service zrap630ui_shop_o4_05b via the alias zodatav4_2 does NOT work

This has been achieved by assigne the follwoing role the technical user which only contains the authorization to start the first service based on the authorization object S_START.

Please note:
Since OData V4 service use the authorization object S_START which is based on the service name it would for example be possible to publish several services that are in the same name range like

zrap630ui_shop_o4_05A, zrap630ui_shop_o4_05B, ... zrap630ui_shop_o4_05Z,

How to section

Create the role

Using PFCG and the role template /IWBEP/RT_MGW_USR we create a role as shown in the screen shot above that only contains the S_START authorization of one OData V4 service called ZRAP630UI_SHOP_O4_05A.

Create the user

As a user we create a technical user whose credentials will be stored in the system alias.

Create the system alias

1. We start by right-clicking on the node opu and choose New subelement.

2. We create a new service element called ZODATAV4_2 and choose the option Alias to an existing service.

3. We choose the tab Target, select the node OdataV4 by double-clicking on it.

4. We navigate to the tab Logon Data, choose Alternative Logon Procedure and enter the credentials of our service user.

5. We navigate down and remove all logon procedures beside Logon using service data.

6. Do not forget to activate the link in SICF.

7. Check the result

How to get a "Display only" Fiori app from a "Manage" Fiori app

2024-03-22T09:32:32.218000+01:00

Ever come across a really good Standard Fiori app which you would like to use both for users that are allowed to create new business context, but also for those who should only display them? Sometimes there is a "display" or "List" app available, but not always. In this blog you'll learn how you can create your own "display only" app without having to redo everything SAP standard "did for you".

Example Case

In this example I'll be using "Manage Sales Order" app (F3893): Manage Sales Orders - Version 2

CDS Development

Step 1: Get Main CDS

The first thing we have to do is to figure out the main CDS view of the original standard app. In this example it's very simple because with have an OData service that was developed with RAP according to ABAP Cloud: C_SALESORDERMANAGE_SRV. We open this object in ADT and soon find the main CDS: C_SalesOrderManage.

I won't go into details here how to find the main CDS. In another blog post I have explained how to check an OData service and find CDS, please check there. If you still need help, maybe I make a new blog for that topic alone, we'll see.

Step 2: Decide Approach (yes, there is more than one)

Now that we have C_SalesOrderManage open (this is a projection view), we can check from which CDS it gets the data; R_SalesOrderTP. Looking at that CDS tells us that this is a root view entity which has composition children. So we can't just select from R_SalesOrderTP in our own CDS and reuse the compositions. For example R_SalesOrderItemTP is linked to R_SalesOrderTP and we cannot change SAP Standard so that it links to our own CDS. Meaning we go 1 level lower to the basic interface view that is used by R_SalesOrderTP; I_SalesOrder. Here some help how the CDS looks like:

We can see that for "as select from" we have I_SalesOrder. This is the one we want to use, because looking at it confirms it's no root view entity, but a regular CDS view/entity which we can reuse for our purpose.

At this point we should make a choice:

Do we want to have full functionality as in the original app, for example navigating from a sales order details page, all the way into a sales order item details page?
Or is it enough with one list report and one detail page? Namely in this example, a way to search for sales orders via filters, then clicking on a sales order and display all wanted details, but no further navigation.

Important: both are possible.

Choice one, full functionality: this means more wrappers and more work. You will basically create your own root view entity, with your own composite child entities (all wrapping around standard ones so you don't create them from scratch, thus called wrapper) for all the data you wish to display in your display-only app. You will then create the proper projection view, just like C_SalesOrderManage, create service definition and binding, which then gives you your OData service for the Fiori app.
Choice two: if we just need a simple list report with details page, we can generate an OData service directly from a CDS view entity. In this example I will go with this option, for simpleness sake. But basically the steps are as said just above, creating a wrapper for all CDS you want in the end and creating a proper OData service with RAP and ABAP Cloud.

Step 3: Create wrapper for CDS

Create a new data definition: ZC_SalesOrderTP (we give it C in its name for "consumption" because we will directly expose this CDS as OData service, and "TP" for transactional processing).
As reference CDS view, be sure to enter I_SalesOrder as identified in the previous step. If you do, ADT will add all fields and associations for you.
First off, at the beginning of your view entity you will need below two semantics. The first will make sure we don't just blindly take over all semantics from I_SalesOrder (this could be handy and potentially faster, but since we may not use absolutely all associations etc., it is in my opinion better to recreate your own semantics and thus the syntax checker will also help you to make sure everything is correct). The second one allows us to create an extra metadata extension file, which we can use for all UI annotations, which makes the whole thing less messy. I always recommend to separate UI annotations from other semantics.

@Metadata.ignorePropagatedAnnotations: true
@Metadata.allowExtensions: true

Next we add that we want to publish this CDS as OData service (with @OData.publish: true). This is only needed if you are going the more simple option. Otherwise you leave this out and create the OData service via Service Definition and Binding, once you built the complete RAP object.
Next I copied some of the semantics from the standard CDS and here is the complete start of my CDS so far:
Add the associations you want to use (again, simply copy from standard CDS) - if you are doing the more functionality route, be sure to use composite child instead of association and you have to create z-wrappers for each, and use the z-CDS here, not for example R_SalesOrderItemTP:

association [0..*] to I_SalesOrderItem as _Item
  on $projection.SalesOrder = _Item.SalesOrder
association [0..*] to R_SalesOrderTextTP as _Text
  on $projection.SalesOrder = _Text.SalesOrder
association [0..*] to I_SalesOrderPartner as _Partner
  on $projection.SalesOrder = _Partner.SalesOrder
association [0..1] to I_SalesOrderPartner as _SoldToParty 
  on  $projection.SalesOrder = _SoldToParty.SalesOrder
  and _SoldToParty.PartnerFunction = 'AG'
association [0..1] to C_SlsDocStdPartnerContactInfo as _SoldToPartyContactInfo 
  on  $projection.SalesOrder = _SoldToPartyContactInfo.SalesDocument
  and $projection.SoldToParty = _SoldToPartyContactInfo.SoldToParty
  and $projection.SalesOrderType = _SoldToPartyContactInfo.SalesDocumentType
association [0..1] to I_SalesOrderPartner as _ShipToParty 
  on  $projection.SalesOrder = _ShipToParty.SalesOrder
  and _ShipToParty.PartnerFunction = 'WE'
association [0..1] to I_SlsOrganizationDistrChnl as _SlsOrganizationDistrChnl 
  on  $projection.SalesOrganization = _SlsOrganizationDistrChnl.SalesOrganization
  and $projection.DistributionChannel = _SlsOrganizationDistrChnl.DistributionChannel

//Extension Association
association [1] to E_SalesDocumentBasic as _Extension on $projection.SalesOrder = _Extension.SalesDocument

Now I do the same per field that is important: add semantics to have a good UX. Here a couple of examples (I won't add everything as it would just get too big):

@Search: {
  defaultSearchElement: true,
  fuzzinessThreshold: 0.9,
  ranking: #HIGH }
key SalesOrder.SalesOrder,

@ObjectModel.text.element: ['CustomerName']
@Search: {
  defaultSearchElement: true,
  fuzzinessThreshold: 0.8 }
SalesOrder.SoldToParty,

@Semantics.text:true
_SoldToParty.FullName as CustomerName,

If you go the more functionality route, you keep creating your z-version for each "composition [0..*] of " that you feel you want to use in your display-only app. Once the wrappers are done, you can come back to the main one and activate it with the correct children-links.

Step 4: Authorization

If you paid attention above, we of course want to make sure that users still only see the sales orders they are supposed to see; the standard authorization. Once again, we don't need to redo this, we can inherit the standard one.

In ADT, create a new Access Control with the same name as your CDS you want to be checked, in my case ZC_SalesOrderTP. Then simply enter the "inheriting conditions from entity", save and done:

@EndUserText.label: 'Sales Order for Display Access'
@MappingRole: true
define role ZC_SALESORDERTP {
  grant
    select on ZC_SalesOrderTP
      where
        inheriting conditions from entity R_SalesOrderTP;
}

Step 5: UI Annotations for Fiori

I recommend to add all UI annotations that you want Fiori display via a metadata extension file. In ADT, create a metadata extension file that has the exact same name as your CDS, in my case ZC_SalesOrderTP. Here once again I opened the standard metadata extension file with Ctrl + Shift + A in ADT, and entering the same name as the main CDS: C_SalesOrderManage. In the dialog that shows all the hits, choose the metadata extension file instead of the Data Definition.

Now, at this point you may need some extra time. Instead of blindly copying all the annotations from the standard file, I went through and only added the facets that I wanted on my display-only app, and only the fields that I wanted. If you add too much (meaning you add annotations to something that doesn't exist in your z-wrapper CDS) syntax check will catch it but, there can be some "hidden" errors. And those will result in your Fiori app not functioning properly. For example, let's say you add a certain facet:

{
  id: 'CompletionStatus',
  label: 'Completion Status',
  purpose: #STANDARD,
  type: #FIELDGROUP_REFERENCE,
  parentId: 'StatusTab',
  importance: #HIGH,
  position: 30,
  targetQualifier: 'CompletionStatus'
},

The above looks all fine and will pass syntax check. We have the "CompletionStatus" and we can add fields to this facet. BUT, if you paid close attention, you may noticed this line: parentId: 'StatusTab'. This means our CompletionStatus facet is inside another, a parent facet. If you now didn't copy that parent facet, and there is no facet with id StatusTab, then your Fiori application will not work properly, because it cannot resolve this.

This is probably the part where you spend most of your time on. Myself when I did this example it took me about 1-2 hours.

Step 6: Publish OData Service

Next we need to publish our custom OData service with transaction /IWFND/MAINT_SERVICE for OData V2 services or /IWFND/V4_ADMIN for OData V4. Note that when using @OData.publish: true the system will add _CDS to your OData service name. Confirm your service and metadata was loaded successfully before continuing.

Fiori Development

Next up, we create our display-only Fiori elements app.

Open Business Application Studio (BAS) on your SAP BTP and start a space for Fiori development.

Create a new Project from Template and choose SAP Fiori application. The first thing we need to do is connect to a data source. In my case an S/4HANA on-premise system that I have connected to my SAP BTP via Cloud Connector. I select in this step the Destination to that S/4HANA system via Cloud Connector, and then I select my OData service:

Next, we enter the project details, for example:

You should add deployment configuration and also FLP configuration here. I again select my S/4HANA system destination and enter a technical name for the Fiori app to be created on the ABAP platform of my S/4HANA system. You also need to enter package and transport at this point.

For the FLP configuration it's business as usual, except be careful with your semantic object and action. Be sure to not reuse what standard is using, for example I used SalesOrder as object (because that is correct) and then I said the action is "displayOnly" to be sure to not have another intent like that:

Once the wizard is done, simply test your app. Because we have done all the UI annotations, you should be good to go.

Deploy your app and we are almost done.

Adding your App to the Fiori Launchpad

The app is now in our system but it has no catalog etc. So we gotta do this per usual practice. I won't go into super details here:

Create a technical catalog if you don't have a suitable one using Launchpad App Manager - Cross Client
From your technical catalog, choose Add App to add an "app descriptor item", or Tile and Target Mapping in other words (so we are still in Launchpad App Manager - Cross Client we have created/navigated to our technical catalog, in edit mode and choose Add App)
Here under application component ID you have to enter the full application name you chose for your Fiori application when you first created it in BAS. In my case i had namespace "disp" and name "salesorderdisplay", meaning disp.salesorderdisplay. If you enter this, the app should fetch all the necessary FLP config you already did in BAS (it will also fetch ICF path for you):
In my case, because I chose "Mange Sales Orders" app, I also added all the parameters which that app uses - be sure not to forget this!
Save this.
Next, we need to add the app to a business catalog (maybe create a new business catalog if needed) or several, depending on your setup
Then we need to add our business catalog(s) for this app to all the appropriate roles who should have this display-only app
Lastly, if the app should be on a Space and Page, we need to do that config

All done! You have a display-only app, using standard CDS which you have wrapped into a custom OData service, for a custom app.

And if you were wondering; Is this Clean Core? Then yes. Custom development that follows the ABAP Cloud programming model is "clean". One thing to consider when you create such "wrappers" (Tier 2) is to keep an eye out if SAP Standard delivers a solution that makes your custom development unnecessary; then you should switch to SAP Standard and retire your own development (and you will be on Tier 1).

Solution

The final app - list report page (including smart links to customer, without us having to code it ourselves):

Details/Object page:

Hope this was helpful! Let me know if you wonder anything.

Step by Step process to publish standard Business events from S/4 Hana to Event Mesh

2024-03-27T10:04:35.331000+01:00

Hi All,

This blog explains Outbound Configuration to send events from S/4 Hana on premise to Event Mesh and test the same.

You need to have below roles

1. SAP_IWXBE_RT_XBE_ADM

2. SAP_IWXBE_RT_XBE_BUSI

3. SAP_IWXBE_RT_XBE_MDT

In S/4 system, please follow below steps.

Create a Channel using T-code “/n/IWXBE/CONFIG”.

Click on “Via Service key”.

Enter Channel name and Description. Get the Event mesh instance key from Basis team. Copy and paste the service key of event mesh as shown below.

select the channel and activate it.

Once it is activated, click on Check connection. You will get the below message if connection successfull.

To Create Outbound binding, please select channel and click on outbound bindings.

Click on create and then F4.

Select the topic from F4 and save it. If you don't find topics in F4 help, you need to implement note "3346777".

Now, you need to create a Queue in Event Mesh and subscribe the topic.

Open Event Mesh and click on Create Queue.

Provide some name and click on create

Once the Queue is created, click on highlighted button and select Queue Subscriptions.

Enter Topic name along with the namespace and click on add button to subscribe to the topic.

Configuration is done in S/4 Hana system and in the BTP Event Mesh.

To test the messages,

Trigger Standard Business Partner Events by creating a business partner using T-Code BP.

Click on Person.

Enter First name and last name and then save it.

Message has been sent to Event Mesh.

Check the payload after consuming the message in CPI by integration team.

Message number decreased to zero in Event Mesh after consuming the message in CPI.

Happy to hear the feedback 🙂

Upload Excel using SAP RAP Only

2024-04-16T12:50:21.211000+02:00

Develop an SAP RAP based App to upload excel (CSV) file just like you used to develop SE38 classical report.

We often get this requirement of developing a utility to create/update mass data for a BO such as Purchase Orders, Materials, Sales Orders etc. In S/4 HANA, the customer prefers to use SAP Fiori applications, rather than using the old classical reports. But can we develop a Fiori application to upload a file without involving using SAP UI5? Yes, we can.

Using the following annotations, we can attach any file to our BO in SAP RAP –

@Semantics.largeObject

The only constraint is that we would need a table holding the uploaded attachment large object. Let’s dive into the steps –

First, we will create database tables. We need to create two DB tables. The first table i.e. parent table will store the file attachment, and the second table i.e. child table will store the data from the uploaded file. In our scenario, we will be uploading and processing CSV file.

File table - ZSES_FILE_TABLE

@EndUserText.label : 'User File Table'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #RESTRICTED
define table zses_file_table {
  key client            : abap.clnt not null;
  key end_user          : uname not null;
      status            : abap.char(1);
      attachment        : xstringval;
      mimetype          : abap.char(128);
      filename          : abap.char(128);
      local_created_by      : abp_creation_user;
      local_created_at      : abp_creation_tstmpl;
      local_last_changed_by : abp_locinst_lastchange_user;
      local_last_changed_at : abp_locinst_lastchange_tstmpl;
      last_changed_at       : abp_lastchange_tstmpl
}

Excel data table - ZSES_DB

@EndUserText.label : 'Excel Data'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #ALLOWED
define table zses_db {
  key mandt      : mandt not null;
  key end_user   : uname not null;
  key entrysheet : lblni not null;
  key ebeln      : ebeln not null;
  key ebelp      : ebelp not null;
  ext_number     : lblne1;
  begdate        : lzvon;
  enddate        : lzbis;
  @Semantics.quantity.unitOfMeasure : 'zses_db.base_uom'
  quantity       : mengev;
  base_uom       : meins;
  fin_entry      : final;
  error          : boolean;
  error_message  : char100;
}

Now, let's create Interface views on top of the tables we just created.

For parent interface view, we create ZI_SES_PARENT.

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Excel File Table'
define root view entity zi_ses_parent
  as select from    usr02           as _user
    left outer join zses_file_table as _ses_file on _user.bname = _ses_file.end_user
  composition [0..*] of zi_ses_excel_data as _ses_excel
{
  key _user.bname                                                                                              as end_user,
      _ses_file.status                                                                                         as status,

      cast( case when _ses_file.filename is initial and _ses_file.status is      initial then 'File Not Uploaded'
                 when _ses_file.filename is not initial and  _ses_file.status is initial  then 'File Uploaded'
                 when _ses_file.filename is initial then 'File Not Uploaded'
                 when  _ses_file.status is not initial then 'File Processed' else ' ' end as abap.char( 20 ) ) as FileStatus,
      cast( case when _ses_file.filename is initial and _ses_file.status is initial then '1'
                 when _ses_file.filename is not initial and  _ses_file.status is initial  then '2'
                 when _ses_file.filename is initial then '1'
                 when  _ses_file.status is not initial then '3' else ' ' end as abap.char( 1 ) )               as CriticalityStatus,
      cast( case when _ses_file.filename is not initial then ' ' else 'X' end as boolean preserving type  )    as HideExcel,
      @Semantics.largeObject:
      { mimeType: 'MimeType',
      fileName: 'Filename',
      acceptableMimeTypes: [ 'text/csv' ],
      contentDispositionPreference: #INLINE }  // This will store the File into our table 
      _ses_file.attachment                                                                                     as Attachment,
      @Semantics.mimeType: true
      _ses_file.mimetype                                                                                       as MimeType,
      _ses_file.filename                                                                                       as Filename,
      @Semantics.user.createdBy: true
      _ses_file.local_created_by                                                                               as Local_Created_By,
      @Semantics.systemDateTime.createdAt: true
      _ses_file.local_created_at                                                                               as Local_Created_At,
      @Semantics.user.lastChangedBy: true
      _ses_file.local_last_changed_by                                                                          as Local_Last_Changed_By,
      //local ETag field --> OData ETag
      @Semantics.systemDateTime.localInstanceLastChangedAt: true
      _ses_file.local_last_changed_at                                                                          as Local_Last_Changed_At,
      //total ETag field
      @Semantics.systemDateTime.lastChangedAt: true
      _ses_file.last_changed_at                                                                                as Last_Changed_At,

      _ses_excel
}
where
  _user.bname = $session.user

Looks complicated? Let me explain -

1. We select primary data from USR02 table and left outer join it with our parent table ZSES_FILE_TABLE, so that every user can use the app without worrying about locking. As this application serves as a utility for excel file upload, multiple users can use it simultaneously.
2. FileStatus field is introduced to decorate the application and show state to the user whether the file is uploaded, processed or not.

Then we create interface view of child entity as ZI_SES_EXCEL_DATA.

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'SES_excel_data'
@Metadata.allowExtensions: true 
define view entity zi_ses_excel_data
  as select from zses_db
  association to parent zi_ses_parent as _ses_file on $projection.end_user = _ses_file.end_user
{
  key end_user              as end_user,
  key zses_db.entrysheet   as Entrysheet,
  key zses_db.ebeln         as Ebeln,
  key zses_db.ebelp         as Ebelp,
      zses_db.ext_number    as Ext_Number,
      zses_db.begdate       as Begdate,
      zses_db.enddate       as Enddate,
      zses_db.quantity      as Quantity,
      zses_db.base_uom      as Base_Uom,
      zses_db.fin_entry     as Fin_Entry,
      zses_db.error         as Error,
      zses_db.error_message as Error_Message,

      _ses_file
}

Now, let's go for consumption views. These are pretty straightforward.

For parent, we create ZC_SES_PARENT.

@EndUserText.label: 'Consumption View for File'
@AccessControl.authorizationCheck: #NOT_REQUIRED
@Metadata.allowExtensions: true
define root view entity zc_ses_parent
  provider contract transactional_query
  as projection on zi_ses_parent
{
  key end_user,
      @EndUserText.label: 'Processing Status'
      FileStatus as status,
      Attachment,
      MimeType,
      Filename,
      Local_Created_By,
      Local_Created_At,
      Local_Last_Changed_By,
      @EndUserText.label: 'Last Action On'
      Local_Last_Changed_At,
      Last_Changed_At,
      CriticalityStatus,
      HideExcel,
      
      /* Associations */
      _ses_excel : redirected to composition child zc_ses_excel
}

For child, we create ZC_SES_EXCEL.

@EndUserText.label: 'Consumption View for Ses Excel Data'
@AccessControl.authorizationCheck: #NOT_REQUIRED
@Metadata.allowExtensions: true 
define view entity zc_ses_excel
  as projection on zi_ses_excel_data
{
  key end_user,
  key Entrysheet,
  key Ebeln,
  key Ebelp,
      Ext_Number,
      Begdate,
      Enddate,
      Quantity,
      Base_Uom,
      Fin_Entry,
      Error,
      Error_Message,
      /* Associations */
      _ses_file : redirected to parent zc_ses_parent
}

We then create Metadata Extensions for both of our consumption/projection views -

@Metadata.layer: #CORE
annotate entity zc_ses_parent with
{
  @UI.facet: [
      /* Header Fecets and Datapoints */
      { purpose: #HEADER,             id:'HDR_USER',        type: #DATAPOINT_REFERENCE,      position: 10, targetQualifier: 'end_user'                                             },
      { purpose: #HEADER,             id:'HDR_FILE',        type: #DATAPOINT_REFERENCE,      position: 20, targetQualifier: 'Local_Last_Changed_At'                                },
      { purpose: #HEADER,             id:'HDR_STATUS',      type: #DATAPOINT_REFERENCE,      position: 30, targetQualifier: 'status'                                               },
  //**----  Body facets
      { label: 'File Information',    id: 'Attachment',     type: #COLLECTION,               position: 10                                                                        },
      { label: 'Invoice Details',     id: 'Invoicedet',     type: #IDENTIFICATION_REFERENCE, position: 10,                             parentId: 'File',        purpose: #STANDARD },
      {                               id: 'Upload',         type: #FIELDGROUP_REFERENCE,     position: 20  ,targetQualifier: 'Upload', parentId: 'Attachment',  purpose: #STANDARD },

  //** --- Excel data Facet **
      { label: 'Excel Data',          id: 'Data',           type: #LINEITEM_REFERENCE,       position: 30,  targetElement: '_ses_excel', parentId: 'Attachment', purpose: #STANDARD } ]// , hidden: #(HideExcel) } ]


  @UI: { lineItem:       [ { position: 10, importance: #HIGH , label: 'Person Responsible'}  ] ,
         identification: [ { position: 10 , label: 'Person Responsible' } ],
                     //      { type: #FOR_ACTION, dataAction: 'uploadExcelData', label: 'Validate and Show' } ] ,
         dataPoint:        { title: 'Responsible Person', targetValueElement: 'end_user' } }
  end_user;
  @UI: { lineItem:       [ { position: 20, importance: #HIGH , label: 'Processing Status'} ] ,
         identification: [ { position: 20 , label: 'Processing Status' } ] ,
         dataPoint:        { title: 'Processing Status', targetValueElement: 'status' ,criticality: 'CriticalityStatus' ,criticalityRepresentation: #WITHOUT_ICON} }
  status;
  @UI: { fieldGroup:     [ { position: 50, qualifier: 'Upload' , label: 'Attachment'} ]}
  @UI: { identification: [ { position: 30 , label: 'File' } ] }
  Attachment;

  @UI.hidden: true
  MimeType;

  @UI.hidden: true
  Filename;
  @UI: { dataPoint:{ title: 'Last Action On', targetValueElement: 'Local_Last_Changed_At' } }
  Local_Last_Changed_At;

}

@Metadata.layer: #CORE
annotate entity zc_ses_excel with
{

  @UI.facet: [{
      id: 'SES',
      type: #FIELDGROUP_REFERENCE,
      purpose: #STANDARD,
      label: 'SES',
      targetQualifier: 'SESDetails'
   }]
  @UI.lineItem: [{ position: 1 }]
  end_user;
  @UI.lineItem: [{ position: 10 , label: 'SES Number', invocationGrouping: #ISOLATED },
  { type: #FOR_ACTION, dataAction: 'createSES', label: 'Process SES' }]
  @UI.fieldGroup: [{ position: 10 , label: 'SES Number', qualifier: 'SESDetails' }]
  Entrysheet;
  @UI.lineItem: [{ position: 20 , label: 'PO' }]
  @UI.fieldGroup: [{ position: 20 , label: 'PO', qualifier: 'SESDetails' }]
  Ebeln;
  @UI.lineItem: [{ position: 30 , label: 'PO Item' }]
  @UI.fieldGroup: [{ position: 30 , label: 'PO Item', qualifier: 'SESDetails' }]
  Ebelp;
  @UI.lineItem: [{ position: 40 , label: 'SES Name' }]
  @UI.fieldGroup: [{ position: 40 , label: 'SES Name', qualifier: 'SESDetails' }]
  Ext_Number;
  @UI.lineItem: [{ position: 50 , label: 'Valid From' }]
  @UI.fieldGroup: [{ position: 50 , label: 'Valid From', qualifier: 'SESDetails' }]
  Begdate;
  @UI.lineItem: [{ position: 60 , label: 'Valid To' }]
  @UI.fieldGroup: [{ position: 60 , label: 'Valid To', qualifier: 'SESDetails' }]
  Enddate;
  @UI.lineItem: [{ position: 70 , label: 'Quantity' }]
  @UI.fieldGroup: [{ position: 70 , label: 'Quantity', qualifier: 'SESDetails' }]
  Quantity;
  @UI.lineItem: [{ position: 80 , label: 'UOM' }]
  @UI.fieldGroup: [{ position: 80 , label: 'UOM', qualifier: 'SESDetails' }]
  Base_Uom;
  @UI.lineItem: [{ position: 90 , label: 'Final Entry' }]
  @UI.fieldGroup: [{ position: 90 , label: 'Final Entry', qualifier: 'SESDetails' }]
  Fin_Entry;
  @UI.lineItem: [{ position: 100 , label: 'Error' , hidden: true}]
  @UI.fieldGroup: [{ position: 100 , label: 'Error' , hidden: true}]
  Error;
  @UI.lineItem: [{ position: 110 , label: 'Error Message' }]
  @UI.fieldGroup: [{ position: 110 , label: 'Error Message', qualifier: 'SESDetails' }]
  Error_Message;
}

Now, we create behavior definition ZI_SES_PARENT -

managed implementation in class zbp_i_ses_parent unique;
strict ( 2 );
with draft;

define behavior for zi_ses_parent alias File
persistent table zses_file_table
lock master
total etag end_user
draft table zses_file_tabled
authorization master ( instance )
etag master end_user
{
  create;
  update;
  delete;
  // Logic to convert uploaded excel into internal table and save to the child entity is written here
  action ( features : instance ) uploadExcelData  result [1] $self;

  association _ses_excel { create; with draft; }
  // Logic to trigger action uploadExcelData
  determination fields on modify { field Filename ; }
  draft action Edit ;
  draft action Activate;
  draft action Discard;
  draft action Resume;
  draft determine action Prepare ;
}

define behavior for zi_ses_excel_data alias ExcelData
persistent table ZSES_DB
lock dependent by _ses_file
draft table zses_dbd
authorization dependent by _ses_file
etag master Begdate
{
  update;
  delete;
  field ( readonly ) end_user;
  association _ses_file { with draft; }
  // Logic to process the uploaded data from excel
  action createSES result [1] $self;
}

And the behavior projection ZC_SES_PARENT -

projection;
strict ( 2 );
use draft;

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

  field ( readonly ) status , Local_Last_Changed_At ;
  use action Edit;
  use action Activate;
  use action Discard;
  use action Resume;
  use action Prepare;
  use association _ses_excel { create; with draft; }
}

define behavior for zc_ses_excel //alias <alias_name>
{
  use update;
  use delete;
  use association _ses_file { with draft; }
  use action createSES;
}

Now, in the behavior implementation class - ZBP_I_SES_PARENT, we have two important methods -

Determination method - 'Fields' -

METHOD fields.

    SELECT @abap_true INTO @DATA(lv_valid) FROM zses_file_table UP TO 1 ROWS WHERE end_user = @SY-uname.
    ENDSELECT.

    IF lv_valid <> abap_true.
      INSERT zses_file_table FROM @( VALUE #( end_user = sy-uname ) ).
    ENDIF.

    MODIFY ENTITIES OF zi_ses_parent IN LOCAL MODE
    ENTITY file
    UPDATE FROM VALUE #( FOR key IN keys ( end_user        = key-end_user
                                           status          = ' ' " Accepted
                                           %control-status = if_abap_behv=>mk-on ) ).

    IF keys[ 1 ]-%is_draft = '01'.

      MODIFY ENTITIES OF zi_ses_parent IN LOCAL MODE
      ENTITY file
      EXECUTE uploadexceldata
      FROM CORRESPONDING #( keys ).
    ENDIF.
  ENDMETHOD.

Explanation:
1. We save an entry with our username to the parent table, so that the once an instance is created and it goes inside the draft, it finds an instance to edit.
2. We call the action uploadexceldata such that whenever a new file is uploaded, it converts the data and store it into the child table.

Action method 'uploadExcelData' -

    READ ENTITIES OF zi_ses_parent IN LOCAL MODE
      ENTITY file
      ALL FIELDS WITH
      CORRESPONDING #( keys )
      RESULT DATA(lt_inv).

    DATA(lv_attachment) = lt_inv[ 1 ]-attachment.

    DATA: rows          TYPE STANDARD TABLE OF string,
          content       TYPE string,
          conv          TYPE REF TO cl_abap_conv_in_ce,
          ls_excel_data TYPE zses_db,
          lt_excel_data TYPE STANDARD TABLE OF zses_db,
          lv_quantity   TYPE char10,
          lv_entrysheet TYPE ebeln.

    conv = cl_abap_conv_in_ce=>create( input = lv_attachment ).
    conv->read( IMPORTING data = content ).

    SPLIT content AT cl_abap_char_utilities=>cr_lf INTO TABLE rows.

    LOOP AT rows INTO DATA(ls_row).
      SPLIT ls_row AT ',' INTO ls_excel_data-entrysheet
                               ls_excel_data-ebeln
                               ls_excel_data-ebelp
                               ls_excel_data-ext_number
                               ls_excel_data-begdate
                               ls_excel_data-enddate
                               lv_quantity
                               "ls_attdata-BASE_UOM
                               ls_excel_data-fin_entry.

      ls_excel_data-entrysheet = lv_entrysheet = |{ ls_excel_data-entrysheet ALPHA = IN }|.
      ls_excel_data-ebeln      = |{ ls_excel_data-ebeln ALPHA = IN }|.
      ls_excel_data-ebelp      = |{ ls_excel_data-ebelp ALPHA = IN }|.
      ls_excel_data-quantity = CONV #( lv_quantity ).
      
      APPEND ls_excel_data TO lt_excel_data.
      CLEAR: ls_row, ls_excel_data.
ENDLOOP.

Explanation -
1. Read the excel file (CSV in our case) from the entity and append it to internal table LT_EXCEL_DATA.
2. Use EML to insert the data from LT_EXCEL_DATA to the child table.

Please refer below code for the implementation class -

CLASS lhc_exceldata DEFINITION INHERITING FROM cl_abap_behavior_handler.

  PRIVATE SECTION.
    METHODS get_instance_authorizations FOR INSTANCE AUTHORIZATION
      IMPORTING keys REQUEST requested_authorizations FOR exceldata RESULT result.

    METHODS createses FOR MODIFY
      IMPORTING keys FOR ACTION exceldata~createses RESULT result.

ENDCLASS.

CLASS lhc_exceldata IMPLEMENTATION.

  METHOD get_instance_authorizations.
  ENDMETHOD.

  METHOD createses.

    READ ENTITIES OF zi_ses_parent IN LOCAL MODE
        ENTITY exceldata
        ALL FIELDS WITH
        CORRESPONDING #( keys )
        RESULT DATA(lt_data).

    DATA:
      ls_header_data TYPE i_serviceentrysheettp_2,
      ls_item_data   TYPE i_serviceentrysheetitemtp_2,

      lt_header_crt  TYPE TABLE FOR CREATE i_serviceentrysheettp_2\\serviceentrysheet,
      lt_item_cba    TYPE TABLE FOR CREATE i_serviceentrysheettp_2\\serviceentrysheet\_serviceentrysheetitem.

* Create SES with reference to a Service Purchase Order Item

*--- Prepare Header Data
    ls_header_data-serviceentrysheetname  = 'Demo SES'.
    ls_header_data-purchaseorder          = `4500000286`.
    ls_header_data-sesoriginobjecttype    = `EX`.

*--- Prepare Item Data
    ls_item_data-purchaseorderitem              = '00010'.
    ls_item_data-confirmedquantity              = '1'.
    ls_item_data-accountassignmentcategory      = 'K'.
    ls_item_data-serviceperformancedate         = '20230207'.
    ls_item_data-multipleacctassgmtdistribution = '0'.


*--- Prepare Payload
    APPEND INITIAL LINE TO lt_header_crt ASSIGNING FIELD-SYMBOL(<ls_hdr_crt>).
    <ls_hdr_crt> = CORRESPONDING #( ls_header_data CHANGING CONTROL ).
    <ls_hdr_crt>-%cid     = `HEADER_1` .

    APPEND INITIAL LINE TO lt_item_cba ASSIGNING FIELD-SYMBOL(<ls_itm_cba>).
    <ls_itm_cba>-%cid_ref = 'HEADER_1'.

    APPEND INITIAL LINE TO <ls_itm_cba>-%target ASSIGNING FIELD-SYMBOL(<item_data>).
    <item_data>       = CORRESPONDING #( ls_item_data CHANGING CONTROL ).
    <item_data>-%cid  = 'Item_1'.


    MODIFY ENTITIES OF i_serviceentrysheettp_2
      ENTITY serviceentrysheet
        CREATE
          FROM lt_header_crt
         CREATE BY \_serviceentrysheetitem
          FROM  lt_item_cba
      FAILED DATA(ls_failed_crt)
      REPORTED DATA(ls_reported_crt)
      MAPPED DATA(ls_mapped_crt).

  ENDMETHOD.

ENDCLASS.

CLASS lhc_file DEFINITION INHERITING FROM cl_abap_behavior_handler.
  PRIVATE SECTION.

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

    METHODS uploadexceldata FOR MODIFY
      IMPORTING keys FOR ACTION file~uploadexceldata RESULT result.
    METHODS fields FOR DETERMINE ON MODIFY
      IMPORTING keys FOR file~fields.
    METHODS get_instance_features FOR INSTANCE FEATURES
      IMPORTING keys REQUEST requested_features FOR file RESULT result.

ENDCLASS.

CLASS lhc_file IMPLEMENTATION.

  METHOD get_instance_authorizations.
  ENDMETHOD.

  METHOD uploadexceldata.

** Check if there exist an entry with current logged in username in parent table
    SELECT @abap_true INTO @DATA(lv_valid) FROM zses_file_table UP TO 1 ROWS WHERE end_user = @SY-uname.
    ENDSELECT.
** Create one entry, if it does not exist
    IF lv_valid <> abap_true.
      INSERT zses_file_table FROM @( VALUE #( end_user = sy-uname ) ).
    ENDIF.
** Read the parent instance
    READ ENTITIES OF zi_ses_parent IN LOCAL MODE
      ENTITY file
      ALL FIELDS WITH
      CORRESPONDING #( keys )
      RESULT DATA(lt_inv).

** Get attachment value from the instance
    DATA(lv_attachment) = lt_inv[ 1 ]-attachment.

** Data declarations
    DATA: rows          TYPE STANDARD TABLE OF string,
          content       TYPE string,
          conv          TYPE REF TO cl_abap_conv_in_ce,
          ls_excel_data TYPE zses_db,
          lt_excel_data TYPE STANDARD TABLE OF zses_db,
          lv_quantity   TYPE char10,
          lv_entrysheet TYPE ebeln.

** Convert excel file with CSV format into internal table of type string 
    conv = cl_abap_conv_in_ce=>create( input = lv_attachment ).
    conv->read( IMPORTING data = content ).

** Split the string table to rows
    SPLIT content AT cl_abap_char_utilities=>cr_lf INTO TABLE rows.

** Process the rows and append to the internal table
    LOOP AT rows INTO DATA(ls_row).
      SPLIT ls_row AT ',' INTO ls_excel_data-entrysheet
                               ls_excel_data-ebeln
                               ls_excel_data-ebelp
                               ls_excel_data-ext_number
                               ls_excel_data-begdate
                               ls_excel_data-enddate
                               lv_quantity
                               "ls_attdata-BASE_UOM
                               ls_excel_data-fin_entry.

      ls_excel_data-entrysheet = lv_entrysheet = |{ ls_excel_data-entrysheet ALPHA = IN }|.
      ls_excel_data-ebeln      = |{ ls_excel_data-ebeln ALPHA = IN }|.
      ls_excel_data-ebelp      = |{ ls_excel_data-ebelp ALPHA = IN }|.
      ls_excel_data-quantity = CONV #( lv_quantity ).

      APPEND ls_excel_data TO lt_excel_data.

      CLEAR: ls_row, ls_excel_data.
    ENDLOOP.

** Delete duplicate records
    DELETE ADJACENT DUPLICATES FROM lt_excel_data.
    DELETE lt_excel_data WHERE ebeln IS INITIAL.

** Prepare the datatypes to store the data from internal table lt_excel_data to child entity through EML
    DATA lt_att_create TYPE TABLE FOR CREATE zi_ses_parent\_ses_excel.

    lt_att_create = VALUE #( (  %cid_ref  = keys[ 1 ]-%cid_ref
                                %is_draft = keys[ 1 ]-%is_draft
                                end_user  = keys[ 1 ]-end_user
                                %target   = VALUE #( FOR ls_data IN lt_excel_data ( %cid       = |{ ls_data-ebeln }{ ls_data-ebelp }|
                                                                                   %is_draft   = keys[ 1 ]-%is_draft
                                                                                   end_user    = sy-uname
                                                                                   entrysheet  = ls_data-entrysheet
                                                                                   ebeln       = ls_data-ebeln
                                                                                   ebelp       = ls_data-ebelp
                                                                                   ext_number  = ls_data-ext_number
                                                                                   begdate     = ls_data-begdate
                                                                                   enddate     = ls_data-enddate
                                                                                   quantity    = ls_data-quantity
                                                                                  " BASE_UOM    = ls_data-
                                                                                   fin_entry   = ls_data-fin_entry
                                                                                  %control = VALUE #( end_user    = if_abap_behv=>mk-on
                                                                                                      entrysheet  = if_abap_behv=>mk-on
                                                                                                      ebeln       = if_abap_behv=>mk-on
                                                                                                      ebelp       = if_abap_behv=>mk-on
                                                                                                      ext_number  = if_abap_behv=>mk-on
                                                                                                      begdate     = if_abap_behv=>mk-on
                                                                                                      enddate     = if_abap_behv=>mk-on
                                                                                                      quantity    = if_abap_behv=>mk-on
                                                                                                     " BASE_UOM    = ls_data-
                                                                                                      fin_entry   = if_abap_behv=>mk-on  ) ) ) ) ).
    READ ENTITIES OF zi_ses_parent IN LOCAL MODE
    ENTITY file
    BY \_ses_excel
    ALL FIELDS WITH
    CORRESPONDING #( keys )
    RESULT DATA(lt_excel).

** Delete already existing entries from child entity
    MODIFY ENTITIES OF zi_ses_parent IN LOCAL MODE
    ENTITY exceldata
    DELETE FROM VALUE #( FOR ls_excel IN lt_excel (  %is_draft = ls_excel-%is_draft
                                                     %key      = ls_excel-%key ) )
    MAPPED DATA(lt_mapped_delete)
    REPORTED DATA(lt_reported_delete)
    FAILED DATA(lt_failed_delete).

** Create the records from the new attached CSV file
    MODIFY ENTITIES OF zi_ses_parent IN LOCAL MODE
    ENTITY file
    CREATE BY \_ses_excel
    AUTO FILL CID
    WITH lt_att_create.


    APPEND VALUE #( %tky = lt_inv[ 1 ]-%tky ) TO mapped-file.
    APPEND VALUE #( %tky = lt_inv[ 1 ]-%tky
                    %msg = new_message_with_text( severity = if_abap_behv_message=>severity-success
                                                  text = 'Excel Data Uploaded' )
                   ) TO reported-file.

    MODIFY ENTITIES OF zi_ses_parent IN LOCAL MODE
    ENTITY file
    UPDATE FROM VALUE #( ( %is_draft = keys[ 1 ]-%is_draft
                           end_user  = sy-uname
                           status     =  'P'
                          " %data     = VALUE #( status = 'P' )
                           %control  = VALUE #( status = if_abap_behv=>mk-on ) ) )
    MAPPED DATA(lt_mapped_update)
    REPORTED DATA(lt_reported_update)
    FAILED DATA(lt_failed_update).

    READ ENTITIES OF zi_ses_parent IN LOCAL MODE
    ENTITY file
    ALL FIELDS WITH CORRESPONDING #( keys )
    RESULT DATA(lt_file_status).

    MODIFY ENTITIES OF zi_ses_parent IN LOCAL MODE
    ENTITY file
    UPDATE FROM VALUE #( FOR ls_file_status IN lt_file_status ( %is_draft = ls_file_status-%is_draft
                                                                %tky      = ls_file_status-%tky
                                                                %data     = VALUE #( status = 'C'  )
                                                                %control  = VALUE #( status = if_abap_behv=>mk-on )
                                                     ) ).

    READ ENTITIES OF zi_ses_parent IN LOCAL MODE
       ENTITY file
       ALL FIELDS WITH
       CORRESPONDING #( keys )
       RESULT DATA(lt_file).



    result = VALUE #( FOR ls_file IN lt_file ( %tky   = ls_file-%tky

                                               %param = ls_file ) ).

  ENDMETHOD.

  METHOD fields.

    SELECT @abap_true INTO @DATA(lv_valid) FROM zses_file_table UP TO 1 ROWS WHERE end_user = @SY-uname.
    ENDSELECT.

    IF lv_valid <> abap_true.
      INSERT zses_file_table FROM @( VALUE #( end_user = sy-uname ) ).
    ENDIF.

    MODIFY ENTITIES OF zi_ses_parent IN LOCAL MODE
    ENTITY file
    UPDATE FROM VALUE #( FOR key IN keys ( end_user        = key-end_user
                                           status          = ' ' " Accepted
                                           %control-status = if_abap_behv=>mk-on ) ).

    IF keys[ 1 ]-%is_draft = '01'.

      MODIFY ENTITIES OF zi_ses_parent IN LOCAL MODE
      ENTITY file
      EXECUTE uploadexceldata
      FROM CORRESPONDING #( keys ).
    ENDIF.
  ENDMETHOD.


  METHOD get_instance_features.

    READ ENTITIES OF zi_ses_parent IN LOCAL MODE
           ENTITY file
             FIELDS ( end_user )
                WITH CORRESPONDING #( keys )
              RESULT DATA(lt_file).


    result = VALUE #( FOR ls_file IN lt_file ( %key = ls_file-%key
                                               %is_draft = ls_file-%is_draft
                                               %features-%action-uploadexceldata = COND #( WHEN ls_file-%is_draft = '00'
                                                                                           THEN if_abap_behv=>fc-f-read_only
                                                                                           ELSE if_abap_behv=>fc-f-unrestricted ) ) ).

  ENDMETHOD.

ENDCLASS.

After this, create service definition, expose both the parent and child consumption views, create a service binding and see the wonders.
The list report page would look like -

Since, we used where clause to filter the parent records based on the current logged-in user in the interface view ZI_SES_PARENT, we should see only 1 record here. You can also skip the list report page in SAP BAS and deploy the app which directly opens the object page.
When navigate to the object page and click on edit.

Once saved, we should see the records -

You can write the logic to process these records in an instance action for child entity, just like we have an action defined as 'Process SES'.
With this process, you can upload CSV file and process the records. You can try changing the logic to process XSLX file as well.

Writing/Unveiling ABAP Unit Tests for Table Functions

2024-04-16T13:01:57.878000+02:00

Introduction

In SAP ABAP development, writing robust code is essential for ensuring the stability and reliability of applications. One powerful tool for achieving this is the ABAP Unit, which allows developers to automate the testing process and validate the behavior of their code. In this blog post, we will explore how to write ABAP unit tests specifically for table functions.

ABAP CDS - Table Functions

A CDS table function is defined in the DDL source code of a CDS data definition in the ABAP development tools for Eclipse using the statement DEFINE TABLE FUNCTION in the CDS DDL of the ABAP Core Data Services (CDS). A CDS table function includes the following (including an example that is included later in the blog):

The CDS entity (e.g., ZFLIGHTS )
An AMDP function implementation ( e.g., ZCL_FLIGHT_DETAILS )

Here, we'll use a classic example of SFLIGHT data to illustrate the creation of the query within the table function.

- Table Function CDS Entity:

The following is the table function, equipped with a parameter to facilitate filtering during selection.

@EndUserText.label: 'Flights and its Details'
@ClientHandling.algorithm: #SESSION_VARIABLE
@ClientHandling.type: #CLIENT_DEPENDENT
define table function ZFLIGHTS
  with parameters
    @Environment.systemField: #CLIENT
    P_mandt     : abap.clnt,
    P_CarrierId : s_carr_id
returns
{
  key mandt        : abap.clnt;
  key carrierId    : s_carr_id;
  key connectionId : s_conn_id;
  key flightDate   : s_date;
      name         : s_carrname;
      planeType    : s_planetye;
      seatsMax     : s_seatsmax;
      currencyCode : s_currcode;
}
implemented by method
  ZCL_FLIGHT_DETAILS=>get_details;

- Implementation of the table AMDP function is below:

CLASS zcl_flight_details DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_amdp_marker_hdb.
    CLASS-METHODS get_details FOR TABLE FUNCTION zflights.

  PROTECTED SECTION.
  PRIVATE SECTION.

ENDCLASS.

CLASS zcl_flight_details IMPLEMENTATION.

  METHOD get_details BY DATABASE FUNCTION
              FOR HDB
              LANGUAGE SQLSCRIPT
              OPTIONS READ-ONLY
              USING s_flights s_carrier.

    RETURN select _flight.mandt,
                  _flight.CarrierId,
                  _flight.ConnectionId,
                  _flight.FlightDate,
                  _carrier.Name,
                  _flight.planetype,
                  _flight.seatsmax,
                  _flight.currencyCode
                  from
                  s_flights as _flight
                  left outer join
                  s_carrier as _carrier
                  on    _flight.mandt     = _carrier.mandt     and
                        _flight.CarrierId = _carrier.CarrierId
                  where _flight.mandt     = :P_mandt           and
                        _flight.CarrierId = :P_CarrierId;
  ENDMETHOD.

ENDCLASS.

Setting Up an ABAP Unit Environment

Before crafting tests for table functions, it is imperative to establish the ABAP unit environment. This process entails crafting a test class along with methods to assess the functionality of the table function. Let's initiate the creation of a class named ZCL_AUNIT_ZFLIGHTS, within which we'll create a local test class termed LCL_CL_AUNIT_ZFLIGHTS.

CLASS lcl_cl_aunit_zflights DEFINITION FINAL FOR TESTING DURATION SHORT RISK LEVEL HARMLESS.

  PUBLIC SECTION.
    CLASS-DATA: environment TYPE REF TO if_amdp_test_environment.

  PRIVATE SECTION.
    CLASS-METHODS class_setup.
    CLASS-METHODS class_teardown.
    METHODS setup.
ENDCLASS.

CLASS lcl_cl_aunit_zflights IMPLEMENTATION.

  METHOD class_setup.
    " For testing an AMDP table function which is a CDS table function source,
    " 1. One would need to configure the AMDP table function class and the method name in the AMDP test configuration step.

    " Here the AMDP method 'ZCL_FLIGHT_DETAILS=>GET_DETAILS' is a table function which is used as a source for the CDS table function 'CDSFRWK_TF_FLIGHT_BOOKING'.
    DATA(environment_config) = cl_amdp_test_environment=>create_test_configuration( ).
    environment_config->add_amdp_class( 'ZCL_FLIGHT_DETAILS' )->add_methods_for_unit_test( VALUE #( ( 'GET_DETAILS' ) ) ).

    environment = cl_amdp_test_environment=>create( environment_config ).
  ENDMETHOD.

  METHOD class_teardown.
    IF environment IS NOT INITIAL.
      environment->destroy( ).
    ENDIF.
  ENDMETHOD.

  METHOD setup.
    " Clears any existing test configuration on the test doubles which are set by other unit test methods.
    environment->clear_doubles( ).
  ENDMETHOD.
ENDCLASS.

In the method class_setup, the environment configuration is done, in which the name of the AMDP class and its method to be tested need to be given.

Mocking Data

For mocking data, we'll create a new method named test_cds_table_function within the private section of the test class. This method will facilitate the generation of mock data for testing purposes.

PRIVATE SECTION.
METHODS test_cds_table_function FOR TESTING RAISING cx_static_check.

By default, if no client is specified, the system client will be assumed. Since I aim to demonstrate data mocking at the client level, I'll simulate data for two distinct clients and execute the query with client-specific information.

- Procedure to mock the data:

"To get the object instance of the dependency used in the AMDP Implementation Class
DATA(lo_object) = environment->get_test_double( DEPENDENCY ).

"Set the client for which the data is being mocked
lo_object->get_view_content_config( )->for_client( CLIENT-INFO ).

"Set the content of the dependency
lo_object->get_view_content_config( )->set_content( CONTENT ).

The actual Implementation of the method is below:

  METHOD test_cds_table_function.

    DATA: lt_flights_001 TYPE STANDARD TABLE OF s_flights,
          lt_flights_714 TYPE STANDARD TABLE OF s_flights,
          lt_carrier_001 TYPE STANDARD TABLE OF s_carrier,
          lt_carrier_714 type standard table of s_carrier.

    lt_flights_001 = VALUE #( ( CarrierId = 'AA' ConnectionId = '0101' FlightDate = '20240101' planetype = 'A340-600'
                                seatsmax = '330' currencycode = 'USD' )
                              ( CarrierId = 'DL' ConnectionId = '0102' FlightDate = '20240201' planetype = 'A340-600'
                                seatsmax = '330' currencycode = 'USD' )
                              ( CarrierId = 'DL' ConnectionId = '0103' FlightDate = '20240301' planetype = 'A340-600'
                                seatsmax = '330' currencycode = 'USD' ) ).

    lt_carrier_001 = VALUE #( ( carrierid = 'AA' Name = 'American Airlines' )
                              ( carrierid = 'DL' Name = 'Delta Airlines' ) ).

    lt_flights_714 = VALUE #( ( CarrierId = 'AA' ConnectionId = '0104' FlightDate = '20240401' planetype = 'A340-600'
                                seatsmax = '330' currencycode = 'USD' )
                              ( CarrierId = 'DL' ConnectionId = '0105' FlightDate = '20240501' planetype = 'A340-600'
                                seatsmax = '330' currencycode = 'USD' )
                              ( CarrierId = 'DL' ConnectionId = '0106' FlightDate = '20240601' planetype = 'A340-600'
                                seatsmax = '330' currencycode = 'USD' ) ).

    lt_carrier_714 = VALUE #( ( carrierid = 'AA' Name = 'American Airlines' )
                              ( carrierid = 'DL' Name = 'Delta Airlines' ) ).

    " Get the test double of "S_FLIGHTS" & "S_CARRIER" from the test environment.
    DATA(lo_flight) = environment->get_test_double( 'S_FLIGHTS' ).
    DATA(lo_carrier) = environment->get_test_double( 'S_CARRIER' ).

    lo_flight->get_view_content_config( )->for_client( '001' ).
    lo_carrier->get_view_content_config( )->for_client( '001' ).

    lo_flight->get_view_content_config( )->set_content( lt_flights_001 ).
    lo_carrier->get_view_content_config( )->set_content( lt_carrier_001 ).

    lo_flight->get_view_content_config( )->for_client( '714' ).
    lo_carrier->get_view_content_config( )->for_client( '714' ).

    lo_flight->get_view_content_config( )->set_content( lt_flights_714 ).
    lo_carrier->get_view_content_config( )->set_content( lt_carrier_714 ).

    SELECT * FROM zflights( p_carrierid = 'DL' ) USING CLIENT '714' INTO TABLE (lt_result).

    cl_abap_unit_assert=>assert_equals(
      EXPORTING
        act                  = lines( lt_result )     " Data object with current value
        exp                  = 2                      " Data object with expected type
    ).

  ENDMETHOD.

While executing the query for client '714', LT_RESULT acquired the following records. The assertion verifies the successful retrieval of 2 records for client '714'.

Conclusion

Writing ABAP unit tests holds significant importance in SAP ABAP development. Thorough testing not only confirms the accuracy of table functions but also enhances the overall stability and performance of the system.

Happy Coding 🙂

Consume Restful Webservices using POST MAN

2024-04-19T15:56:31.284000+02:00

HTTP-based APIs integrate easily with RESTful web services. There are many ways to use HTTP methods to consume and update and retrieve these API data.

HTTP API methods and understand how to use them appropriately on resources

Method 1: GET

The most common HTTP method is GET, which returns a representational view of a resource's contents and data. GET should be used in read-only mode, which keeps the data safe, You should get the same results no matter how many times you use this method, unless it is modified by another client in the interim.

Method 2: POST

Post request used to create resource (Record ) in server, While creating record we have to pass Body data Parameters(key, values) to create the Record as JSON, Form formats are supported.

While submitting the data we have to update Header tab content type with application/JSON.

After create new record by using browser you will received updated data. By default Browsers using HTTP Protocol with GET method to retrieve data from service.

Method 3: PATCH

PATCH is another HTTP method used to update resources. As opposed to replacing resources, like the PUT method does, PATCH only modifies resource contents. As a general rule, these modifications worked based on Key.

While submitting the data we have to update Header tab content type with application/JSON.

Patch update the record based on Id, after update you will find latest records by refresh your browser.

We have create additional record 4 for other operations in above list.

Method 5: DELETE

The last HTTP method DELETE. When a DELETE method targets a single resource, that resource is removed entirely(Hard Delete). we have to pass based on Key ID (4).

Delete Method will delete the 4th record based on Key. after we can refresh browser data.

Authentication

Authentication tab help to protect the API data using different security ways.

Basic Authentication

Basic Authentication is a method of securing HTTP requests through a special header:

Authorization Tab

let’s send a GET request to a Basic Auth-secured endpoint and expect an Unauthorized status for the response:

Now, let’s add the credentials. To do this, we simply go to the “Authorization” tab and select “Basic Auth” as the authorization type. After that, we insert the username and password and we’re all set:

2) Authorization: Basic <credentials>

To generate the credentials token, we need to write the username and password, joined by the semicolon character. After that, we need to encode the resulting string with Base64.

Let’s assume the username is “admin” and the password is “baeldung“. First, we’ll create the credentials string, which will be “admin:baeldung“. Then, we’ll encode it with Base64, add the “Basic” keyword, and set it as the header’s value:

What is Bearer Authentication?

HTTP provides a framework for controlling access to protected resources. HTTP authentication is performed by sending authentication credentials in the authorization header to access the protected resource. Bearer authentication (also called token authentication) is one of the HTTP authentication schemes that grant access to the bearer of this token. Bearer token authentication is done by sending a security token with every HTTP request we make to the server. You can do bearer authentication with any programming language.

Bearer Token Authentication Syntax

Authorization: Bearer {token}

Postman displays the response data sent from the server in the lower pane.

Exploring GraphQL and REST for SAP Developers

2024-04-26T14:10:06.068000+02:00

I came across GraphQL while working on a side project and as a SAP Developer who worked a lot with REST APIs, I was wondering what advantages GraphQL could offer me, and how to apply it for different use cases. So, I decided to explore both APIs and how to use them in the SAP context. Here is a brief overview of my thoughts about both APIs.

Introduction

let's start with a brief definition of the APIs concept, APIs are the lifeblood of modern software development, bridging the gap between different systems. They define rules for accessing functionality and data remotely. Let's delve into API concepts and see how GraphQL and REST fit into the SAP world.

Over the past decade, REST has been the go-to for web APIs, but it's not without its flaws. Enter GraphQL, developed to tackle the shortcomings of REST and provide more flexibility and efficiency for developers.

Understanding APIs: APIs act as intermediaries facilitating communication between software applications. They come in two main flavors: SOAP, known for its strict standards, and REST, favored for its simplicity and scalability.

GraphQL: GraphQL, developed by Facebook, offers a more powerful alternative to REST. It allows clients to request specific data, reducing over-fetching issues common in REST APIs.

REST: REST, an architectural style for building networked applications, relies on stateless, client-server communication via HTTP.

Key Differences

Data Fetching: GraphQL enables precise data fetching with a single request, unlike REST which may lead to over-fetching or under-fetching.
Endpoint Complexity: REST APIs often require multiple endpoints, while GraphQL offers a single endpoint handling various data requests.
Versioning: REST commonly relies on versioning, unlike GraphQL which allows backward-compatible changes without versioning.
Caching: REST APIs leverage HTTP caching mechanisms, while GraphQL responses typically require additional configuration for caching.

Similarities

Both GraphQL and REST facilitate data exchange between services or applications, following a client-server model.

Architecture

Both are stateless and use a client-server model based on HTTP.

Resource-based Design

Both REST and GraphQL design data interchange around resources, each with its unique identifier and set of operations.

Data Exchange

Both support JSON as the primary data exchange format and caching for improved performance.

When to Use What?

Use REST When:

You need a straightforward and widely adopted solution.
Your data requirements are consistent and well-defined.
Caching is crucial for your application's performance.
You're working with legacy systems that are compatible with REST.

Use GraphQL When:

Your data requirements are dynamic and vary across different clients.
Over-fetching or under-fetching of data is a concern.
You want to reduce the number of API calls and improve efficiency.
You're developing a new application or service and want flexibility in data retrieval.

Conclusion

GraphQL and REST are vital for integration and data exchange in the SAP ecosystem. While REST is popular for its simplicity, GraphQL's flexibility is gaining traction. Understanding their nuances empowers SAP developers to design effective APIs for their solutions.

Adobe form with RAP Based OData Service

2024-05-14T10:53:12.611000+02:00

This blog emphasizes on the data source of custom developed Adobe form with fragments. But before we begin, below are the summarized instructions on the creation of a form Data Provider by SAP:

In SAP S/4HANA Cloud, the creation of a gateway service via SEGW is only possible by SAP.
The concept is intended to be "cloud-ready" under all circumstances.
It is not intended for the customer to create a form data provider, neither from on-premise nor from cloud. Only SAP creates a form data provider.
If the customer still uses on-premise, but later switches to cloud, there is no effort required to adapt.
The customer can create their own forms but must use a form data provider from SAP.
Typically, they will download a pre-delivered SAP template and create an adapted copy of it.
The customer’s form uses the same form data provider as the SAP template.

For details, please refer: https://learning.sap.com/learning-journeys/getting-started-with-sap-forms-service-by-adobe/explaining-master-form-templates_cb9c491f-6647-4165-b7ad-f357c6007902

Keeping in mind the information above, if business demands for the custom solution, then we can proceed creating custom data provider service for custom adobe form with fragments. In this blog, we will demonstrate Adobe form with fragment with form type – ‘Content’ without master form template.

To achieve that, we will be following below steps –

Create an Adobe form
Create an OData service
Map OData service to adobe form
Design form layout
Create an OData service act as a driver program to call the Adobe form
Consume driver OData service in UI5

Create an Adobe form:

Adobe forms with OData service can only be created through the Fiori app – ‘Maintain Form Templates’.

When we create an adobe form, we must specify a data source with OData service. But it does not list custom OData service by default. We also must upload a template while creating a form. For template, we can first create a layout without any bindings in Adobe LiveCycle Designer tool and save it as XDP file.

Alternatively, you can try to find a standard form which has similar attributes and copy it and create a custom adobe form. This will pick the template from the standard form which we can override with our changes.

Create an OData service:

Based on the complexity of data, we will decide which OData service creation is best suited for the requirement:

DDIC Based SAP Gateway OData Service
OData Service with Data Source Reference as CDS Views
SAP RAP OData V2 Service

The prerequisite for opting any of the above option is that there will always be a root entity which must have all the key fields like the parent node. Didn’t get it?

Let us understand it better with an example of standard OData service - FDP_EF_PURCHASE_ORDER which is used for an Adobe form MM_PUR_PURCHASE_ORDER –

This OData service has ‘PurchaseOrder’ as the parent node and ‘PurchaseOrderItems’ as the child node. The association of one to many has also been maintained –

Even though the parent node of the OData service is the Entity Set – ‘PurchaseOrder’. The entry point for this OData service is the Entity Set - ‘Query’, so we consider ‘Query’ as the root node.

For same reason, we have association and association sets are maintained between ‘QueryNode’ and ‘PurchaseOrderNode’ –

In case of RAP based OData service as well, we need to maintain the relationship in similar fashion that there will be a root node with composition to the node which is the parent node. And that parent node will again have composition node if needed.

So, for purchase order header and item, we will create a root node including the keys of purchase order header. Then we will create a child of the root node which will be purchase order header. And finally, we will create purchase order item as a child of purchase order header.

As for the prerequisite, we can see that the parent node - ‘PurchaseOrderNode’ has a key ‘PurchaseOrder’ –

And the root node ‘QueryNode’ also has the key ‘PurchaseOrder’ along with few more keys –

For developing a custom DDIC Based SAP Gateway OData service for adobe form, we can refer to any standard OData service such as FDP_EF_PURCHASE_ORDER from the Fiori app - ‘Maintain Form Templates’.

In this blog, we will demonstrate creating RAP based OData V2 service as a data source of adobe form. Note that SAP does not support OData V4 services for Adobe Forms developed through the Fiori app – ‘Maintain Form Templates’ as of today.

So, let’s dive to practical part and develop a RAP based OData V2 Web API. The steps are as follows:

As mentioned before, first we will create a root node ZSAC_R_PO_QUERY –

Then comes the parent node ZSAC_I_PO_HEADER which is purchase order header –

And then comes the child node ZSAC_I_PO_ITEM which is purchase order item –

It’s quite simple, right? It is just a two-level CDS hierarchy where the root node has all the key fields present in parent node.

Now we just create service definition ZSAC_UI_PURCHASE_ORDER, expose all three data definitions we just created –

And finally, we create a service binding of type OData V2 Web API as ZSAC_UI_PURCHASE_ORDER –

For OData service using Data Source Reference as CDS Views, we can design the CDS nodes relation in the manner explained above.

Map OData service to adobe form:

Now that OData service is created, map it to the custom form by opening it in T-code: SFP –

You can validate the change by checking for form in Fiori app – ‘Maintain Form Templates’ –

Design form layout:

Download the layout from the Fiori app –

Open Adobe LiveCycle Designer app and open the XSD file. Click yes to the below popup which will load the bindings from the custom OData service we created –

We can find the bindings under ‘Data View’ tab as shown below –

Once you design the form as per requirement, save it, and upload it back –

Create an OData service act as a driver program to call the Adobe form:

In our case, we need an OData service which take Purchase Order as input and return the PDF with details in the designed layout. For that, we will create a Custom entity-based RAP Web API.

CDS View - ZSAC_I_PO_PDF

Below is the logic in the query class ZSAC_CL_PDF –

CLASS zsac_cl_pdf DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .
  PUBLIC SECTION.
    INTERFACES if_rap_query_provider .
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS zsac_cl_pdf IMPLEMENTATION.

  METHOD if_rap_query_provider~select.

    DATA: lt_tab                   TYPE TABLE OF zsac_i_po_pdf,
          lv_content               TYPE  xstring,
          lo_cl_somu_form_services TYPE REF TO cl_somu_form_services,

          lt_keys                  TYPE cl_somu_form_services=>ty_gt_key.
    TRY.
        IF io_request->is_data_requested(  ).
          DATA(lv_offset) = io_request->get_paging( )->get_offset( ).
          DATA(lv_page_size) = io_request->get_paging( )->get_page_size( ).
          DATA(lv_max_rows) = COND #( WHEN lv_page_size = if_rap_query_paging=>page_size_unlimited
                                        THEN 0 ELSE lv_page_size )  .
       
   TRY.
              DATA(lt_parameters) = io_request->get_parameters( ).

              DATA(lv_po) =   VALUE #( lt_parameters[ parameter_name =  'P_PURCHASEORDER' ]-value OPTIONAL ).

              lt_keys =  VALUE #( ( name = 'PurchaseOrder'     value = lv_po ) ) .
              lo_cl_somu_form_services = cl_somu_form_services=>get_instance( ).

           TRY.
             lo_cl_somu_form_services->get_document( EXPORTING iv_form_name = 'ZZ1_PO_FORM'
                                                               it_key               = lt_keys
                                                     IMPORTING ev_content           = lv_content
                                                      ).

            CATCH cx_somu_error INTO DATA(lv_formerror).
            ENDTRY.

              lt_tab = VALUE #( ( pdf = lv_content   ) ).
              io_response->set_total_number_of_records( 1 ).
              io_response->set_data( lt_tab ).
            CATCH cx_rap_query_filter_no_range INTO DATA(lv_range).
              DATA(lv_msg) = lv_range->get_text( ).
          ENDTRY.
        ENDIF.

      CATCH cx_rap_query_provider.

    ENDTRY.
  ENDMETHOD.

ENDCLASS.

Logic explanation:

Taking the value from input parameter: P_PURCHASEORDER
Populating LT_KEYS with input parameters where we are expected to pass all the key fields mentioned in the root node ZSAC_R_PO_QUERY
Instantiate the class CL_SOMU_FORM_SERVICES
Call method GET_DOCUMENT of the class CL_SOMU_FORM_SERVICES by passing the adobe form name and LT_KEYS
Pass back the PDF as rawstring from LV_CONTENT to the custom entity.

For exposing the custom entity, create a separate Service Definition and Service Binding –

The reason why we created a separate Service Definition and Service Binding is because the OData Binding must have a root and only it’s child entities. If we add a custom entity in the binding which is not related to the root entity through association or consumption, we will get the error – “Service ZSAC_UI_PURCHASE_ORDER does not have a unique top node” when we call the adobe form.

To test the OData service, you can check in T-code: /IWFND/GW_CLIENT.

Consume driver OData service in UI5:

For consuming the OData service developed above in a Fiori application, you can write your own logic. To understand how PDF can be previewed, you could refer below blog –

https://community.sap.com/t5/technology-blogs-by-sap/preview-download-fragmented-forms-from-fiori-list-report-part-2/ba-p/13547933

If you are wondering, how to call adobe form having a master form template assigned? Refer the same blog mentioned above for added syntax.

As you may know that we cannot create a custom OData service and assign it to any form from the Fiori app ‘Maintain Form Templates’. If we are not using on-premise system, it is not possible to opt for the custom solution we developed above. It’s one of the reason SAP does not recommend creating custom data provider OData service in the first place.

Thanks for reading it.

How to enable automatic transport determination for the RAP BO of a customizing table

2024-05-18T18:00:00.023000+02:00

Introduction

If you use the ADT wizard to generate a business configuration maintenance object, the automatic transport determination is enabled by default as of release 2405. When the Edit action is performed, a customizing transport request is determined automatically. You can find the determination logic in the ABAP documentation of method get_transport_request of interface if_mbc_cp_rap_tdat_cts.

This blog shows you how to migrate an existing maintenance object to enable the automatic transport determination in edit mode.

If you do not want automatic transport determination, you can choose the option "Manual" instead of "Manual with preselection" when generating a new maintenance object in the wizard.

This blog is relevant for:

Behavior definition and implementation

In the behavior definition, add the annotation "with additional implementation" to the draft action Edit:

draft action ( features : instance ) Edit with additional implementation;

Save and activate. Place the cursor on Edit and use the quick assist (Ctrl+1) to generate the missing method implementation.
If you use a transport object, implement the method as follows. Adjust the placeholders my_singleton_entity_name and my_singleton_entity_alias accordingly.

  METHOD EDIT.
    CHECK lhc_rap_tdat_cts=>get( )->is_transport_mandatory( ).
    DATA(transport_request) = lhc_rap_tdat_cts=>get( )->get_transport_request( ).
    IF transport_request IS NOT INITIAL.
      MODIFY ENTITY IN LOCAL MODE my_singleton_entity_name
        EXECUTE SelectCustomizingTransptReq FROM VALUE #( ( %IS_DRAFT = if_abap_behv=>mk-on
                                                            SingletonID = 1
                                                            %PARAM-transportrequestid = transport_request ) ).
      reported-my_singleton_entity_alias = VALUE #( ( %IS_DRAFT = if_abap_behv=>mk-on
                                     SingletonID = 1
                                     %MSG = mbc_cp_api=>message( )->get_transport_selected( transport_request ) ) ).
    ENDIF.
  ENDMETHOD.

If the method IS_TRANSPORT_MANDATORY is not available because you do not use a transport object, use the following source code instead. Prior to release 2402, the ADT wizard did not generate a transport object by default. Adjust the placeholders my_singleton_entity_name, my_basis_table and my_singleton_entity_alias accordingly.

  METHOD EDIT.
    TRY.
        DATA(task_or_request) =  cl_bcfg_cd_reuse_api_factory=>get_transport_service_instance(
                                   iv_objectname = my_basis_table
                                   iv_objecttype = cl_bcfg_cd_reuse_api_factory=>simple_table )->get_transport_request( )->get_task( ).
        IF task_or_request IS NOT INITIAL.
          DATA(transport_request) = xco_cp_cts=>transport->for( task_or_request )->get_request( )->value.
        ENDIF.
      CATCH cx_bcfg_transport_request
            cx_xco_runtime_exception.
        CLEAR transport_request.
    ENDTRY.
    IF transport_request IS NOT INITIAL.
      MODIFY ENTITY IN LOCAL MODE my_singleton_entity_name
        EXECUTE SelectCustomizingTransptReq FROM VALUE #( ( %IS_DRAFT = if_abap_behv=>mk-on
                                                            SingletonID = 1
                                                            %PARAM-transportrequestid = transport_request ) ).
      reported-my_singleton_entity_alias = VALUE #( ( %IS_DRAFT = if_abap_behv=>mk-on
                                     SingletonID = 1
                                     %MSG = mbc_cp_api=>message( )->get_transport_selected( transport_request ) ) ).
    ENDIF.
  ENDMETHOD.

SAP Fiori Elements Feature Showcase App with RAP for Release 2402 - Why is it late?

2024-05-20T09:00:00.028000+02:00

What's New in 2402

Wait a minute, SAP BTP, ABAP Environment (aka Steampunk) is already on Release 2405, what do you mean that the Feature Showcase App (henceforth shortened to FSA) is only on release 2402?

Due to some unforeseen circumstances, we were unable to release FSA earlier according to schedule. So even though Steampunk is on 2405, the new features described here will only include those released with 2402. If you are new to the scene, read this blog post to find out what exactly is FSA.

At the risk of sounding cliché, better late than never. Let's begin!

RAP Treeview

Ignore the Folder Size in GB, it obviously doesn't tally up...

In RAP, it is possible to display a CDS Hierarchy as a readonly treeview in the object page. All you need is a database table, a base CDS view and a hierarchy. We show you this in the feature showcase app with a directory.

👆#RAPTreeview

Export RAP Treeview

What's your Favourite Colour

After building your hierarchy, you can now also export it to PDF.

👆#ExportTreeview

UI.adaptationHidden

Lock Up your UI Components...

UI adaptation is a feature of SAPUI5 flexibility that allows key users without technical knowledge to easily make UI changes for all users of an app, end users to personalize controls, and developers to extend the UIs of SAPUI5 applications.

However if you do not want to allow users this flexibility, it is possible to exclude UI components via an annotation.

👆#UI.adaptationHidden

RAP Streams as Read-Only

Protect your Upload from Being Edited

You can enable static or dynamic feature control for your stream properties at the list report or in the object page.

👆#StreamStaticFeatureCtrl-LR
👆#StreamDynamicFeatureCtrl-LR
👆#StreamStaticFeatureCtrl-OP
👆#StreamDynamicFeatureCtrl-OP

RAP Default Value Functions

Now Default Values can be Filled In Programatically

With the annotation UI.defaultValue we were able to set a default value for our action parameters, but it was only either a constant or using an existing value from a reference value. Now with the new default functions, you can define in the behaviour implementation what the default values should be, calculated or otherwise. And this works for create, create-by-association and also actions.

👆#DefaultFunction-ForCreate, -ForAction, -ForCBA

Hiding Datapoints

Playing Hide and Seek

If you are showing data points in the sections of your object page, it is possible to hide them using annotation UI.dataPoint.hidden. Beware of the constraints though, as UI does not support this for Header facet yet.

👆#DatapointHidden

RAP Simple Types

Simple to Use

You can create user-defined data types in ABAP CDS, which work similarly to Data Elements in DDIC, with the added advantage of CDS annotations.

👆#SimpleType

Additional Side Effects

2 additional side effects possibility are showcased in one new example:

$self as Source
permission of association as Target

👆#SelfAffectsPermissionAssociation

Bonus - Entity affects Field

Worka, workaround

One use case that we encountered was the possibility to change a field via side effect, after an instance of an associated entity was deleted. While there is currently no syntax to cater for this, a workaround was found.

👆#SideEffectWorkaround

What else is new?

More Structure means More to Click Through

The Guide that you are used to has now been updated into a new format, which 6 sections describing the different features, links available from README. If you are however used to the old format and search function, the Wiki is still updated with new contents.

👆#README

A gentle reminder

If you already have the previous version of the app in your system, run the data generator after you have done the pull and activated the objects. Feedback and comments are as always very much welcomed. See you next release!

Our Way into the Clean Core

2024-05-21T09:42:10.210000+02:00

Where are we coming from

We are a long-standing software partner of SAP, specializing in supply chain AddOns for nearly 20 years. We have different solutions inside of the portfolio and the older ones are more procedural coding, while the newer ones have more object oriented, more unit testing, and so on. But the big majority of all user interfaces are ALV Grid, ALV Tree and graphics (based on cl_gui_chart_engine). By the time we developed our own framework for these tools, so that it is easy to create several new containers with ALVs, letting the user decide, if he wants to use docking containers or dialogbox containers, support multi screens and so on.

In essence, we had a user interface that our end users greatly appreciated due to its ease of use. However, despite creating additional UI5 applications in recent years, most of our current users continue to work primarily within the SAP GUI. As a result, our initial plans were to gradually transition to more UI5-based applications. But the pressure to do so wasn’t significant, at least not from our customer base.

The majority of our customers continue to operate on onPremise systems. However, we also serve a significant number of private cloud customers. Interestingly, we have only one customer currently using a public cloud system. As for the software versions, most customers are still on ECC 6.0, although many are currently undergoing S/4 conversion projects. Despite this, we haven’t observed a substantial shift toward public cloud scenarios. But some customers are transitioning from their on-premise systems to private cloud environments.

Steampunk and embedded steampunk

Upon learning about steampunk in the context of public cloud scenarios, we decided to explore its potential. However, our assessment revealed more disadvantages than benefits for our specific situation.

Whitelisted APIs posed challenges, being slow and not always designed to meet our specific needs. Additionally, data availability was an issue—critical data often remained inaccessible via the whitelisted APIs.

Our unique challenge lies in providing highly integrative solutions that primarily operate on SAP documents, MRP results, capacities, production orders, and more. Unlike scenarios where data is merely replicated from the ERP system, our solution often involves real-time interactions with orders, order conversions, and other dynamic processes. Unfortunately, this doesn’t align well with the steampunk approach.

In 2021, we encountered the first information about embedded steampunk. A blog post featured the following picture, which caught our attention:

Direct access to (released) CDS-Views would give us the opportunity to read data in a fast way and without the need to replicate it onto other systems sounded good. Also BAdI usage was announced, RAP as the programming model, and maybe one codeline for onPrem, private and public cloud was also interesting.

Clean core project with SAP

And then in late 2022 we heard that SAP is looking for customers and partners, which want to participate in a pilot project for clean core development on private cloud systems. This would give us the opportunity to get more experience with clean core development, would get a glimpse at the new tools like the landscape portal, learn more about the changing software development process, etc. That sounded great, so we picked an smaller part of our application, where details of purchasing requirements are shown, with additional alerts, additional text functions, functions for releasing, source determination and conversion into purchase orders. That looked good as a first example, with which we would get our first experiences.

So we began to discuss the approach with the SAP project team members, started development and the SAP colleagues always helped us, when we were stuck, didn't know how special parts had to be implemented to fit the clean core requirements, etc.

Namespace and package structure

Our initial step involved creating a new namespace and package structure to house all our new code. As the project progressed and information about Tier 2 became more detailed, we also established an additional namespace and package structure specifically for Tier 2 development. In summary:

Tier 1: We maintain a separate namespace and package structure for Tier 1 components. All packages within the Tier 1 software component use the “ABAP for Cloud Development” language version.
Tier 2: A distinct namespace and package structure is dedicated to Tier 2 development. The language version for Tier 2 packages remains as “Standard ABAP.”
Our old legacy AddOn continues to exist as Tier 3.

To change the ABAP language version to “ABAP for Cloud,” execute the report "RSMAINTAIN_SWCOMPONENTS" (see screenshot).

Looking for the released APIs

The next step was, that we had to look for released APIs, to get our data read. For this we normally start on api.sap.com and then looking into the Product "SAP S/4HANA Cloud Private Edition" and checking the CDS View tab. This often helps, but sometimes it can get complicated to find the correct object. For example we were looking for the missing part indicator in the reservations. We quickly found reservation data, but this didn't offer the missing part indicator.

So we created an Customer-Influence Request (CI-Request), to get this field added to the existing CDS view. But the reply was, that we should use the CDS views of the planned order and production order, because the information is available there. Additionally we created a little helper report, where we could enter the old table and field name, which then checks for released or not released CDS views, which container this field.

When it got more clear, how the process is working with Tier 2, additionally the Cloudification Repository Viewer can be helpful, because you could easily look up, if an object is already released for Tier 1 or Tier 2.

We additionally decided to create an internal list to keep track of all our topics, the successor objects, CI-Request numbers for public and private cloud, etc.

But in total we will have to create most likely a few hundred CI-Request until we get most of our application transferred to the clean core and we will have to see, if some of our application won't be able to work in a clean core environment.

Time delays and non-strategic solutions

CI-Request take time… When we created CI-Request the response time was quite different. Some got early feedback, some took several weeks. And the majority of them, didn't get positive results immediately. Many needed additional information, why the information is important for us, and some were declined, because the information was belonging to solutions, which are not strategic for SAP, but still usable by our customers. This is of course problematic for us, because we cannot offer our customers a solution, if we don't get the data, even if the SAP solution is not officially obsolete.

Additionally it could take quite a long time, even if SAP is willing to modify or create an API for us. Let's sketch an example:

We want to offer a solution to private cloud and onPrem customers and an API is missing
We request this API on may 1st, 2024
SAP has some questions, but let's say give us a positive feedback two month later. After a positive feedback, it could of course take time to develop this API and this could of course interfere with the deadlines for specific SAP release cycles. But let's assume it will be directly available in the next private cloud and the next onPrem Release
With the current 2 year release cycle onPrem, this would be fall 2025
To use it for our own developments we would have to upgrade our own development system onto this level and would ideally ship the first product which is using this in 2026
This scenario is quite positive, depending on release cycles of SAP or ourselves it could be easily later…

And last but not least, the customer also have to be on SAP release 2025 and have our latest release installed. So from a todays point of view, it takes additional years until maybe half of our customers can use this function…

Tier 2

At least for some of these problems Tier 2 can be a solution. Tier 2 basically says, that SAP allows us the use of functionality, which has not been designed for clean core, but can still be used, until SAP has a new API available. So old function modules, database tables, and so on could get a tier 2 release, so that we might not have the above stated problem, but directly can use Tier 2, but also preparing our Tier 2 coding, so that it could later be easily replaced with the new API.

This tier 2 will be an own software component, where only the neccessary Tier 2 parts are available, and which releases it's data for the Tier 1 and Tier 3 software component, which basically results in the following installation sequence for customers:

Tier 2
Tier 1
Tier 3 (old legacy AddOn, until we have transferred all of it's functions and applications into Tier 1 and 2)

Success is a process

Since our AddOn is quite big and in many parts very integrated into the SAP system, this is not a fast and easy conversion, but it will take years. So our current plan is to transfer functionality year by year into the new solution, certify the new solution and in the first years our customers will normally be installing both solutions, the old legacy addon and the clean core solution, but in some years, maybe the old legacy addon will no longer be neccessary. It's currently not completely clear for us, how much data we will provide in the BTP layer, but there might also be some additional dashboards, etc. on this level. But since our applications are highly integrative the data part will be on-stack almost all of the time.

In the following graphic you can see he evolution of the feature scope which we are offering, and where the percentage of functions which shall be offered with a clean core certification will increase over the years.

Migrating applications and migrating code

When we want to migrate our solutions into the cloud, then it's a challenge on multiple levels. For new applications it might be a bit easier, because you can directly create the concept with regards to the available data and the UI5 possibilities.

It get's more complicated, when we are looking at old applications, which are still running with ALVs. On the one hand it's not uncommon, that not all of the data is available through released APIs, on the other hand even if the data is available, automatic checks of the current code are often difficult.

When I analyze the source code of an old application, all the data elements, structures, etc. which are connected to the old framework (for example ALVs) is not really relevant for me, because if I create it new there will be no ALV for the output. So I am mainly interrested in the selection and the processing of the data. If I am lucky, then data and framework are separated, but at least in our case it is not separated by packages, or something like this, so that I cannot build my object list for ATC checks only on the data level.

In our case it is normally separated through methods and form routines, so we did manual checks in these objects, which data we are reading, and checking the APIs afterwards. Since our solutions contains ~5.8 million lines of source code, we don't do this directly at once. Each of our different development teams picks an pilot application out of their product scope, which will be transformed first. Since the first transformations will be slower, due to the learning curve, this pilot application shouldn't be too large.

Since it is problematic, when we i.e. need 20 not released objects for one of the pilot applications, and we don't get alle important parts released (or released on a different times), we created CI requests with multiple objects as well. Of course this makes only sense, if alle the different objects are from the same SAP module, because otherwise the handling on SAP side would be difficult. But when they are in the same SAP module, this might make sense, so that we might get the objects released in the same time and it is clear, that we have problems if only some are successful.

Outlook

When we are looking at the clean core project until now, then we still think, that this is the way to go, at least for solutions, which are tightly coupled with ERP processes and data. Otherwise it might make sense to check, if the solution should be created on the BTP.

But the clean core on-stack development looks good as a replacement for the classical on-stack development. Of course, this topic is still quite new and therefore there are still some problems, but we are seeing that SAP is trying to build up a good development and delivery process for clean core.

How to implement additional authorization objects for the RAP BO of a customizing table

2024-05-24T15:38:39.591000+02:00

Introduction

If you use the ADT wizard to generate a business configuration maintenance object, the authorization control is based on authorization object S_TABU_NAM and the CDS view entity name of the base table.

This blog shows you how to implement additional authorization objects.

This blog is relevant for:

Use case 1: no CDS elements of the CDS entity are relevant for the access condition

You want to use additional authorization objects that are independent of the CDS elements of the CDS entity. This means that the configuration user can either read/edit all entities or none. This setup is recommended as the configuration user should not only work with a subset of configuration entries.

Proceed as follows:

1. Enhance the generated access control for the table entity. In this example, the authorization object ZAO_PROFILE is added.

@MappingRole: true
define role ZI_Example {
  grant select on ZI_Example
  where ( ) = ASPECT pfcg_auth ( 'S_TABU_NAM', ACTVT = '03', TABLE = 'ZI_EXAMPLE' )
  AND ( ) = ASPECT pfcg_auth ( 'ZAO_PROFILE', ACTVT = '03', PROFILE = 'CONFIGURATION' ) ;
}

2. In the generated behavior implementation class, enhance all authorization checks:

  METHOD get_global_authorizations.
    DATA(is_authorized) = if_abap_behv=>auth-unauthorized.
    AUTHORITY-CHECK OBJECT 'S_TABU_NAM' ID 'TABLE' FIELD 'ZI_EXAMPLE' ID 'ACTVT' FIELD '02'.
    IF sy-subrc = 0.
      AUTHORITY-CHECK OBJECT 'ZAO_PROFILE' ID 'PROFILE' FIELD 'CONFIGURATION' ID 'ACTVT' FIELD '02'.
      IF sy-subrc = 0.
        is_authorized = if_abap_behv=>auth-allowed.
      ENDIF.
    ENDIF.
    result-%update      = is_authorized.
    result-%action-Edit = is_authorized.
    result-%action-SelectCustomizingTransptReq = is_authorized.
  ENDMETHOD.

Use case 2: CDS elements of the CDS entity are relevant for the access condition

You want to use additional authorization objects that refer to the CDS elements of the CDS entity. This means that the configuration user may only be able to work with a subset of the configuration entries.

Example objects

The example table for plants contains the field REGION (EMEA, NA, ...) to be used for authorization control.
The configuration expert shall only work with plants from a specific region.

@EndUserText.label : 'Plant'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #C
@AbapCatalog.dataMaintenance : #ALLOWED
define table zplant {
  key client            : abap.clnt not null;
  key plant_id          : abap.numc(3) not null;
  region                : zd_region;
  last_changed_at       : abp_lastchange_tstmpl;
  local_last_changed_at : abp_locinst_lastchange_tstmpl;
}

For this purpose, an authorization object ZAO_REGION with the authorization field ZAF_REGION is created based on the data element ZD_REGION.

Adjust Authorization Control Object

Add the authorization object ZAO_REGION to the generated access control object of the table entity. This access control restricts read access to the data returned by the CDS view. For example, what you can see when you open the Custom Business Configurations app in read-only mode.

@MappingRole: true
define role ZI_Plant {
  grant select on ZI_Plant
  where ( ) = ASPECT pfcg_auth ( 'S_TABU_NAM', ACTVT = '03', TABLE = 'ZI_PLANT' )
  and ( Region ) = ASPECT pfcg_auth ( 'ZAO_REGION', ACTVT = '03', ZAF_REGION ) ;
}

Create Draft Query view

When you switch to edit mode, a draft version is created for all entities. Since the access control for the CDS view is not applied to the draft table, the user can see the draft version for entities that they would not see in display mode. To restrict read access for the draft entity, a draft query view is required.

1. Right-click the draft entity table and choose New Data Definition.
2. Enter ZR_PLANT as Name and Draft Query View: Plant as Description.
3. Select defineViewEntity as a template.
4. Set authorizationCheck to CHECK.

@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Draft Query View: Plant'
define view entity ZR_PLANT
  as select from zplant_d
{
  key plantid                       as Plantid,
      region                        as Region,
      lastchangedat                 as Lastchangedat,
      locallastchangedat            as Locallastchangedat,
      singletonid                   as Singletonid,
      draftentitycreationdatetime   as Draftentitycreationdatetime,
      draftentitylastchangedatetime as Draftentitylastchangedatetime,
      draftadministrativedatauuid   as Draftadministrativedatauuid,
      draftentityoperationcode      as Draftentityoperationcode,
      hasactiveentity               as Hasactiveentity,
      draftfieldchanges             as Draftfieldchanges
}

Create an Authorization Control Object for the Draft Query View:

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

In the behavior definition add the query annotation to the draft table:

draft table zplant_d query ZR_PLANT

Implement Prechecks for Operations

It must be prevented that the configuration user can create/update/delete plants for regions for which they are not authorized. This can be achieved with a pre-check of the operation.

In the behavior definition, add the annotation precheck to the action create in the singleton entity and the action update, delete in the table entity:

association _Plant { create ( features : instance, precheck ); with draft; }

update( features : global, precheck );
delete( features : global, precheck );

Place the cursor on the actions and use the quick assist (CTRL+1) to create the missing method implementations:

  METHOD precheck_cba_Plant.
    LOOP AT entities ASSIGNING FIELD-SYMBOL(<entity>).
      LOOP AT <entity>-%target ASSIGNING FIELD-SYMBOL(<plant>).
        AUTHORITY-CHECK OBJECT 'ZAO_REGION' ID 'ZAF_REGION' FIELD <plant>-Region ID 'ACTVT' FIELD '01'.
        CHECK sy-subrc <> 0.
        APPEND VALUE #( %cid = <plant>-%cid
                        ) TO failed-plant.
        APPEND VALUE #( %cid = <plant>-%cid
                        %element-Region = if_abap_behv=>mk-on
                        %msg = new_message_with_text( text = |Not authorized to create plants in region { <plant>-region }| ) ) TO reported-plant.
      ENDLOOP.
    ENDLOOP.
  ENDMETHOD.

  METHOD precheck_update.
    LOOP AT entities ASSIGNING FIELD-SYMBOL(<plant>).
      AUTHORITY-CHECK OBJECT 'ZAO_REGION' ID 'ZAF_REGION' FIELD <plant>-Region ID 'ACTVT' FIELD '02'.
      CHECK sy-subrc <> 0.
      APPEND VALUE #( %cid = <plant>-%cid_ref ) TO failed-plant.
      APPEND VALUE #( %cid = <plant>-%cid_ref
                      %element-Region = if_abap_behv=>mk-on
                      %msg = new_message_with_text( text = |Not authorized to change plants in region { <plant>-region }| ) ) TO reported-plant.
    ENDLOOP.
  ENDMETHOD.

  METHOD precheck_delete.
    READ ENTITY IN LOCAL MODE zi_plant
    FIELDS ( region ) WITH CORRESPONDING #( keys )
    RESULT DATA(plants).
    LOOP AT plants ASSIGNING FIELD-SYMBOL(<plant>).
      AUTHORITY-CHECK OBJECT 'ZAO_REGION' ID 'ZAF_REGION' FIELD <plant>-Region ID 'ACTVT' FIELD '06'.
      CHECK sy-subrc <> 0.
      READ TABLE keys WITH KEY draft COMPONENTS %tky = <plant>-%tky ASSIGNING FIELD-SYMBOL(<key>).
      APPEND VALUE #( %cid = <key>-%cid_ref ) TO failed-plant.
      APPEND VALUE #( %cid = <key>-%cid_ref
                      %element-Region = if_abap_behv=>mk-on
                      %msg = new_message_with_text( text = |Not authorized to delete plants in region { <plant>-region }| ) ) TO reported-plant.
    ENDLOOP.
  ENDMETHOD.

Consider using the authorization control also for value helps, for example, the user can only select the region for which he or she is authorized. Consider adapting or using operation defaulting so that, for example, the region field is set to the region for which the user is authorized when creating a new plant.

Develop an application utilizing the RAP Web API with SAP Build Apps framework in S4Hana OnPremise

2024-06-16T13:17:48.896000+02:00

In this blog it will be shown how SAP Restful Application Programming Model can be used and consumed in SAP Build App to create an APP.

Technology used:

SAP RAP
SAP Build Apps
SAP BTP

Development Steps:

1. Create RAP Model objects in Managed scenario.

Database Table
Interface View
Transactional View
Consumption View
Transactional Behavior Definition
Consumption Behavior Definition
Service Definition
Service Binding

2. The Service Binding should be published as Web API.

3. Create a Destination .

4. Create A SAP App in SAP Build Apps using the RAP service.

5. Home Page to Display list of records.

6. Update Page to Create New Records.

Test :

Open the APP in Preview Mode. It will display all the existing records in the Table using RAP service.

2. After click ‘Create New Student’ button Update page will open. Create a New Record.

3. After Create button clicked. New record will be created using RAP Post service.

4. You can also see the data in ADT Data Preview .

This blog summarizes how to utilize RAP services within SAP Build Apps, detailing necessary configurations in SAP BTP.

Extending a Standard API - A Guide to Enhancing API_QUALITYNOTIFICATION

2024-06-26T18:13:09.567000+02:00

Hello SAP Community Members,

We hope this post finds you well.

While there are few others which generalizes on extending standard APIs, we would like to call out the steps required to extend the API_QUALITYNOTIFICATION, should you have the same requirement(s).

Our goal is to add a field to the standard API response. This process can be adapted to add or extend multiple fields as needed.

Finding the Service Definition for the Standard API

The first step is to locate the Service Definition. For our example, the Service Definition is API_QUALITYNOTIFICATION. You can find the Service Definition using the API URL or alternatively, you can use Eclipse to perform a pattern search with the API name.

Once you have the Service Definition, identify the fields within the entities present in the service definition. For our requirement, we needed to add the NotificationPriorityText field. The path for this field is as follows:

> A_QltyNotification (viewEntity)
> R_QltyNotificationTP (viewEntity)
> I_QltyNotification (View)
> I_Notification (View)
> I_NotificationPriority (View)
> I_NotificationPriorityText (View)
> NotificationPriorityText (Field)

Creating extendView / extendViewEntity

To begin, create a new Data Definition using the template VIEW > extendView.
[Choose extendView if the original data source is a View, or extendViewEntity if the original data source is a viewEntity.]

In our case, we extended I_QltyNotification first as it was the initial CDS view from the top (note that associations cannot be used in an extendViewEntity).

extend view I_QltyNotification with <YOUR EXTEND VIEW NAME>
association [1..1] to I_NotificationPriorityText as _NotificationPriority1 on
_NotificationPriority1.NotificationPriority = $projection.notificationpriority and
_NotificationPriority1.NotificationPriorityType = $projection.notificationprioritytype and
_NotificationPriority1.Language = $projection.masterlanguage
{
  _NotificationPriority1.NotificationPriorityText
}

Important Notes:

- Always choose the first CDS view from the top to minimize the number of extended views needed.
- Ensure all key fields are included in the association's ON condition. For I_NotificationPriorityText, this includes NotificationPriority, NotificationPriorityType, and Language.

Next, proceed step by step, creating one extendView / extendViewEntity at a time and adding your extended field. For our example, after extending I_QltyNotification, we extended R_QltyNotificationTP (viewEntity) next.

extend view entity R_QltyNotificationTP with {
    Notification.NotificationPriorityText
}

Finally, extend A_QltyNotification (CDS View Entity), which is already exposed in the API_QualityNotification Service Definition.

extend view entity A_QltyNotification with
{
    _QltyNotification.NotificationPriorityText
}

Conclusion

You have successfully extended the standard API. The newly added field can now be seen in the standard API response.

Feel free to reach out if you have any questions or need further clarification.

ABAP RESTful Application Programming Model (RAP)

2024-06-28T16:07:38.695000+02:00

Introduction

The SAP landscape has evolved significantly, with businesses seeking simpler, more efficient solutions that offer excellent user experiences. Many organizations remain deeply embedded in the SAP ecosystem, primarily focusing on ABAP over other languages. So, is it possible to develop feature-rich applications without other frontend languages? Yes, leveraging ABAP with RAP (ABAP Restful Application Programming) makes it possible.

Restful Application Programming is an ABAP programming model for creating business applications and services in an AS ABAP or BTP ABAP environment. RAP offers a standardized way of developing applications using Core Data Services (CDS), the modernized extended ABAP language, OData protocol, and the concept of business objects and services. RAP applications can only be created through ABAP development tools (ADT) and it’s available in SAP BTP ABAP Environment, SAP S/4 HANA Cloud, and AS ABAP >=7.56.

Before digging deeper into RAP, let’s explore CDS, annotations, and business services. To illustrate these concepts, let’s create a simple read-only list report application.

Developing an OData Service for simple list reporting

An OData service follows the best practices for developing and consuming RESTful APIs. This service can be used in SAP Fiori applications and can also be exposed as Web APIs. Below are the steps for creating a simple list report application:

Let’s explore each step in detail by creating the application.

Sample requirement: Create a read-only list report application which shows purchase order information.

Create an interface CDS view which takes data from Purchase Order Header (EKKO) and Item (EKPO).

Create two interface CDS views for showing master data of purchase order type and material details.

Make an association between the purchase order type CDS view and material details CDS view from the purchase order header/item CDS view. The associated views will act as Search Help in the list report after applying the annotations.
- Create a consumption view on top of the Purchase Order Header/Item interface view (ZI_PURCHASE_ORDER_RVN).
The UI annotations needed for the application are written in the consumption CDS View or Metadata Extensions.

Now, we have the data model and the required annotations to manifest semantics for it. The next step is to create the OData service and binding the service.
To define a service, we first need to create a service definition. In service definition, we specify the CDS entities that need to be exposed. In this example, the gateway client is replaced by the service definition and service binding.

As a last step, create the service binding for service definition.

Set the binding type as OData V2 – UI, since this is an OData V2 service.

After publishing the service, the exposed entity and associated entities will be visible. Click on the entity and click the preview button to see the preview of the application.

Purchasing Doc Type Search Help

Material Search Help

Conclusion

This blog serves as an introduction to developing OData services for simple list reporting using the ABAP Restful Application Programming (RAP) model. By following the steps outlined, you can create a read-only list report application that showcases purchase order information. We have covered the basics of creating CDS views, defining and binding OData services, and incorporating annotations for enhanced functionality.

This is just the beginning of what you can achieve with RAP. As you explore further, you will discover more advanced features and capabilities that can help you build robust, scalable, and user-friendly applications within the SAP ecosystem.

Happy Learning and exploring the vast possibilities with RAP!

References

https://help.sap.com/docs/abap-cloud/abap-rap/abap-restful-application-programming-model

https://help.sap.com/docs/abap-cloud/abap-rap/cds-annotations

SAP RAP Unmanaged scenario example-Simplified

2024-07-04T06:47:06.640000+02:00

SAP RAP (ABAP RESTful Application Programming Model) has two main flavors: managed and unmanaged. Let's focus on the unmanaged version.

Unmanaged SAP RAP refers to a development approach where developers have more control over the data persistence and business logic compared to the managed approach. Here are some key aspects:

Custom Logic: In unmanaged RAP, developers write their own custom logic for handling data retrieval, manipulation, and persistence. This gives more flexibility in how data is processed and stored.
Direct Database Access: Developers can directly access the database tables and define their own data models using Core Data Services (CDS) views or ABAP classes.
Explicit Service Definition: Unlike managed RAP, where service definitions are automatically generated based on annotations, unmanaged RAP requires developers to explicitly define service implementations and behaviors.
Manual CRUD Operations: CRUD (Create, Read, Update, Delete) operations need to be implemented explicitly in unmanaged RAP, giving full control over how data is managed.
Integration with Existing Systems: Unmanaged RAP is often used when integrating with existing systems or when there is a need for complex business logic that cannot be easily handled by the managed approach.
Flexibility: Developers have more freedom to implement complex validation rules, authorization checks, and other custom requirements directly in the application logic.

Overall, unmanaged SAP RAP provides a more hands-on approach to application development compared to the managed approach, allowing developers to leverage their expertise in ABAP programming and database handling while building modern RESTful APIs.

Top of Form

In this example, we will show a simple application for Employee build with RAP Unmanaged flavors.

Development steps.

To be summarized below object will be created for Unmanaged scenario.

Table ZT01_EMPLOYEE

Base CDS View Z_I_EMPLOYEES_U

Consumption CDS view Z_C_EMPLOYEES_U

Behavior Definition

Bottom of Form

Behavior definition

Implement the Create method

Implement Update Method

Implement Delete Method

Implement Adjust_Numbers method.

Implement Save method.

Test

Open the Application.

2. Click on Create. Give Input value and Create.

3. New Record got created.

4. Select any Row , click on Edit.

5. Change the value and Save.

6. Record will be updated.

7. Select the Rows and click on Delete.

8. Records will be deleted.

9. In the Database table also you can see the records.

So, all the CRUD operation is successful using RAP Unmanaged flavors.

Using Multivaluefield with RAP ODATAV4

2024-07-12T15:38:36.592000+02:00

INTRODUCTION
Although the multivaluefield component in RAP ODATA v4 is technically similar to the multiinput component we used before, it is structurally different and a little more complex to use. In ODATA v4 structure, if we need multiple value input, we need to use multivaluefield. I will simplify the use of multivaluefield, which has a more complex structure compared to other components, and explain it in detail in this blog post.

Basically, if we need a multivaluefield in an application, the structure in the cds should be create in the most correct way.

It is necessary to create a structure in which the asset to be given as a context is connected with a 1-N relationship.

!! This relationship must be added in projection view.

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Main CDS Label'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.usageType:{
    serviceQuality: #X,
    sizeCategory: #S,
    dataClass: #MIXED
}
define root view entity  main_cds_name
  as select from source_table as Table
  composition [1..*] of child_entity (CDS view)  as _ChildEntity
{
  key key1   as Key,
    //other properties
   //Child
   _ChildEntity
}

On the UI side, since the multivaluefield component will be linked to a field in the child entity, a valuehelp annotation must be added to the corresponding field in this child entity.

@EndUserText.label: 'Child entity cds label'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.usageType:{
    serviceQuality: #X,
    sizeCategory: #S,
    dataClass: #MIXED
}

define view entity child_entity
  as select from source_table_for_child as _ChildEntity
 association [0..1] to valuehelp    as _ValueHelp on 
                                 $projection.header = _ ValueHelp.header
{
  //other properties
      @Consumption.valueHelpDefinition: [{ entity: { name: 'valuehelp', element: 'HeaderIdConcat' } }]
      header_id              as HeaderId,
      _ ValueHelp.HeaderId as HeaderIdText,
      //association
      _ ValueHelp,
}

After this structure is created with Restful ABAP and the ODATAV4 service is published, we can use the multivaluefield component on the ui side.

A custom page application is created with new project from template using BAS.

 <macros:MultiValueField
           id="idMultivalufield"
           metaPath="_ChildEntity/HeaderId" />

The view will be as follows.

and Valuehelp appear like follows.

Note: If there is a custom workflow and the draft structure is not used, the MultiValueField component may come in "display" mode as the edit mode when the create property is not provided. In these cases, you can activate the edit mode of the component from the controller with the setEditMode("Editable") function.

Note: If multivalufield valuhelp is to be displayed as a dropdown and not as a dialog, the following structure can be added to the annotation.

  <Annotations Target="SAP__self.childEntity/HeaderId">
     <Annotation Term="SAP__common.ValueListWithFixedValues" Bool="false">
     </Annotation>
  </Annotations>

SAP RAP - Trigger workflow events upon save action in RAP Applications

2024-07-16T18:39:36.729000+02:00

Hello SAP Community,

In this post, I will walk you through a technical solution for triggering workflow events from the save action of a Restful ABAP Programming (RAP) application. We aim to assign a buyer to each Purchase Requisition and send a workflow confirmation dialog to the buyer's inbox for necessary actions, such as creating a purchase order.

The main idea here is to utilize the unmanaged save in the behavior definition to call a function module in the background.

Using a managed save, the 'save' implementation method restricts you from calling functions, performing rollbacks, commits, or using classic ABAP statements. In contrast, an unmanaged save provides the 'save_modified' method, which allows you to call a function module in a background task and addresses the limitations of classic ABAP statements.

For more information, you can refer to this Q&A thread.

Let's dive into the implementation details.

Scenario

We need to assign a buyer to each Purchase Requisition. Once the buyer is assigned, a workflow confirmation dialog is sent to their inbox, prompting them to take necessary actions, such as creating a purchase order.

Solution Outline

To achieve this, we'll use an unmanaged save in the behavior definition to call a function module in the background. Here's a step-by-step guide on how to implement this solution.

Note: I will include my complete solution. You might notice several options in the behavior definition. such as:

authorization master (instance);
update (features: instance, precheck);

These instance options enable you to check for edit authority (i.e., who has the edit role).

Additionally, the validation ensures that the Buyer field is validated upon the save action.

validation validateBuyer on save { field Buyer; create; update; }

1. Apend the field Buyer which is from type same as system user (char12)

Note: I prefer to create a new z table without appending the field to standard table EBAN, but I used this case because I was searching for a way to add this editable field in standard screen of Purchase requisition ME53N .. anyway lets complete the structure ZEBAN is append structure for standard table EBAN

2. Implement the RAP Application Logic:

Create CDS View: we will use standard cds I_PurchaseReqnItem as reference because our app is most like the standard fiori app Process Purchase Requisitions (App ID F1048)

@EndUserText.label: 'PR Buyer Assign'
@Metadata.allowExtensions: true

@ObjectModel.modelCategory: #BUSINESS_OBJECT
@ObjectModel.compositionRoot: true
@ObjectModel.transactionalProcessingEnabled: true
@ObjectModel.writeActivePersistence: 'ZMM_PR_BUYER_BO'

@ObjectModel:{
createEnabled: true,
updateEnabled: true,
deleteEnabled: true
}
@Search.searchable: true


define root view entity ZCDS_PR_Buyer_Assign

as select from I_PurchaseReqnItem as header
    inner join eban on eban.banfn = header.PurchaseRequisition and eban.bnfpo = header.PurchaseRequisitionItem
    association [0..1] to I_PurchasingGroup as _PurchasingGroup on  $projection.PurchasingGroup = _PurchasingGroup.PurchasingGroup
  association [0..1] to pa0001 as pa on $projection.RequisitionerName =  pa.pernr
{

      //@Consumption.valueHelpDefinition: [{entity:{name:'C_PurchaseReqnHeader' , element: 'PurchaseRequisition'}}]
      @Consumption.valueHelpDefinition: [{entity:{name:'ZCDS_PR_SEARCH_VALUE' , element: 'PurchaseRequisition'}}]
      @Consumption.semanticObject: 'PurchaseRequisition'
      //semanticObjectAction : 'displayAdvanced'
      key header.PurchaseRequisition,
      
      @ObjectModel.readOnly: true
      header.PurchaseRequisitionItem,

      @Consumption.valueHelpDefinition: [{entity:{name:'/BSNAGT/P_USR21' , element: 'bname'}}]
      @ObjectModel.readOnly: false
      eban.buyer as Buyer,
      
      @ObjectModel.readOnly: false
      eban.comments as Comments,
      
      @ObjectModel.readOnly: true
      header.PurchaseRequisitionType,

      @Consumption.filter.hidden:true
      @ObjectModel.readOnly: true
      @ObjectModel.virtualElement : true
      @ObjectModel.virtualElementCalculatedBy: 'ABAP:ZCL_PURCHASEREQN_PROF_TRA_EXT'
      // cast('' as batxt)                      as PurchasingDocumentTypeName,
      cast('' as abap.char( 20 ))          as PurchasingDocumentTypeName,


      @ObjectModel.readOnly: true
      @Consumption.semanticObject: 'Supplier'
      header.Supplier,
      
      @ObjectModel.virtualElement : true
      @ObjectModel.virtualElementCalculatedBy: 'ABAP:ZCL_PURCHASEREQN_PROF_TRA_EXT'
      @ObjectModel.readOnly: true
      @EndUserText.label: 'Number of Items'
      cast(0 as abap.int8 )                as NumberOfItems,

      header.PurchasingDocumentSubtype,

      @EndUserText.label: 'Total Value'
      @Semantics.amount: {currencyCode: 'Currency'}
      @ObjectModel.readOnly: true
      @ObjectModel.virtualElement : true
      @ObjectModel.virtualElementCalculatedBy: 'ABAP:ZCL_PURCHASEREQN_PROF_TRA_EXT'
      cast ( ('00')  as abap.curr(15,2) )  as TotalNetAmount,

      @EndUserText.label: 'Currency'
      @ObjectModel.readOnly: true
      @ObjectModel.virtualElement : true
      @ObjectModel.virtualElementCalculatedBy: 'ABAP:ZCL_PURCHASEREQN_PROF_TRA_EXT'
      cast ( ('')    as abap.cuky( 5 ) )   as Currency,
      
      @ObjectModel.readOnly: true
      header.Material,
      
      @ObjectModel.readOnly: true
      header.PurchaseRequisitionItemText,
      
      //@Semantics.businessDate.at:true
      //header.CreationDate, //this is BADAT field originally
      @ObjectModel.readOnly: true
      eban.creationdate as CreationDate,
      
      @ObjectModel.readOnly: true
      header.Plant,
      
      @ObjectModel.readOnly: true
      header.PurReqnReleaseStatus,
      
      @ObjectModel.readOnly: true
      header.PurchasingGroup,
      
      @ObjectModel.readOnly: true
      _PurchasingGroup.PurchasingGroupName as PurchasingGroupName,
      
      @ObjectModel.readOnly: true
      header.ProcessingStatus,
      
      @ObjectModel.readOnly: true
      header.RequisitionerName,
      //pa0001.ename as RequisitionerNameFull
      
      @ObjectModel.readOnly: true
      header.CreatedByUser,
      
      @ObjectModel.readOnly: true
      pa.ename as CreatedByFullName
      
}

where
header.PurchaseRequisitionItem = '00010'
and header.ProcessingStatus = 'N'
and header.PurReqnReleaseStatus = '05'
and header.PurchaseRequisitionType <> 'NB'

2.class for virtual elemets ZCL_PURCHASEREQN_PROF_TRA_EXT

class ZCL_PURCHASEREQN_PROF_TRA_EXT definition
  public
  final
  create public .

public section.

  interfaces IF_SADL_EXIT .
  interfaces IF_SADL_EXIT_CALC_ELEMENT_READ .
protected section.
private section.

  data MO_PURCHASEREQN_API type ref to CL_PURCHASEREQN_PROF_BOPF_API .
ENDCLASS.

CLASS ZCL_PURCHASEREQN_PROF_TRA_EXT IMPLEMENTATION.

  METHOD IF_SADL_EXIT_CALC_ELEMENT_READ~CALCULATE.

    DATA lt_calculated_purchasereqn TYPE tt_cpurreqn.
    DATA lt_calculated_purchasereqn2 TYPE table of ZCDS_PR_Buyer_Assign.

    DATA(lo_purchasereqn_api) = cl_purchasereqn_prof_bopf_api=>get_instance( ).

    "proceed only if atleast one row of data was read
    IF it_original_data IS NOT INITIAL.

      "only if atleast one of the transient fields are requested
      IF line_exists( it_requested_calc_elements[ table_line = 'PURREQNHEADERDESCRIPTION' ] )
        OR line_exists( it_requested_calc_elements[ table_line = 'TOTALNETAMOUNT' ] )
          OR line_exists( it_requested_calc_elements[ table_line = 'CURRENCY' ] )

              "Added in 1908 Dev code as a part of refactoring
              OR line_exists( it_requested_calc_elements[ table_line = 'NUMBEROFITEMS' ] )
              OR line_exists( it_requested_calc_elements[ table_line = 'PURCHASINGDOCUMENTTYPENAME' ] )
              .

***************performance improvement code*************************

        CALL METHOD lo_purchasereqn_api->calc_header_transient_fields
          EXPORTING
            it_original_data       = it_original_data
          IMPORTING
            et_purchasereqn_header = lt_calculated_purchasereqn.

***************performance improvement code*************************

        MOVE-CORRESPONDING lt_calculated_purchasereqn TO lt_calculated_purchasereqn2.

        MOVE-CORRESPONDING lt_calculated_purchasereqn2 TO ct_calculated_data.

      ENDIF.

    ENDIF.

  ENDMETHOD.

  METHOD IF_SADL_EXIT_CALC_ELEMENT_READ~GET_CALCULATION_INFO.

  ENDMETHOD.
ENDCLASS.

As you notice it is also copy from the standard one for virtual elements.

3.Create Metadata Extension:
Use the annotation in main CDS @Metadata.allowExtensions: true to allow extensions.

This extension manages the object page in fiori element app.

@Metadata.layer: #PARTNER
@Search.searchable: true
annotate view ZCDS_PR_Buyer_Assign with
{

  @Search: {defaultSearchElement: true, ranking: #MEDIUM, fuzzinessThreshold: 0.8}
  : {
  lineItem: [ { position: 10, importance: #HIGH } ],
  selectionField: [ { position: 10 } ],
  identification:[ { position: 10 } ]
  }
  PurchaseRequisition;
  
  : {
  lineItem: [ { position: 20, importance: #HIGH } ],
  selectionField: [ { position: 20 } ],
  identification:[ { position: 20 } ]
  }
  Buyer;
  
  : {
  lineItem: [ { position: 30, importance: #HIGH } ],
//  selectionField: [ { position: 30 } ],
  identification:[ { position: 30 } ]
  //multiLineText: true
  }
  Comments;
}

4.Behavior Definition (Unmanaged Save):

managed implementation in class zbp_cds_pr_buyer_assign unique;

define behavior for ZCDS_PR_Buyer_Assign 
lock master
authorization master ( instance )
with unmanaged save
{
  update ( features : instance, precheck );
  delete ( features : instance, precheck );

  field ( mandatory : create, readonly : update ) PurchaseRequisition;
  field ( mandatory : create ) buyer;


    field (readonly) PurchaseRequisitionItem;
    field (readonly) PurchaseRequisitionType;
    field (readonly) PurchasingDocumentTypeName;
    field (readonly) NumberOfItems;
    field (readonly) PurchasingDocumentSubtype;
    field (readonly) Currency;
    field (readonly) TotalNetAmount;
    field (readonly) Material;
    field (readonly) PurchaseRequisitionItemText;
    field (readonly) Plant;
    field (readonly) PurReqnReleaseStatus;
    field (readonly) PurchasingGroup;
    field (readonly) PurchasingGroupName;
    field (readonly) RequisitionerName;
    field (readonly) CreatedByUser;
    field (readonly) CreatedByFullName;


validation validateBuyer on save { field Buyer; create;update; }

}

5.Implement Behavior Class:

CLASS zbp_cds_pr_buyer_assign DEFINITION PUBLIC ABSTRACT FINAL FOR BEHAVIOR OF zcds_pr_buyer_assign.
ENDCLASS.

CLASS zbp_cds_pr_buyer_assign IMPLEMENTATION.
ENDCLASS.

CLASS lhc_ZCDS_PR_Buyer_Assign DEFINITION INHERITING FROM cl_abap_behavior_handler.
  PRIVATE SECTION.

    METHODS validateBuyer FOR VALIDATE ON SAVE
      IMPORTING keys FOR ZCDS_PR_Buyer_Assign~validateBuyer.

    METHODS get_authorizations FOR INSTANCE AUTHORIZATION
        IMPORTING keys REQUEST requested_authorizations FOR ZCDS_PR_Buyer_Assign RESULT result.

    METHODS get_instance_features FOR INSTANCE FEATURES
      IMPORTING keys REQUEST requested_features FOR ZCDS_PR_Buyer_Assign RESULT result.

    METHODS is_update_granted
      RETURNING VALUE(update_granted) TYPE abap_bool.

ENDCLASS.

CLASS lhc_ZCDS_PR_Buyer_Assign IMPLEMENTATION.

  METHOD validateBuyer.


    " Read relevant data
    READ ENTITIES OF zcds_pr_buyer_assign IN LOCAL MODE
    ENTITY ZCDS_PR_Buyer_Assign
    FIELDS (  Buyer ) WITH CORRESPONDING #( keys )
    RESULT DATA(lt_buyer_assign)
  FAILED DATA(lt_failed).

    failed =  CORRESPONDING #( DEEP lt_failed  ).
    DATA lt_buyer TYPE SORTED TABLE OF demo_sales_bupa
      WITH UNIQUE KEY id.

    lt_buyer = CORRESPONDING #( lt_buyer_assign
                 MAPPING id = Buyer EXCEPT * ).


    DATA ls_buyer_assign LIKE LINE OF lt_buyer_assign.
    DATA ls_buyer LIKE LINE OF lt_buyer.
    DATA lo_message TYPE REF TO if_abap_behv_message.

    READ TABLE lt_buyer_assign INTO ls_buyer_assign INDEX 1.
    READ TABLE lt_buyer INTO ls_buyer INDEX 1.

    data(has_error) = abap_false.
    data message_number type numchar3.

    IF ls_buyer-id IS INITIAL.
        has_error = abap_true.
        message_number = 002.
    ELSE.
        select single BNAME from usr21 into (lv_BNAME) where BNAME = _buyer-id.
        if sy-subrc <> 0.
            has_error = abap_true.
            message_number = 003.
        endif.
    ENDIF.


    if has_error = abap_true.
        " If so we are loading a message from the global message class ZCONNECTION_MESSAGES.
          lo_message = me->new_message(
            id = 'ZFIORI'
            number = message_number "002
            severity = ms-error
          ).

          " Appending the message to the RAP runtime to show it to the user.
          APPEND VALUE #(
            %tky = ls_buyer_assign-%tky
            %msg = lo_message
          ) TO reported-zcds_pr_buyer_assign.

          " Abort the save by adding an entry to the failed component.
          APPEND VALUE #(
            %tky = ls_buyer_assign-%tky
          ) TO failed-zcds_pr_buyer_assign.
    endif.




  ENDMETHOD.


  METHOD get_authorizations.

    DATA update_grtanted TYPE abap_bool.
    "update_grtanted = abap_false.
      DATA lo_message TYPE REF TO if_abap_behv_message.

      READ ENTITIES OF zcds_pr_buyer_assign IN LOCAL MODE
        ENTITY ZCDS_PR_Buyer_Assign
        FIELDS ( Buyer ) WITH CORRESPONDING #( keys )
        RESULT DATA(ZCDS_PR_Buyer_Assign_Edit)
        FAILED failed.

      CHECK ZCDS_PR_Buyer_Assign_Edit is not initial.
      data(update_requested) = COND #( WHEN requested_authorizations-%update = if_abap_behv=>mk-on
                                       THEN abap_true ELSE abap_false ).
      data(delete_requested) = COND #( WHEN requested_authorizations-%delete = if_abap_behv=>mk-on
                                       THEN abap_true ELSE abap_false ).

      loop at ZCDS_PR_Buyer_Assign_Edit ASSIGNING FIELD-SYMBOL(<lfs_Buyer_Assign>).
        if update_requested = abap_true or delete_requested = abap_true.

            update_grtanted = is_update_granted(  ).

            if update_grtanted = abap_false.

                lo_message = me->new_message(
                    id = 'ZFIORI'
                    number = 004
                    severity = ms-error
                ).
                APPEND VALUE #(  %tky = <lfs_Buyer_Assign>-%tky ) to failed-ZCDS_PR_Buyer_Assign.
                APPEND VALUE #( %tky = keys[ 1 ]-%tky
                                 %msg = lo_message
                ) to reported-ZCDS_PR_Buyer_Assign.

            ENDIF.
        endif.
      endloop.

  ENDMETHOD.

  METHOD get_instance_features.

    READ ENTITIES OF zcds_pr_buyer_assign IN LOCAL MODE
        ENTITY ZCDS_PR_Buyer_Assign
         ALL FIELDS
         WITH CORRESPONDING #( keys )
         RESULT DATA(entities).


   data(lv_update_delete) = COND #( WHEN is_update_granted( ) IS INITIAL
                                                      THEN if_abap_behv=>fc-o-disabled
                                                      ELSE if_abap_behv=>fc-o-enabled ).
    result = VALUE #( FOR entity IN entities
                    ( %tky                   = entity-%tky
                      %update                = lv_update_delete
                      %delete                = lv_update_delete
                       ) ).

  ENDMETHOD.
  METHOD is_update_granted.
    "For instance auth

      AUTHORITY-CHECK OBJECT 'ZMM_BUYER'
        ID 'ACTVT'      FIELD '02'.
      update_granted = COND #( WHEN sy-subrc = 0 THEN abap_true ELSE abap_false ).
  ENDMETHOD.

ENDCLASS.


CLASS lsc_ZCDS_PR_Buyer_Assign DEFINITION INHERITING FROM cl_abap_behavior_saver.
  PROTECTED SECTION.


    METHODS save_modified             REDEFINITION .

ENDCLASS.

CLASS lsc_ZCDS_PR_Buyer_Assign IMPLEMENTATION.


  METHOD save_modified.

    DATA ls_PR_BUYER_BO TYPE zmm_PR_BUYER_BO.
    DATA lt_PR_BUYER_BO TYPE TABLE OF zmm_PR_BUYER_BO.

    DATA(trigger_wf) = abap_true.

    IF create IS NOT INITIAL.
      "Populate the values
      lt_PR_BUYER_BO = CORRESPONDING #( create-zcds_pr_buyer_assign ).
      READ TABLE lt_PR_BUYER_BO INTO ls_PR_BUYER_BO INDEX 1.


      GET TIME STAMP FIELD ls_PR_BUYER_BO-crea_date_time.
      ls_PR_BUYER_BO-crea_uname = sy-uname.

      GET TIME STAMP FIELD ls_PR_BUYER_BO-lchg_date_time.
      ls_PR_BUYER_BO-lchg_uname = sy-uname.

      MODIFY zmm_pr_buyer_bo FROM ls_PR_BUYER_BO.

      UPDATE eban
            SET buyer = ls_PR_BUYER_BO-buyer
                comments = ls_PR_BUYER_BO-comments
            WHERE banfn = ls_PR_BUYER_BO-purchaserequisition AND
              bnfpo = '00010'.


    ELSEIF update IS NOT INITIAL.

      lt_PR_BUYER_BO = CORRESPONDING #( update-zcds_pr_buyer_assign ).
      READ TABLE lt_PR_BUYER_BO INTO ls_PR_BUYER_BO INDEX 1.


      GET TIME STAMP FIELD ls_PR_BUYER_BO-lchg_date_time.
      ls_PR_BUYER_BO-lchg_uname = sy-uname.

      MODIFY zmm_pr_buyer_bo FROM ls_PR_BUYER_BO.


      IF ls_PR_BUYER_BO-buyer IS NOT INITIAL.
        UPDATE eban
                    SET buyer = ls_PR_BUYER_BO-buyer
                        comments = ls_PR_BUYER_BO-comments
                    WHERE banfn = ls_PR_BUYER_BO-purchaserequisition AND
                      bnfpo = '00010'.
      ELSE.
        UPDATE eban
              SET comments = ls_PR_BUYER_BO-comments
              WHERE banfn = ls_PR_BUYER_BO-purchaserequisition AND
                bnfpo = '00010'.
      ENDIF.

    ELSEIF delete IS NOT INITIAL.
      trigger_wf = abap_false.
      lt_PR_BUYER_BO = CORRESPONDING #( delete-zcds_pr_buyer_assign ).

      READ TABLE lt_PR_BUYER_BO INTO ls_PR_BUYER_BO INDEX 1.
      GET TIME STAMP FIELD ls_PR_BUYER_BO-lchg_date_time.
      ls_PR_BUYER_BO-lchg_uname = sy-uname.

      MODIFY zmm_pr_buyer_bo FROM ls_PR_BUYER_BO.

      UPDATE eban
          SET buyer = ''
              comments = ''
          WHERE banfn = ls_PR_BUYER_BO-purchaserequisition AND
            bnfpo = '00010'.

    ENDIF.


    IF trigger_wf = abap_true.
      IF ls_PR_BUYER_BO IS INITIAL.


      ENDIF.

      CALL FUNCTION 'ZMM_WF_PR_ASSIGN_NOT' IN BACKGROUND TASK
        EXPORTING
          i_pr_buyer = ls_PR_BUYER_BO.
    ENDIF.

  ENDMETHOD.



ENDCLASS.

6.Create FM zmm_wf_pr_assign_not

FUNCTION zmm_wf_pr_assign_not
  IMPORTING
    VALUE(i_pr_buyer) TYPE zmm_pr_buyer_bo.

*  Data Declaration for Class
  DATA lr_wf_pgr TYPE REF TO zmm_wf_pr_assign_notification.
  DATA ls_pr_buyer TYPE zmm_pr_buyer_bo.

  CREATE OBJECT lr_wf_pgr.

  MOVE-CORRESPONDING i_pr_buyer TO ls_pr_buyer.
*   Trigger Workflow

  CONCATENATE 'US' ls_pr_buyer-buyer INTO ls_pr_buyer-buyer.

  lr_wf_pgr->register_buyer( EXPORTING i_pr_buyer = ls_pr_buyer ).

ENDFUNCTION.

Table zmm_pr_buyer_bo:

3. Create Workflow: (Class based workflow)

1. Workflow template

2. Workflow Class

class ZMM_WF_PR_ASSIGN_NOTIFICATION definition
  public
  final
  create public .

public section.

  interfaces BI_OBJECT .
  interfaces BI_PERSISTENT .
  interfaces IF_WORKFLOW .

  events REGISTER
    exporting
      value(I_PR_BUYER) type ZMM_PR_BUYER_BO .

  methods REGISTER_BUYER
    importing
      !I_PR_BUYER type ZMM_PR_BUYER_BO .
  methods NOTIFICATION
    importing
      !I_PR_BUYER type ZMM_PR_BUYER_BO .
protected section.
private section.
ENDCLASS.



CLASS ZMM_WF_PR_ASSIGN_NOTIFICATION IMPLEMENTATION.


  method NOTIFICATION.
  endmethod.


  METHOD REGISTER_BUYER.



* Data Declarations
    DATA: lv_objtype          TYPE sibftypeid,
          lv_event            TYPE sibfevent,
          lv_objkey           TYPE sibfinstid,
          lr_event_parameters TYPE REF TO if_swf_ifs_parameter_container.
*          lv_param_name       TYPE swfdname,
**          lv_id               TYPE char10.
*          lv_id               TYPE zmm_pgr_not_log.


* Setting values of Event Name
    lv_objtype = 'ZMM_WF_PR_ASSIGN_NOTIFICATION'. " Your Class Name
    lv_event   = 'REGISTER'.  " Event Name.

* Instantiate an empty event container
    CALL METHOD cl_swf_evt_event=>get_event_container
      EXPORTING
        im_objcateg  = cl_swf_evt_event=>mc_objcateg_cl
        im_objtype   = lv_objtype
        im_event     = lv_event
      RECEIVING
        re_reference = lr_event_parameters.

** Set up the name/value pair to be added to the container
*    lv_param_name  = 'I_PGR_LOG'.  " parameter name of the event
*    lv_id          = i_pgr_log.

* Add the name/value pair to the event conainer
    TRY.
        CALL METHOD lr_event_parameters->set
          EXPORTING
            name  = 'I_PR_BUYER'
            value = I_PR_BUYER.

      CATCH cx_swf_cnt_cont_access_denied .
      CATCH cx_swf_cnt_elem_access_denied .
      CATCH cx_swf_cnt_elem_not_found .
      CATCH cx_swf_cnt_elem_type_conflict .
      CATCH cx_swf_cnt_unit_type_conflict .
      CATCH cx_swf_cnt_elem_def_invalid .
      CATCH cx_swf_cnt_container .
    ENDTRY.

* Raise the event passing the prepared event container
    TRY.
        CALL METHOD cl_swf_evt_event=>raise
          EXPORTING
            im_objcateg        = cl_swf_evt_event=>mc_objcateg_cl
            im_objtype         = lv_objtype
            im_event           = lv_event
            im_objkey          = lv_objkey
            im_event_container = lr_event_parameters.
      CATCH cx_swf_evt_invalid_objtype .
      CATCH cx_swf_evt_invalid_event .
    ENDTRY.

    COMMIT WORK.

  ENDMETHOD.
ENDCLASS.

Action the Complete button of this specific task in

Create Enhancement implementation for badi /IWWRK/ES_WF_WI_BEFORE_UPD_IB

make sure to map filter values correctly as below

class ZCL_MM_WF_PGR_NOT definition
  public
  final
  create public .

public section.

  interfaces /IWWRK/IF_WF_WI_BEFORE_UPD_IB .
  interfaces IF_BADI_INTERFACE .
protected section.
private section.
ENDCLASS.



CLASS ZCL_MM_WF_PGR_NOT IMPLEMENTATION.


  method /IWWRK/IF_WF_WI_BEFORE_UPD_IB~BEFORE_UPDATE.


* Local Data Declaration
    DATA: lv_subrc  TYPE sy-subrc,
          lv_status TYPE sww_wistat.

    CLEAR: lv_subrc,
           lv_status.
    IF iv_decision_key EQ '0001'.
* Status: Ready to Committed Status
      CALL FUNCTION 'SAP_WAPI_WORKITEM_COMPLETE'
        EXPORTING
          workitem_id = is_wi_details-wi_id
        IMPORTING
          return_code = lv_subrc
          new_status  = lv_status.
      IF lv_subrc EQ 0
        AND lv_status NE 'COMPLETED'.
        CLEAR: lv_status.
* Status: Committed to Completed Status
        CALL FUNCTION 'SAP_WAPI_WORKITEM_COMPLETE'
          EXPORTING
            workitem_id = is_wi_details-wi_id
          IMPORTING
            return_code = lv_subrc
            new_status  = lv_status.
      ENDIF.
    ENDIF.
  endmethod.
ENDCLASS.

4.Publish app to Fiori Launchpad

I went with the minimum option (without SAP Business Application Studio) as follows:

published the cds view in SEGW project and created a project from template (List Report) in webide then deploy it to server under name zmm_pr_assign

Target mapping

I'm sure you will manage to create tile, catalog, group, and pfcg role. 🙂

5.Output:

Once saved here you find wf item in my inbox with binded details of PR.. with the complete button visible

I've included all the important details in sequence, but there may still be some missing information.

Please feel free to ask about any additional details you'd like me to include.

Regards,

Abdelrahman Zaki